From 641dcaa3bf927b3ba1b7c78fa8b7275bc774be57 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:42 +0000 Subject: [PATCH 01/59] sim: keep the world measured and assume league-level robots The simulator's settings fall into two kinds. The world (ball friction, vision noise and dropouts, latency) comes from measurements; robot capability (kick, dribbler, motors) is assumed good at league level, with real robots' shortfalls handled in the control layer. Drop per-robot real kicks from rsim, and have the sim's commands compensate for its latency as real robots do. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- docs/real_robot_setup.md | 6 +- docs/sim_realism.md | 14 +- tools/field_physics.py | 267 ++++++++++++++++++ tools/field_sessions.json | 32 +++ .../motion_planning/src/common/pose_ahead.py | 5 +- .../rsoccer_simulator/src/Utils/real_kick.py | 67 ----- .../rsoccer_simulator/src/Utils/sim_noise.py | 6 + .../src/ssl/envs/standard_ssl.py | 18 -- utama_core/run/strategy_runner.py | 22 +- .../src/controllers/common/robot_profile.py | 7 +- .../tests/analysis/test_field_physics.py | 152 ++++++++++ .../tests/rsoccer_simulator/test_real_kick.py | 73 ----- .../strategy_runner/test_kick_bend_wiring.py | 25 +- .../strategy_runner/test_sim_pose_ahead.py | 34 +++ 14 files changed, 519 insertions(+), 209 deletions(-) create mode 100644 tools/field_physics.py create mode 100644 tools/field_sessions.json delete mode 100644 utama_core/rsoccer_simulator/src/Utils/real_kick.py create mode 100644 utama_core/tests/analysis/test_field_physics.py delete mode 100644 utama_core/tests/rsoccer_simulator/test_real_kick.py create mode 100644 utama_core/tests/strategy_runner/test_sim_pose_ahead.py diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index 0de60f5e..e47df6d9 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -236,10 +236,8 @@ which every example reads (`load_profile`). Nothing to copy by hand: - `carry_speed`, `carry_turn`: the carry ladder's slowest direction, the fastest speed it kept the ball every time; `move()` holds this robot to them (`RobotParams.CARRY_*` otherwise). -rsim kicks a robot given its profile as it measured (`real_kick.py`): at its kick speed, off its -heading by its bias and bend, scattered by its spread, and passes and shots aim against bend and -bias there too. So an example rehearsed in rsim (`--mode rsim`) kicks like the robot on the field. -Matches without profiles (the strategy evaluation) keep the sim's own kick. +rsim keeps its own kick, and kick bend and bias are applied on real robots only, so a rehearsal in +rsim (`--mode rsim`) does not kick like the robot on the field. **Kicker charge in play.** On real robots a robot that has not kicked for 25 s fires an empty kick, when the ball is neither on it (ball sensor) nor within 30 cm (vision), and never in a HALT diff --git a/docs/sim_realism.md b/docs/sim_realism.md index 9882177e..38955696 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -94,7 +94,7 @@ friction). **Within** means kick-to-kick noise for the same robot. | Kick speed: between and within | How much time the keeper has; pass weight | Yes: peak ball speed after each kick, per team | Fixed | | Kick direction error | Wide rate (6% vs 22%) | Partly: shot miss distance, pass error relative to the receiver | None: exact | | Robot top speed, acceleration, braking, turn rate | Who reaches the ball first | Yes: from the tracker, per robot | One limit for all robots (2 m/s for evaluation) | -| Vision noise and dropped frames (ball especially, also when blocked) | Every decision; keeper tracking | Yes from raw vision packets in the logs; the converter currently reads the filtered tracker | Yes: `SimNoise` (`--sim-noise`, the pool's `sim_noise`) in `run_match`, the round-robin and `evaluate.py`; `rsim_noise` and `rsim_vanishing` in `StrategyRunner` are its older form | +| Vision noise and dropped frames (ball especially, also when blocked) | Every decision; keeper tracking | Yes from raw vision packets in the logs; the converter currently reads the filtered tracker | Yes: `SimNoise` (`--sim-noise`, the reference's `world.json`) in `run_match`, the round-robin and `evaluate.py`; `rsim_noise` and `rsim_vanishing` in `StrategyRunner` are its older form | | Dribbler: hold strength, ball loss when turning or touched, release speed | Possession, passing | Weak: only possession-loss rates as a proxy | Fixed, with the fork's dribbler fixes (`vendor/rSim/FORK_NOTES.md`) | | Ball bounce off robots and walls | Rebounds, deflections | Partly: speed before and after contact | Fixed | | Robots fielded per team | Defenders in the way of each shot (real 4.5 on average, sim always 6) | Yes: robots on the field in live play, per match | Always 6 | @@ -340,13 +340,13 @@ direction SD 3° (per robot 1.5°), ball slide 2.5–4.0 then roll 0.27–0.33 m All of these are built (2026-10-17): `SimNoise` draws each knob per match from its range, seeded and recorded in the replay, and reaches `run_match`, the round-robin option, `evaluate.py` and -`pool_v1` (the v3 ranges, played as `v3_seed2` in the 2026-10-17 round-robin). A knob at zero +the reference `tools/evaluation/reference/world.json` (the v3 ranges, played as `v3_seed2` in the 2026-10-17 round-robin, have since changed). A knob at zero reproduces the old behaviour, so results played without `--sim-noise` are unchanged. Each knob is off by default, so current results are unchanged, and each comes with a test that pins its effect: -- **Latency:** a delay buffer between the strategy's command and rsim (Python). This is the cheapest and probably biggest. +- **Latency:** a delay buffer between the strategy's command and rsim (Python). This is the cheapest and probably biggest. Current range: 50 to 90 ms in `tools/evaluation/reference/world.json`. - **Vision noise and dropped frames:** done. `SimNoise` (`--sim-noise`, the pool's `sim_noise`) goes through `run_match`, the round-robin and `evaluate.py`. - **Kick speed noise:** perturb the commanded kick speed (Python). - **Kick direction noise:** perturb the direction inside the C++ kicker (fork change, recorded in `FORK_NOTES.md`). @@ -459,14 +459,16 @@ detections, because the two cameras disagreed by several cm. Vision noise comes #### Our robots' kicks in rsim rehearsals (2026-10-29) +Removed 2026-11-09: simulation models the measured world and assumes robots work; see `tools/evaluation/reference/`. + A robot's calibrated profile now drives its kick in rsim when a run gives the profile (the examples do): ball speed `kick_speed` (yellow 0 2.19 m/s, blue 0 1.31, the medians of 2026-10-28's kicks), direction bias + bend × ball offset + normal scatter of `kick_spread_deg` (`utama_core/rsoccer_simulator/src/Utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than the kick speed commanded, at 1 to 5 m/s, so the command adds that back. The strategy evaluation passes no profiles, so its matches are unchanged: whether evaluation should use our kick is the -Phase 4 / roadmap 2a decision, not this one. Latency is left out: real robots predict their -79 ms delay, and rsim would need both to stay faithful. +Phase 4 / roadmap 2a decision, not this one. Latency is not in this kick profile: rsim's latency is `SimNoise`'s (`reference/world.json`), and real robots predict their +79 ms delay, so rsim would need both to stay faithful. ## P1: Value model on real data @@ -516,7 +518,7 @@ Writing `ball_seen` into converted logs would let a later pass tell hidden from Built instead of a cheaper outcome (V, shots, xG, stat combinations: all rejected, see `docs/signals.md`, "Ranking"): `tools/evaluation/evaluate.py` judges a candidate against the -champion of a fixed, versioned pool (`tools/evaluation/pools/pool_v1.json`) in rounds of seeded +champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`) in rounds of seeded noisy matches, with ratings from goal margins (`analysis/ratings.py`) and a ledger of every match (`replays/eval/ledger.jsonl`); see `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". This covers Phase 4's "several seeds per pairing, paired seeds for A/B". diff --git a/tools/field_physics.py b/tools/field_physics.py new file mode 100644 index 00000000..9d19ba1d --- /dev/null +++ b/tools/field_physics.py @@ -0,0 +1,267 @@ +"""World physics measured from field logs, for the sim's settings: loop delay, ball rolling +deceleration, and detection noise at rest for the ball and the robots. + +Only the sessions and measurements allowed in `tools/field_sessions.json` are read. Each log's +values are grouped by (day, radio) and printed as a median with its middle half and count, then +checked for agreement across the groups: a setting is only trusted if the days repeat it. + + pixi run python tools/field_physics.py [--logs replays/field] [--workers 2] [--json OUT] +""" + +from __future__ import annotations + +import argparse +import glob +import json +import os +import sys +from multiprocessing import Pool +from pathlib import Path +from typing import Optional + +import numpy as np + +REPO_ROOT = Path(__file__).resolve().parents[1] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from utama_core.analysis import robot_calibration as rc # noqa: E402 + +REGISTER = Path(__file__).with_name("field_sessions.json") +MEASUREMENTS = ("loop_delay", "ball_roll", "ball_noise", "robot_noise") +UNITS = {"loop_delay": "ms", "ball_roll": "m/s^2", "ball_noise": "mm", "robot_noise": "mm"} +ROLL_MAX_RMS_MM = 12.0 # a roll fit this noisy is not a clean roll +ROLL_MIN_DECEL = 0.0 +ROLL_MIN_SECS = 0.6 +STEP_MIN_CMD = 0.3 # commanded speed (m/s or rad/s) for a step to count as a delay measurement +STEP_AXES = ("forward", "left") +FIELD_BOUNDS = {"top_left": [-1.5, 1.125], "bottom_right": [1.5, -1.125]} +ROLL_MIN_SPEED = 0.8 # m/s, ball speed of a kick +ROLL_EDGE_M = 0.1 # the fit stops this far from the field edge +ROLL_ROBOT_M = 0.25 # and this far from any robot + + +def load_register(path: Path = REGISTER) -> dict: + """The field sessions register: which days may be used for which measurements.""" + with open(path) as f: + return json.load(f) + + +def session_of(log_name: str) -> str: + """The day (first 8 characters of the file name), e.g. '20261028' for '20261028_...log.gz'.""" + return Path(log_name).name[:8] + + +def allowed(register: dict, day: str, measurement: str) -> bool: + """True only if the day is registered and lists the measurement in its `use`.""" + session = register.get("sessions", {}).get(day) + if session is None: + return False + return measurement in session.get("use", []) + + +def ball_rolls(log, robot_kicks: list[dict], bounds) -> list[dict]: + """Rolling deceleration after clean kicks, single camera, away from robots and field edge. + + Each kick's ball path is fitted with a quadratic in distance travelled; the fit is kept only + if it is clean (rms < ROLL_MAX_RMS_MM), decelerating and at least ROLL_MIN_SECS long.""" + if len(log.balls) < 30: + return [] + b = rc._main_camera(np.column_stack([log.balls[:, :2], log.balls[:, 2:], np.zeros(len(log.balls))])).astype(float) + out = [] + (xl, yt), (xr, yb) = bounds + for k in robot_kicks: + if k["ball_speed"] < ROLL_MIN_SPEED or k.get("chip"): + continue + t0 = k["t"] + w = (b[:, 0] > t0 + 0.3) & (b[:, 0] < t0 + 5) + if w.sum() < 25: + continue + r = b[w] + dt = np.diff(r[:, 0]) + cut = np.flatnonzero(dt > 0.1) + if len(cut): + r = r[: cut[0] + 1] + inside = ( + (r[:, 2] > xl + ROLL_EDGE_M) + & (r[:, 2] < xr - ROLL_EDGE_M) + & (r[:, 3] > yb + ROLL_EDGE_M) + & (r[:, 3] < yt - ROLL_EDGE_M) + ) + # distance from the ball to the nearest robot at each sample + d = np.full(len(r), np.inf) + for rows in log.robots.values(): + q = rows[np.argsort(rows[:, 0].astype(float))].astype(float) + d = np.minimum( + d, + np.hypot( + np.interp(r[:, 0], q[:, 0], q[:, 2]) - r[:, 2], np.interp(r[:, 0], q[:, 0], q[:, 3]) - r[:, 3] + ), + ) + ok = inside & (d > ROLL_ROBOT_M) + n = int(np.argmin(ok)) if not ok.all() else len(r) + r = r[:n] + if len(r) < 25: + continue + t = r[:, 0] - r[0, 0] + s = np.r_[0, np.cumsum(np.hypot(np.diff(r[:, 2]), np.diff(r[:, 3])))] + moving = np.flatnonzero(np.gradient(s, t) > 0.15) + if len(moving) < 25: + continue + e = moving[-1] + 1 + t, s = t[:e], s[:e] + if t[-1] < 0.4: + continue + c = np.polyfit(t, s, 2) + row = dict( + decel=round(float(-2 * c[0]), 3), + v0=round(float(c[1]), 3), + secs=round(float(t[-1]), 2), + rms_mm=round(1000 * float(np.std(s - np.polyval(c, t))), 2), + ) + if row["rms_mm"] < ROLL_MAX_RMS_MM and row["decel"] > ROLL_MIN_DECEL and row["secs"] >= ROLL_MIN_SECS: + out.append(row) + return out + + +def step_delays_ms(steps: list[dict]) -> list[float]: + """Each fitted step's delay in ms, for steps moving forward or left at >= STEP_MIN_CMD.""" + out = [] + for s in steps: + delay = s.get("delay_s") + if not delay or delay <= 0: + continue + if s.get("axis") not in STEP_AXES or abs(s.get("commanded", 0.0)) < STEP_MIN_CMD: + continue + out.append(delay * 1000) + return out + + +def measure_log(path) -> Optional[dict]: + """The allowed measurements of one field log, or None if its mode is not real or its day + allows nothing. Each value is (measurement, radio or None, value).""" + name = os.path.basename(str(path)) + day = session_of(name) + register = load_register() + if not any(allowed(register, day, m) for m in MEASUREMENTS): + return None + try: + log = rc.FieldLog(path) + if log.info.get("mode") != "real": + return None + fb = log.info.get("field_bounds", FIELD_BOUNDS) + bounds = (fb["top_left"], fb["bottom_right"]) + values: list[tuple] = [] + for r in rc.calibrate(log): + if "error" in r: + continue + fw = r["firmware_id"] + if allowed(register, day, "loop_delay"): + values += [("loop_delay", fw, ms) for ms in step_delays_ms(r["steps"])] + if allowed(register, day, "ball_roll"): + values += [("ball_roll", fw, roll["decel"]) for roll in ball_rolls(log, r["kicks"], bounds)] + if allowed(register, day, "robot_noise") and r["vision"].get("position_mm") is not None: + values.append(("robot_noise", fw, r["vision"]["position_mm"])) + if allowed(register, day, "ball_noise"): + pos = rc.ball_noise(log.balls).get("position_mm") + if pos is not None: + values.append(("ball_noise", None, pos)) + return {"log": name, "day": day, "values": values} + except Exception as e: # one bad log must not lose the run + return {"log": name, "day": day, "error": str(e), "values": []} + + +def summarise(rows: list[dict]) -> dict: + """{measurement: {(day, radio): {median, lo, hi, n}}}: lo and hi are the 25th and 75th percentiles.""" + grouped: dict[str, dict[tuple, list[float]]] = {} + for row in rows: + if not row: + continue + for measurement, radio, value in row["values"]: + grouped.setdefault(measurement, {}).setdefault((row["day"], radio), []).append(float(value)) + out: dict = {} + for measurement, groups in grouped.items(): + out[measurement] = {} + for key, vals in sorted(groups.items(), key=lambda kv: (kv[0][0], -1 if kv[0][1] is None else kv[0][1])): + a = np.array(vals, float) + out[measurement][key] = { + "median": round(float(np.median(a)), 3), + "lo": round(float(np.percentile(a, 25)), 3), + "hi": round(float(np.percentile(a, 75)), 3), + "n": len(a), + } + return out + + +def agreement(groups: dict, tolerance: float = 0.25, min_n: int = 5) -> dict: + """Whether the groups' medians agree: highest - lowest <= tolerance * median of the medians. + Only groups with at least `min_n` values count. Fewer than two usable groups gives agree None.""" + medians = [g["median"] for g in groups.values() if g["n"] >= min_n] + if len(medians) < 2: + return {"medians": [min(medians), max(medians)] if medians else [], "agree": None, "groups_used": len(medians)} + lowest, highest = min(medians), max(medians) + return { + "medians": [lowest, highest], + "agree": bool(highest - lowest <= tolerance * float(np.median(medians))), + "groups_used": len(medians), + } + + +def _key(day: str, radio) -> str: + return f"{day}|{'all' if radio is None else radio}" + + +def main(argv: Optional[list[str]] = None) -> int: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--logs", default="replays/field", help="folder of *.log.gz files") + parser.add_argument("--workers", type=int, default=2) + parser.add_argument("--json", type=Path, help="write the summary, agreement and errors here") + args = parser.parse_args(argv) + + files = sorted(glob.glob(os.path.join(args.logs, "*.log.gz"))) + print(f"{len(files)} logs in {args.logs}") + with Pool(args.workers) as pool: + rows = [r for r in pool.imap(measure_log, files, chunksize=1) if r is not None] + errors = [r for r in rows if "error" in r] + for r in errors: + print(f"ERROR {r['log']}: {r['error']}") + print(f"{len(rows)} logs used, {len(errors)} errored") + + summary = summarise(rows) + agree_all: dict = {} + for measurement in MEASUREMENTS: + groups = summary.get(measurement, {}) + unit = UNITS[measurement] + print(f"\n{measurement} ({unit})") + if not groups: + print(" no values") + agree_all[measurement] = agreement({}) + continue + print(f" {'day':<10}{'radio':<7}{'median':>10}{'middle half':>24}{'n':>7}") + for (day, radio), g in groups.items(): + radio_s = "all" if radio is None else str(radio) + middle = "%s to %s" % (g["lo"], g["hi"]) + print(f" {day:<10}{radio_s:<7}{g['median']:>10}{middle:>24}{g['n']:>7}") + ag = agreement(groups) + agree_all[measurement] = ag + if ag["agree"] is None: + verdict = f"too few groups to compare ({ag['groups_used']} with n >= 5)" + elif ag["agree"]: + verdict = "agree" + else: + verdict = "disagree: find the setup difference or use the spread as the range" + print(f" agreement: {verdict}") + + if args.json: + payload = { + "summary": {m: {_key(d, r): g for (d, r), g in groups.items()} for m, groups in summary.items()}, + "agreement": agree_all, + "errors": [{"log": r["log"], "error": r["error"]} for r in errors], + } + args.json.write_text(json.dumps(payload, indent=1)) + print(f"\nwritten {args.json}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/field_sessions.json b/tools/field_sessions.json new file mode 100644 index 00000000..1557b969 --- /dev/null +++ b/tools/field_sessions.json @@ -0,0 +1,32 @@ +{ + "note": "Every field session, and which measurements it may be used for. tools/field_physics.py reads only what is allowed here. Stop rule: a number enters the sim only if it repeats across runs, or its spread is deliberately used as the range.", + "source_archive": "replays/field_logs_20261102_211613.tar.gz (untrimmed, local only; do not delete). Trimmed logs: release v2.5.0, field_logs_20261102_233700.tar.gz.", + "measurements": ["loop_delay", "ball_roll", "ball_noise", "robot_noise"], + "sessions": { + "20261021": { + "setup": "Logged as mode=real but synthetic: zero noise, 4 cameras.", + "use": [], + "why": "Not real data." + }, + "20261022": { + "setup": "Real logs mixed with 7 grSim logs. Cameras disagree by about 71 mm.", + "use": ["ball_noise"], + "why": "Camera disagreement rules out anything from motion." + }, + "20261027": { + "setup": "One calibration run, vision about 44 Hz with about 20 ms processing.", + "use": ["loop_delay", "ball_roll", "ball_noise", "robot_noise"], + "why": "Usable as a second day to check agreement, but thin: 79 ms and 1.8 m/s^2 sideways came from this one run." + }, + "20261028": { + "setup": "2 radios, 7 usable calibration runs, wired vision, cameras within about 11 mm.", + "use": ["loop_delay", "ball_roll", "ball_noise", "robot_noise"], + "why": "The main reference." + }, + "20261029": { + "setup": "Vision over a 2.4 GHz phone hotspot: frames bunched, delays up to about 145 ms.", + "use": ["ball_noise", "robot_noise"], + "why": "Timing and anything fitted from motion are corrupted by the link." + } + } +} diff --git a/utama_core/motion_planning/src/common/pose_ahead.py b/utama_core/motion_planning/src/common/pose_ahead.py index 62724e9a..9ab7b0c4 100644 --- a/utama_core/motion_planning/src/common/pose_ahead.py +++ b/utama_core/motion_planning/src/common/pose_ahead.py @@ -30,8 +30,9 @@ class PoseAhead: this (4 cm with no delay); the motion benchmark's collisions went from 7 to 3. Only our robots move ahead, and only for planning their motion (`move()`): the game itself, - its history and every other decision keep what vision saw. With no latency (the simulators) - `game()` returns the game unchanged. + its history and every other decision keep what vision saw. rsim with simulated delay uses this + too, at the middle of its range (`SimNoise.latency_estimate_s`). With no latency `game()` + returns the game unchanged. """ def __init__(self, latency_s: float): diff --git a/utama_core/rsoccer_simulator/src/Utils/real_kick.py b/utama_core/rsoccer_simulator/src/Utils/real_kick.py deleted file mode 100644 index a9cf15d9..00000000 --- a/utama_core/rsoccer_simulator/src/Utils/real_kick.py +++ /dev/null @@ -1,67 +0,0 @@ -"""Our robots' kickers as calibrated (`RobotProfile`), for the robots of a rehearsal in rsim. - -A real kick leaves at the robot's own speed (about 2.1 m/s, not the sim's 5), off its heading by -its bias, bent towards the side the ball sits on the dribbler, and scattered kick to kick. A run -that gives rsim our robots' profiles (the examples do) kicks them so; a match without profiles -(the evaluation) keeps the sim's kick. Angles here are in our frame, anticlockwise +. -""" - -from __future__ import annotations - -import math -from dataclasses import dataclass -from typing import Optional - -import numpy as np - -# rsim's ball leaves this much slower than the kick speed commanded, at any speed (measured -# 2026-10-29: 1 to 5 m/s); a profile's kick speed is the ball's, as calibration measures it. -CONTACT_LOSS = 0.26 - - -@dataclass(frozen=True) -class RealKick: - speed: Optional[float] = None # m/s; None: the sim's - bend_deg_per_cm: float = 0.0 - bias_deg: float = 0.0 - spread_deg: float = 0.0 # SD of each kick's direction about the fit - - @classmethod - def of(cls, profile) -> Optional["RealKick"]: - """The kick `profile` (a `RobotProfile`) measured; None if it measured none.""" - kick = cls( - profile.kick_speed, profile.kick_bend_deg_per_cm, profile.kick_bias_deg, profile.kick_spread_deg or 0.0 - ) - return None if kick == cls() else kick - - -class RealKicks: - """Each kick of a robot with a `RealKick`: its speed, and its direction drawn when the kick - command starts and held while it lasts (the kicker fires once per command).""" - - def __init__(self, kicks: dict[tuple[str, int], RealKick], seed: int = 0): - self.kicks = kicks - self._rngs = {key: np.random.default_rng([seed, i]) for i, key in enumerate(sorted(kicks))} - self._held: dict[tuple[str, int], Optional[float]] = {} - - def __contains__(self, key: tuple[str, int]) -> bool: - return key in self.kicks - - def reset(self) -> None: - self._held.clear() - - def speed(self, key: tuple[str, int], nominal: float) -> float: - speed = self.kicks[key].speed - return nominal if speed is None else speed + CONTACT_LOSS - - def angle(self, key: tuple[str, int], kicking: bool, ball_left_m: float) -> float: - """Radians off the heading, anticlockwise +, with the ball `ball_left_m` left of the - robot's centre line.""" - if not kicking: - self._held[key] = None - return 0.0 - if self._held.get(key) is None: - k = self.kicks[key] - deg = k.bias_deg + k.bend_deg_per_cm * ball_left_m * 100.0 + self._rngs[key].normal() * k.spread_deg - self._held[key] = math.radians(deg) - return self._held[key] diff --git a/utama_core/rsoccer_simulator/src/Utils/sim_noise.py b/utama_core/rsoccer_simulator/src/Utils/sim_noise.py index be1d9d9d..8dcbb17c 100644 --- a/utama_core/rsoccer_simulator/src/Utils/sim_noise.py +++ b/utama_core/rsoccer_simulator/src/Utils/sim_noise.py @@ -103,6 +103,12 @@ def __post_init__(self): assert self.kick_angle_offset_sd_deg >= 0 and self.kick_angle_sd_deg >= 0 assert self.substeps >= 1 + @property + def latency_estimate_s(self) -> float: + """The one delay the control layer assumes (`PoseAhead`): the middle of `latency_s`. Each + robot's real draw differs from it, as a real robot's delay differs from its setting.""" + return sum(self.latency_s) / 2 + @property def native_physics(self) -> bool: """Whether any setting needs the fork's C++ physics (`set_physics_params`).""" diff --git a/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py b/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py index b20b59fb..6088faaa 100644 --- a/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py +++ b/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py @@ -1,5 +1,4 @@ import logging -import math import random from typing import List, Optional, Tuple @@ -26,7 +25,6 @@ from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv from utama_core.rsoccer_simulator.src.Utils import KDTree from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.src.Utils.real_kick import RealKicks from utama_core.rsoccer_simulator.src.Utils.sim_noise import ( CommandDelay, KickAngleNoise, @@ -172,8 +170,6 @@ def __init__( self._kick_noise: Optional[KickSpeedNoise] = None self._kick_angle: Optional[KickAngleNoise] = None self._motion_limits: Optional[MotionLimits] = None - # Our robots' kickers as calibrated, by (colour, id); set by StrategyRunner from robot profiles. - self.real_kicks: Optional[RealKicks] = None self._noise_rng = None # None: `gaussian_noise`/`vanishing` use the global RNG, as before if sim_noise is not None: assert gaussian_noise == RsimGaussianNoise() and not vanishing, "pass vision noise in sim_noise only" @@ -225,8 +221,6 @@ def reset(self, *, seed=None, options=None): self._kick_noise.reset() if self._kick_angle is not None: self._kick_angle.reset() - if self.real_kicks is not None: - self.real_kicks.reset() return super().reset(seed=seed, options=options) def step(self, action): @@ -387,8 +381,6 @@ def _get_commands(self, actions) -> list[Robot]: return commands def _kick_direction(self, colour: str, robot_id: int, kicking: bool) -> float: - if self.real_kicks is not None and (colour, robot_id) in self.real_kicks: - return -self.real_kicks.angle((colour, robot_id), kicking, self._ball_left(colour, robot_id)) if self._kick_angle is not None: return self._kick_angle.angle(colour, robot_id, kicking) return 0.0 @@ -400,17 +392,7 @@ def _apply_motion_limits(self, commands: list[Robot]) -> None: ) self._motion_limits.apply(colour, cmd.id, cmd, robots[cmd.id]) - def _ball_left(self, colour: str, robot_id: int) -> float: - """How far the ball sits left of the robot's centre line (m, our frame: the sim's y and - headings are mirrored).""" - robot = (self.frame.robots_yellow if colour == "team_yellow" else self.frame.robots_blue)[robot_id] - heading = -math.radians(robot.theta) - dx, dy = self.frame.ball.x - robot.x, -(self.frame.ball.y - robot.y) - return -math.sin(heading) * dx + math.cos(heading) * dy - def _kick_speed(self, colour: str, robot_id: int, kicking: bool) -> float: - if kicking and self.real_kicks is not None and (colour, robot_id) in self.real_kicks: - return self.real_kicks.speed((colour, robot_id), RSIM_PARAMS.KICK_SPD) if self._kick_noise is not None: return self._kick_noise.speed(colour, robot_id, kicking, RSIM_PARAMS.KICK_SPD) return RSIM_PARAMS.KICK_SPD if kicking else 0.0 diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 4a80fbfd..83f62b47 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -58,7 +58,6 @@ from utama_core.replay.replay_writer import ReplayWriter, ReplayWriterConfig from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.src.Utils.real_kick import RealKick, RealKicks from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.run import GameGater from utama_core.run.field_check import LOOP_STALL_S, FieldCheck @@ -995,7 +994,6 @@ def _load_sim( vanishing=rsim_vanishing, sim_noise=sim_noise, ) - rsim_env.real_kicks = self._real_kicks(sim_noise) if self.opp: self.opp.strategy.load_rsim_env(rsim_env) @@ -1363,22 +1361,14 @@ def _load_robot_controllers(self): self.opp.strategy.load_robot_controller(opp_robot_controller) self.opp.strategy.load_motion_controller(self._motion_controller(self.opp, opp_profiles)) - def _real_kicks(self, sim_noise: Optional[SimNoise]) -> Optional[RealKicks]: - """rsim's kicks for the robots given profiles that measured their kick (a rehearsal); None - when none did, as in the evaluation's matches.""" - kicks = { - (f"team_{colour}", rid): kick - for colour, profiles in (("yellow", self.yellow_robot_profiles), ("blue", self.blue_robot_profiles)) - for rid, profile in profiles.items() - if (kick := RealKick.of(profile)) is not None - } - return RealKicks(kicks, seed=sim_noise.seed if sim_noise is not None else 0) if kicks else None - def _motion_controller(self, team, profiles: dict[int, RobotProfile]) -> MotionController: - """`team`'s motion controller, with its profiled robots' kick bends, biases (real robots and - rsim, which kicks them so) and carry caps (`RobotProfile`).""" + """`team`'s motion controller, with its profiled robots' kick bends and biases (real robots + only: the sims keep their own kick) and carry caps (`RobotProfile`, every mode).""" controller = team.motion_controller(self.mode, self.rsim_env) - if self.mode in (Mode.REAL, Mode.RSIM): + sim_noise = getattr(self.rsim_env, "sim_noise", None) + if self.mode == Mode.RSIM and sim_noise is not None: # commands are delayed: compensate as real robots do + controller.pose_ahead.latency_s = sim_noise.latency_estimate_s + if self.mode == Mode.REAL: controller.kick_bend = { rid: math.radians(p.kick_bend_deg_per_cm) * 100.0 for rid, p in profiles.items() diff --git a/utama_core/team_controller/src/controllers/common/robot_profile.py b/utama_core/team_controller/src/controllers/common/robot_profile.py index bbcfc2ec..a6cfd870 100644 --- a/utama_core/team_controller/src/controllers/common/robot_profile.py +++ b/utama_core/team_controller/src/controllers/common/robot_profile.py @@ -49,8 +49,7 @@ class RobotProfile: `kick_bend_deg_per_cm`: how far its kick leaves the heading towards the side the ball sits on the dribbler, per cm the ball is off-centre. Passes and shots aim against it - (`kick_bend`), on real robots and in rsim, which kicks a profiled robot so (`real_kick.py`); - grSim kicks along the heading. + (`kick_bend`), on real robots only: the sims keep their own kick, along the heading. `kick_bias_deg`: how far its kick leaves the heading vision reports with the ball centred, anticlockwise + (a kicker, or a tag stuck on turned); aimed against with the bend. Fitted @@ -61,8 +60,8 @@ class RobotProfile: (`PositionRefiner`); a tag is a sticker, measured once per lid. `kick_speed`: its kick's ball speed (m/s, the median of its kicks); `kick_spread_deg`: how far - its kicks scatter about bias and bend (rms of the fit). rsim kicks a profiled robot so. None: - not measured, the sim's speed and no scatter. + its kicks scatter about bias and bend (rms of the fit). Calibration records these as measurements; + the sims keep their own kick. None: not measured, the sim's speed and no scatter. `carry_speed`, `carry_turn`: the fastest it carries the ball, m/s and rad/s, from its carry ladder; `move()` holds it to them. None: the team's (`RobotParams.CARRY_*`). diff --git a/utama_core/tests/analysis/test_field_physics.py b/utama_core/tests/analysis/test_field_physics.py new file mode 100644 index 00000000..e012fbff --- /dev/null +++ b/utama_core/tests/analysis/test_field_physics.py @@ -0,0 +1,152 @@ +"""Unit tests for tools/field_physics.py: the register filter, step delays, ball rolls, agreement. + +No real logs and no rsim: the ball roll is checked on a synthetic ball with a known deceleration. +""" + +from __future__ import annotations + +import types + +import numpy as np +import pytest + +from tools import field_physics + + +def _group(median: float, n: int) -> dict: + return {"median": median, "lo": median, "hi": median, "n": n} + + +# allowed + + +def test_allowed_listed_measurement_true_unlisted_false(): + register = {"sessions": {"20261028": {"use": ["loop_delay", "ball_roll"]}}} + assert field_physics.allowed(register, "20261028", "loop_delay") is True + assert field_physics.allowed(register, "20261028", "ball_noise") is False + + +def test_allowed_unregistered_day_false(): + register = {"sessions": {"20261028": {"use": ["loop_delay"]}}} + assert field_physics.allowed(register, "20261030", "loop_delay") is False + + +def test_allowed_on_real_register(): + register = field_physics.load_register() + for measurement in field_physics.MEASUREMENTS: + assert field_physics.allowed(register, "20261021", measurement) is False + assert field_physics.allowed(register, "20261029", "loop_delay") is False + assert field_physics.allowed(register, "20261029", "ball_noise") is True + + +# step_delays_ms + + +def test_step_delays_commanded_boundary(): + steps = [ + {"axis": "forward", "commanded": 0.3, "delay_s": 0.05}, + {"axis": "forward", "commanded": 0.29, "delay_s": 0.05}, + ] + assert field_physics.step_delays_ms(steps) == pytest.approx([50.0]) + + +def test_step_delays_excludes_turn_zero_delay_and_missing_delay(): + steps = [ + {"axis": "turn", "commanded": 1.0, "delay_s": 0.05}, + {"axis": "left", "commanded": -0.5, "delay_s": 0.06}, + {"axis": "forward", "commanded": 0.5, "delay_s": 0.0}, + {"axis": "forward", "commanded": 0.5}, + ] + assert field_physics.step_delays_ms(steps) == pytest.approx([60.0]) + + +# ball_rolls + + +def _synthetic_log(robots: dict | None = None, duration: float = 4.0): + """A ball rolling from x=0 at 2 m/s with deceleration 0.25 m/s^2, seen at 60 Hz by one camera.""" + t = np.arange(0.0, duration, 1 / 60) + x = 2.0 * t - 0.5 * 0.25 * t**2 + balls = np.column_stack([t, np.zeros_like(t), x, np.zeros_like(t)]) + return types.SimpleNamespace(balls=balls, robots=robots or {}) + + +BOUNDS = ((-4.5, 3.0), (4.5, -3.0)) +KICK = [{"t": 0.0, "ball_speed": 2.0, "chip": False}] + + +def test_ball_rolls_recovers_known_decel(): + rolls = field_physics.ball_rolls(_synthetic_log(), KICK, BOUNDS) + assert len(rolls) == 1 + assert rolls[0]["decel"] == pytest.approx(0.25, abs=0.01) + assert rolls[0]["rms_mm"] < 1.0 + + +def test_ball_rolls_truncated_by_robot_in_path_does_not_crash(): + # A robot 2.5 m along the ball's path stops the fit early: a shorter fit, still the right decel. + robot = np.column_stack( + [np.arange(0.0, 4.0, 1 / 60), np.zeros(240), np.full(240, 2.5), np.zeros(240), np.zeros(240)] + ) + rolls = field_physics.ball_rolls(_synthetic_log(robots={("yellow", 3): robot}), KICK, BOUNDS) + assert len(rolls) == 1 + assert rolls[0]["decel"] == pytest.approx(0.25, abs=0.01) + assert rolls[0]["secs"] < 1.5 + + +def test_ball_rolls_robot_at_half_metre_leaves_no_fit(): + # A robot 0.5 m along the path is already inside the 0.25 m exclusion when the fit starts (0.3 s): + # no fit, and no crash. + robot = np.column_stack( + [np.arange(0.0, 4.0, 1 / 60), np.zeros(240), np.full(240, 0.5), np.zeros(240), np.zeros(240)] + ) + assert field_physics.ball_rolls(_synthetic_log(robots={("yellow", 3): robot}), KICK, BOUNDS) == [] + + +# agreement + + +def test_agreement_close_medians_agree(): + groups = {("20261028", 0): _group(0.20, 10), ("20261027", None): _group(0.25, 10)} + res = field_physics.agreement(groups, tolerance=0.25) + # highest - lowest = 0.05 must be <= 0.25 * median(0.20, 0.25) = 0.05625 + assert 0.25 - 0.20 <= 0.25 * np.median([0.20, 0.25]) + assert res["agree"] is True + assert res["medians"] == [0.20, 0.25] + assert res["groups_used"] == 2 + + +def test_agreement_exact_boundary_agrees(): + # 9 - 7 = 2.0 equals 0.25 * median(7, 9) = 2.0: exactly equal counts as agreeing. + groups = {("a", 0): _group(7.0, 10), ("b", 0): _group(9.0, 10)} + assert field_physics.agreement(groups, tolerance=0.25)["agree"] is True + + +def test_agreement_just_past_boundary_disagrees(): + groups = {("a", 0): _group(7.0, 10), ("b", 0): _group(9.01, 10)} + assert field_physics.agreement(groups, tolerance=0.25)["agree"] is False + + +def test_agreement_clearly_larger_spread_disagrees(): + groups = {("20261028", 0): _group(0.20, 10), ("20261027", None): _group(0.40, 10)} + res = field_physics.agreement(groups, tolerance=0.25) + assert res["agree"] is False + assert res["groups_used"] == 2 + + +def test_agreement_ignores_groups_below_min_n(): + groups = { + ("20261028", 0): _group(0.20, 10), + ("20261027", None): _group(0.25, 10), + ("20261028", 1): _group(0.90, 4), + } + res = field_physics.agreement(groups) + assert res["groups_used"] == 2 + assert res["medians"] == [0.20, 0.25] + assert res["agree"] is True + + +def test_agreement_one_usable_group_is_none(): + groups = {("20261028", 0): _group(0.20, 10), ("20261028", 1): _group(0.90, 4)} + res = field_physics.agreement(groups) + assert res["agree"] is None + assert res["groups_used"] == 1 diff --git a/utama_core/tests/rsoccer_simulator/test_real_kick.py b/utama_core/tests/rsoccer_simulator/test_real_kick.py deleted file mode 100644 index 573f9959..00000000 --- a/utama_core/tests/rsoccer_simulator/test_real_kick.py +++ /dev/null @@ -1,73 +0,0 @@ -"""rsim kicks a robot with a calibrated kicker (`RealKick`) at its measured ball speed, off its -heading by its bias, bent towards the side the ball sits on the dribbler, scattered by its spread; -a robot without one keeps the sim's kick.""" - -import math - -import numpy as np -import pytest - -from utama_core.config.physical_constants import ROBOT_RADIUS -from utama_core.config.robot_params import RSIM_PARAMS -from utama_core.rsoccer_simulator.src.ssl.envs.standard_ssl import SSLStandardEnv -from utama_core.rsoccer_simulator.src.Utils.real_kick import RealKick, RealKicks -from utama_core.team_controller.src.controllers.common.robot_profile import RobotProfile - -STILL = {"team_yellow": (np.zeros(5, np.float32),), "team_blue": ()} -KICK = {"team_yellow": (np.array([0, 0, 0, 1, 0], np.float32),), "team_blue": ()} - - -@pytest.fixture(scope="module") -def env(): - env = SSLStandardEnv(n_robots_yellow=1, n_robots_blue=0, render_mode=None) - env.reset() - return env - - -def kick(env, real: RealKick = None, ball_left=0.0): - """(direction in degrees anticlockwise of the robot's heading, top speed) of one kick.""" - env.real_kicks = RealKicks({("team_yellow", 0): real}) if real else None - env.teleport_robot(True, 0, 0.0, 0.0, 0.0) - env.teleport_ball(ROBOT_RADIUS + 0.025, ball_left) - env.step(KICK) - speeds = [] - for _ in range(10): - env.step(STILL) - speeds.append(math.hypot(env.frame.ball.v_x, env.frame.ball.v_y)) - b = env.frame.ball # the sim's y is ours mirrored - return math.degrees(math.atan2(-b.v_y, b.v_x)), max(speeds) - - -def test_the_ball_leaves_at_the_robots_measured_speed(env): - assert kick(env, RealKick(speed=2.19))[1] == pytest.approx(2.19, abs=0.03) - assert kick(env)[1] == pytest.approx(RSIM_PARAMS.KICK_SPD, abs=0.3) # no profile: the sim's - - -def test_bias_and_bend_turn_the_kick_anticlockwise_towards_the_balls_side(env): - assert kick(env, RealKick(bias_deg=20.0))[0] == pytest.approx(20.0, abs=1.5) - assert kick(env, RealKick(bend_deg_per_cm=5.0), ball_left=0.02)[0] == pytest.approx(10.0, abs=1.5) - assert kick(env, RealKick(bend_deg_per_cm=5.0), ball_left=-0.02)[0] == pytest.approx(-10.0, abs=1.5) - - -def test_spread_scatters_kicks_by_its_sd_the_same_way_for_a_seed(): - def angles(seed): - kicks = RealKicks({("team_yellow", 0): RealKick(spread_deg=9.0)}, seed=seed) - out = [] - for _ in range(400): - out.append(math.degrees(kicks.angle(("team_yellow", 0), True, 0.0))) - kicks.angle(("team_yellow", 0), False, 0.0) # the kick command ends - return out - - assert np.std(angles(0)) == pytest.approx(9.0, rel=0.15) - assert angles(0) == angles(0) and angles(0) != angles(1) - - -def test_a_kick_held_over_several_ticks_keeps_one_direction(): - kicks = RealKicks({("team_yellow", 0): RealKick(spread_deg=9.0)}) - first = kicks.angle(("team_yellow", 0), True, 0.0) - assert kicks.angle(("team_yellow", 0), True, 0.03) == first - - -def test_only_a_profile_that_measured_its_kick_has_one(): - assert RealKick.of(RobotProfile()) is None - assert RealKick.of(RobotProfile(kick_bias_deg=2.7, kick_speed=2.19)) == RealKick(2.19, 0.0, 2.7, 0.0) diff --git a/utama_core/tests/strategy_runner/test_kick_bend_wiring.py b/utama_core/tests/strategy_runner/test_kick_bend_wiring.py index 72fcb1d3..c0d989a0 100644 --- a/utama_core/tests/strategy_runner/test_kick_bend_wiring.py +++ b/utama_core/tests/strategy_runner/test_kick_bend_wiring.py @@ -1,7 +1,7 @@ """`StrategyRunner` gives a team's motion controller its profiled robots' kick bends, in rad per metre off-centre (`RobotProfile.kick_bend_deg_per_cm`), and biases, in rad (`kick_bias_deg`), on -real robots and in rsim (which kicks them so, `real_kick.py`) but not grSim (which kicks along the -heading); their carry caps in every mode; and on real robots only its vision the tags' offsets.""" +real robots only: the sims (rsim and grSim) keep their own kick. Carry caps apply in every mode, +and real robots alone get the vision tags' offsets.""" import math from types import SimpleNamespace @@ -21,8 +21,8 @@ _BEND = {1: math.radians(4.7) * 100.0} -@pytest.mark.parametrize("mode, expected", [(Mode.REAL, _BEND), (Mode.RSIM, _BEND), (Mode.GRSIM, {})]) -def test_profiled_robots_get_their_kick_bend_except_in_grsim(mode, expected): +@pytest.mark.parametrize("mode, expected", [(Mode.REAL, _BEND), (Mode.RSIM, {}), (Mode.GRSIM, {})]) +def test_profiled_robots_get_their_kick_bend_on_real_robots_only(mode, expected): runner = SimpleNamespace(mode=mode, rsim_env=None) team = SimpleNamespace(motion_controller=FastPathPlanningController) @@ -34,8 +34,8 @@ def test_profiled_robots_get_their_kick_bend_except_in_grsim(mode, expected): _BIAS = {3: math.radians(2.3)} -@pytest.mark.parametrize("mode, expected", [(Mode.REAL, _BIAS), (Mode.RSIM, _BIAS), (Mode.GRSIM, {})]) -def test_profiled_robots_get_their_kick_bias_except_in_grsim(mode, expected): +@pytest.mark.parametrize("mode, expected", [(Mode.REAL, _BIAS), (Mode.RSIM, {}), (Mode.GRSIM, {})]) +def test_profiled_robots_get_their_kick_bias_on_real_robots_only(mode, expected): runner = SimpleNamespace(mode=mode, rsim_env=None) team = SimpleNamespace(motion_controller=FastPathPlanningController) @@ -61,16 +61,3 @@ def test_profiled_robots_get_their_own_carry_caps_and_the_team_cap_where_unset(m controller = StrategyRunner._motion_controller(runner, team, profiles) assert controller.robot_carry == {0: (0.7, controller.carry_turn), 1: (controller.carry_speed, 3.0)} - - -def test_rsim_kicks_the_profiled_robots_that_measured_their_kick_and_no_others(): - runner = SimpleNamespace( - yellow_robot_profiles={0: RobotProfile(kick_speed=2.19, kick_bias_deg=2.7), 1: RobotProfile()}, - blue_robot_profiles={0: RobotProfile(kick_spread_deg=9.1)}, - ) - kicks = StrategyRunner._real_kicks(runner, None) - assert set(kicks.kicks) == {("team_yellow", 0), ("team_blue", 0)} - assert kicks.kicks[("team_yellow", 0)].speed == 2.19 - - unprofiled = SimpleNamespace(yellow_robot_profiles={}, blue_robot_profiles={0: RobotProfile()}) - assert StrategyRunner._real_kicks(unprofiled, None) is None # the evaluation's matches keep the sim's kick diff --git a/utama_core/tests/strategy_runner/test_sim_pose_ahead.py b/utama_core/tests/strategy_runner/test_sim_pose_ahead.py new file mode 100644 index 00000000..18a4b3c6 --- /dev/null +++ b/utama_core/tests/strategy_runner/test_sim_pose_ahead.py @@ -0,0 +1,34 @@ +"""rsim with simulated delay compensates for it the way real robots do; without delay it must not.""" + +from types import SimpleNamespace + +import pytest + +from utama_core.config.enums import Mode +from utama_core.config.robot_params import REAL_PARAMS +from utama_core.motion_planning.src.controllers.fastpathplanning import ( + FastPathPlanningController, +) +from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.run.strategy_runner import StrategyRunner + +TEAM = SimpleNamespace(motion_controller=FastPathPlanningController) + + +def latency(mode, rsim_env): + runner = SimpleNamespace(mode=mode, rsim_env=rsim_env) + return StrategyRunner._motion_controller(runner, TEAM, {}).pose_ahead.latency_s + + +def test_rsim_looks_ahead_by_the_middle_of_its_simulated_delay(): + env = SimpleNamespace(sim_noise=SimNoise(latency_s=(0.05, 0.09))) + assert latency(Mode.RSIM, env) == pytest.approx(0.07) + + +@pytest.mark.parametrize("env", [None, SimpleNamespace(sim_noise=None), SimpleNamespace(sim_noise=SimNoise())]) +def test_rsim_without_delay_does_not_look_ahead(env): + assert latency(Mode.RSIM, env) == 0.0 + + +def test_real_robots_keep_their_own_setting(): + assert latency(Mode.REAL, None) == REAL_PARAMS.CONTROL_LATENCY_S From 06592399d595d1dd96fbc41800e91a00879b8723 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:44 +0000 Subject: [PATCH 02/59] referee: fix restart rules and the free-kick actions Fixes to the in-process referee and the restart actions robots run under it, with tests. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- docs/custom_referee.md | 2 +- docs/custom_referee_design_decisions.md | 2 +- utama_core/custom_referee/actions.py | 193 +++++++++++++++--- .../custom_referee/profiles/simulation.yaml | 2 +- .../custom_referee/rules/ball_speed_rule.py | 23 ++- .../custom_referee/rules/double_touch_rule.py | 19 +- .../custom_referee/rules/keep_out_rule.py | 5 +- utama_core/custom_referee/state_machine.py | 56 +---- .../custom_referee/test_custom_referee.py | 84 ++++++-- .../tests/engine/test_referee_override.py | 10 +- .../test_referee_overrides_customization.py | 1 + utama_core/tests/referee/test_referee_unit.py | 129 +++++++++++- .../strategy_runner/test_referee_rsim.py | 4 +- 13 files changed, 407 insertions(+), 123 deletions(-) diff --git a/docs/custom_referee.md b/docs/custom_referee.md index 5568f211..196e1d2f 100644 --- a/docs/custom_referee.md +++ b/docs/custom_referee.md @@ -61,7 +61,7 @@ Built in `_build_active_rules` (`custom_referee.py`), in this priority order; de |---|---|---| | 1 | `STOP` → queued restart | all robots ≥0.5m from ball (15s clear timeout) | | 2 | `PREPARE_KICKOFF_*`/`PREPARE_PENALTY_*` → `NORMAL_START` | prepare timer + kicker in position (kick-off: and every robot in its own half, waited for at most 10 s past the prepare timer, `_KICKOFF_POSITIONING_CAP_S`), held 2s | -| 3 | `DIRECT_FREE_*` → `NORMAL_START` | the free kick is taken: the ball has moved ≥0.05m from where it was when the command began (at once, from any kick during the preparation); or kicker ≤0.3m from ball, defenders ≥0.5m, held 2s | +| 3 | `DIRECT_FREE_*` → `NORMAL_START` | the free kick is taken: the ball has moved ≥0.05m from where it was when the command began (at once). Not taken within 10 s: `FORCE_START` | | 4 | `BALL_PLACEMENT_*` → next command | ball ≤0.15m from target, held 2s (10s placement timeout) | | 5 | `NORMAL_START` → `FORCE_START` | `kickoff_timeout_seconds` elapsed and ball unmoved | | 6 | end of a half → second half, then `POST_GAME` | the half's playing time (`half_duration_seconds`) used up | diff --git a/docs/custom_referee_design_decisions.md b/docs/custom_referee_design_decisions.md index e1245330..3a3c9610 100644 --- a/docs/custom_referee_design_decisions.md +++ b/docs/custom_referee_design_decisions.md @@ -71,7 +71,7 @@ Checked against the [SSL rulebook](https://robocup-ssl.github.io/ssl-rules/sslru | Free-kick position (§5.3.3) | ≥ 0.2 m from all lines and ≥ 1 m from either defense area, else the closest valid spot | 0.65 m from a defense area (planner margin) | Fixed: 1 m. Sim: the spot is pushed out along x only (a square corner), not to the Euclidean closest point, and lines aren't re-clamped for in-field positions | | Throw-in, goal kick, corner kick (§6.1.1, §6.2.1–2) | Throw-in 0.2 m in from the touch line; goal kick 1 m / 0.2 m; corner kick 0.2 m / 0.2 m, in the corner | Ball placed where it crossed, 0.25 m infield, 0.5 m on both axes near a corner, then kept 1 m off the box | Fixed: over a goal line, a corner kick 0.5 m from both lines or a goal kick 1 m from the goal line, 0.5 m from the touch line, the same spot as every other goal kick (`RefereeGeometry.goal_kick_position`; a disallowed goal or a penalty out of time put it 0.2 m from the touch line) (placing it where it crossed made a free kick 2 m in front of goal: 521 kicks, 150 goals in one round-robin). Sim: 0.5 m, not 0.2 m, from the touch line, and a throw-in stays 0.25 m in; 0.2 m from two lines at once let a drifting ball go straight back out (the corner-loop fix in `OutOfBoundsRule`) | | Aimless kick (§6.2.3, Div B) | A ball touched by a robot that then crosses the halfway line and the opponent's goal line outside the goal, touching no other robot: free kick for the opponent from where it was kicked | Not implemented: a goal kick in the opponent's corner, so a blind clearance cost nothing (28% of goal kicks led to one at the other end within seconds, tournament_20261005_170958) | Fixed: `OutOfBoundsRule` keeps where the ball was last touched in this spell of play (`last_touch.touching_team`), and restarts from there when the touch was on the far side of the halfway line, strictly (a kick-off from the line itself is not aimless); the spot is kept 0.25 m inside the lines and 1 m off the defense areas like any free kick. `out_of_bounds.aimless_kick`, on in both profiles: we play Division B | -| Free kick stages (§5.3.3) | One free-kick command; the kick puts the ball in play | `DIRECT_FREE_*` preparation, then `NORMAL_START` once the kicker is ready | Sim: kept. The two stages give the auto-advance a readiness check with no human referee. A kick during the preparation stage ends it too: the ball moved 0.05 m from where it was when the command began, so `NORMAL_START` (live play, as after a ready kick) and `KeepOutRule` stops. Before, the referee missed the kick and charged a defender the ball rolled onto with keep_out (`free_kick_robot_drives_in_at_start`). Auto-advance profiles only (`direct_free_to_normal`); a human-run referee issues `NORMAL_START` itself | +| Free kick stages (§5.3.3) | One free-kick command; the kick puts the ball in play | One free-kick command; `DirectFreeOursStep` takes the kick and the ball moving 0.05 m from where it was when the command began makes it `NORMAL_START` (live play, and `KeepOutRule` stops). Fixed 2026-11-10: the referee also started play 2 s after the kicker came near, before any kick, and the tactics then stood over an unstruck ball. Before, the referee missed the kick and charged a defender the ball rolled onto with keep_out (`free_kick_robot_drives_in_at_start`). Auto-advance profiles only (`direct_free_to_normal`); a human-run referee issues `NORMAL_START` itself | | Ball placement (§5.2) | The team places the ball | With a simulator controller, `StrategyRunner` teleports the ball to `designated_position` on entry to `BALL_PLACEMENT_*`, then the restart itself follows (only a `STOP` queued for `FORCE_START`, no progress, force-starts) | Sim: kept, so matches don't wait on physical placement. Real mode still places | | Multiple Defenders (§8.4.1) | A non-keeper entirely inside its own area touching the ball: penalty | More than `max_defenders` (1) with centres inside, one touching | Fixed: the goalkeeper's own touch is exempt. The keeper id comes from the referee data on the frame (`GameFrame.referee`, the team info's `goalkeeper`); with no referee data attached every touch counts. The occupancy proxy (`max_defenders`) is kept | | Double Touch (§8.2) | Kicker may not touch again before another robot; free kick from the ball position | Same | Already correct | diff --git a/utama_core/custom_referee/actions.py b/utama_core/custom_referee/actions.py index 06c2188c..9989c1c6 100644 --- a/utama_core/custom_referee/actions.py +++ b/utama_core/custom_referee/actions.py @@ -10,6 +10,7 @@ """ import math +from typing import Optional from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.config.referee_constants import ( @@ -25,12 +26,30 @@ from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D +from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.global_utils.math_utils import ( detour_around_circle, distance_point_to_segment, ) +from utama_core.shared.pass_and_score_geometry import ( + enemy_goal_line, + has_ball, + kick_bend, + open_teammate, + oriented_towards, + restart_support, +) from utama_core.shared.tolerance import Sticky -from utama_core.skills.src.utils.move_utils import empty_command, move, turn_on_spot +from utama_core.skills.src.man_mark import mark_target +from utama_core.skills.src.utils.move_utils import ( + empty_command, + kick, + move, + turn_on_spot, +) + +_WALL_FROM_BALL_M = BALL_KEEP_OUT_DISTANCE + 0.15 +_STOP_FORMATION_SPEED_MPS = 1.2 # under RobotStopSpeedRule's limit def _all_stop(blackboard) -> None: @@ -453,13 +472,19 @@ class StopStep: """Moves encroaching robots out of the keep-out radius and stops the rest.""" def update(self) -> None: + game = self.blackboard.game + next_is_theirs = _next_is_their_free_kick(game) _clear_to_legal_positions( self.blackboard, ball_keep_dist=BALL_KEEP_OUT_DISTANCE, clear_opp_defense_area=True, clear_own_defense_area=True, max_own_defenders=1, + intended_targets=their_free_kick_targets(game) if next_is_theirs else None, ) + if next_is_theirs: + for robot_id, command in self.blackboard.cmd_map.items(): + self.blackboard.cmd_map[robot_id] = _capped_speed(command, _STOP_FORMATION_SPEED_MPS) # --------------------------------------------------------------------------- @@ -978,11 +1003,16 @@ def update(self) -> None: class DirectFreeOursStep: - """Positions our robots for our direct free kick. + """Takes our direct free kick. + + The robot closest to the ball becomes the kicker, gets behind it and kicks it + to an open teammate. With none in range the nearest teammate comes to a spot + towards the enemy goal first; only if there is no such spot does it shoot. All + other robots stop in place, the teammate being kicked to facing the ball. - The robot closest to the ball becomes the kicker and approaches from the - field-inward side so it cannot push the ball out of bounds. - All other robots stop in place. + It used to stand behind the ball and leave the kick to the tactics once the + referee started play, which a real game controller does not do, and the taker + walked off or stood there for up to 10 s (round-robin of 2026-11-09). """ # How close the robot center should get behind the ball before turning/kicking. @@ -990,6 +1020,11 @@ class DirectFreeOursStep: _APPROACH_READY_DISTANCE = 0.04 _KICK_READY_DISTANCE = 0.16 _FACE_READY_ANGLE = 0.18 + # A receiver facing the ball within 10 degrees catches 95% of passes, 10-20 degrees 7%. + _RECEIVER_READY_ANGLE = 0.17 + _RECEIVER_AT_SPOT_M = 0.1 + _KEEP_OUT_EDGE_M = 0.05 + _NEW_RESTART_M = 0.05 # the ball this far from where the target was chosen is another free kick # Robot-body clearance only, not the full OPPONENT_DEFENSE_AREA_KEEP_ # DISTANCE (0.25m) `StopStep`/`_clear_to_legal_positions` use for general @@ -1026,21 +1061,38 @@ class DirectFreeOursStep: def __init__(self): self._kicker_sticky = Sticky[int](margin=self._KICKER_REASSIGN_MARGIN_M) + self._target: Optional[tuple[int, Vector2D, Optional[int], Optional[Vector2D], float]] = None @staticmethod def _angle_error(current: float, target: float) -> float: return math.atan2(math.sin(target - current), math.cos(target - current)) - def _nearest_enemy_to_ball(self, game, ball_pos: Vector2D): - if not game.enemy_robots: - return None, None - enemy_id = min(game.enemy_robots, key=lambda rid: game.enemy_robots[rid].p.distance_to(ball_pos)) - return enemy_id, game.enemy_robots[enemy_id] - - def _kick_target_enemy(self, game, ball_pos: Vector2D): - if 1 in game.enemy_robots: - return 1, game.enemy_robots[1] - return self._nearest_enemy_to_ball(game, ball_pos) + def _kick_target(self, game, kicker_id: int, ball_pos: Vector2D) -> tuple[Optional[int], Optional[Vector2D], float]: + """(teammate or None, the spot it must come to or None, heading from the ball). Chosen once a + free kick: a target flipping as lanes open and shut would send the kicker round the ball again. + Only the teammate is fixed: the heading follows it, once it is at any spot it was called to.""" + target = self._target + if target is None or target[0] != kicker_id or target[1].distance_to(ball_pos) > self._NEW_RESTART_M: + teammate = open_teammate(game, kicker_id, origin=ball_pos) + spot = None + if teammate is not None: + point = game.friendly_robots[teammate].p + else: + support = restart_support(game, kicker_id, ball_pos) + if support is not None: + teammate, spot = support + point = spot + else: + goal_x, goal_y1, goal_y2 = enemy_goal_line(game) + point = Vector2D(goal_x, (goal_y1 + goal_y2) / 2.0) + target = self._target = (kicker_id, ball_pos, teammate, spot, ball_pos.angle_to(point)) + teammate, spot, heading = target[2:] + if teammate in game.friendly_robots: + position = game.friendly_robots[teammate].p + if spot is None or position.distance_to(spot) <= self._RECEIVER_AT_SPOT_M: + # Who is fixed, where it stands is not: it has moved since, by 0.17 m at 2 m in a kick that missed. + heading = ball_pos.angle_to(position) + return teammate, spot, heading def update(self) -> None: game = self.blackboard.game @@ -1053,18 +1105,32 @@ def update(self) -> None: distances = {rid: game.friendly_robots[rid].p.distance_to(ball.p) for rid in game.friendly_robots} kicker_id = self._kicker_sticky.update(list(distances), score_fn=lambda rid: -distances[rid]) + receiver_command = None for robot_id in game.friendly_robots: if robot_id == kicker_id: robot = game.friendly_robots[robot_id] ball_pos = Vector2D(ball.p.x, ball.p.y) distance_to_ball = robot.p.distance_to(ball_pos) - _, enemy = self._kick_target_enemy(game, ball_pos) - - if enemy is None: - target_oren = robot.p.angle_to(ball_pos) - else: - target_oren = ball_pos.angle_to(enemy.p) + receiver_id, receiver_spot, kick_heading = self._kick_target(game, kicker_id, ball_pos) + target_oren = kick_heading - kick_bend(game, motion_controller, robot_id) + receiver_ready = True + if receiver_id in game.friendly_robots: + receiver = game.friendly_robots[receiver_id] + to_ball = receiver.p.angle_to(ball_pos) + if receiver_spot is not None and receiver.p.distance_to(receiver_spot) > self._RECEIVER_AT_SPOT_M: + receiver_ready = False + receiver_command = ( + receiver_id, + move(game, motion_controller, receiver_id, receiver_spot, receiver_spot.angle_to(ball_pos)), + ) + else: + receiver_ready = oriented_towards(game, receiver_id, to_ball, self._RECEIVER_READY_ANGLE) + if not receiver_ready: + receiver_command = ( + receiver_id, + turn_on_spot(game, motion_controller, receiver_id, to_ball), + ) kick_dir = Vector2D(math.cos(target_oren), math.sin(target_oren)) approach = Vector2D( @@ -1098,17 +1164,38 @@ def update(self) -> None: ) elif distance_to_ball > self._KICK_READY_DISTANCE: self.blackboard.cmd_map[robot_id] = move(game, motion_controller, robot_id, approach, target_oren) - else: + elif not receiver_ready: self.blackboard.cmd_map[robot_id] = empty_command(False) + elif has_ball(game, robot_id): + self.blackboard.cmd_map[robot_id] = kick() + else: + self.blackboard.cmd_map[robot_id] = move( + game, motion_controller, robot_id, ball_pos, target_oren, dribbling=True + ) + exempt = {kicker_id} + # A robot cleared in the stoppage stands a millimetre inside the circle, and clearing it again + # pointed it away from the ball: the receiver never turned and 69 free kicks timed out (2026-11-10). + if ( + receiver_command is not None + and BALL_KEEP_OUT_DISTANCE - self._KEEP_OUT_EDGE_M + <= distances[receiver_command[0]] + < BALL_KEEP_OUT_DISTANCE + ): + exempt.add(receiver_command[0]) _clear_to_legal_positions( self.blackboard, ball_keep_dist=BALL_KEEP_OUT_DISTANCE, clear_opp_defense_area=True, clear_own_defense_area=True, max_own_defenders=1, - exempt_robot_ids={kicker_id}, + exempt_robot_ids=exempt, ) + # That stops every robot already standing legally; this one still has to get ready. + if receiver_command is not None and ( + receiver_command[0] in exempt or self.blackboard.cmd_map[receiver_command[0]] == empty_command(False) + ): + self.blackboard.cmd_map[receiver_command[0]] = receiver_command[1] # --------------------------------------------------------------------------- @@ -1116,6 +1203,65 @@ def update(self) -> None: # --------------------------------------------------------------------------- +def _next_is_their_free_kick(game) -> bool: + command = getattr(game.referee, "next_command", None) + if game.my_team_is_yellow: + return command in (RefereeCommand.DIRECT_FREE_BLUE, RefereeCommand.INDIRECT_FREE_BLUE) + return command in (RefereeCommand.DIRECT_FREE_YELLOW, RefereeCommand.INDIRECT_FREE_YELLOW) + + +def their_free_kick_targets(game) -> dict[int, Vector2D]: + """Where to stand for an opponent's free kick: the nearest robot in the wall on the ball's line + to our goal, and each other one goal-side of a receiver, those nearest our goal first. Standing + wherever the stop left them, a side conceded 1.35 goals a match from free kicks (`docs/signals.md`). + The keeper keeps its own job.""" + ball = game.ball + if ball is None: + return {} + ref = game.referee + keeper_id = (ref.yellow_team if game.my_team_is_yellow else ref.blue_team).goalkeeper + ball_pos = Vector2D(ball.p.x, ball.p.y) + free = { + rid: robot.p + for rid, robot in game.friendly_robots.items() + if rid != keeper_id and not _must_clear_first(game, robot.p, ball_pos) + } + if not free: + return {} + goal = Vector2D(float(game.field.my_goal_line[0][0]), 0.0) + wall = _outside_own_defense_area(game, ball_pos + (goal - ball_pos).norm() * _WALL_FROM_BALL_M) + targets: dict[int, Vector2D] = {} + wall_robot = min(free, key=lambda rid: free[rid].distance_to(wall)) + targets[wall_robot] = wall + del free[wall_robot] + + enemies = sorted(game.enemy_robots, key=lambda eid: game.enemy_robots[eid].p.distance_to(ball_pos))[1:] + enemies.sort(key=lambda eid: game.enemy_robots[eid].p.distance_to(goal)) + for enemy_id in enemies: + if not free: + break + mark = _outside_own_defense_area(game, mark_target(game, enemy_id)) + marker = min(free, key=lambda rid: free[rid].distance_to(mark)) + targets[marker] = mark + del free[marker] + return targets + + +def _must_clear_first(game, position: Vector2D, ball_pos: Vector2D) -> bool: + """Inside the keep-out circle or a defense area: on its way out before it takes up a spot.""" + return ( + position.distance_to(ball_pos) < BALL_KEEP_OUT_DISTANCE + or _is_in_own_defense_area(game, position.x, position.y) + or _project_outside_opp_defense_area(game, position, OPPONENT_DEFENSE_AREA_KEEP_DISTANCE) != position + ) + + +def _outside_own_defense_area(game, point: Vector2D) -> Vector2D: + return ( + Vector2D(_own_defense_area_exit_x(game), point.y) if _is_in_own_defense_area(game, point.x, point.y) else point + ) + + class DirectFreeTheirsStep: """Actively clear our robots out of the ball keep-out radius and defense areas.""" @@ -1126,4 +1272,5 @@ def update(self) -> None: clear_opp_defense_area=True, clear_own_defense_area=True, max_own_defenders=1, + intended_targets=their_free_kick_targets(self.blackboard.game), ) diff --git a/utama_core/custom_referee/profiles/simulation.yaml b/utama_core/custom_referee/profiles/simulation.yaml index 30b6a600..cda81c2b 100644 --- a/utama_core/custom_referee/profiles/simulation.yaml +++ b/utama_core/custom_referee/profiles/simulation.yaml @@ -64,7 +64,7 @@ game: stop_to_next_command: true # STOP → queued restart when all robots clear prepare_kickoff_to_normal: true # PREPARE_KICKOFF_* → NORMAL_START when kicker in circle prepare_penalty_to_normal: true # PREPARE_PENALTY_* → NORMAL_START when kicker reaches the mark - direct_free_to_normal: true # DIRECT_FREE_* → NORMAL_START when kicker ready + direct_free_to_normal: true # DIRECT_FREE_* → NORMAL_START when the kick is taken ball_placement_to_next: true # BALL_PLACEMENT_* → next_command when ball at target normal_start_to_force: true # NORMAL_START → FORCE_START on kickoff timeout end_of_half: true # half's playing time up → second half, then POST_GAME diff --git a/utama_core/custom_referee/rules/ball_speed_rule.py b/utama_core/custom_referee/rules/ball_speed_rule.py index 173ce040..42f822b2 100644 --- a/utama_core/custom_referee/rules/ball_speed_rule.py +++ b/utama_core/custom_referee/rules/ball_speed_rule.py @@ -11,6 +11,11 @@ from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +# Frames in a row over the limit before it counts. 67-91% of the calls in the round-robins of +# 2026-11-09 were one frame, up to 39 m/s, with the robot's kick at a median 5.3 m/s: vision noise +# in the ball's velocity, not a kick. +_FRAMES_OVER_LIMIT = 2 + _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START, @@ -24,14 +29,14 @@ class BallSpeedRule(BaseRule): Only the ball's ground speed (x/y) counts — a bounce's z-velocity is not part of the kick-speed rule and would otherwise cause false positives. - Edge-detected: fires once when the ball crosses above the limit, not - every frame it remains fast, mirroring how a real kick is a single - event rather than a sustained state. + Fires once when the ball has been over the limit for `_FRAMES_OVER_LIMIT` + frames in a row, not every frame it remains fast, mirroring how a real + kick is a single event rather than a sustained state. """ def __init__(self, max_speed_mps: float = 6.5) -> None: self._max_speed = max_speed_mps - self._was_over_limit = False + self._frames_over_limit = 0 # True = friendly last touched, False = enemy, None = unknown. # Maintained colour-blind by `infer_last_touch_team` (see last_touch.py). self._last_touch_was_friendly: Optional[bool] = None @@ -46,7 +51,7 @@ def check( designated_position: Optional[tuple[float, float]] = None, ) -> Optional[RuleViolation]: if current_command not in _ACTIVE_PLAY_COMMANDS: - self._was_over_limit = False + self._frames_over_limit = 0 self._prev_ball_v = None # the ball may be moved or placed while play is stopped return None @@ -60,11 +65,9 @@ def check( self._prev_ball_v = (ball.v.x, ball.v.y) speed = math.hypot(ball.v.x, ball.v.y) - is_over_limit = speed > self._max_speed - rising_edge = is_over_limit and not self._was_over_limit - self._was_over_limit = is_over_limit + self._frames_over_limit = self._frames_over_limit + 1 if speed > self._max_speed else 0 - if not rising_edge or self._last_touch_was_friendly is None: + if self._frames_over_limit != _FRAMES_OVER_LIMIT or self._last_touch_was_friendly is None: return None # SSL rulebook §8.4.2 "Ball Speed" is a non-stopping foul: the kicking @@ -82,5 +85,5 @@ def check( ) def reset(self) -> None: - self._was_over_limit = False + self._frames_over_limit = 0 self._last_touch_was_friendly = None diff --git a/utama_core/custom_referee/rules/double_touch_rule.py b/utama_core/custom_referee/rules/double_touch_rule.py index ac052f27..6a1ecd38 100644 --- a/utama_core/custom_referee/rules/double_touch_rule.py +++ b/utama_core/custom_referee/rules/double_touch_rule.py @@ -82,6 +82,9 @@ def __init__(self) -> None: self._kicker: Optional[RobotKey] = None self._kicking_team_is_yellow: Optional[bool] = None self._had_ball_last_frame: set[RobotKey] = set() + # The kicking team's robot on the ball while the restart was still being prepared. A free + # kick is struck under DIRECT_FREE_*: it is the kicker, not the first robot to receive it. + self._restart_toucher: Optional[RobotKey] = None def check( self, @@ -90,15 +93,20 @@ def check( current_command: RefereeCommand, designated_position: Optional[tuple[float, float]] = None, ) -> Optional[RuleViolation]: + if current_command in _RESTART_COMMANDS: + self._restart_toucher = self._toucher_of_kicking_team(game_frame, current_command) or self._restart_toucher if current_command == RefereeCommand.NORMAL_START and self._prev_command in _RESTART_COMMANDS: self._armed = True - self._kicker = None + self._kicker = self._restart_toucher self._kicking_team_is_yellow = self._prev_command in _YELLOW_RESTARTS - self._had_ball_last_frame = set() + # Still in contact at the changeover is the same touch, not a second one. + self._had_ball_last_frame = {self._kicker} if self._kicker is not None else set() elif current_command != RefereeCommand.NORMAL_START: self._armed = False self._kicker = None + if current_command not in _RESTART_COMMANDS: + self._restart_toucher = None self._prev_command = current_command if not self._armed: @@ -144,6 +152,12 @@ def check( return violation + @staticmethod + def _toucher_of_kicking_team(game_frame: GameFrame, command: RefereeCommand) -> Optional[RobotKey]: + is_friendly = game_frame.my_team_is_yellow == (command in _YELLOW_RESTARTS) + robots = game_frame.friendly_robots if is_friendly else game_frame.enemy_robots + return next(((is_friendly, robot.id) for robot in robots.values() if robot.has_ball), None) + def _other_robot_touching(self, game_frame: GameFrame) -> bool: ball = game_frame.ball if ball is None: @@ -169,6 +183,7 @@ def reset(self) -> None: def reset_for_new_episode(self) -> None: self.reset() self._prev_command = None + self._restart_toucher = None def _violation_for(self, kicker: RobotKey, game_frame: GameFrame, geometry: RefereeGeometry) -> RuleViolation: kicker_is_friendly, kicker_id = kicker diff --git a/utama_core/custom_referee/rules/keep_out_rule.py b/utama_core/custom_referee/rules/keep_out_rule.py index e676d033..f87d6094 100644 --- a/utama_core/custom_referee/rules/keep_out_rule.py +++ b/utama_core/custom_referee/rules/keep_out_rule.py @@ -30,9 +30,8 @@ class KeepOutRule(BaseRule): keep-out radius of the ball during the other team's kick-off or free kick. Non-stopping: the rulebook's sanction is a foul-counter increment and a reset of - the kicking team's timer, not a stop. The timer reset needs nothing here: the - state machine only counts down a free kick or kick-off once every defender is - clear (`_free_kick_ready`), so an encroaching defender already holds it back. + the kicking team's timer, not a stop: the state machine restarts the free kick's + clock from the foul. Stopping play and re-awarding the free kick, as this rule used to, voided the restart -- in sim straight into a FORCE_START scramble. diff --git a/utama_core/custom_referee/state_machine.py b/utama_core/custom_referee/state_machine.py index 7c8bfb1d..874bb5b1 100644 --- a/utama_core/custom_referee/state_machine.py +++ b/utama_core/custom_referee/state_machine.py @@ -188,7 +188,6 @@ def _reset_state(self) -> None: # Timestamps for sustained-readiness countdown before play-starting advances. # Set to math.inf when condition is not yet met; fire when elapsed >= _AUTO_ADVANCE_DELAY. self._advance2_ready_since: float = math.inf # PREPARE_* → NORMAL_START - self._advance3_ready_since: float = math.inf # DIRECT_FREE_* → NORMAL_START self._advance4_ready_since: float = math.inf # BALL_PLACEMENT_* → next_command # First Defender Too Close foul of the current free kick; restarts its clock. self._defender_too_close_at: float = -math.inf @@ -303,7 +302,6 @@ def step( self._advance4_ready_since = math.inf elif self.command in self._DIRECT_FREE_COMMANDS: self.next_command = RefereeCommand.NORMAL_START - self._advance3_ready_since = math.inf elif self.command in self._PREPARE_KICKOFF_COMMANDS or self.command in self._PREPARE_PENALTY_COMMANDS: self.next_command = RefereeCommand.NORMAL_START self._prepare_entered_time = current_time @@ -389,13 +387,10 @@ def step( self._advance2_ready_since = math.inf # ---------------------------------------------------------------- - # Auto-advance 3: DIRECT_FREE_* → NORMAL_START - # Fires when the kicker is within _KICKER_READY_DIST of the ball - # AND all defending robots are ≥ _BALL_CLEAR_DIST away, sustained - # for _AUTO_ADVANCE_DELAY seconds. + # Auto-advance 3: DIRECT_FREE_* → NORMAL_START once the kick is taken, + # FORCE_START if it is not within the time limit. # ---------------------------------------------------------------- elif self._auto_advance.direct_free_to_normal and self.command in self._DIRECT_FREE_COMMANDS: - ready = game_frame is not None and self._free_kick_ready(self.command, game_frame) kick_clock_start = max(self.command_timestamp, self._defender_too_close_at) if self._free_kick_taken(game_frame): # The kicker has kicked: the ball is in play, as after the kick of a ready free kick @@ -409,17 +404,7 @@ def step( self.command_timestamp = current_time self.next_command = None self.status_message = None - self._advance3_ready_since = math.inf self._last_transition_time = current_time - elif ready: - if self._advance3_ready_since == math.inf: - self._advance3_ready_since = current_time - logger.debug("Advance 3 countdown started (%s)", self.command.name) - elif (current_time - self._advance3_ready_since) >= _AUTO_ADVANCE_DELAY: - logger.info("Free kick ready — auto-advancing %s → NORMAL_START", self.command.name) - self._start_normal_play(current_time, game_frame) - else: - self._advance3_ready_since = math.inf # ---------------------------------------------------------------- # Auto-advance 4: BALL_PLACEMENT_* → next_command @@ -617,34 +602,6 @@ def _penalty_kicker_ready(self, command: RefereeCommand, game_frame: "GameFrame" closest = min(math.hypot(robot.p.x - penalty_mark_x, robot.p.y) for robot in attackers.values()) return closest <= _KICKER_READY_DIST - def _free_kick_ready(self, command: RefereeCommand, game_frame: "GameFrame") -> bool: - """Return True when a free kick is ready to start: - - The kicker (closest attacker to ball) is within _KICKER_READY_DIST of the ball. - - All defending robots are ≥ _BALL_CLEAR_DIST from the ball. - """ - ball = game_frame.ball - if ball is None: - return False - bx, by = ball.p.x, ball.p.y - - kicking_is_yellow = command == RefereeCommand.DIRECT_FREE_YELLOW - attackers = ( - game_frame.friendly_robots if kicking_is_yellow == game_frame.my_team_is_yellow else game_frame.enemy_robots - ) - defenders = ( - game_frame.enemy_robots if kicking_is_yellow == game_frame.my_team_is_yellow else game_frame.friendly_robots - ) - - # Check defending robots are all clear. - if any(math.hypot(r.p.x - bx, r.p.y - by) < _BALL_CLEAR_DIST for r in defenders.values()): - return False - - # Check at least one attacker is close to the ball (kicker in position). - if not attackers: - return False - closest = min(math.hypot(r.p.x - bx, r.p.y - by) for r in attackers.values()) - return closest <= _KICKER_READY_DIST - def _ball_has_moved(self, game_frame: "GameFrame") -> bool: """Return True if the ball has moved ≥ 0.05 m since NORMAL_START.""" if self._ball_pos_at_normal_start is None or game_frame.ball is None: @@ -666,8 +623,8 @@ def _ball_xy(game_frame: Optional["GameFrame"]) -> Optional[tuple[float, float]] return (game_frame.ball.p.x, game_frame.ball.p.y) def _start_normal_play(self, current_time: float, game_frame: "GameFrame") -> None: - """DIRECT_FREE_* → NORMAL_START (the kicker was ready, or the ball has been kicked): the ball - is in play, and NORMAL_START's own timeout measures from here.""" + """DIRECT_FREE_* → NORMAL_START (the ball has been kicked): the ball is in play, and + NORMAL_START's own timeout measures from here.""" self.command = RefereeCommand.NORMAL_START self.command_counter += 1 self.command_timestamp = current_time @@ -675,7 +632,6 @@ def _start_normal_play(self, current_time: float, game_frame: "GameFrame") -> No self.status_message = None self._normal_start_time = current_time self._ball_pos_at_normal_start = self._ball_xy(game_frame) - self._advance3_ready_since = math.inf self._last_transition_time = current_time def _ball_placement_done(self, game_frame: "GameFrame") -> bool: @@ -698,7 +654,6 @@ def _advance_past_ball_placement(self, current_time: float) -> None: self.command_timestamp = current_time if completed_command in self._DIRECT_FREE_COMMANDS: self.next_command = RefereeCommand.NORMAL_START - self._advance3_ready_since = math.inf elif completed_command in self._PREPARE_KICKOFF_COMMANDS or completed_command in self._PREPARE_PENALTY_COMMANDS: self.next_command = RefereeCommand.NORMAL_START self._prepare_entered_time = current_time @@ -818,7 +773,6 @@ def set_command(self, command: RefereeCommand, timestamp: float) -> None: self._post_ball_placement_command = None self.status_message = None self._advance2_ready_since = math.inf - self._advance3_ready_since = math.inf self._advance4_ready_since = math.inf if command in (RefereeCommand.STOP, RefereeCommand.HALT): @@ -852,7 +806,6 @@ def force_command( self._post_ball_placement_command = None self.status_message = None self._advance2_ready_since = math.inf - self._advance3_ready_since = math.inf self._advance4_ready_since = math.inf if ball_placement_target is not None: self.ball_placement_target = ball_placement_target @@ -874,7 +827,6 @@ def resume_from_halt(self, timestamp: float) -> bool: self._stop_entered_time = timestamp self.status_message = None self._advance2_ready_since = math.inf - self._advance3_ready_since = math.inf self._advance4_ready_since = math.inf logger.info("Resuming from HALT (queued: %s)", self.next_command.name if self.next_command else "None") return self.next_command in self._NEEDS_STOP_FIRST or self.next_command == RefereeCommand.FORCE_START diff --git a/utama_core/tests/custom_referee/test_custom_referee.py b/utama_core/tests/custom_referee/test_custom_referee.py index 77ae529f..22bd7dee 100644 --- a/utama_core/tests/custom_referee/test_custom_referee.py +++ b/utama_core/tests/custom_referee/test_custom_referee.py @@ -239,6 +239,7 @@ def test_fires_when_ball_exceeds_speed_limit(self): rule = BallSpeedRule(max_speed_mps=6.5) friendly = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=True)} frame = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) + rule.check(frame, GEO, RefereeCommand.NORMAL_START) violation = rule.check(frame, GEO, RefereeCommand.NORMAL_START) assert violation is not None assert violation.rule_name == "ball_speed" @@ -260,10 +261,9 @@ def test_only_fires_once_per_kick_not_every_frame(self): rule = BallSpeedRule(max_speed_mps=6.5) friendly = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=True)} frame = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) - first = rule.check(frame, GEO, RefereeCommand.NORMAL_START) - second = rule.check(frame, GEO, RefereeCommand.NORMAL_START) - assert first is not None - assert second is None # still fast, but not a new kick + assert rule.check(frame, GEO, RefereeCommand.NORMAL_START) is None + assert rule.check(frame, GEO, RefereeCommand.NORMAL_START) is not None + assert rule.check(frame, GEO, RefereeCommand.NORMAL_START) is None # still fast, but not a new kick def test_fires_again_after_dropping_below_and_back_above_limit(self): rule = BallSpeedRule(max_speed_mps=6.5) @@ -271,10 +271,21 @@ def test_fires_again_after_dropping_below_and_back_above_limit(self): fast = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) slow = _frame(ball=_ball(0.0, 0.0, vx=1.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) + rule.check(fast, GEO, RefereeCommand.NORMAL_START) assert rule.check(fast, GEO, RefereeCommand.NORMAL_START) is not None assert rule.check(slow, GEO, RefereeCommand.NORMAL_START) is None + rule.check(fast, GEO, RefereeCommand.NORMAL_START) assert rule.check(fast, GEO, RefereeCommand.NORMAL_START) is not None + def test_one_frame_over_the_limit_is_noise_not_a_kick(self): + rule = BallSpeedRule(max_speed_mps=6.5) + friendly = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=True)} + spike = _frame(ball=_ball(0.0, 0.0, vx=39.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) + normal = _frame(ball=_ball(0.0, 0.0, vx=5.3, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) + for _ in range(3): + assert rule.check(spike, GEO, RefereeCommand.NORMAL_START) is None + assert rule.check(normal, GEO, RefereeCommand.NORMAL_START) is None + def test_non_stopping_foul_charged_to_the_kicking_team(self): """SSL rulebook §8.4.2 lists Ball Speed as a non-stopping foul: friendly (yellow) kicked too fast -> yellow is charged, play continues. Ours used @@ -282,6 +293,7 @@ def test_non_stopping_foul_charged_to_the_kicking_team(self): rule = BallSpeedRule(max_speed_mps=6.5) friendly = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=True)} frame = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), friendly_robots=friendly, my_team_is_yellow=True) + rule.check(frame, GEO, RefereeCommand.NORMAL_START) violation = rule.check(frame, GEO, RefereeCommand.NORMAL_START) assert violation is not None assert violation.is_stopping is False @@ -304,6 +316,7 @@ def test_enemy_kick_attributed_symmetrically(self): rule = BallSpeedRule(max_speed_mps=6.5) enemy = {0: _robot(0, 0.0, 0.0, is_friendly=False, has_ball=True)} frame = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), enemy_robots=enemy, my_team_is_yellow=True) + rule.check(frame, GEO, RefereeCommand.NORMAL_START) violation = rule.check(frame, GEO, RefereeCommand.NORMAL_START) assert violation is not None assert violation.offending_teams == (False,) @@ -315,6 +328,7 @@ def test_scrum_kick_tie_broken_by_distance_not_colour(self): friendly = {0: _robot(0, 0.08, 0.0, is_friendly=True, has_ball=True)} enemy = {0: _robot(0, 0.03, 0.0, is_friendly=False, has_ball=True)} # 0.03 m — closer frame = _frame(ball=_ball(0.0, 0.0, vx=7.0, vy=0.0), friendly_robots=friendly, enemy_robots=enemy) + rule.check(frame, GEO, RefereeCommand.NORMAL_START) violation = rule.check(frame, GEO, RefereeCommand.NORMAL_START) assert violation is not None assert violation.offending_teams == (False,) # enemy (blue) kicked @@ -336,6 +350,44 @@ def _arm_double_touch(rule: DoubleTouchRule, restart_command: RefereeCommand) -> class TestDoubleTouchRule: + @staticmethod + def _kick_during_the_free_kick(rule): + kicking = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=True)} + rule.check( + _frame(ball=_ball(0.0, 0.0), friendly_robots=kicking, my_team_is_yellow=True), + GEO, + RefereeCommand.DIRECT_FREE_YELLOW, + ) + rule.reset() + gone = {0: _robot(0, 0.0, 0.0, is_friendly=True, has_ball=False)} + rule.check( + _frame(ball=_ball(0.5, 0.0, vx=5.0), friendly_robots=gone, my_team_is_yellow=True), + GEO, + RefereeCommand.NORMAL_START, + ) + + def test_the_taker_of_a_kick_struck_before_play_started_cannot_touch_it_again(self): + rule = DoubleTouchRule() + self._kick_during_the_free_kick(rule) + back = {0: _robot(0, 0.5, 0.0, is_friendly=True, has_ball=True)} + violation = rule.check( + _frame(ball=_ball(0.5, 0.0), friendly_robots=back, my_team_is_yellow=True), GEO, RefereeCommand.NORMAL_START + ) + assert violation is not None and violation.offending_robots == ((True, 0),) + + def test_the_receiver_of_a_kick_struck_before_play_started_is_not_the_kicker(self): + rule = DoubleTouchRule() + self._kick_during_the_free_kick(rule) + taker_away = _robot(0, -2.0, 0.0, is_friendly=True, has_ball=False) + for has_ball in (True, False, True): + robots = {0: taker_away, 1: _robot(1, 2.0, 0.0, is_friendly=True, has_ball=has_ball)} + violation = rule.check( + _frame(ball=_ball(2.0, 0.0), friendly_robots=robots, my_team_is_yellow=True), + GEO, + RefereeCommand.NORMAL_START, + ) + assert violation is None + def test_same_robot_touching_twice_after_a_restart_fouls(self): rule = DoubleTouchRule() _arm_double_touch(rule, RefereeCommand.DIRECT_FREE_YELLOW) @@ -1020,7 +1072,6 @@ def test_reset_clears_auto_advance_timers(self): sm.reset() assert sm._advance2_ready_since == math.inf - assert sm._advance3_ready_since == math.inf assert sm._advance4_ready_since == math.inf assert sm._last_transition_time == -math.inf @@ -1270,23 +1321,20 @@ def test_simulation_double_touch_after_direct_free_kick_is_flagged(self): data = referee.step(clear_frame, current_time=2.0) assert data.referee_command == RefereeCommand.DIRECT_FREE_BLUE - # Blue kicker ready, defenders clear -> auto-advances to NORMAL_START. - ready_frame = _frame( - ball=_ball(0.0, 0.0), - enemy_robots={0: _robot(0, 0.0, 0.0, is_friendly=False)}, - ts=5.0, - ) - referee.step(ready_frame, current_time=5.0) - data = referee.step(ready_frame, current_time=8.0) - assert data.referee_command == RefereeCommand.NORMAL_START - - # Blue kicker touches the ball (the restart kick itself). + # Blue kicker strikes the ball: it has moved, so the free kick is taken. kicker_touch = _frame( ball=_ball(0.0, 0.0), enemy_robots={0: _robot(0, 0.0, 0.0, is_friendly=False, has_ball=True)}, - ts=8.1, + ts=5.0, + ) + referee.step(kicker_touch, current_time=5.0) + struck = _frame( + ball=_ball(0.1, 0.0), + enemy_robots={0: _robot(0, 0.0, 0.0, is_friendly=False, has_ball=False)}, + ts=5.1, ) - referee.step(kicker_touch, current_time=8.1) + data = referee.step(struck, current_time=5.1) + assert data.referee_command == RefereeCommand.NORMAL_START # Kicker releases, then touches again — no one else touched it. Foul. released = _frame( diff --git a/utama_core/tests/engine/test_referee_override.py b/utama_core/tests/engine/test_referee_override.py index c7f2a758..a88a305c 100644 --- a/utama_core/tests/engine/test_referee_override.py +++ b/utama_core/tests/engine/test_referee_override.py @@ -400,15 +400,13 @@ def test_our_direct_free_moves_kicker_to_the_ball(split_shape_runner): _set_referee_command(split_shape_runner, RefereeCommand.DIRECT_FREE_YELLOW) + dist_to_ball = math.inf for _ in range(200): split_shape_runner.step_once() + ball = game.ball.p + for robot in game.friendly_robots.values(): + dist_to_ball = min(dist_to_ball, math.hypot(robot.p.x - ball.x, robot.p.y - ball.y)) - ball = game.ball.p - kicker = min( - game.friendly_robots.values(), - key=lambda robot: math.hypot(robot.p.x - ball.x, robot.p.y - ball.y), - ) - dist_to_ball = math.hypot(kicker.p.x - ball.x, kicker.p.y - ball.y) assert ( dist_to_ball < 0.3 ), f"no robot approached the ball for our direct free kick: closest dist={dist_to_ball:.3f}m" diff --git a/utama_core/tests/engine/test_referee_overrides_customization.py b/utama_core/tests/engine/test_referee_overrides_customization.py index 3bb92b80..584efbac 100644 --- a/utama_core/tests/engine/test_referee_overrides_customization.py +++ b/utama_core/tests/engine/test_referee_overrides_customization.py @@ -144,6 +144,7 @@ def tick(self, game, ctx, robot_ids, mem): ) game = Mock() + game.friendly_robots = game.enemy_robots = {} game.my_team_is_yellow = True referee = Mock() referee.referee_command = RefereeCommand.NORMAL_START diff --git a/utama_core/tests/referee/test_referee_unit.py b/utama_core/tests/referee/test_referee_unit.py index e145025b..8f471aee 100644 --- a/utama_core/tests/referee/test_referee_unit.py +++ b/utama_core/tests/referee/test_referee_unit.py @@ -131,7 +131,11 @@ def _make_blackboard(game: Game, cmd_map=None): bb.game = game bb.cmd_map = cmd_map if cmd_map is not None else {} bb.motion_controller = SimpleNamespace( - calculate=lambda **kwargs: (Vector2D(0.0, 0.0), 0.0), pose_ahead=PoseAhead(0.0), min_turn=None + calculate=lambda **kwargs: (Vector2D(0.0, 0.0), 0.0), + pose_ahead=PoseAhead(0.0), + min_turn=None, + kick_bend={}, + kick_bias={}, ) return bb @@ -1168,7 +1172,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri node.update() - assert len(captured) == 1 + assert len(captured) == 2 # the other robot takes the wall assert captured[0][0] == 0 assert captured[0][1] == Vector2D(-3.25, 0.0) @@ -1355,7 +1359,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri node.update() - assert len(captured) == 1 + assert len(captured) == 2 # the other robot takes the wall assert captured[0][0] == 0 assert captured[0][1] == Vector2D(0.8, 0.0) @@ -1954,6 +1958,119 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri class TestDirectFreeOursStep: + @staticmethod + def _at_the_ball(friendly_robots, enemy_robots=None): + """Attacking -x, ball at (1, 0), robot 0 on it from behind.""" + frame = GameFrame( + ts=0.0, + my_team_is_yellow=True, + my_team_is_right=True, + friendly_robots=friendly_robots, + enemy_robots=enemy_robots or {}, + ball=_ball(1.0, 0.0), + referee=_make_referee_data(command=RefereeCommand.DIRECT_FREE_YELLOW), + ) + game = Game( + past=GameHistory(10), + current=frame, + field=Field( + my_team_is_right=True, + field_dims=STANDARD_FIELD_DIMS, + field_bounds=STANDARD_FIELD_DIMS.full_field_bounds, + ), + ) + from utama_core.custom_referee import actions as referee_actions + + node = referee_actions.DirectFreeOursStep() + node.blackboard = _make_blackboard(game, _make_cmd_map(game)) + return node + + @staticmethod + def _taker(orientation=math.pi, has_ball=True): + return dataclasses.replace(_robot(0, 1.1, 0.0), orientation=orientation, has_ball=has_ball) + + def test_the_taker_kicks_at_the_goal_with_no_teammate_open(self): + node = self._at_the_ball({0: self._taker()}) + node.update() + assert node.blackboard.cmd_map[0].kick == 1 + + def test_the_taker_kicks_only_with_the_ball_on_the_kicker(self): + node = self._at_the_ball({0: self._taker(has_ball=False)}) + node.update() + assert node.blackboard.cmd_map[0].kick == 0 + + def test_the_taker_waits_for_the_teammate_to_face_the_ball_and_it_turns(self, monkeypatch): + from utama_core.custom_referee import actions as referee_actions + from utama_core.entities.data.command import RobotCommand + + turning = RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=2.0, kick=0, chip=0, dribble=0) + monkeypatch.setattr(referee_actions, "turn_on_spot", lambda *a, **k: turning) + away = dataclasses.replace(_robot(1, -1.0, 0.0), orientation=math.pi) + node = self._at_the_ball({0: self._taker(), 1: away}) + node.update() + assert node.blackboard.cmd_map[0].kick == 0 + assert node.blackboard.cmd_map[1] is turning + + @pytest.mark.parametrize("from_ball, turns", [(0.799, True), (0.751, True), (0.749, False)]) + def test_a_receiver_on_the_keep_out_edge_turns_instead_of_being_cleared(self, monkeypatch, from_ball, turns): + from utama_core.custom_referee import actions as referee_actions + + turning = object() + cleared = object() + monkeypatch.setattr(referee_actions, "turn_on_spot", lambda *a, **k: turning) + monkeypatch.setattr(referee_actions, "move", lambda *a, **k: cleared) + away = dataclasses.replace(_robot(1, 1.0 - from_ball, 0.0), orientation=math.pi) + node = self._at_the_ball({0: self._taker(), 1: away}) + node.update() + assert node.blackboard.cmd_map[1] is (turning if turns else cleared) + + def test_the_taker_kicks_once_the_teammate_faces_the_ball(self): + facing = dataclasses.replace(_robot(1, -1.0, 0.0), orientation=0.17 - 0.01) + node = self._at_the_ball({0: self._taker(), 1: facing}) + node.update() + assert node.blackboard.cmd_map[0].kick == 1 + + def test_the_kick_target_is_kept_while_lanes_open_and_shut(self): + facing = dataclasses.replace(_robot(1, -1.0, 0.0), orientation=0.0) + node = self._at_the_ball({0: self._taker(), 1: facing}) + game = node.blackboard.game + assert node._kick_target(game, 0, Vector2D(1.0, 0.0))[0] == 1 + node._target = (0, Vector2D(1.0, 0.0), None, None, 0.25) + assert node._kick_target(game, 0, Vector2D(1.04, 0.0)) == (None, None, 0.25) + assert node._kick_target(game, 0, Vector2D(1.06, 0.0))[0] == 1 + + def test_with_nobody_in_range_the_nearest_teammate_comes_and_the_taker_waits(self, monkeypatch): + from utama_core.custom_referee import actions as referee_actions + + monkeypatch.setattr(referee_actions, "move", lambda *a, **k: ("move", a[2], a[3])) + far = dataclasses.replace(_robot(1, -3.0, 2.5), orientation=0.0) + node = self._at_the_ball({0: self._taker(), 1: far}) + node.update() + receiver, spot, _ = node._kick_target(node.blackboard.game, 0, Vector2D(1.0, 0.0)) + assert receiver == 1 and abs(spot.distance_to(Vector2D(1.0, 0.0)) - 2.0) < 1e-6 + assert node.blackboard.cmd_map[1] == ("move", 1, spot) + assert node.blackboard.cmd_map[0].kick == 0 + + def test_the_kick_follows_the_chosen_teammate_where_it_stands_now(self): + ball = Vector2D(1.0, 0.0) + node = self._at_the_ball({0: self._taker(), 1: _robot(1, -1.0, 1.0)}) + node._target = (0, ball, 1, None, 0.25) + assert node._kick_target(node.blackboard.game, 0, ball)[2] == pytest.approx(ball.angle_to(Vector2D(-1.0, 1.0))) + + def test_the_kick_follows_a_called_teammate_only_once_it_has_arrived(self): + ball = Vector2D(1.0, 0.0) + for off_spot, expected in ((0.11, 0.25), (0.09, math.pi)): # arrived within 0.1 m + node = self._at_the_ball({0: self._taker(), 1: _robot(1, -1.0 + off_spot, 0.0)}) + node._target = (0, ball, 1, Vector2D(-1.0, 0.0), 0.25) + assert node._kick_target(node.blackboard.game, 0, ball)[2] == pytest.approx(expected) + + def test_the_taker_kicks_when_the_called_teammate_has_arrived(self): + arrived = dataclasses.replace(_robot(1, -1.0, 0.0), orientation=0.0) + node = self._at_the_ball({0: self._taker(), 1: arrived}) + node._target = (0, Vector2D(1.0, 0.0), 1, Vector2D(-1.0, 0.0), math.pi) + node.update() + assert node.blackboard.cmd_map[0].kick == 1 + def test_kicker_is_closest_robot_to_ball(self, monkeypatch): from utama_core.custom_referee import actions as referee_actions @@ -2301,6 +2418,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri return ("move", robot_id) monkeypatch.setattr(referee_actions, "move", fake_move) + monkeypatch.setattr(referee_actions, "restart_support", lambda *a: None) # Robot 1 is kicker near ball at (1.0, 0.0); Robot 0 is inside opp defense area at (-4.3, 0.0) robots = {0: _robot(0, -4.3, 0.0), 1: _robot(1, 1.2, 0.0)} @@ -2344,6 +2462,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri return ("move", robot_id) monkeypatch.setattr(referee_actions, "move", fake_move) + monkeypatch.setattr(referee_actions, "restart_support", lambda *a: None) # Ball at (1.0, 0.0). Robot 1 is kicker at (1.1, 0.0). Robot 0 is non-kicker at (1.3, 0.0) inside 0.8m keep-out. robots = {0: _robot(0, 1.3, 0.0), 1: _robot(1, 1.1, 0.0)} @@ -2401,7 +2520,7 @@ def test_robot_outside_keep_out_stays_put(self, monkeypatch): assert cmd_map[0] is not None assert cmd_map[0] != ("move", 0) - def test_multiple_robots_only_encroaching_ones_move(self, monkeypatch): + def test_encroaching_robot_clears_and_the_nearest_other_takes_the_wall(self, monkeypatch): from utama_core.custom_referee import actions as referee_actions captured = [] @@ -2427,7 +2546,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri node.update() moved_ids = [rid for rid, _ in captured] - assert moved_ids == [0] + assert moved_ids == [0, 1] assert cmd_map[1] is not None assert cmd_map[2] is not None diff --git a/utama_core/tests/strategy_runner/test_referee_rsim.py b/utama_core/tests/strategy_runner/test_referee_rsim.py index 8569bfd0..d08eff75 100644 --- a/utama_core/tests/strategy_runner/test_referee_rsim.py +++ b/utama_core/tests/strategy_runner/test_referee_rsim.py @@ -44,6 +44,7 @@ from utama_core.custom_referee import CustomReferee from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.engine import ball_release from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy @@ -461,11 +462,12 @@ def eval_status(self, game: Game) -> TestingStatus: return TestingStatus.IN_PROGRESS -def test_no_progress_restart_separates_robots_before_force_start(headless): +def test_no_progress_restart_separates_robots_before_force_start(headless, monkeypatch): """The runner's sim shortcut forced FORCE_START on the STOP's first tick, with the ball teleported to where it already lay. Two robots locked on the ball never separated, so no_progress fired every 10 s for 230 s of tiki_taka_plus_vs_zone_fluid (tournament_20261005_115048). A queued FORCE_START waits for StopStep's clearing.""" + monkeypatch.setattr(ball_release, "HELD_STILL_S", float("inf")) # the robot must keep holding the ball referee = CustomReferee.from_profile_name("simulation") runner = StrategyRunner( strategy=_go_to_ball_strategy(robot_id=0), From 03c56971ab6cf3a27bf9e7186b47390db16115bd Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:47 +0000 Subject: [PATCH 03/59] strategy: fix shared skills, tactics and ball handling Sprint at contested balls, fix the free-kick first-touch stall and ball release, and improve approach, goalkeeping and man marking. Sim results for these are in the frozen evaluation against v2.5.0. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- utama_core/engine/ball_release.py | 133 +++++++ utama_core/engine/ball_roles.py | 165 +++++++++ utama_core/engine/context.py | 6 +- utama_core/engine/strategy.py | 12 + .../src/common/motion_controller.py | 2 + utama_core/motion_planning/src/pid/configs.py | 4 + utama_core/motion_planning/src/pid/pid.py | 15 + utama_core/shared/pass_and_score_geometry.py | 235 +++++++++++++ utama_core/skills/src/go_to_ball.py | 42 +++ utama_core/skills/src/goalkeep.py | 35 +- utama_core/skills/src/kick_upfield.py | 11 +- utama_core/skills/src/man_mark.py | 28 ++ utama_core/skills/src/utils/move_utils.py | 50 ++- utama_core/strategy/pickers.py | 5 +- utama_core/tactics/_pass_and_score.py | 28 +- utama_core/tactics/defense.py | 13 +- utama_core/tactics/give_and_go.py | 35 +- utama_core/tactics/goalkeeper.py | 2 +- utama_core/tactics/press_and_contain.py | 1 + .../tests/engine/test_all_strategy_configs.py | 6 +- utama_core/tests/engine/test_ball_release.py | 332 ++++++++++++++++++ utama_core/tests/engine/test_ball_roles.py | 323 +++++++++++++++++ utama_core/tests/engine/test_carrier_first.py | 36 ++ .../tests/engine/test_commitment_deadline.py | 3 + .../tests/engine/test_give_and_go_tactic.py | 29 +- .../engine/test_shadow_and_mark_tactic.py | 2 +- utama_core/tests/engine/test_strategy.py | 5 +- .../motion_planning/test_pid_approach.py | 58 +++ utama_core/tests/skills/test_go_to_ball.py | 39 ++ utama_core/tests/skills/test_goalkeep.py | 41 +++ utama_core/tests/skills/test_move_utils.py | 58 ++- 31 files changed, 1705 insertions(+), 49 deletions(-) create mode 100644 utama_core/engine/ball_release.py create mode 100644 utama_core/engine/ball_roles.py create mode 100644 utama_core/tests/engine/test_ball_release.py create mode 100644 utama_core/tests/engine/test_ball_roles.py create mode 100644 utama_core/tests/engine/test_carrier_first.py create mode 100644 utama_core/tests/motion_planning/test_pid_approach.py diff --git a/utama_core/engine/ball_release.py b/utama_core/engine/ball_release.py new file mode 100644 index 00000000..40966928 --- /dev/null +++ b/utama_core/engine/ball_release.py @@ -0,0 +1,133 @@ +"""Aim and force a kick when holding the ball on any longer would cost it. + +Tactics decide when to shoot or pass; this is the backstop behind all of them, run on the commands +they return. A robot that finds no shot keeps sliding for one with the ball on its dribbler, with +nothing to end that. In the 2026-11-09 round-robin that gave 387 solo excessive-dribbling fouls, +and with an enemy on the same ball a jam of 90 s per match, 230 s at worst, the ball creeping just +enough for the no-progress rule never to fire. Kept here and not in tactics' memory so a hand-over +between tactics in the middle of a carry does not restart the count, as the referee's does not. +""" + +from __future__ import annotations + +import math +from typing import TYPE_CHECKING, Optional + +from utama_core.entities.data.command import RobotCommand +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.shared.pass_and_score_geometry import ( + ANNOUNCE_PASS_RAD, + RELEASE_LANE_CLEARANCE, + open_teammate, + oriented_towards, + reaches_own_goal, + release_heading, +) +from utama_core.skills.src.utils.move_utils import turn_on_spot + +if TYPE_CHECKING: + from utama_core.engine.context import TickContext + from utama_core.entities.game import Game + +# Past tactics' own CARRY_LIMIT_M (0.8): their carries are not cut short, this catches the rest. +CARRY_RELEASE_M = 0.96 +# Aim from here: a carry of 0.8 turning to shoot has stopped, and is left to its tactic. +CARRY_AIM_M = 0.85 +# Ball travel before a kick sent now leaves the robot: the command delay and a tick. +_RELEASE_LAG_S = 0.12 +_CARRY_BRAKING_MPS2 = 4.0 +PINNED_RELEASE_S = 1.5 +# With a teammate to kick to there is nothing to wait for: an enemy on the ball only gets stronger. +PINNED_WITH_LANE_S = 0.3 +# Stood on the ball this long with it not moving. Whatever a tactic is waiting for, this is what the +# stalls of the 2026-11-09 round-robin looked like: nothing else on the pitch moves it. +HELD_STILL_S = 2.0 +_HELD_STILL_M = 0.05 +# Kicked blind along the heading, 82% of pinned releases and 41% of carry ones went out of play +# (12 matches, 2026-11-09). A turn gets most of that back, without letting a release wait. +AIM_LIMIT_S = 0.6 +_AIM_TOLERANCE_RAD = 0.15 +CONTACT_M = 0.13 # robot centre to ball with both touching: 0.09 + 0.0215 and some slack +_LIVE_COMMANDS = frozenset({RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START}) +_KICK = RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=0, kick=1, chip=0, dribble=0) + + +class BallRelease: + def __init__(self) -> None: + self._carry_origin: dict[int, tuple[float, float]] = {} + self._pinned_since: dict[int, float] = {} + self._aiming_since: dict[int, float] = {} + self._still_at: dict[int, tuple[tuple[float, float], float]] = {} + + def reset(self) -> None: + self._still_at.clear() + self._carry_origin.clear() + self._pinned_since.clear() + self._aiming_since.clear() + + def apply(self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand]) -> dict[int, RobotCommand]: + """`commands` with a kick for any robot that must release the ball now. Live play only.""" + referee = getattr(game, "referee", None) + ball = getattr(game, "ball", None) + if ball is None or referee is None or referee.referee_command not in _LIVE_COMMANDS: + self.reset() + return commands + + here = (ball.p.x, ball.p.y) + enemy_on_ball = any(math.dist((e.p.x, e.p.y), here) <= CONTACT_M for e in game.enemy_robots.values()) + for robot_id, robot in game.friendly_robots.items(): + if enemy_on_ball and math.dist((robot.p.x, robot.p.y), here) <= CONTACT_M: + self._pinned_since.setdefault(robot_id, game.ts) + else: + self._pinned_since.pop(robot_id, None) + if not robot.has_ball: + self._carry_origin.pop(robot_id, None) + self._aiming_since.pop(robot_id, None) + self._still_at.pop(robot_id, None) + continue + origin = self._carry_origin.setdefault(robot_id, here) + spot, still_since = self._still_at.setdefault(robot_id, (here, game.ts)) + if math.dist(here, spot) >= _HELD_STILL_M: + self._still_at[robot_id], still_since = (here, game.ts), game.ts + + command: Optional[RobotCommand] = commands.get(robot_id) + if command is None or command.kick or command.chip: + continue + carried = math.dist(here, origin) + speed = math.hypot(ball.v.x, ball.v.y) + pinned_since = self._pinned_since.get(robot_id) + teammate = open_teammate(game, robot_id, RELEASE_LANE_CLEARANCE) + if carried + speed * _RELEASE_LAG_S >= CARRY_RELEASE_M: + if not reaches_own_goal(game, robot.p, robot.orientation): + ctx.trace(game, f"release[{robot_id}]", "carry limit") + commands[robot_id] = _KICK + continue + if carried + speed * _RELEASE_LAG_S + speed**2 / (2.0 * _CARRY_BRAKING_MPS2) >= CARRY_AIM_M: + reason = "carry limit" + elif pinned_since is not None and game.ts - pinned_since >= PINNED_RELEASE_S: + reason = "pinned" + elif pinned_since is not None and game.ts - pinned_since >= PINNED_WITH_LANE_S and teammate is not None: + reason = "pinned, teammate open" + elif game.ts - still_since >= HELD_STILL_S: + reason = "held still" + else: + self._aiming_since.pop(robot_id, None) + continue + aiming_for = game.ts - self._aiming_since.setdefault(robot_id, game.ts) + heading = release_heading(game, robot_id) + if teammate is not None and oriented_towards(game, robot_id, heading, ANNOUNCE_PASS_RAD): + ctx.expected_receivers.add(teammate) + aimed = oriented_towards(game, robot_id, heading, _AIM_TOLERANCE_RAD) + if (aimed or aiming_for >= AIM_LIMIT_S) and not reaches_own_goal(game, robot.p, robot.orientation): + ctx.trace(game, f"release[{robot_id}]", reason) + commands[robot_id] = _KICK + else: + ctx.trace(game, f"release[{robot_id}]", f"aiming · {reason}") + commands[robot_id] = turn_on_spot( + game=game, + motion_controller=ctx.motion_controller, + robot_id=robot_id, + target_oren=heading, + dribbling=True, + ) + return commands diff --git a/utama_core/engine/ball_roles.py b/utama_core/engine/ball_roles.py new file mode 100644 index 00000000..702cf88f --- /dev/null +++ b/utama_core/engine/ball_roles.py @@ -0,0 +1,165 @@ +"""Who on the team deals with the ball this tick, whichever tactics each robot is in. + +Tactics each decide for their own robots, so two of them (an attack slot and a press slot, say) +send one robot each at the same ball. In the 2026-11-09 round-robin a side with a robot on the ball +had a teammate within 0.6 m of it 46% of the time. Run on the commands every tactic returned: + +- the robot a free ball is rolling to meets it on its path, whether or not a pass was announced, + and stays on it until the ball arrives or goes elsewhere; +- a robot a teammate is turning to pass to stops and faces the ball; +- of the robots driving at a loose ball, the nearest carries on and the others cover it. With the + ball ours they keep clear of it where they are: covering pulled attackers back to our side of it. +""" + +from __future__ import annotations + +import math +from typing import TYPE_CHECKING, Iterable, Optional + +from utama_core.entities.data.command import RobotCommand +from utama_core.entities.data.vector import Vector2D +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.shared.pass_and_score_geometry import ( + ball_line_receive_point, + clamp_outside_enemy_defense_area, + clamp_outside_own_defense_area, + clamp_to_field, + receiver_of_rolling_ball, + still_receiving, +) +from utama_core.skills.src.utils.move_utils import move, turn_on_spot + +if TYPE_CHECKING: + from utama_core.engine.context import TickContext + from utama_core.entities.game import Game + +COVER_M = 1.0 # from the ball, on the line to our goal +_COVER_ANGLES_RAD = (0.0, 0.7, -0.7, 1.4, -1.4) +ON_BALL_SWITCH_MARGIN_M = 0.2 # nearer than the robot already on the ball by this, or it stays on it +_LIVE_COMMANDS = frozenset({RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START}) + + +class BallRoles: + def __init__(self) -> None: + self._on_ball: Optional[int] = None + self._receiving: Optional[int] = None + + def reset(self) -> None: + self._on_ball = None + self._receiving = None + + def apply( + self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand], outfield: Iterable[int] + ) -> dict[int, RobotCommand]: + """`commands` with the robots above changed. Live play only.""" + referee = getattr(game, "referee", None) + if getattr(game, "ball", None) is None or referee is None or referee.referee_command not in _LIVE_COMMANDS: + self.reset() + return commands + + candidates = [rid for rid in outfield if rid in commands and rid in game.friendly_robots] + # A new pick replaces the last one: the ball's velocity is unreliable on the first tick of a kick, + # and a robot chosen on it kept the job. The hold is for ticks when the reach check finds nobody. + pick = receiver_of_rolling_ball(game, candidates) + if pick is not None or self._receiving not in candidates or not still_receiving(game, self._receiving): + self._receiving = pick + receiver = self._receiving + if receiver is not None and not game.friendly_robots[receiver].has_ball: + self._receive(game, ctx, commands, receiver) + for robot_id in ctx.expected_receivers: + if robot_id in commands and robot_id != receiver and not game.friendly_robots[robot_id].has_ball: + self._get_ready(game, ctx, commands, robot_id) + self._one_on_the_ball(game, ctx, commands, receiver) + return commands + + def _receive(self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand], robot_id: int) -> None: + spot = ball_line_receive_point(game, robot_id) + if spot is None: + return + ctx.trace(game, f"ball[{robot_id}]", "receiving") + robot = game.friendly_robots[robot_id] + commands[robot_id] = move( + game=game, + motion_controller=ctx.motion_controller, + robot_id=robot_id, + target_coords=clamp_outside_enemy_defense_area(game, clamp_outside_own_defense_area(game, spot)), + target_oren=robot.p.angle_to(game.ball.p.to_2d()), + dribbling=True, + # A 5 m/s pass 2 m away arrives in 0.4 s. In 20 free-kick drills sprinting, with the pick + # above, took passes received from 9 to 14 and balls out of play from 13 to 8 (2026-11-10). + sprint=True, + ) + + def _get_ready(self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand], robot_id: int) -> None: + ctx.trace(game, f"ball[{robot_id}]", "waiting for the pass") + robot = game.friendly_robots[robot_id] + commands[robot_id] = turn_on_spot( + game=game, + motion_controller=ctx.motion_controller, + robot_id=robot_id, + target_oren=robot.p.angle_to(game.ball.p.to_2d()), + dribbling=True, + ) + + def _one_on_the_ball( + self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand], receiver: Optional[int] + ) -> None: + claims = sorted(rid for rid in ctx.ball_claims if rid in commands and rid in game.friendly_robots) + holder = next((rid for rid, robot in game.friendly_robots.items() if robot.has_ball), None) + ours = receiver if receiver is not None else holder + if ours is not None: + self._on_ball = ours + for robot_id in claims: + if robot_id != ours: + ctx.trace(game, f"ball[{robot_id}]", "keeping clear") + self._send(game, ctx, commands, robot_id, _clear_of_ball(game, robot_id)) + return + if not claims: + self._on_ball = None + return + self._on_ball = self._nearest(game, claims) + closest = min(claims, key=lambda rid: game.friendly_robots[rid].p.distance_to(game.ball.p.to_2d())) + for rank, robot_id in enumerate(rid for rid in claims if rid not in (self._on_ball, closest)): + ctx.trace(game, f"ball[{robot_id}]", "covering") + self._send(game, ctx, commands, robot_id, _cover_point(game, rank)) + + def _send( + self, game: "Game", ctx: "TickContext", commands: dict[int, RobotCommand], robot_id: int, target: Vector2D + ) -> None: + commands[robot_id] = move( + game=game, + motion_controller=ctx.motion_controller, + robot_id=robot_id, + target_coords=target, + target_oren=game.friendly_robots[robot_id].p.angle_to(game.ball.p.to_2d()), + ) + + def _nearest(self, game: "Game", claims: list[int]) -> int: + ball = game.ball.p.to_2d() + distance = {rid: game.friendly_robots[rid].p.distance_to(ball) for rid in claims} + nearest = min(claims, key=lambda rid: distance[rid]) + current = self._on_ball + if current in distance and distance[nearest] > distance[current] - ON_BALL_SWITCH_MARGIN_M: + return current + return nearest + + +def _clear_of_ball(game: "Game", robot_id: int) -> Vector2D: + """Where the robot stands, or straight out from the ball to `COVER_M` if it is nearer than that.""" + ball = game.ball.p.to_2d() + position = game.friendly_robots[robot_id].p + offset = position - ball + distance = offset.mag() + if distance >= COVER_M or distance == 0.0: + return position + point = ball + offset * (COVER_M / distance) + return clamp_outside_enemy_defense_area(game, clamp_outside_own_defense_area(game, clamp_to_field(point, game))) + + +def _cover_point(game: "Game", rank: int) -> Vector2D: + """`COVER_M` from the ball towards our goal; the further covers spread either side of that line.""" + ball = game.ball.p.to_2d() + to_goal = ball.angle_to(Vector2D(float(game.field.my_goal_line[0][0]), 0.0)) + angle = to_goal + _COVER_ANGLES_RAD[rank % len(_COVER_ANGLES_RAD)] + point = ball + Vector2D(math.cos(angle), math.sin(angle)) * COVER_M + return clamp_outside_enemy_defense_area(game, clamp_outside_own_defense_area(game, clamp_to_field(point, game))) diff --git a/utama_core/engine/context.py b/utama_core/engine/context.py index d04a27bb..b0038360 100644 --- a/utama_core/engine/context.py +++ b/utama_core/engine/context.py @@ -12,7 +12,7 @@ from __future__ import annotations -from dataclasses import dataclass +from dataclasses import dataclass, field from typing import TYPE_CHECKING, Any, Optional from utama_core.motion_planning.src.common.motion_controller import MotionController @@ -31,6 +31,10 @@ class TickContext: # match logging is disabled (the common case — tournament/CI runs) so # tracing a tick is a single `is not None` check, not a real cost. match_log: Optional["MatchLog"] = None + # This tick's: robots driving at the ball (`go_to_ball`, a presser) and robots a teammate is + # about to pass to. `BallRoles` reads both once every tactic has ticked; `Strategy` clears them. + ball_claims: set[int] = field(default_factory=set) + expected_receivers: set[int] = field(default_factory=set) def trace(self, game: "Game", key: str, value: Any) -> None: """`match_log.trace_if_changed` at this tick's time; nothing without a match log. A key diff --git a/utama_core/engine/strategy.py b/utama_core/engine/strategy.py index 02d4f412..a0ad75f4 100644 --- a/utama_core/engine/strategy.py +++ b/utama_core/engine/strategy.py @@ -37,6 +37,8 @@ from dataclasses import dataclass, field from typing import Callable, Optional +from utama_core.engine.ball_release import BallRelease +from utama_core.engine.ball_roles import BallRoles from utama_core.engine.context import TickContext from utama_core.engine.match_log import MatchLog from utama_core.engine.referee_override import ( @@ -177,6 +179,8 @@ def __init__( self._their_restart: Optional[tuple[RefereeCommand, float, float]] = None self._pending_barrier_reset: Optional[dict[TacticId, frozenset[RobotId]]] = None self._referee_override = RefereeOverride(overrides=referee_overrides) + self._ball_release = BallRelease() + self._ball_roles = BallRoles() # Robots the referee, not a tactic, drives this tick, with their job (see `referee_control`). self._referee_control: dict[RobotId, str] = {} @@ -349,7 +353,15 @@ def _held_restart(self, game: Game, command: RefereeCommand) -> Optional[Referee def tick(self, game: Game) -> dict[RobotId, RobotCommand]: self._tick_count += 1 + self._ctx.ball_claims.clear() + self._ctx.expected_receivers.clear() commands = self._tick(game) + if self._referee_control: # a restart or HALT drives the robots: nothing to release + self._ball_release.reset() + self._ball_roles.reset() + else: + commands = self._ball_release.apply(game, self._ctx, commands) + commands = self._ball_roles.apply(game, self._ctx, commands, self._outfield_robot_ids) if self.match_log is not None: self.match_log.clear_untraced(self._tick_count, getattr(game, "ts", 0.0)) return commands diff --git a/utama_core/motion_planning/src/common/motion_controller.py b/utama_core/motion_planning/src/common/motion_controller.py index c7db53c0..413e8acf 100644 --- a/utama_core/motion_planning/src/common/motion_controller.py +++ b/utama_core/motion_planning/src/common/motion_controller.py @@ -19,6 +19,8 @@ def __init__(self, mode: Mode, rsim_env: SSLStandardEnv | None = None): self.pose_ahead = PoseAhead(control_latency_s(mode)) # `move()` holds a robot with the ball to these (`RobotParams.CARRY_SPEED`/`CARRY_TURN`). params = _PARAMS_BY_MODE[Mode(mode)] + self.max_speed: float = params.MAX_VEL + self.max_acceleration: float = params.MAX_ACCELERATION self.carry_speed: float | None = params.CARRY_SPEED self.carry_turn: float | None = params.CARRY_TURN self.min_turn: float | None = params.MIN_TURN diff --git a/utama_core/motion_planning/src/pid/configs.py b/utama_core/motion_planning/src/pid/configs.py index 577055e0..17ecf7e9 100644 --- a/utama_core/motion_planning/src/pid/configs.py +++ b/utama_core/motion_planning/src/pid/configs.py @@ -29,6 +29,8 @@ class TranslationPIDConfigs: integral_min: Union[float, None] = None integral_max: Union[float, None] = None max_acceleration: float = 0.0 + # Share of the speed it can still stop from that a robot holds on its last metre; 0 leaves it to kp. + approach_brake_fraction: float = 0.0 @dataclass(slots=True) @@ -59,6 +61,8 @@ def get_pid_configs(mode: Mode) -> PIDConfigs: integral_min=-5, integral_max=5, max_acceleration=RSIM_PARAMS.MAX_ACCELERATION, + # 2026-11-10, 20 free-kick drills: taken 1 s sooner at the median. 0.8 left two untaken. + approach_brake_fraction=0.6, ), ) if mode == Mode.GRSIM: diff --git a/utama_core/motion_planning/src/pid/pid.py b/utama_core/motion_planning/src/pid/pid.py index 259b0014..d18f0d08 100644 --- a/utama_core/motion_planning/src/pid/pid.py +++ b/utama_core/motion_planning/src/pid/pid.py @@ -115,6 +115,11 @@ def _calculate( return output +_APPROACH_MIN_M = 0.1 # closer than this kp settles the robot, which a higher speed would overshoot +_APPROACH_MAX_M = 1.0 # the planner's carrot is this far ahead until then, so kp is at cruising speed +_STRAIGHT_RUN_M = 0.02 + + class TwoDPID(AbstractPID[Vector2D]): """A 2D PID controller that controls the X and Y dimensions and scales the resulting velocity vector to a maximum speed if needed.""" @@ -126,6 +131,7 @@ def __init__( super().__init__(config) self.max_velocity = config.max_velocity self.max_acceleration = config.max_acceleration + self.approach_brake_fraction = config.approach_brake_fraction # Set by a caller (`FastPathPlanningController`) right before # `calculate()` when `target` is a lookahead "carrot" rather than the # robot's actual destination — see `set_final_target`'s docstring for @@ -263,6 +269,15 @@ def _calculate(self, target: Vector2D, current: Vector2D, robot_id: int) -> Vect max_brake_vel = ( math.sqrt(2 * self.max_acceleration * brake_distance) if self.max_acceleration > 0 else self.max_velocity ) + if self.approach_brake_fraction and final_target is not None and error > 0.0: + # Kp * error is 0.45 m/s with 0.25 m to go, so the last half metre of every move took over 1 s. + # Only inside the last metre: cruising speed is left alone, a higher kp crashed crowded robots. + # And only straight at the destination: a nearer waypoint is a corner, which the planner + # takes by slowing down, and at speed a robot cut across the ball's keep-out circle. + if _APPROACH_MIN_M < brake_distance < _APPROACH_MAX_M and error >= brake_distance - _STRAIGHT_RUN_M: + floor = min(self.Kp * _APPROACH_MAX_M, self.approach_brake_fraction * max_brake_vel) + if output < floor: + x_vel, y_vel = floor * (dx / error), floor * (dy / error) return self._apply_speed_limits(x_vel, y_vel, min(self.max_velocity, max_brake_vel)) def _apply_speed_limits(self, x_vel: float, y_vel: float, max_vel: float) -> Vector2D: diff --git a/utama_core/shared/pass_and_score_geometry.py b/utama_core/shared/pass_and_score_geometry.py index 47919a4f..56ac33b8 100644 --- a/utama_core/shared/pass_and_score_geometry.py +++ b/utama_core/shared/pass_and_score_geometry.py @@ -360,6 +360,16 @@ def intercept_point( _PASS_ROLLING_MPS = 0.5 +_BALL_CONTACT_M = 0.13 # robot centre to ball with both touching +_BALL_ROLL_DECEL_MPS2 = 0.3 # tools/evaluation/reference/world.json, ball_roll_decel +# Off a ball's path by this much a robot can still meet it: the width of its dribbler and a sidestep. +_RECEIVE_REACH_M = 0.1 +_RECEIVE_SIDESTEP_MPS = 1.0 +_RECEIVE_REACH_MAX_M = 1.0 +_INTERCEPT_MIN_M = 0.3 +_INTERCEPT_STEP_S = 0.05 +_CHASE_SPEED_MPS = 1.5 +_CHASE_START_S = 0.1 def ball_line_receive_point(game: Game, receiver_id: int) -> Optional[Vector2D]: @@ -379,6 +389,91 @@ def ball_line_receive_point(game: Game, receiver_id: int) -> Optional[Vector2D]: return clamp_to_field(ball_pos + velocity * (along / speed), game) +def _ball_untouched(game: Game) -> bool: + ball = game.ball.p.to_2d() + robots = [*game.friendly_robots.values(), *game.enemy_robots.values()] + return all(robot.p.distance_to(ball) > _BALL_CONTACT_M for robot in robots) + + +def receiver_of_rolling_ball(game: Game, robot_ids) -> Optional[int]: + """The first of `robot_ids` a ball rolling free will come to and that can get onto its path in + time. Whoever kicked it, a pass nobody announced or an enemy's: the ball is coming either way. + None for a shot at the enemy goal, which a teammate must not stop, or when an enemy is first + to it: going for those, the enemy got there first 42% of the time (2026-11-09).""" + if not robot_ids: + return None + ball = game.ball + velocity = Vector2D(ball.v.x, ball.v.y) + speed = velocity.mag() + if speed < _PASS_ROLLING_MPS or not _ball_untouched(game): + return None + start = ball.p.to_2d() + if _reaches_goal(game.field.enemy_goal_line, start, math.atan2(velocity.y, velocity.x), 0.0): + return None + best, best_along = None, None + for robot_id in robot_ids: + along = _distance_along_ball_path(game.friendly_robots[robot_id].p, start, velocity) + if along is not None and (best is None or along < best_along): + best, best_along = robot_id, along + if best is None: + return None + for enemy in game.enemy_robots.values(): + along = _distance_along_ball_path(enemy.p, start, velocity) + if along is not None and along < best_along: + return None + return best + + +def _distance_along_ball_path(position: Vector2D, start: Vector2D, velocity: Vector2D) -> Optional[float]: + """How far down the path of a ball rolling from `start` a robot at `position` can meet it. + None if it is behind the ball, past where the ball stops, or cannot get onto the path in time.""" + speed = velocity.mag() + direction = velocity * (1.0 / speed) + offset = position - start + along = offset.dot(direction) + if along <= 0.0 or along > speed**2 / (2.0 * _BALL_ROLL_DECEL_MPS2): + return None + lateral = abs(offset.x * direction.y - offset.y * direction.x) + if lateral > min(_RECEIVE_REACH_MAX_M, _RECEIVE_REACH_M + _RECEIVE_SIDESTEP_MPS * along / speed): + return None + return along + + +def still_receiving(game: Game, robot_id: int) -> bool: + """The free ball a robot set out to meet is still on its way to it. Looser than choosing the + receiver (`receiver_of_rolling_ball`), whose reach check came and went with vision noise and + left a robot receiving for 0.16 s on average (2026-11-09).""" + if ball_line_receive_point(game, robot_id) is None or not _ball_untouched(game): + return False + ball = game.ball + velocity = Vector2D(ball.v.x, ball.v.y) + offset = game.friendly_robots[robot_id].p - ball.p.to_2d() + return abs(offset.x * velocity.y - offset.y * velocity.x) / velocity.mag() <= _RECEIVE_REACH_MAX_M + + +def ball_intercept_point(game: Game, robot_id: int) -> Optional[Vector2D]: + """Where `robot_id` can first meet a ball rolling free, or where it comes to rest if never + before. None for a slow ball, one a robot is touching, or a robot already beside it.""" + ball = game.ball + velocity = Vector2D(ball.v.x, ball.v.y) + speed = velocity.mag() + start = ball.p.to_2d() + position = game.friendly_robots[robot_id].p + if speed < _PASS_ROLLING_MPS or position.distance_to(start) < _INTERCEPT_MIN_M or not _ball_untouched(game): + return None + direction = velocity * (1.0 / speed) + stops_after = speed / _BALL_ROLL_DECEL_MPS2 + t = 0.0 + while t < stops_after: + spot = start + direction * (speed * t - 0.5 * _BALL_ROLL_DECEL_MPS2 * t**2) + if position.distance_to(spot) / _CHASE_SPEED_MPS + _CHASE_START_S <= t: + break + t += _INTERCEPT_STEP_S + else: + spot = start + direction * (speed**2 / (2.0 * _BALL_ROLL_DECEL_MPS2)) + return clamp_outside_enemy_defense_area(game, clamp_outside_own_defense_area(game, clamp_to_field(spot, game))) + + def enemy_positions(game: Game) -> list[Vector2D]: return [enemy.p for enemy in game.enemy_robots.values() if enemy is not None] @@ -706,7 +801,143 @@ def find_best_shot( return _find_best_shot(point, enemy_robots, goal_x, goal_y1, goal_y2, prev_best_shot_y, switch_margin) +# A kick that has to go now: the lane only has to clear the ball's width past a robot's body, and +# a robot touching the ball beside this one does not block a kick that leaves away from it. +RELEASE_LANE_CLEARANCE = ROBOT_RADIUS + BALL_RADIUS + 0.05 +_OWN_GOAL_RELEASE_MARGIN_M = 0.3 +_MIN_OPEN_TEAMMATE_M = 0.7 +# Further than this a full-power kick reached the teammate less than 45% of the time and left the +# pitch more than 40%, against 52% and 30% from 1.5 m to 3.5 m (36 matches, 2026-11-09). +MAX_OPEN_TEAMMATE_M = 3.5 +# A passer tells its receiver once it is this near its aim: a turn away from the kick. Told any +# earlier, the ball came to only 14% of the receivers that stopped for it (2026-11-09). +ANNOUNCE_PASS_RAD = 0.5 + + +def _reaches_goal(line, point: Vector2D, heading: float, margin: float) -> bool: + goal_x = float(line[0][0]) + half_width = max(abs(float(line[0][1])), abs(float(line[1][1]))) + to_line = goal_x - point.x + if math.cos(heading) * to_line <= 0.0: + return False + return abs(point.y + math.tan(heading) * to_line) <= half_width + margin + + +def reaches_own_goal(game: Game, point: Vector2D, heading: float) -> bool: + """A kick from `point` along `heading` would reach our goal mouth.""" + return _reaches_goal(game.field.my_goal_line, point, heading, _OWN_GOAL_RELEASE_MARGIN_M) + + +def open_teammate( + game: Game, robot_id: int, clearance: float = ROBOT_RADIUS + 0.15, origin: Optional[Vector2D] = None +) -> Optional[int]: + """Id of the most advanced teammate in range of a kick down a clear lane, outside our own box. + From `origin` for a robot not at the ball yet, otherwise from where the robot stands.""" + position = game.friendly_robots[robot_id].p if origin is None else origin + enemies = enemy_positions(game) + goal_x = enemy_goal_line(game)[0] + best, best_to_goal = None, None + for teammate_id, teammate in game.friendly_robots.items(): + if ( + teammate_id == robot_id + or not _MIN_OPEN_TEAMMATE_M <= position.distance_to(teammate.p) <= MAX_OPEN_TEAMMATE_M + ): + continue + if in_own_defense_area(game, teammate.p) or segment_blocked(position, teammate.p, enemies, clearance): + continue + to_goal = abs(goal_x - teammate.p.x) + if best is None or to_goal < best_to_goal: + best, best_to_goal = teammate_id, to_goal + return best + + +_RESTART_SUPPORT_M = 2.0 +_RESTART_SUPPORT_OFFSETS_RAD = (0.0, 0.5, -0.5, 1.0, -1.0) +_RESTART_SUPPORT_FIELD_MARGIN_M = 0.3 + + +def restart_support(game: Game, kicker_id: int, ball: Vector2D) -> Optional[tuple[int, Vector2D]]: + """(teammate, spot) for a restart with nobody to pass to: the nearest teammate outside our box and + a spot `_RESTART_SUPPORT_M` from the ball towards the enemy goal with a clear lane from it, kept + inside the pitch. None when no teammate can come or no such spot exists.""" + others = { + rid: robot + for rid, robot in game.friendly_robots.items() + if rid != kicker_id and not in_own_defense_area(game, robot.p) + } + if not others: + return None + enemies = enemy_positions(game) + goal_x, goal_y1, goal_y2 = enemy_goal_line(game) + to_goal = ball.angle_to(Vector2D(goal_x, (goal_y1 + goal_y2) / 2.0)) + for offset in _RESTART_SUPPORT_OFFSETS_RAD: + spot = ball + Vector2D(math.cos(to_goal + offset), math.sin(to_goal + offset)) * _RESTART_SUPPORT_M + in_field = ( + abs(spot.x) <= game.field.half_length - _RESTART_SUPPORT_FIELD_MARGIN_M + and abs(spot.y) <= game.field.half_width - _RESTART_SUPPORT_FIELD_MARGIN_M + ) + if not in_field or spot.distance_to(clamp_outside_enemy_defense_area(game, spot)) > 0.0: + continue + if spot.distance_to(clamp_outside_own_defense_area(game, spot)) > 0.0: + continue + if not segment_blocked(ball, spot, enemies, RELEASE_LANE_CLEARANCE): + return min(others, key=lambda rid: others[rid].p.distance_to(spot)), spot + return None + + +def _distance_to_field_edge(game: Game, point: Vector2D, heading: float) -> float: + dx, dy = math.cos(heading), math.sin(heading) + limits = [] + if abs(dx) > 1e-9: + limits.append((math.copysign(game.field.half_length, dx) - point.x) / dx) + if abs(dy) > 1e-9: + limits.append((math.copysign(game.field.half_width, dy) - point.y) / dy) + return max(0.0, min(limits)) + + +def release_heading(game: Game, robot_id: int) -> float: + """Where to kick a ball that cannot be held any longer: at an open teammate, otherwise at the + enemy goal, turned off it just enough to clear an enemy in the way. Kicked down whichever lane + looked clear instead, 56% left the pitch and on-target kicks halved (round-robin of 2026-11-09).""" + robot = game.friendly_robots[robot_id] + teammate = open_teammate(game, robot_id, RELEASE_LANE_CLEARANCE) + if teammate is not None: + return robot.p.angle_to(game.friendly_robots[teammate].p) + goal_x, goal_y1, goal_y2 = enemy_goal_line(game) + return _nearest_clear_heading( + game, robot_id, robot.p.angle_to(Vector2D(goal_x, (goal_y1 + goal_y2) / 2.0)), _RELEASE_OFFSETS_RAD + ) + + +_CLEARANCE_OFFSETS_RAD = (0.0, 0.26, -0.26, 0.52, -0.52) +# Wide enough to clear an enemy touching the ball dead ahead (a body 0.21 m from the kicker's). +_RELEASE_OFFSETS_RAD = (0.0, 0.35, -0.35, 0.7, -0.7, 1.05, -1.05, 1.4, -1.4) +_CLEARANCE_LANE_M = 2.0 + + +def upfield_heading(game: Game, robot_id: int) -> float: + """Straight upfield, or the nearest angle off it with a clear lane that stays in play.""" + return _nearest_clear_heading(game, robot_id, math.pi if game.my_team_is_right else 0.0, _CLEARANCE_OFFSETS_RAD) + + +def _nearest_clear_heading(game: Game, robot_id: int, base: float, offsets_rad: tuple[float, ...]) -> float: + """`base`, or the angle off it nearest to it with a clear lane that stays in play.""" + robot = game.friendly_robots[robot_id] + enemies = enemy_positions(game) + # Of two equal angles, the one towards the middle of the field. + ordered = sorted(offsets_rad, key=lambda o: (abs(o), abs(robot.p.y + _CLEARANCE_LANE_M * math.sin(base + o)))) + for offset in ordered: + heading = base + offset + if offset != 0.0 and _distance_to_field_edge(game, robot.p, heading) < _CLEARANCE_LANE_M: + continue + lane_end = robot.p + Vector2D(math.cos(heading), math.sin(heading)) * _CLEARANCE_LANE_M + if not segment_blocked(robot.p, lane_end, enemies, RELEASE_LANE_CLEARANCE): + return heading + return base + + _NO_SHOT_STRAFE_STEP = 0.6 # metres of lateral reposition per tick while hunting for a lane +_DEEP_NEAR_LINE_M = 1.5 def no_shot_reposition_target( @@ -765,6 +996,10 @@ def _clamped_target_y(sign: float) -> float: -field_half_width + margin, min(field_half_width - margin, carrier_pos.y + sign * _NO_SHOT_STRAFE_STEP) ) + if abs(goal_x - carrier_pos.x) < _DEEP_NEAR_LINE_M and not goal_y1 <= carrier_pos.y <= goal_y2: + # Deep and wide of the goal, the way out is towards the middle: the other way is the corner. + away_sign = 1.0 if carrier_pos.y < 0.0 else -1.0 + target_y = _clamped_target_y(away_sign) if abs(target_y - carrier_pos.y) < _NO_SHOT_STRAFE_STEP / 2: # The preferred direction was clamped away to a near-zero step — diff --git a/utama_core/skills/src/go_to_ball.py b/utama_core/skills/src/go_to_ball.py index 07e4dca8..fcf1b83d 100644 --- a/utama_core/skills/src/go_to_ball.py +++ b/utama_core/skills/src/go_to_ball.py @@ -36,6 +36,7 @@ import math from typing import Optional +from utama_core.config.enums import Mode from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.engine.context import TickContext from utama_core.entities.data.command import RobotCommand @@ -44,6 +45,8 @@ from utama_core.motion_planning.src.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import ( ball_in_enemy_defense_area, + ball_intercept_point, + clamp_outside_own_defense_area, enemy_defense_area_hold_point, ) from utama_core.skills.src.go_to_point import go_to_point @@ -56,6 +59,13 @@ _APPROACH_OVERSHOOT_M = ROBOT_RADIUS * 0 _DRIBBLE_OVERSHOOT_M = ROBOT_RADIUS * (1 / 10) +# A ball with an enemy on it or about to reach it is a race, and the planner covers the last metre +# slowly. In about 230 paired drills of contested balls, sprinting gave our side 7.1 points more +# possession (±2.2) at a free ball and a further 7.3 (±1.9) at one an enemy holds, with hard contacts +# roughly level (2026-11-10). Simulation only: no field data for it yet. +_RACE_ROBOT_RANGE_M = 1.2 +_RACE_ENEMY_RANGE_M = 0.6 + def _target_past_ball(ball: Vector2D, approach_oren: float, overshoot_distance: float) -> Vector2D: if overshoot_distance <= 0.0: @@ -66,6 +76,12 @@ def _target_past_ball(ball: Vector2D, approach_oren: float, overshoot_distance: return Vector2D(ball.x + dx * overshoot_distance, ball.y + dy * overshoot_distance) +def _racing_for_ball(game: Game, motion_controller: MotionController, robot: Vector2D, ball: Vector2D) -> bool: + if motion_controller.mode == Mode.REAL or robot.distance_to(ball) >= _RACE_ROBOT_RANGE_M: + return False + return any(enemy.p.distance_to(ball) < _RACE_ENEMY_RANGE_M for enemy in game.enemy_robots.values()) + + def go_to_ball( game: Game, motion_controller: MotionController, @@ -97,6 +113,9 @@ def go_to_ball( ball = game.ball.p.to_2d() robot = game.friendly_robots[robot_id].p + if ctx is not None: + ctx.ball_claims.add(robot_id) + if ball_in_enemy_defense_area(game): if ctx is not None and ctx.match_log is not None: ctx.match_log.trace_if_changed( @@ -110,6 +129,29 @@ def go_to_ball( game=game, motion_controller=motion_controller, robot_id=robot_id, target_coords=hold, dribbling=False ) + intercept = ball_intercept_point(game, robot_id) + if intercept is not None: + # Moving, the ball will be somewhere else by the time the robot arrives. + return move( + game=game, + motion_controller=motion_controller, + robot_id=robot_id, + target_coords=intercept, + target_oren=robot.angle_to(ball), + dribbling=dribble_when_near, + ) + + if _racing_for_ball(game, motion_controller, robot, ball): + return move( + game=game, + motion_controller=motion_controller, + robot_id=robot_id, + target_coords=clamp_outside_own_defense_area(game, ball), + target_oren=robot.angle_to(ball), + dribbling=dribble_when_near, + sprint=True, + ) + if shield: approach_oren, shielding = shielded_approach_angle(game, robot, ball, robot_id) else: diff --git a/utama_core/skills/src/goalkeep.py b/utama_core/skills/src/goalkeep.py index f2f75427..b13e33c9 100644 --- a/utama_core/skills/src/goalkeep.py +++ b/utama_core/skills/src/goalkeep.py @@ -21,14 +21,20 @@ `docs/strategies.md`'s "Known open bugs"). """ -from typing import Optional +from typing import TYPE_CHECKING, Optional from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.data_processing.predictors.position import predict_ball_pos_at_x from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import ball_in_own_defense_area, has_ball +from utama_core.shared.pass_and_score_geometry import ( + ANNOUNCE_PASS_RAD, + ball_in_own_defense_area, + has_ball, + open_teammate, + oriented_towards, +) from utama_core.skills.src.go_to_point import go_to_point from utama_core.skills.src.kick_upfield import kick_upfield from utama_core.skills.src.utils.defense_utils import ( @@ -36,9 +42,16 @@ intersection_with_x_line, single_defender_stop_y, ) +from utama_core.skills.src.utils.move_utils import kick, turn_on_spot + +if TYPE_CHECKING: + from utama_core.engine.context import TickContext # TODO: instead of checking number of friendly, should check roles +# A pass out from our own goal has to be safe: an enemy this near its line can step onto it. +_KEEPER_PASS_CLEARANCE = 0.4 +_KEEPER_PASS_TOLERANCE_RAD = 0.12 _RETRIEVE_BALL_SPEED = 0.3 # m/s — below this, a ball in our box is "at rest," not a live shot to block # `predict_ball_pos_at_x` returns None the instant the ball's x reaches (or @@ -109,10 +122,26 @@ def _ball_needs_clearing(game: Game, robot_id: int) -> bool: return has_ball(game, robot_id, visual=True) +def _distribute(game: Game, motion_controller: MotionController, robot_id: int, ctx: Optional["TickContext"]): + """Kick the held ball to a teammate standing free, and only without one upfield.""" + teammate = open_teammate(game, robot_id, _KEEPER_PASS_CLEARANCE) + if teammate is None: + return kick_upfield(game, motion_controller, robot_id) + target_oren = game.friendly_robots[robot_id].p.angle_to(game.friendly_robots[teammate].p) + if ctx is not None and oriented_towards(game, robot_id, target_oren, ANNOUNCE_PASS_RAD): + ctx.expected_receivers.add(teammate) + if oriented_towards(game, robot_id, target_oren, _KEEPER_PASS_TOLERANCE_RAD): + return kick() + return turn_on_spot( + game=game, motion_controller=motion_controller, robot_id=robot_id, target_oren=target_oren, dribbling=True + ) + + def goalkeep( game: Game, motion_controller: MotionController, robot_id: int, + ctx: Optional["TickContext"] = None, ): """Move `robot_id` (the goalkeeper) to cover the predicted shot on the goal line. @@ -148,7 +177,7 @@ def goalkeep( # creep in the box until `KeeperHeldBallRule` fired (5-6 per round-robin). # Face the ball and take it onto the dribbler first, as retrieval does. return go_to_point(game, motion_controller, robot_id, game.ball.p.to_2d(), dribbling=True) - return kick_upfield(game, motion_controller, robot_id) + return _distribute(game, motion_controller, robot_id, ctx) edge_offset = BALL_RADIUS + ROBOT_RADIUS goal_x = game.field.my_goal_line[0][0] diff --git a/utama_core/skills/src/kick_upfield.py b/utama_core/skills/src/kick_upfield.py index bd2f63dc..64904fb2 100644 --- a/utama_core/skills/src/kick_upfield.py +++ b/utama_core/skills/src/kick_upfield.py @@ -7,10 +7,9 @@ `ShadowAndMarkTactic`. """ -from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import oriented_towards +from utama_core.shared.pass_and_score_geometry import oriented_towards, upfield_heading from utama_core.skills.src.utils.move_utils import kick, turn_on_spot # A clearance only has to go upfield, not along a line: kick within ~11 degrees of it. With the @@ -21,13 +20,11 @@ def kick_upfield(game: Game, motion_controller: MotionController, robot_id: int): - """Kick once facing straight upfield (away from our own goal, along the - field's long axis); until then, turn on the spot with the dribbler on. + """Kick once facing upfield (`upfield_heading`: straight, or off it when + that lane is blocked); until then, turn on the spot with the dribbler on. Assumes the ball is on `robot_id`'s dribbler — check contact `has_ball` first, a kick without it does nothing.""" - robot = game.friendly_robots[robot_id] - upfield_sign = -1.0 if game.my_team_is_right else 1.0 - target_oren = robot.p.angle_to(Vector2D(robot.p.x + upfield_sign * 2.0, robot.p.y)) + target_oren = upfield_heading(game, robot_id) if oriented_towards(game, robot_id, target_oren, CLEARANCE_TOLERANCE_RAD): return kick() return turn_on_spot( diff --git a/utama_core/skills/src/man_mark.py b/utama_core/skills/src/man_mark.py index bc07ff22..36eeef8c 100644 --- a/utama_core/skills/src/man_mark.py +++ b/utama_core/skills/src/man_mark.py @@ -11,12 +11,17 @@ `press_and_contain.py`. """ +import math + from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.motion_planning.src.common.motion_controller import MotionController from utama_core.skills.src.utils.move_utils import face_ball, move MARK_STANDOFF = 0.6 # metres — mark from this distance on the goal side of the opponent, not on top of them +_ON_BALL_M = 0.13 # robot centre to ball with both touching +_MIN_READ_PASS_M = 1.2 # nearer than the standoff and a bit, there is no room to step between them +_PASS_READ_RAD = 0.2 def mark_target(game: Game, opponent_id: int) -> Vector2D: @@ -26,9 +31,32 @@ def mark_target(game: Game, opponent_id: int) -> Vector2D: # Toward our own goal. The sign was reversed until 2026-10-05: markers stood on the # far side, leaving the opponent a clear run at goal. direction = -1.0 if goal_x < opponent.p.x else 1.0 + passer = _passer_facing(game, opponent_id) + if passer is not None: + # The ball is about to come to this opponent: stand in its way rather than behind it. + towards_passer = (passer.p - opponent.p).norm() + return opponent.p + towards_passer * MARK_STANDOFF return Vector2D(opponent.p.x + direction * MARK_STANDOFF, opponent.p.y) +def _passer_facing(game: Game, opponent_id: int): + """The enemy on the ball if it is facing `opponent_id` from far enough to pass to it.""" + ball = game.ball + if ball is None: + return None + here = ball.p.to_2d() + opponent = game.enemy_robots[opponent_id] + for enemy_id, enemy in game.enemy_robots.items(): + if enemy_id == opponent_id or enemy.p.distance_to(here) > _ON_BALL_M: + continue + if enemy.p.distance_to(opponent.p) < _MIN_READ_PASS_M: + continue + off = (enemy.p.angle_to(opponent.p) - enemy.orientation + math.pi) % (2.0 * math.pi) - math.pi + if abs(off) <= _PASS_READ_RAD: + return enemy + return None + + def man_mark(game: Game, motion_controller: MotionController, robot_id: int, target_id: int): """Move `robot_id` to `mark_target` for `target_id`, facing the ball.""" robot = game.friendly_robots[robot_id] diff --git a/utama_core/skills/src/utils/move_utils.py b/utama_core/skills/src/utils/move_utils.py index e33aa7c1..4c76c661 100644 --- a/utama_core/skills/src/utils/move_utils.py +++ b/utama_core/skills/src/utils/move_utils.py @@ -13,9 +13,46 @@ # Off its target orientation by more than this, a robot turns at least `MotionController.min_turn`. _MIN_TURN_FROM_RAD = 0.01 +# Crashing is a foul above 1.5 m/s of closing speed. In 12 matches on 2026-11-09 all 33 charges +# were head-on, both robots closing at 1.2-1.5 m/s from 1.5-2 m apart and neither braking: the +# path planner steers around robots but does not slow for them. Each robot sheds its own share, +# so two robots using this meet legally, and one facing an enemy that does not slow is the slower. +_LEGAL_CLOSING_MPS = 1.3 +_MIN_CONTACT_APPROACH_MPS = 0.5 +_ENEMY_BRAKING_MPS2 = 3.0 # of rsim's 4 m/s²: leaves room for the command delay +_ENEMY_BRAKING_RANGE_M = 1.2 + ### TODO: IT IS CONTENTIOUS IF WE EVEN NEED THIS MOVE FUNCTION ANYMORE. POTENTIALLY JUST SEND DIRECTLY TO MOTION CONTROLLER ### +def _limit_closing_speed(robot, enemies, velocity: Vector2D) -> Vector2D: + """`velocity` with its component towards each nearby enemy capped to what can still brake.""" + vx, vy = velocity.x, velocity.y + for enemy in enemies: + dx, dy = enemy.p.x - robot.p.x, enemy.p.y - robot.p.y + distance = math.hypot(dx, dy) + if not 1e-6 < distance < _ENEMY_BRAKING_RANGE_M: + continue + ux, uy = dx / distance, dy / distance + approach = vx * ux + vy * uy + enemy_approach = max(0.0, -(enemy.v.x * ux + enemy.v.y * uy)) + at_contact = max(_MIN_CONTACT_APPROACH_MPS, _LEGAL_CLOSING_MPS - enemy_approach) + limit = at_contact + math.sqrt(_ENEMY_BRAKING_MPS2 * max(0.0, distance - 2.0 * ROBOT_RADIUS)) + if approach > limit: + vx -= (approach - limit) * ux + vy -= (approach - limit) * uy + return Vector2D(vx, vy) if (vx, vy) != (velocity.x, velocity.y) else velocity + + +def _sprint_velocity(position: Vector2D, target: Vector2D, max_speed: float, max_acceleration: float) -> Vector2D: + """Towards `target`, as fast as a robot braking at `max_acceleration` can still stop on it.""" + offset = target - position + distance = offset.mag() + if distance == 0.0: + return Vector2D(0.0, 0.0) + return offset * (min(max_speed, math.sqrt(2.0 * max_acceleration * distance)) / distance) + + def move( game: Game, motion_controller: MotionController, @@ -23,8 +60,11 @@ def move( target_coords: Vector2D, target_oren: float, dribbling: bool = False, + sprint: bool = False, ) -> RobotCommand: - """Calculate the robot command to move towards a target point with a specified orientation.""" + """Calculate the robot command to move towards a target point with a specified orientation. + `sprint`: straight at the target, as fast as it can still stop there, instead of along the planner's + path, which covers a short hop at about 0.45 m/s. Only for a short, clear step that cannot wait.""" # From where our robots will be when this command takes effect (`PoseAhead`), and in the # robot's frame as it will be turned by then. @@ -38,8 +78,14 @@ def move( target_oren=target_oren, ) + if sprint: + global_velocity = _sprint_velocity( + robot.p, target_coords, motion_controller.max_speed, motion_controller.max_acceleration + ) + capped_velocity = _limit_closing_speed(robot, ahead.enemy_robots.values(), global_velocity) + adjusted = sprint or capped_velocity is not global_velocity + global_velocity = capped_velocity forward_vel, left_vel = rotate_vector(global_velocity.x, global_velocity.y, robot.orientation) - adjusted = False # A turn slower than the robot can make leaves it short of its target orientation for good. min_turn = motion_controller.min_turn diff --git a/utama_core/strategy/pickers.py b/utama_core/strategy/pickers.py index c4bca5b2..1cb14555 100644 --- a/utama_core/strategy/pickers.py +++ b/utama_core/strategy/pickers.py @@ -286,7 +286,10 @@ def dist(robot) -> float: rid, robot = min(game.friendly_robots.items(), key=lambda item: dist(item[1])) enemy_nearest = min((dist(e) for e in game.enemy_robots.values()), default=math.inf) - return rid if dist(robot) <= _KICK_REACH_M and dist(robot) < enemy_nearest else None + # An enemy in reach too is a contest, not a kicker waiting. Comparing the two distances there + # (0.112 m against 0.113 m) changed the answer every tick and with it who held the attack + # slot, each change wiping that tactic's memory (press_and_pass_vs_tiki_taka_plus, 2026-11-09). + return rid if dist(robot) <= _KICK_REACH_M < enemy_nearest else None def holds_ball(game: Game, robot_id: RobotId) -> bool: diff --git a/utama_core/tactics/_pass_and_score.py b/utama_core/tactics/_pass_and_score.py index 2bf6c1de..12df2437 100644 --- a/utama_core/tactics/_pass_and_score.py +++ b/utama_core/tactics/_pass_and_score.py @@ -24,6 +24,7 @@ from utama_core.entities.game import Game from utama_core.shared.field_scaling import scale_point_from_standard_field from utama_core.shared.pass_and_score_geometry import ( + ANNOUNCE_PASS_RAD, at_target, ball_line_receive_point, carry_exhausted, @@ -39,6 +40,7 @@ intercept_point, kick_bend, no_shot_reposition_target, + open_teammate, oriented_towards, score_pass_setup, segment_blocked, @@ -445,15 +447,37 @@ def _pass_exec( FACE_GOAL_RAD = 0.3 +_LAY_OFF_TOLERANCE_RAD = 0.1 + + def move_for_a_shot(game: Game, ctx: TickContext, robot_id: int) -> RobotCommand: - """No clear shot: with the ball, slide sideways for one (`no_shot_reposition_target`), - facing the goal. A robot that took the ball facing elsewhere pivots on it to face the goal + """No clear shot: pass to an open teammate; with none, slide sideways for a shot + (`no_shot_reposition_target`), facing the goal. A robot that took the ball facing elsewhere pivots on it to face the goal first: turning while sliding lost the ball every time on the real robots (shooting drill, 2026-10-28), while the pivot is what pass_receive turns with. It pivots only with the ball sensor on: seen on the dribbler's edge but not on the sensor, the pivot turned away from the ball and pushed it off (save_and_counter, 2026-10-28), so it settles the ball first.""" goal_x, goal_y1, goal_y2 = enemy_goal_line(game) robot = game.friendly_robots[robot_id] + teammate = open_teammate(game, robot_id) if has_ball(game, robot_id) else None + if teammate is not None: + # Sliding sideways gains no ground and was the loop behind the jams of 2026-11-09. + target_oren = robot.p.angle_to(game.friendly_robots[teammate].p) - kick_bend( + game, ctx.motion_controller, robot_id + ) + if oriented_towards(game, robot_id, target_oren, ANNOUNCE_PASS_RAD): + ctx.expected_receivers.add(teammate) + if oriented_towards(game, robot_id, target_oren, _LAY_OFF_TOLERANCE_RAD): + ctx.trace(game, f"shoot[{robot_id}]", "no clear shot · passing") + return kick() + ctx.trace(game, f"shoot[{robot_id}]", "no clear shot · turning to pass") + return turn_on_spot( + game=game, + motion_controller=ctx.motion_controller, + robot_id=robot_id, + target_oren=target_oren, + dribbling=True, + ) goal_oren = robot.p.angle_to(Vector2D(goal_x, (goal_y1 + goal_y2) / 2.0)) if not oriented_towards(game, robot_id, goal_oren, FACE_GOAL_RAD): if not has_ball(game, robot_id): diff --git a/utama_core/tactics/defense.py b/utama_core/tactics/defense.py index ffb53c03..5a85413b 100644 --- a/utama_core/tactics/defense.py +++ b/utama_core/tactics/defense.py @@ -49,7 +49,6 @@ from utama_core.engine.context import TickContext from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag from utama_core.entities.data.command import RobotCommand -from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.shared.pass_and_score_geometry import ( ball_in_own_defense_area, @@ -57,6 +56,7 @@ has_ball, oriented_towards, own_defense_area_exit_point, + upfield_heading, ) from utama_core.skills.src.defend_parameter import defend_parameter from utama_core.skills.src.go_to_ball import go_to_ball @@ -64,10 +64,6 @@ from utama_core.skills.src.utils.move_utils import kick, turn_on_spot _LOOSE_BALL_CLAIM_RANGE = 1.5 # metres — matches ball_is_loose's own contest range -# How far upfield (away from our own goal) the clearance aims, along the -# ball's current y — simpler than `ClearBallTactic`'s multi-lane scoring, -# appropriate for this tactic's "minimal baseline" role (see class docstring). -_CLEAR_DISTANCE = 4.5 @dataclass @@ -190,12 +186,7 @@ def _clear(self, game: Game, ctx: TickContext, robot_id: RobotId) -> RobotComman docstring). `robot_id` is only ever called here once it already has the ball (`carrier_id`'s definition in `tick()`), so there is no chase branch.""" - ball_pos = game.ball.p.to_2d() - attack_dir = -1.0 if game.my_team_is_right else 1.0 - half_length = game.field.half_length - target_x = max(-half_length + 0.5, min(half_length - 0.5, ball_pos.x + attack_dir * _CLEAR_DISTANCE)) - target = Vector2D(target_x, ball_pos.y) - target_oren = game.friendly_robots[robot_id].p.angle_to(target) + target_oren = upfield_heading(game, robot_id) if oriented_towards(game, robot_id, target_oren) and has_ball(game, robot_id): return kick() return turn_on_spot( diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index 8faf854b..d665b640 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -39,6 +39,7 @@ from dataclasses import dataclass, field from typing import Optional +from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.config.settings import CONTROL_FREQUENCY from utama_core.engine.context import TickContext from utama_core.engine.tactic import BaseTactic, RobotId, TacticId, TacticTag @@ -63,6 +64,7 @@ no_shot_reposition_target, oriented_towards, own_defense_area_exit_point, + release_heading, score_pass_setup, segment_blocked, shot_heading_reachable, @@ -90,6 +92,10 @@ # reposition path (same one used when no pass lane exists at all) breaks # the deadlock regardless of which specific geometry caused the receiver to # never arrive. +# How long a carrier waits with the ball for its receiver to get into place before passing to it +# where it stands. Waited out to `_MAX_HOP_TICKS`, twice over on a first touch, carriers stood still +# for 9 s after free kicks (high_press_vs_split_shape t=500.6, tournament_20261109_225810). +_MAX_PASS_WAIT_TICKS = round(1.0 * CONTROL_FREQUENCY) _MAX_HOP_TICKS = round(4.0 * CONTROL_FREQUENCY) # 4s — generous vs. a real catch, short vs. a match # An enemy walking onto the direct carrier-receiver line mid-hop makes the # pass interceptable, but is a much more urgent signal than "receiver is @@ -130,6 +136,7 @@ # `_MAX_HOPS_PER_POSSESSION` and force the shot rather than repositioning # forever. _FIRST_TOUCH_FORCE_SHOT_TICKS = round(15.0 * CONTROL_FREQUENCY) # 15s — well past any real restart window +_RELOCATE_LANE_CLEARANCE = ROBOT_RADIUS + 0.1 _RELOCATE_MIN_SEPARATION = 0.9 # metres — a relocating support point must clear the carrier and other supports # Retreat standoff from our own area front edge while the ball is in our own # half: support robots hold this far off the box line instead of packing it. @@ -261,8 +268,13 @@ def _relocate_target(game: Game, robot_id: int, avoid: list[Vector2D]) -> Vector # reachable run beats a short lateral shuffle); among similarly # advanced options, the one nearest this robot, so the target holds # still once reached. `avoid` already keeps support robots apart. + # A run nobody can pass to first of all: the lane from the ball counts before the progress. + # Wider for a spot further from where the robot stands, so it does not leave a lane it has + # for one that only looks a little better. + lane = _RELOCATE_LANE_CLEARANCE + (0.1 if point.distance_to(current) > 0.5 else 0.0) + lane_open = not segment_blocked(game.ball.p.to_2d(), point, enemy_positions(game), lane) progress = point.x * attack_sign - key = (progress, -point.distance_to(current)) + key = (lane_open, progress, -point.distance_to(current)) if best_progress is None or key > best_progress: best, best_progress = point, key return best if best is not None else current @@ -487,8 +499,7 @@ def tick( # the shoot branch below, which would reintroduce the double- # touch bug this whole block exists to prevent. Retry next tick # as `_relocate_others` keeps repositioning teammates; give up - # and force a solo shot only after `_MAX_HOP_TICKS`, the same - # timeout budget the in-flight pass handshake already uses. + # and force a solo shot after `_MAX_PASS_WAIT_TICKS`. # # The give-up is once per possession (`first_touch_hold_spent`): # it used to fall through for one tick and then hold again for @@ -501,7 +512,7 @@ def tick( # around them (tournament_20261003_102921, # clear_danger_vs_overload_flow_RK t=171-192 s). mem.hop_ticks += 1 - if mem.hop_ticks < _MAX_HOP_TICKS: + if mem.hop_ticks < _MAX_PASS_WAIT_TICKS: carrier_pos = game.friendly_robots[carrier_id].p goal_x, goal_y1, goal_y2 = enemy_goal_line(game) commands[carrier_id] = move( @@ -540,7 +551,9 @@ def tick( mem.hop_ticks = 0 mem.lane_blocked_ticks = 0 else: - hop_commands, pass_complete, lane_blocked = _pass_exec(game, ctx, carrier_id, mem.receiver_id) + hop_commands, pass_complete, lane_blocked = _pass_exec( + game, ctx, carrier_id, mem.receiver_id, kick_now=mem.hop_ticks >= _MAX_PASS_WAIT_TICKS + ) mem.lane_blocked_ticks = mem.lane_blocked_ticks + 1 if lane_blocked else 0 commands.update(hop_commands) self._relocate_others(game, ctx, robot_ids, carrier_id, commands, also_exclude=mem.receiver_id) @@ -588,12 +601,10 @@ def tick( # The strafe below carries the ball sideways with no end of its own; # past 1.0m that is an excessive-dribbling foul (51 in the 2026-09-23 - # round-robin). Once the carry is spent, shoot at the goal centre - # instead: a blocked shot keeps the ball live, a foul hands it over. + # round-robin). Once the carry is spent, kick to an open teammate or + # open space instead: a foul hands the ball over. carry_spent = carry_exhausted(game, mem.carry_origin) blind_shot = carry_spent and best_shot_y is None - if blind_shot: - best_shot_y = (goal_y1 + goal_y2) / 2.0 if not carry_spent and (best_shot_y is None or (first_touch_stuck and not force_shot)): # No open lane at all — freezing here (the old behaviour) never # resolves against a stationary blocker (e.g. a keeper at the @@ -603,8 +614,10 @@ def tick( commands[carrier_id] = move_for_a_shot(game, ctx, carrier_id) else: bend = kick_bend(game, ctx.motion_controller, carrier_id) - target_oren = carrier_pos.angle_to(Vector2D(goal_x, best_shot_y)) - bend - # A blind shot has no clear line to wait for: it kicks once aimed at the goal centre. + # A blind shot has no clear line to the goal: to an open teammate, or at the goal anyway. + target_oren = ( + release_heading(game, carrier_id) if blind_shot else carrier_pos.angle_to(Vector2D(goal_x, best_shot_y)) + ) - bend aimed = ( oriented_towards(game, carrier_id, target_oren) if blind_shot diff --git a/utama_core/tactics/goalkeeper.py b/utama_core/tactics/goalkeeper.py index 571028a6..68c76f25 100644 --- a/utama_core/tactics/goalkeeper.py +++ b/utama_core/tactics/goalkeeper.py @@ -80,7 +80,7 @@ def tick( if mem.pid_controller is None: mem.pid_controller = PIDController(ctx.motion_controller.mode, ctx.motion_controller.rsim_env) - command = goalkeep(game, mem.pid_controller, self.robot_id) + command = goalkeep(game, mem.pid_controller, self.robot_id, ctx) if command is None: command = empty_command(False) return {self.robot_id: command}, mem diff --git a/utama_core/tactics/press_and_contain.py b/utama_core/tactics/press_and_contain.py index ed6fd5a9..22901fd1 100644 --- a/utama_core/tactics/press_and_contain.py +++ b/utama_core/tactics/press_and_contain.py @@ -180,6 +180,7 @@ def tick( ) marker_ids = tuple(rid for rid in robot_ids if rid != presser_id) mem.presser_id = presser_id + ctx.ball_claims.add(presser_id) if ctx.match_log is not None: ctx.match_log.trace_if_changed( diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index 6453eac4..014b557a 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -88,13 +88,13 @@ def _make(build_kernel_strategy_factory): r.close() -@pytest.mark.parametrize("build_factory", _CONFIGS) -def test_partitions_every_outfield_robot_and_never_the_keeper_for_30_ticks(build_factory, make_runner): +@pytest.mark.parametrize("name", _CONFIGS) +def test_partitions_every_outfield_robot_and_never_the_keeper_for_30_ticks(name, make_runner): """30 ticks, not 5-10: enough for PressAndContainTactic's applicable() to plausibly flip in configs that use it, exercising the exact hazard `_press_and_pass_split_picker`/`_three_way_picker` exist to avoid (a Partitioner proposing robots for a currently-inapplicable tactic).""" - runner = make_runner(build_factory) + runner = make_runner(name) strategy = runner.my.strategy assert isinstance(strategy._kernel_strategy, Strategy) assert strategy._goalkeeper_id == 0 diff --git a/utama_core/tests/engine/test_ball_release.py b/utama_core/tests/engine/test_ball_release.py new file mode 100644 index 00000000..5beeba68 --- /dev/null +++ b/utama_core/tests/engine/test_ball_release.py @@ -0,0 +1,332 @@ +"""The backstop that kicks before a held ball costs a foul or jams against an enemy.""" + +import math +from types import SimpleNamespace +from unittest.mock import MagicMock + +import numpy as np +import pytest + +from utama_core.engine.ball_release import ( + AIM_LIMIT_S, + CARRY_AIM_M, + CONTACT_M, + HELD_STILL_S, + PINNED_RELEASE_S, + PINNED_WITH_LANE_S, + BallRelease, +) +from utama_core.engine.context import TickContext +from utama_core.entities.data.command import RobotCommand +from utama_core.entities.data.vector import Vector2D +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.shared.pass_and_score_geometry import ( + ANNOUNCE_PASS_RAD, + MAX_OPEN_TEAMMATE_M, + open_teammate, + reaches_own_goal, + release_heading, + upfield_heading, +) +from utama_core.tactics import _pass_and_score as pas + +_STRAFE = RobotCommand(local_forward_vel=0, local_left_vel=0.3, angular_vel=0, kick=0, chip=0, dribble=1) +_TURN = RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=2.0, kick=0, chip=0, dribble=1) +_ROBOT = 1 + + +def _game( + ts=0.0, + ball=(0.0, 0.0), + v=(0.0, 0.0), + has_ball=True, + heading=math.pi, + enemy=None, + cmd=RefereeCommand.NORMAL_START, + mates=(), +): + """Our goal at +x, the robot just behind the ball, facing the enemy goal (-x) by default.""" + robot = SimpleNamespace(p=Vector2D(ball[0] + 0.09, ball[1]), orientation=heading, has_ball=has_ball) + enemies = {} if enemy is None else {0: SimpleNamespace(p=Vector2D(*enemy))} + friends = {_ROBOT: robot, **{i + 2: SimpleNamespace(p=Vector2D(*m), has_ball=False) for i, m in enumerate(mates)}} + return SimpleNamespace( + ts=ts, + ball=SimpleNamespace(p=Vector2D(*ball), v=Vector2D(*v)), + referee=SimpleNamespace(referee_command=cmd), + friendly_robots=friends, + enemy_robots=enemies, + field=SimpleNamespace( + my_goal_line=np.array([[4.5, 0.5], [4.5, -0.5]]), + enemy_goal_line=np.array([[-4.5, 0.5], [-4.5, -0.5]]), + my_defense_area=np.array([[4.5, 1.0], [3.5, 1.0], [3.5, -1.0], [4.5, -1.0]]), + half_length=4.5, + half_width=3.0, + ), + ) + + +@pytest.fixture(autouse=True) +def _turn(monkeypatch): + monkeypatch.setattr("utama_core.engine.ball_release.turn_on_spot", lambda **kw: _TURN) + + +@pytest.fixture +def no_held_limit(monkeypatch): + monkeypatch.setattr("utama_core.engine.ball_release.HELD_STILL_S", 100.0) + + +def _step(release, game, command=_STRAFE): + return release.apply(game, MagicMock(), {_ROBOT: command})[_ROBOT] + + +def test_carry_is_left_alone_just_short_of_the_limit(): + release = BallRelease() + _step(release, _game()) + assert _step(release, _game(ts=1.0, ball=(0.0, CARRY_AIM_M - 0.01))) is _STRAFE + + +def test_carry_is_released_at_the_limit(): + release = BallRelease() + _step(release, _game()) + assert _step(release, _game(ts=1.0, ball=(0.0, 0.97))).kick + + +def test_a_fast_carry_is_released_early_enough_for_the_kick_to_land(): + release = BallRelease() + _step(release, _game()) + assert _step(release, _game(ts=1.0, ball=(0.0, 0.85), v=(0.0, 1.0))).kick + + +def test_losing_the_ball_restarts_the_carry(): + release = BallRelease() + _step(release, _game()) + _step(release, _game(ts=1.0, ball=(0.0, 0.5), has_ball=False)) + _step(release, _game(ts=1.1, ball=(0.0, 0.5))) + assert not _step(release, _game(ts=2.0, ball=(0.0, 1.2))).kick + + +def test_pinned_with_a_lane_open_is_released_early(monkeypatch): + enemy = (-CONTACT_M + 0.01, 0.0) + monkeypatch.setattr("utama_core.engine.ball_release.open_teammate", lambda *a: 2) + release = BallRelease() + _step(release, _game(enemy=enemy)) + assert _step(release, _game(ts=PINNED_WITH_LANE_S - 0.01, enemy=enemy)) is _STRAFE + assert _step(release, _game(ts=PINNED_WITH_LANE_S, enemy=enemy)) is not _STRAFE + + +def test_pinned_against_an_enemy_is_released_only_after_the_limit(monkeypatch): + monkeypatch.setattr("utama_core.engine.ball_release.open_teammate", lambda *a: None) + enemy = (-CONTACT_M + 0.01, 0.0) + release = BallRelease() + _step(release, _game(enemy=enemy)) + assert _step(release, _game(ts=PINNED_RELEASE_S - 0.01, enemy=enemy)) is _STRAFE + assert _step(release, _game(ts=PINNED_RELEASE_S, enemy=enemy)) is not _STRAFE + + +def test_an_enemy_leaving_the_ball_restarts_the_pinned_clock(no_held_limit, monkeypatch): + monkeypatch.setattr("utama_core.engine.ball_release.open_teammate", lambda *a: None) + enemy = (-CONTACT_M + 0.01, 0.0) + release = BallRelease() + _step(release, _game(enemy=enemy)) + _step(release, _game(ts=1.0, enemy=(-1.0, 0.0))) + _step(release, _game(ts=1.1, enemy=enemy)) + assert _step(release, _game(ts=1.1 + PINNED_RELEASE_S - 0.01, enemy=enemy)) is _STRAFE + + +def test_an_enemy_out_of_contact_does_not_pin(no_held_limit): + enemy = (-CONTACT_M - 0.01, 0.0) + release = BallRelease() + _step(release, _game(enemy=enemy)) + assert _step(release, _game(ts=5.0, enemy=enemy)) is _STRAFE + + +def test_never_kicks_at_our_own_goal(): + release = BallRelease() + _step(release, _game(heading=0.0)) + assert not _step(release, _game(ts=1.0, ball=(0.0, 0.1), heading=0.0)).kick + # past the carry limit but still dead on our goal (the ball is 1.0 up, the goal line 4.5 away) + heading_at_goal = math.atan2(-1.0, 4.41) + assert not _step(release, _game(ts=2.0, ball=(0.0, 1.0), heading=heading_at_goal)).kick + + +def test_a_heading_wide_of_our_goal_may_kick(): + release = BallRelease() + _step(release, _game(heading=math.pi / 2)) + assert _step(release, _game(ts=1.0, ball=(0.0, 0.97), heading=math.pi / 2)).kick + + +def test_only_in_live_play(): + release = BallRelease() + _step(release, _game(cmd=RefereeCommand.STOP)) + _step(release, _game(ts=1.0, ball=(0.0, 0.5), cmd=RefereeCommand.STOP)) + assert not _step(release, _game(ts=2.0, ball=(0.0, 0.97), cmd=RefereeCommand.STOP)).kick + + +def test_no_referee_means_no_release(): + release = BallRelease() + game = _game() + game.referee = None + _step(release, game) + far = _game(ts=1.0, ball=(0.0, 2.0)) + far.referee = None + assert not _step(release, far).kick + + +def test_a_robot_with_no_command_stays_without_one(): + release = BallRelease() + release.apply(_game(), MagicMock(), {}) + assert release.apply(_game(ts=1.0, ball=(0.0, 0.97)), MagicMock(), {}) == {} + + +def test_a_release_turns_away_from_the_enemy_it_is_pinned_against(no_held_limit): + enemy = (-CONTACT_M + 0.01, 0.0) # dead ahead of a robot facing -x + release = BallRelease() + _step(release, _game(enemy=enemy)) + assert _step(release, _game(ts=PINNED_RELEASE_S, enemy=enemy)) is _TURN + + +def test_a_release_kicks_at_the_aim_limit_even_when_not_aimed(no_held_limit): + enemy = (-CONTACT_M + 0.01, 0.0) + release = BallRelease() + _step(release, _game(enemy=enemy)) + _step(release, _game(ts=PINNED_RELEASE_S, enemy=enemy)) + assert _step(release, _game(ts=PINNED_RELEASE_S + AIM_LIMIT_S - 0.01, enemy=enemy)) is _TURN + assert _step(release, _game(ts=PINNED_RELEASE_S + AIM_LIMIT_S, enemy=enemy)).kick + + +def test_a_carry_aims_before_the_hard_limit_and_kicks_without_waiting_at_it(): + release = BallRelease() + _step(release, _game(heading=0.3)) + assert _step(release, _game(ts=1.0, ball=(0.0, CARRY_AIM_M), heading=0.3)) is _TURN + assert _step(release, _game(ts=1.1, ball=(0.0, 0.97), heading=0.3)).kick + + +def test_release_heading_prefers_an_open_teammate(): + game = _game(mates=[(-1.0, 2.0)]) + robot = game.friendly_robots[_ROBOT] + assert release_heading(game, _ROBOT) == pytest.approx(robot.p.angle_to(Vector2D(-1.0, 2.0))) + + +def test_a_teammate_behind_an_enemy_is_not_open(): + assert open_teammate(_game(mates=[(-2.0, 0.0)], enemy=(-1.0, 0.0)), _ROBOT) is None + + +def test_a_teammate_inside_our_own_box_is_not_open(): + assert open_teammate(_game(mates=[(4.0, 0.0)]), _ROBOT) is None + + +def test_the_most_advanced_open_teammate_is_chosen(): + assert open_teammate(_game(mates=[(-1.0, 2.0), (-2.5, -2.0)]), _ROBOT) == 3 + + +def test_a_teammate_out_of_kicking_range_is_not_open(): + robot_x = 0.09 # `_game` stands the robot just behind the ball + assert open_teammate(_game(mates=[(robot_x - MAX_OPEN_TEAMMATE_M + 0.01, 0.0)]), _ROBOT) == 2 + assert open_teammate(_game(mates=[(robot_x - MAX_OPEN_TEAMMATE_M - 0.01, 0.0)]), _ROBOT) is None + + +def test_a_release_goes_round_an_enemy_dead_ahead_and_no_wider_than_it_must(): + game = _game(enemy=(-CONTACT_M + 0.01, 0.0)) + offset = abs(math.remainder(release_heading(game, _ROBOT) - math.pi, 2.0 * math.pi)) + assert offset == pytest.approx(1.05) + + +def test_release_with_no_open_teammate_goes_at_the_enemy_goal(): + game = _game(ball=(0.0, 2.9), enemy=(-1.0, 2.9), heading=math.pi / 2) + robot = game.friendly_robots[_ROBOT] + assert release_heading(game, _ROBOT) == pytest.approx(robot.p.angle_to(Vector2D(-4.5, 0.0))) + + +def test_a_robot_standing_on_the_ball_releases_it_only_at_the_limit(): + release = BallRelease() + _step(release, _game()) + assert _step(release, _game(ts=HELD_STILL_S - 0.01)) is _STRAFE + assert _step(release, _game(ts=HELD_STILL_S)).kick + + +def test_moving_the_ball_restarts_the_held_still_clock(): + release = BallRelease() + _step(release, _game()) + _step(release, _game(ts=1.5, ball=(0.0, 0.06))) + assert _step(release, _game(ts=1.5 + HELD_STILL_S - 0.01, ball=(0.0, 0.06))) is _STRAFE + + +def _announced(heading): + release = BallRelease() + ctx = TickContext(motion_controller=None, expected_receivers=set()) + release.apply(_game(heading=heading, mates=[(-2.0, 0.0)]), ctx, {_ROBOT: _STRAFE}) + release.apply(_game(ts=HELD_STILL_S, heading=heading, mates=[(-2.0, 0.0)]), ctx, {_ROBOT: _STRAFE}) + return ctx.expected_receivers + + +def test_a_receiver_is_told_only_once_the_passer_is_nearly_aimed(): + assert _announced(math.pi + ANNOUNCE_PASS_RAD - 0.01) == {2} + assert _announced(math.pi + ANNOUNCE_PASS_RAD + 0.01) == set() + + +def test_release_heading_at_the_touchline_points_back_into_play(): + game = _game(ball=(0.0, 2.9), heading=math.pi / 2) + assert math.sin(release_heading(game, _ROBOT)) <= 0.0 + + +def test_release_heading_never_points_at_our_own_goal(): + game = _game(ball=(2.0, 0.0), enemy=(1.0, 0.0), heading=0.0) + robot = game.friendly_robots[_ROBOT] + assert not reaches_own_goal(game, robot.p, release_heading(game, _ROBOT)) + + +def _upfield_game(enemy=None, y=0.0): + game = _game(ball=(0.0, y), enemy=enemy) + game.my_team_is_right = True + return game + + +def test_clearance_goes_straight_when_the_lane_is_clear(): + assert upfield_heading(_upfield_game(), _ROBOT) == pytest.approx(math.pi) + + +def test_clearance_angles_off_a_blocked_lane(): + heading = upfield_heading(_upfield_game(enemy=(-1.5, 0.0)), _ROBOT) + assert abs(heading - math.pi) == pytest.approx(0.26) + + +def test_clearance_angles_towards_the_middle_of_the_field(): + heading = upfield_heading(_upfield_game(enemy=(-0.5, 1.0), y=1.0), _ROBOT) + assert math.sin(heading) < 0.0 # y falls towards the middle + + +def test_clearance_does_not_angle_off_the_field(): + # Blocked straight ahead on the touchline: the only angle left aims back into play. + heading = upfield_heading(_upfield_game(enemy=(-0.5, 2.9), y=2.9), _ROBOT) + assert math.sin(heading) < 0.0 + + +def _shot_game(mates=(), enemy=None, heading=math.pi): + game = _game(mates=mates, enemy=enemy, heading=heading) + game.my_team_is_right = True + return game + + +def _ctx(): + ctx = MagicMock() + ctx.motion_controller.kick_bend = 0.0 + return ctx + + +def test_no_shot_passes_to_an_open_teammate_once_aimed(monkeypatch): + monkeypatch.setattr(pas, "kick_bend", lambda *a: 0.0) + assert pas.move_for_a_shot(_shot_game(mates=[(-2.0, 0.0)]), _ctx(), _ROBOT).kick + + +def test_no_shot_turns_towards_the_teammate_first(monkeypatch): + monkeypatch.setattr(pas, "kick_bend", lambda *a: 0.0) + monkeypatch.setattr(pas, "turn_on_spot", lambda **kw: _TURN) + assert pas.move_for_a_shot(_shot_game(mates=[(-2.0, 0.0)], heading=0.3), _ctx(), _ROBOT) is _TURN + + +def test_no_shot_with_nobody_open_keeps_moving_for_one(monkeypatch): + monkeypatch.setattr(pas, "kick_bend", lambda *a: 0.0) + monkeypatch.setattr(pas, "open_teammate", lambda *a: None) + monkeypatch.setattr(pas, "no_shot_reposition_target", lambda *a: Vector2D(0.0, 0.6)) + monkeypatch.setattr(pas, "move", lambda **kw: _STRAFE) + assert pas.move_for_a_shot(_shot_game(), _ctx(), _ROBOT) is _STRAFE diff --git a/utama_core/tests/engine/test_ball_roles.py b/utama_core/tests/engine/test_ball_roles.py new file mode 100644 index 00000000..1e3d4bfa --- /dev/null +++ b/utama_core/tests/engine/test_ball_roles.py @@ -0,0 +1,323 @@ +"""`BallRoles` and the shared helpers it and the tactics lean on: who deals with the ball.""" + +import math +from types import SimpleNamespace + +import numpy as np +import pytest + +from utama_core.config.physical_constants import ROBOT_RADIUS +from utama_core.custom_referee.actions import ( + _WALL_FROM_BALL_M, + _is_in_own_defense_area, + _next_is_their_free_kick, + their_free_kick_targets, +) +from utama_core.engine.ball_roles import COVER_M, ON_BALL_SWITCH_MARGIN_M, BallRoles +from utama_core.engine.context import TickContext +from utama_core.entities.data.command import RobotCommand +from utama_core.entities.data.vector import Vector2D +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.shared.pass_and_score_geometry import ( + _DEEP_NEAR_LINE_M, + _INTERCEPT_MIN_M, + _PASS_ROLLING_MPS, + ball_intercept_point, + no_shot_reposition_target, + receiver_of_rolling_ball, + segment_blocked, +) +from utama_core.skills.src.man_mark import MARK_STANDOFF, mark_target +from utama_core.tactics.give_and_go import _relocate_target + +_ORIGINAL = RobotCommand(local_forward_vel=1, local_left_vel=0, angular_vel=0, kick=0, chip=0, dribble=0) +_TURN = RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=2.0, kick=0, chip=0, dribble=1) + + +def _robot(x, y, has_ball=False, orientation=0.0): + return SimpleNamespace(p=Vector2D(x, y), orientation=orientation, has_ball=has_ball) + + +def _game(friends, enemies=(), ball=(0.0, 0.0), v=(0.0, 0.0), cmd=RefereeCommand.NORMAL_START): + """Our goal at +x, attacking -x. `friends`/`enemies` are robots or (x, y); friend ids are their indices.""" + make = lambda items: {i: (r if isinstance(r, SimpleNamespace) else _robot(*r)) for i, r in enumerate(items)} # noqa + return SimpleNamespace( + ts=0.0, + ball=SimpleNamespace(p=SimpleNamespace(x=ball[0], y=ball[1], to_2d=lambda: Vector2D(*ball)), v=Vector2D(*v)), + referee=SimpleNamespace(referee_command=cmd), + friendly_robots=make(friends), + enemy_robots=make(enemies), + my_team_is_right=True, + field=SimpleNamespace( + my_goal_line=np.array([[4.5, 0.5], [4.5, -0.5]]), + enemy_goal_line=np.array([[-4.5, 0.5], [-4.5, -0.5]]), + my_defense_area=np.array([[4.5, 1.0], [3.5, 1.0], [3.5, -1.0], [4.5, -1.0]]), + enemy_defense_area=np.array([[-4.5, 1.0], [-3.5, 1.0], [-3.5, -1.0], [-4.5, -1.0]]), + half_length=4.5, + half_width=3.0, + half_defense_area_width=1.0, + half_defense_area_depth=0.5, + defense_area_rules=True, + ), + ) + + +@pytest.fixture +def moves(monkeypatch): + calls = {} + + def _move(**kw): + calls[kw["robot_id"]] = kw + return RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=0, kick=0, chip=0, dribble=9) + + monkeypatch.setattr("utama_core.engine.ball_roles.move", _move) + monkeypatch.setattr("utama_core.engine.ball_roles.turn_on_spot", lambda **kw: _TURN) + return calls + + +def _ctx(claims=(), expected=()): + return TickContext(motion_controller=None, ball_claims=set(claims), expected_receivers=set(expected)) + + +def _commands(n): + return {i: _ORIGINAL for i in range(n)} + + +# --- one robot on the ball --------------------------------------------------------------- + + +def test_of_two_robots_driving_at_the_ball_the_further_covers(moves): + game = _game([(1.0, 0.0), (0.5, 0.0)]) + commands = BallRoles().apply(game, _ctx(claims=[0, 1]), _commands(2), [0, 1]) + assert commands[1] is _ORIGINAL + assert commands[0] is not _ORIGINAL + assert moves[0]["target_coords"].distance_to(Vector2D(COVER_M, 0.0)) < 1e-6 # towards our goal at +x + + +def test_a_single_claim_is_left_alone(moves): + assert BallRoles().apply(_game([(1.0, 0.0)]), _ctx(claims=[0]), _commands(1), [0])[0] is _ORIGINAL + + +def test_the_robot_on_the_ball_keeps_it_until_another_is_clearly_nearer(moves): + roles = BallRoles() + roles.apply(_game([(0.5, 0.0), (1.0, 0.0)]), _ctx(claims=[0, 1]), _commands(2), [0, 1]) + just_short = 1.0 - ON_BALL_SWITCH_MARGIN_M + 0.01 + assert ( + roles.apply(_game([(1.0, 0.0), (just_short, 0.0)]), _ctx(claims=[0, 1]), _commands(2), [0, 1])[0] is _ORIGINAL + ) + clearly = 1.0 - ON_BALL_SWITCH_MARGIN_M - 0.01 + assert roles.apply(_game([(1.0, 0.0), (clearly, 0.0)]), _ctx(claims=[0, 1]), _commands(2), [0, 1])[1] is _ORIGINAL + + +def test_a_teammate_holding_the_ball_sends_a_claimer_to_cover(moves): + game = _game([_robot(0.1, 0.0, has_ball=True), (1.0, 0.0)]) + assert BallRoles().apply(game, _ctx(claims=[1]), _commands(2), [0, 1])[1] is not _ORIGINAL + + +def test_a_claimer_near_a_held_ball_steps_straight_out_and_is_not_pulled_back(moves): + game = _game([_robot(0.1, 0.0, has_ball=True), (-0.5, 0.0)]) # the attacker is on the far side of the ball + BallRoles().apply(game, _ctx(claims=[1]), _commands(2), [0, 1]) + assert moves[1]["target_coords"].distance_to(Vector2D(-COVER_M, 0.0)) < 1e-6 + + +def test_a_claimer_far_from_a_held_ball_stays_where_it_is(moves): + game = _game([_robot(0.1, 0.0, has_ball=True), (-2.0, 1.0)]) + BallRoles().apply(game, _ctx(claims=[1]), _commands(2), [0, 1]) + assert moves[1]["target_coords"].distance_to(Vector2D(-2.0, 1.0)) < 1e-6 + + +def test_the_closest_robot_is_not_made_to_cover_a_loose_ball(moves): + roles = BallRoles() + roles.apply(_game([(0.5, 0.0), (1.0, 0.0)]), _ctx(claims=[0, 1]), _commands(2), [0, 1]) + # 1 has become closest but not by the margin that moves the ball to it: both carry on + commands = roles.apply(_game([(0.8, 0.0), (0.7, 0.0)]), _ctx(claims=[0, 1]), _commands(2), [0, 1]) + assert commands[0] is _ORIGINAL and commands[1] is _ORIGINAL + + +def test_nothing_changes_outside_live_play(moves): + game = _game([(1.0, 0.0), (0.5, 0.0)], cmd=RefereeCommand.STOP) + assert BallRoles().apply(game, _ctx(claims=[0, 1]), _commands(2), [0, 1])[0] is _ORIGINAL + + +# --- receiving --------------------------------------------------------------------------- + + +def test_the_robot_a_free_ball_rolls_to_meets_it_on_its_path(moves): + game = _game([(2.0, 0.3), (-2.0, 0.0)], v=(3.0, 0.0)) + commands = BallRoles().apply(game, _ctx(), _commands(2), [0, 1]) + assert commands[0] is not _ORIGINAL and commands[1] is _ORIGINAL + assert moves[0]["dribbling"] is True + assert abs(moves[0]["target_coords"].y) < 1e-6 + + +def test_a_passer_chasing_its_own_pass_covers_while_the_receiver_takes_it(moves): + game = _game([(2.0, 0.0), (-0.5, 0.0)], v=(3.0, 0.0)) + commands = BallRoles().apply(game, _ctx(claims=[1]), _commands(2), [0, 1]) + assert commands[1] is not _ORIGINAL + assert moves[0]["dribbling"] is True + + +def test_a_receiver_stays_on_the_ball_when_the_reach_check_drops_it(moves): + roles = BallRoles() + roles.apply(_game([(1.0, 0.1)], v=(3.0, 0.0)), _ctx(), _commands(1), [0]) + assert receiver_of_rolling_ball(_game([(1.0, 0.6)], v=(3.0, 0.0)), [0]) is None + assert roles.apply(_game([(1.0, 0.6)], v=(3.0, 0.0)), _ctx(), _commands(1), [0])[0] is not _ORIGINAL + + +def test_a_receiver_lets_go_once_the_ball_has_passed(moves): + roles = BallRoles() + roles.apply(_game([(1.0, 0.1)], v=(3.0, 0.0)), _ctx(), _commands(1), [0]) + assert roles.apply(_game([(-0.5, 0.1)], v=(3.0, 0.0)), _ctx(), _commands(1), [0])[0] is _ORIGINAL + + +def test_a_receiver_sprints_onto_the_path(moves): + BallRoles().apply(_game([(1.0, 0.1)], v=(3.0, 0.0)), _ctx(), _commands(1), [0]) + assert moves[0]["sprint"] is True + + +def test_a_new_pick_replaces_a_robot_the_first_tick_chose(moves): + roles = BallRoles() + roles.apply(_game([(1.0, 0.1), (3.0, 3.0)], v=(3.0, 0.0)), _ctx(), _commands(2), [0, 1]) + assert roles._receiving == 0 + # robot 0 is still within the hold's reach of the path, but robot 1 is the one the ball comes to + roles.apply(_game([(1.0, 0.6), (0.5, 0.05)], v=(3.0, 0.0)), _ctx(), _commands(2), [0, 1]) + assert roles._receiving == 1 + + +def test_a_ball_an_enemy_reaches_first_is_not_received(): + assert receiver_of_rolling_ball(_game([(2.0, 0.0)], [(1.0, 0.05)], v=(3.0, 0.0)), [0]) is None + assert receiver_of_rolling_ball(_game([(1.0, 0.0)], [(2.0, 0.05)], v=(3.0, 0.0)), [0]) == 0 + + +def test_only_the_first_robot_along_the_path_receives(): + game = _game([(3.0, 0.0), (1.5, 0.0)], v=(3.0, 0.0)) + assert receiver_of_rolling_ball(game, [0, 1]) == 1 + + +def test_a_shot_at_the_enemy_goal_is_not_received(): + assert receiver_of_rolling_ball(_game([(-2.0, 0.0)], v=(-3.0, 0.0)), [0]) is None + + +def test_a_slow_ball_is_not_received(): + game = _game([(0.5, 0.0)], v=(_PASS_ROLLING_MPS - 0.01, 0.0)) + assert receiver_of_rolling_ball(game, [0]) is None + + +def test_a_ball_at_a_robots_feet_is_not_a_free_ball(): + assert receiver_of_rolling_ball(_game([(2.0, 0.0)], [(0.1, 0.0)], v=(3.0, 0.0)), [0]) is None + + +def test_a_ball_that_stops_short_is_not_received(): + speed = 1.0 # rolls 1 / (2 * 0.3) = 1.67 m + assert receiver_of_rolling_ball(_game([(1.6, 0.0)], v=(speed, 0.0)), [0]) == 0 + assert receiver_of_rolling_ball(_game([(1.75, 0.0)], v=(speed, 0.0)), [0]) is None + + +def test_a_receiver_out_of_reach_of_the_path_is_passed_over(): + assert receiver_of_rolling_ball(_game([(0.6, 0.19)], v=(6.0, 0.0)), [0]) == 0 # reach 0.1 + 0.1 + assert receiver_of_rolling_ball(_game([(0.6, 0.21)], v=(6.0, 0.0)), [0]) is None + + +def test_the_robot_about_to_be_passed_to_stops_and_faces_the_ball(moves): + commands = BallRoles().apply(_game([(2.0, 0.3)]), _ctx(expected=[0]), _commands(1), [0]) + assert commands[0] is _TURN + + +# --- going to where the ball will be ----------------------------------------------------- + + +def test_a_chaser_heads_for_where_it_can_catch_the_ball(): + spot = ball_intercept_point(_game([(1.0, 1.0)], v=(1.0, 0.0)), 0) + assert 0.5 < spot.x < 1.67 and spot.y == pytest.approx(0.0) + + +def test_a_chaser_that_cannot_catch_it_goes_to_where_it_stops(): + spot = ball_intercept_point(_game([(-3.0, 0.0)], v=(1.0, 0.0)), 0) + assert spot.x == pytest.approx(1.0 / (2 * 0.3), abs=0.01) + + +def test_no_intercept_for_a_slow_ball_or_a_robot_beside_it(): + assert ball_intercept_point(_game([(1.0, 1.0)], v=(_PASS_ROLLING_MPS - 0.01, 0.0)), 0) is None + assert ball_intercept_point(_game([(_INTERCEPT_MIN_M - 0.01, 0.0)], v=(3.0, 0.0)), 0) is None + + +def test_the_intercept_stays_out_of_our_box(): + spot = ball_intercept_point(_game([(-3.0, 0.0)], ball=(2.5, 0.0), v=(3.0, 0.0)), 0) + assert spot.x < 3.5 + + +# --- releases, corners, supporters, marking ---------------------------------------------- + + +def _reposition(x, y, enemy): + return no_shot_reposition_target(Vector2D(x, y), [enemy], -4.5, -0.3, 0.3, 3.0) + + +def test_deep_and_wide_of_the_goal_a_carrier_strafes_towards_the_middle(): + deep = -4.5 + _DEEP_NEAR_LINE_M - 0.01 + assert _reposition(deep, 2.0, Vector2D(deep, 1.8)).y < 2.0 # the blocker would send it to the corner + assert _reposition(deep, -2.0, Vector2D(deep, -1.8)).y > -2.0 + + +def test_short_of_the_deep_zone_a_carrier_still_strafes_away_from_the_blocker(): + shallow = -4.5 + _DEEP_NEAR_LINE_M + 0.01 + assert _reposition(shallow, 2.0, Vector2D(shallow, 1.8)).y > 2.0 + + +def test_a_support_run_with_a_lane_beats_a_deeper_one_without(): + open_field = _relocate_target(_game([(-1.0, 1.2), (0.1, 0.0)]), 0, []) + blocker = (open_field.x * 0.5, open_field.y * 0.5) + chosen = _relocate_target(_game([(-1.0, 1.2), (0.1, 0.0)], [blocker]), 0, []) + assert chosen.distance_to(open_field) > 0.1 + assert not segment_blocked(Vector2D(0.0, 0.0), chosen, [Vector2D(*blocker)], ROBOT_RADIUS + 0.1) + + +def _facing(angle): + return _robot(0.05, 0.0, orientation=angle) + + +def test_a_marker_steps_into_the_lane_when_the_passer_faces_its_opponent(): + game = _game([], [_facing(0.0), (2.0, 0.0)]) + target = mark_target(game, 1) + assert target.x == pytest.approx(2.0 - MARK_STANDOFF) # between the passer and the opponent + + +def test_a_marker_stays_goal_side_when_the_passer_looks_elsewhere(): + game = _game([], [_facing(0.21), (2.0, 0.0)]) + assert mark_target(game, 1).x == pytest.approx(2.0 + MARK_STANDOFF) + + +def test_a_marker_stays_goal_side_when_the_passer_is_too_near_to_step_between(): + game = _game([], [_facing(0.0), (1.2, 0.0)]) + assert mark_target(game, 1).x == pytest.approx(1.2 + MARK_STANDOFF) + + +# --- an opponent's free kick ------------------------------------------------------------- + + +def _free_kick_game(friends, enemies, ball): + game = _game(friends, enemies, ball=ball) + game.my_team_is_yellow = True + game.referee.yellow_team = SimpleNamespace(goalkeeper=0) + game.referee.next_command = RefereeCommand.DIRECT_FREE_BLUE + return game + + +def test_their_free_kick_puts_a_wall_on_the_line_and_marks_the_receivers(): + game = _free_kick_game([(4.2, 0.0), (1.0, 0.5), (0.0, 2.0)], [(-0.15, 0.0), (0.0, -2.0), (2.5, 2.0)], (0.0, 0.0)) + targets = their_free_kick_targets(game) + assert 0 not in targets # the keeper keeps its own job + assert targets[1].distance_to(Vector2D(_WALL_FROM_BALL_M, 0.0)) < 1e-6 + assert targets[2].distance_to(Vector2D(2.5 + MARK_STANDOFF, 2.0)) < 1e-6 # nearest our goal first, not the taker + + +def test_the_wall_stays_out_of_our_own_box(): + game = _free_kick_game([(4.2, 0.0), (2.0, 0.5)], [(2.85, 0.0)], (3.0, 0.0)) + assert not _is_in_own_defense_area(game, *their_free_kick_targets(game)[1]) + + +def test_stop_only_prepares_for_a_free_kick_that_is_theirs(): + game = _free_kick_game([(4.2, 0.0)], [], (0.0, 0.0)) + assert _next_is_their_free_kick(game) + game.referee.next_command = RefereeCommand.DIRECT_FREE_YELLOW + assert not _next_is_their_free_kick(game) diff --git a/utama_core/tests/engine/test_carrier_first.py b/utama_core/tests/engine/test_carrier_first.py new file mode 100644 index 00000000..0b98aafb --- /dev/null +++ b/utama_core/tests/engine/test_carrier_first.py @@ -0,0 +1,36 @@ +"""`carrier_first`'s kicker at a still ball: a free-kick taker counts, a contested ball does not.""" + +from types import SimpleNamespace + +from utama_core.strategy.pickers import _KICK_REACH_M, carrier_first + + +def _robot(x, has_ball=False): + return SimpleNamespace(p=SimpleNamespace(x=x, y=0.0), has_ball=has_ball) + + +def _game(kicker_x, enemy_x): + return SimpleNamespace( + ball=SimpleNamespace(p=SimpleNamespace(x=0.0, y=0.0), v=SimpleNamespace(x=0.0, y=0.0)), + friendly_robots={1: _robot(0.8), 3: _robot(kicker_x)}, + enemy_robots={0: _robot(enemy_x)}, + ) + + +def test_a_kicker_waiting_at_a_still_ball_goes_first(): + assert carrier_first(_game(0.11, 0.6), frozenset({1, 3})) == [3, 1] + + +def test_a_contested_ball_has_no_waiting_kicker_whichever_robot_is_nearer(): + assert carrier_first(_game(0.111, 0.112), frozenset({1, 3})) == [1, 3] + assert carrier_first(_game(0.113, 0.112), frozenset({1, 3})) == [1, 3] + + +def test_an_enemy_just_out_of_reach_leaves_the_kicker_first(): + assert carrier_first(_game(0.11, _KICK_REACH_M + 0.001), frozenset({1, 3})) == [3, 1] + + +def test_a_robot_with_the_ball_goes_first_even_when_contested(): + game = _game(0.11, 0.112) + game.friendly_robots[3].has_ball = True + assert carrier_first(game, frozenset({1, 3})) == [3, 1] diff --git a/utama_core/tests/engine/test_commitment_deadline.py b/utama_core/tests/engine/test_commitment_deadline.py index b13ed0ef..e5dca0bf 100644 --- a/utama_core/tests/engine/test_commitment_deadline.py +++ b/utama_core/tests/engine/test_commitment_deadline.py @@ -15,6 +15,7 @@ from __future__ import annotations from dataclasses import dataclass +from types import SimpleNamespace from typing import Optional from utama_core.engine.context import TickContext @@ -54,6 +55,8 @@ def __init__( self.referee = _FakeReferee(referee_command) if referee_command is not None else None self.ts = ts self.ball = _FakeBall(_FakeVector(ball_x, ball_y)) + self.friendly_robots = {0: SimpleNamespace(has_ball=False, p=_FakeVector(9.0, 9.0))} # the pinned keeper + self.enemy_robots = {} @dataclass diff --git a/utama_core/tests/engine/test_give_and_go_tactic.py b/utama_core/tests/engine/test_give_and_go_tactic.py index d6faf3b0..0f426432 100644 --- a/utama_core/tests/engine/test_give_and_go_tactic.py +++ b/utama_core/tests/engine/test_give_and_go_tactic.py @@ -41,6 +41,7 @@ _FIRST_TOUCH_FORCE_SHOT_TICKS, _MAX_FIRST_TOUCH_TICKS, _MAX_HOP_TICKS, + _MAX_PASS_WAIT_TICKS, GiveAndGoMem, GiveAndGoTactic, _relocate_target, @@ -185,7 +186,7 @@ def test_carrier_does_not_hold_again_after_the_first_touch_hold_times_out(): tactic = GiveAndGoTactic() mem = tactic.initial_mem() - for _ in range(_MAX_HOP_TICKS - 1): + for _ in range(_MAX_PASS_WAIT_TICKS - 1): _, mem = tactic.tick(game, ctx, (1, 2), mem) held = ctx.motion_controller.targets[1] assert held.distance_to(Vector2D(0.0, 0.0)) < 1e-6 # holding in place during the hold @@ -198,6 +199,25 @@ def test_carrier_does_not_hold_again_after_the_first_touch_hold_times_out(): assert ctx.motion_controller.targets[1].distance_to(Vector2D(0.0, 0.0)) > 0.5 +def test_a_carrier_stops_waiting_for_its_receiver_after_the_limit(monkeypatch): + """Carriers stood with the ball for 9 s after free kicks, two 4 s waits for a receiver in + a row (high_press_vs_split_shape t=500.6, tournament_20261109_225810).""" + calls = [] + + def _fake_pass_exec(game, ctx, passer, receiver, kick_now=False): + calls.append(kick_now) + return {}, False, False + + monkeypatch.setattr("utama_core.tactics.give_and_go._pass_exec", _fake_pass_exec) + game = _make_game(carrier_pos=Vector2D(0.0, 0.0), teammate_pos=Vector2D(1.0, 1.0), enemy_pos=Vector2D(3.0, -2.5)) + ctx = TickContext(motion_controller=_PerRobotMotionController(), match_log=None) + tactic = GiveAndGoTactic() + mem = tactic.initial_mem() + for _ in range(_MAX_PASS_WAIT_TICKS): + _, mem = tactic.tick(game, ctx, (1, 2), mem) + assert calls[-2:] == [False, True] + + def _make_flicker_game() -> Game: """Carrier facing +x, teammate off-axis at (1.5, 2.0), enemy at (1.0, 0.0). @@ -472,13 +492,14 @@ def test_relocate_others_clamps_deep_targets_outside_the_enemy_defense_area(): @pytest.mark.parametrize(("carried", "expect_kick"), [(0.79, False), (0.80, True)]) -def test_no_lane_strafe_shoots_once_the_carry_reaches_0_8m(carried, expect_kick): +def test_no_lane_strafe_shoots_once_the_carry_reaches_0_8m(carried, expect_kick, monkeypatch): """With every shot lane walled off, the carrier strafes sideways looking for one (`no_shot_reposition_target`). That strafe had no end of its own and carried the ball past `ExcessiveDribblingRule`'s 1.0m — 51 fouls in the 2026-09-23 round-robin. At `CARRY_LIMIT_M` (0.8m) from where the - dribble began, it must shoot at the goal centre instead (already facing - it here, so `kick()` this tick).""" + dribble began, it must kick along `release_heading` instead (already + facing it here, so `kick()` this tick).""" + monkeypatch.setattr("utama_core.tactics.give_and_go.release_heading", lambda *a: math.pi) carrier_pos = Vector2D(-3.0, 0.0) friendly = { 1: Robot( diff --git a/utama_core/tests/engine/test_shadow_and_mark_tactic.py b/utama_core/tests/engine/test_shadow_and_mark_tactic.py index 876feff0..cbf80cff 100644 --- a/utama_core/tests/engine/test_shadow_and_mark_tactic.py +++ b/utama_core/tests/engine/test_shadow_and_mark_tactic.py @@ -51,7 +51,7 @@ def test_shadow_holding_the_ball_clears_it_instead_of_defending_on_it(): 3: _robot(3, 3.3, 0.0, True, has_ball=True, orientation=math.pi), 4: _robot(4, 3.3, 0.25, True), } - enemy = {1: _robot(1, 2.8, 0.0, False)} # close enough that the ball isn't "loose" + enemy = {1: _robot(1, 2.8, 0.8, False)} # close enough that the ball isn't "loose", off the lane zero = Vector3D(0.0, 0.0, 0.0) frame = GameFrame( ts=0.0, diff --git a/utama_core/tests/engine/test_strategy.py b/utama_core/tests/engine/test_strategy.py index 61bda265..2dbbca94 100644 --- a/utama_core/tests/engine/test_strategy.py +++ b/utama_core/tests/engine/test_strategy.py @@ -872,7 +872,10 @@ def __init__(self, command: RefereeCommand, ball_x: float = 0.0): self.referee = _FakeReferee(command) self.my_team_is_yellow = True - self.ball = SimpleNamespace(p=SimpleNamespace(x=ball_x, y=0.0)) + self.ball = SimpleNamespace(p=SimpleNamespace(x=ball_x, y=0.0), v=SimpleNamespace(x=0.0, y=0.0)) + self.friendly_robots = {} + self.enemy_robots = {} + self.ts = 0.0 def _held_restart_strategy(): diff --git a/utama_core/tests/motion_planning/test_pid_approach.py b/utama_core/tests/motion_planning/test_pid_approach.py new file mode 100644 index 00000000..028e91a0 --- /dev/null +++ b/utama_core/tests/motion_planning/test_pid_approach.py @@ -0,0 +1,58 @@ +"""The last metre of a move: speed floor under `TwoDPID`, leaving cruising and settling to kp.""" + +import pytest + +from utama_core.entities.data.vector import Vector2D +from utama_core.motion_planning.src.pid.configs import TranslationPIDConfigs +from utama_core.motion_planning.src.pid.pid import TwoDPID + +_ORIGIN = Vector2D(0.0, 0.0) +_KP = 1.8 + + +def _speed(distance: float, fraction: float = 0.6, has_final_target: bool = True) -> float: + pid = TwoDPID( + TranslationPIDConfigs(max_velocity=2.0, kp=_KP, max_acceleration=4.0, approach_brake_fraction=fraction) + ) + target = Vector2D(distance, 0.0) + if has_final_target: + pid.set_final_target(0, target) + return pid._calculate(target, _ORIGIN, 0).mag() + + +def test_the_last_metre_holds_a_share_of_the_speed_it_can_stop_from(): + assert _speed(0.25) == pytest.approx(0.6 * (2 * 4.0 * 0.25) ** 0.5) + + +def test_the_floor_starts_just_inside_a_metre(): + assert _speed(0.99) > _KP * 0.99 - 1e-9 + assert _speed(1.01) == pytest.approx(_KP * 1.01, rel=0.02) + + +def test_the_floor_never_exceeds_cruising_speed(): + assert _speed(0.95, fraction=1.0) <= _KP + 1e-9 + + +def test_kp_settles_the_robot_inside_the_last_ten_centimetres(): + assert _speed(0.09) == pytest.approx(_KP * 0.09, rel=0.02) + assert _speed(0.11) == pytest.approx(0.6 * (2 * 4.0 * 0.11) ** 0.5) + + +def test_a_fraction_of_zero_leaves_the_speed_to_kp(): + assert _speed(0.25, fraction=0.0) == pytest.approx(_KP * 0.25, rel=0.02) + + +def test_a_caller_without_a_final_target_is_left_to_kp(): + assert _speed(0.25, has_final_target=False) == pytest.approx(_KP * 0.25, rel=0.02) + + +def test_a_waypoint_nearer_than_the_destination_is_left_to_kp(): + def speed(destination_x: float) -> float: + pid = TwoDPID( + TranslationPIDConfigs(max_velocity=2.0, kp=_KP, max_acceleration=4.0, approach_brake_fraction=0.6) + ) + pid.set_final_target(0, Vector2D(destination_x, 0.0)) + return pid._calculate(Vector2D(0.25, 0.0), _ORIGIN, 0).mag() + + assert speed(0.26) > _KP * 0.25 + 0.1 # 1 cm past the waypoint: still a straight run + assert speed(0.28) == pytest.approx(_KP * 0.25, rel=0.02) # 3 cm: a corner diff --git a/utama_core/tests/skills/test_go_to_ball.py b/utama_core/tests/skills/test_go_to_ball.py index ce48c2a5..274fa8af 100644 --- a/utama_core/tests/skills/test_go_to_ball.py +++ b/utama_core/tests/skills/test_go_to_ball.py @@ -1,8 +1,10 @@ +import dataclasses import math from unittest.mock import MagicMock import pytest +from utama_core.config.enums import Mode from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot @@ -11,6 +13,8 @@ from utama_core.skills.src.go_to_ball import ( _APPROACH_OVERSHOOT_M, _DRIBBLE_OVERSHOOT_M, + _RACE_ENEMY_RANGE_M, + _RACE_ROBOT_RANGE_M, _target_past_ball, go_to_ball, ) @@ -132,3 +136,38 @@ def test_approaches_facing_the_ball(monkeypatch, robot_xy): go_to_ball(game=game, motion_controller=_motion_controller(), robot_id=1, shield=False) assert captured["target_oren"] == pytest.approx(math.atan2(0.0 - robot_xy[1], 1.0 - robot_xy[0])) + + +def _race_sprints(robot_x: float, enemy_x: float, monkeypatch, mode=Mode.RSIM, enemy_has_ball=False) -> bool: + from utama_core.skills.src import go_to_ball as module + + enemy = _robot(0, enemy_x, 0.0, False) + enemy = dataclasses.replace(enemy, has_ball=enemy_has_ball) + game = _game({0: _robot(0, robot_x, 0.0, True)}, {0: enemy}, (0.0, 0.0)) + captured = {} + monkeypatch.setattr(module, "move", lambda **kwargs: captured.update(kwargs)) + motion_controller = _motion_controller() + motion_controller.mode = mode + go_to_ball(game=game, motion_controller=motion_controller, robot_id=0, shield=False) + return captured.get("sprint", False) + + +@pytest.mark.parametrize( + "robot_x, enemy_x, sprints", + [ + (-_RACE_ROBOT_RANGE_M + 0.01, _RACE_ENEMY_RANGE_M - 0.01, True), + (-_RACE_ROBOT_RANGE_M - 0.01, _RACE_ENEMY_RANGE_M - 0.01, False), + (-_RACE_ROBOT_RANGE_M + 0.01, _RACE_ENEMY_RANGE_M + 0.01, False), + ], +) +def test_sprints_only_at_a_ball_an_enemy_is_near(monkeypatch, robot_x, enemy_x, sprints): + assert _race_sprints(robot_x, enemy_x, monkeypatch) is sprints + + +def test_sprints_at_a_ball_an_enemy_holds(monkeypatch): + assert _race_sprints(-0.5, 0.11, monkeypatch, enemy_has_ball=True) is True + + +@pytest.mark.parametrize("mode, sprints", [(Mode.RSIM, True), (Mode.GRSIM, True), (Mode.REAL, False)]) +def test_sprints_for_a_contested_ball_only_in_simulation(monkeypatch, mode, sprints): + assert _race_sprints(-0.5, 0.3, monkeypatch, mode=mode) is sprints diff --git a/utama_core/tests/skills/test_goalkeep.py b/utama_core/tests/skills/test_goalkeep.py index 3614c0c1..1ea6377e 100644 --- a/utama_core/tests/skills/test_goalkeep.py +++ b/utama_core/tests/skills/test_goalkeep.py @@ -43,6 +43,7 @@ def _std_field(my_team_is_right: bool): my_goal_line=goal_line, half_goal_width=0.5, my_defense_area=_defense_area(goal_x, depth=0.5, width=1.0), + enemy_goal_line=np.array([[-goal_x, 0.5], [-goal_x, -0.5]]), ) @@ -546,6 +547,7 @@ def test_goalkeep_clears_retrieved_ball_without_dribbling_it_out(monkeypatch): exact carry). Facing its own goal (pi) here, so it must turn on the spot toward upfield (+x for a left-side team).""" game = SimpleNamespace( + enemy_robots={}, my_team_is_yellow=True, my_team_is_right=False, field=_std_field(False), @@ -573,6 +575,7 @@ def test_goalkeep_kicks_held_ball_once_oriented_upfield(monkeypatch): the box too.""" exit_x = -2.93 game = SimpleNamespace( + enemy_robots={}, my_team_is_yellow=True, my_team_is_right=False, field=_std_field(False), @@ -649,6 +652,7 @@ def test_clearance_kicks_within_its_tolerance_of_upfield(monkeypatch, off_rad, k """The real keeper settled ~0.07 rad off upfield and never reached the 0.05 rad shot tolerance, so it never cleared (2026-10-27 field runs).""" game = SimpleNamespace( + enemy_robots={}, my_team_is_yellow=True, my_team_is_right=False, field=_std_field(False), @@ -661,3 +665,40 @@ def test_clearance_kicks_within_its_tolerance_of_upfield(monkeypatch, off_rad, k assert ku.kick_upfield(game, motion_controller=object(), robot_id=0) == ( "sentinel-kick" if kicks else "sentinel-turn" ) + + +def _held_ball_game(teammate, enemy=None, orientation=0.0): + """A left-side keeper holding the ball, one outfield robot upfield.""" + return SimpleNamespace( + enemy_robots={} if enemy is None else {0: SimpleNamespace(p=Vector2D(*enemy))}, + my_team_is_yellow=True, + my_team_is_right=False, + field=_std_field(False), + friendly_robots={ + 0: SimpleNamespace(p=Vector2D(-4.2, 0.0), orientation=orientation, has_ball=True), + 1: SimpleNamespace(p=Vector2D(*teammate), orientation=0.0, has_ball=False), + }, + ball=SimpleNamespace(p=Vector3D(-4.11, 0.0, 0.0), v=Vector3D(0.0, 0.0, 0.0)), + ) + + +def test_keeper_passes_to_a_teammate_standing_free(monkeypatch): + monkeypatch.setattr(gk, "kick", lambda: "pass") + monkeypatch.setattr(gk, "kick_upfield", lambda *a: "clear") + ctx = SimpleNamespace(expected_receivers=set()) + assert gk.goalkeep(_held_ball_game((-1.0, 0.0)), None, 0, ctx) == "pass" + assert ctx.expected_receivers == {1} + + +def test_keeper_turns_to_the_teammate_before_passing(monkeypatch): + monkeypatch.setattr(gk, "turn_on_spot", lambda **kw: kw["target_oren"]) + target = gk.goalkeep(_held_ball_game((-2.0, 2.0), orientation=-0.5), None, 0) + assert target == pytest.approx(math.atan2(2.0, 2.2)) + + +def test_keeper_clears_upfield_when_the_teammate_is_marked(monkeypatch): + monkeypatch.setattr(gk, "kick_upfield", lambda *a: "clear") + # 0.39 m off the lane is inside the keeper's safety margin + assert gk.goalkeep(_held_ball_game((-1.0, 0.0), enemy=(-2.0, 0.39)), None, 0) == "clear" + monkeypatch.setattr(gk, "kick", lambda: "pass") + assert gk.goalkeep(_held_ball_game((-1.0, 0.0), enemy=(-2.0, 0.41)), None, 0) == "pass" diff --git a/utama_core/tests/skills/test_move_utils.py b/utama_core/tests/skills/test_move_utils.py index f899dc85..bcfab63e 100644 --- a/utama_core/tests/skills/test_move_utils.py +++ b/utama_core/tests/skills/test_move_utils.py @@ -8,7 +8,7 @@ from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot from utama_core.motion_planning.src.common.pose_ahead import PoseAhead -from utama_core.skills.src.utils.move_utils import move, turn_on_spot +from utama_core.skills.src.utils.move_utils import _sprint_velocity, move, turn_on_spot PIVOT_RADIUS = ROBOT_RADIUS + BALL_RADIUS @@ -293,3 +293,59 @@ def test_only_real_robots_have_a_slowest_turn(): assert REAL_PARAMS.MIN_TURN == _MIN_TURN assert RSIM_PARAMS.MIN_TURN is GRSIM_PARAMS.MIN_TURN is None + + +def _head_on(distance: float, ours: float, theirs: float): + enemy = Robot( + id=0, + is_friendly=False, + has_ball=False, + p=Vector2D(distance, 0.0), + v=Vector2D(-theirs, 0.0), + a=Vector2D(0, 0), + orientation=0.0, + ) + game = _game({1: _robot(1, 0.0, 0.0, True)}, {0: enemy}, (3.0, 3.0)) + mc = MagicMock() + mc.min_turn = None + mc.robot_carry = {} + mc.pose_ahead = PoseAhead(0.0) + mc.calculate.return_value = (Vector2D(ours, 0.0), 0.0) + return game, mc + + +def test_move_brakes_for_an_enemy_coming_head_on(): + game, mc = _head_on(2 * ROBOT_RADIUS + 0.02, 1.5, 1.5) + command = move(game, mc, 1, Vector2D(2.0, 0.0), 0.0) + assert command.local_forward_vel == pytest.approx(0.5 + math.sqrt(3.0 * 0.02)) + mc.sent.assert_called_once() + + +def test_move_keeps_a_legal_approach_to_an_enemy_standing_still(): + game, mc = _head_on(2 * ROBOT_RADIUS + 0.02, 1.2, 0.0) + assert move(game, mc, 1, Vector2D(2.0, 0.0), 0.0).local_forward_vel == pytest.approx(1.2) + mc.sent.assert_not_called() + + +def test_move_is_not_capped_outside_braking_range(): + game, mc = _head_on(1.21, 2.0, 2.0) + assert move(game, mc, 1, Vector2D(2.0, 0.0), 0.0).local_forward_vel == pytest.approx(2.0) + + +def test_move_is_not_capped_driving_away_from_an_enemy(): + game, mc = _head_on(0.25, -2.0, 2.0) + assert move(game, mc, 1, Vector2D(-2.0, 0.0), 0.0).local_forward_vel == pytest.approx(-2.0) + + +def test_a_sprint_goes_as_fast_as_it_can_still_stop(): + velocity = _sprint_velocity(Vector2D(0.0, 0.0), Vector2D(0.125, 0.0), max_speed=2.0, max_acceleration=4.0) + assert velocity.x == pytest.approx(1.0) and velocity.y == 0.0 + + +def test_a_sprint_is_capped_at_top_speed(): + velocity = _sprint_velocity(Vector2D(0.0, 0.0), Vector2D(0.0, 1.0), max_speed=2.0, max_acceleration=4.0) + assert velocity.y == pytest.approx(2.0) + + +def test_a_sprint_already_on_the_target_stands_still(): + assert _sprint_velocity(Vector2D(1.0, 1.0), Vector2D(1.0, 1.0), max_speed=2.0, max_acceleration=4.0).mag() == 0.0 From 33defacc4c8308cb05593043023308f8b9e58991 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:49 +0000 Subject: [PATCH 04/59] evaluation: fixed reference opponents, world and robot settings Replace pool_v1 with tools/evaluation/reference/ (opponents, world, robots) and add the field-physics tooling that the world settings come from. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- AGENTS.md | 14 +++--- docs/STRATEGY_DEVELOPMENT.md | 49 +++++++++++++-------- docs/roadmap.md | 6 +-- docs/strategies.md | 8 ++-- docs/tools.md | 1 + tools/evaluation/evaluate.py | 26 ++++++----- tools/evaluation/match.py | 4 +- tools/evaluation/pools/pool_v1.json | 30 ------------- tools/evaluation/reference/opponents.json | 17 +++++++ tools/evaluation/reference/robots.json | 15 +++++++ tools/evaluation/reference/world.json | 17 +++++++ tools/evaluation/round_robin.py | 14 +++--- tools/evaluation/sim_settings.py | 42 ++++++++++++++++++ tools/moments.py | 10 +++-- utama_core/engine/match_stats.py | 15 +++++-- utama_core/tests/engine/test_match_stats.py | 15 +++++++ 16 files changed, 194 insertions(+), 89 deletions(-) delete mode 100644 tools/evaluation/pools/pool_v1.json create mode 100644 tools/evaluation/reference/opponents.json create mode 100644 tools/evaluation/reference/robots.json create mode 100644 tools/evaluation/reference/world.json create mode 100644 tools/evaluation/sim_settings.py diff --git a/AGENTS.md b/AGENTS.md index 524c6c3f..879dc753 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -51,12 +51,14 @@ One term per thing; reuse these instead of coining new ones. the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. -- **Evaluation / ratings / reference pool / ledger** — `tools/evaluation/evaluate.py`: is a - candidate stronger than the champion of a fixed, versioned reference pool - (`tools/evaluation/pools/pool_vN.json`)? Rounds of matches against the pool's opponents under - seeded sim noise, decided on paired results (candidate and champion against the same opponent - under the same noise) and stopping once the answer is clear; ratings (strength ± SD in goals - per match, `analysis/ratings.py`) over every match in the ledger (`replays/eval/ledger.jsonl`). +- **Evaluation / ratings / reference opponents / ledger** — `tools/evaluation/evaluate.py`: is a + candidate stronger than the champion of a fixed set of reference opponents + (`tools/evaluation/reference/opponents.json`: the champion, six opponents, three held-out + opponents)? Rounds of matches against those opponents in the simulated world and robots + (`tools/evaluation/reference/world.json`, `robots.json`) under seeded sim noise, decided on + paired results (candidate and champion against the same opponent under the same noise) and + stopping once the answer is clear; ratings (strength ± SD in goals per match, + `analysis/ratings.py`) over every match in the ledger (`replays/eval/ledger.jsonl`). Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. - **Situation / goal ledger** — a situation starts when a restart goes live or a side wins the diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index df41ca6b..d4e89840 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -119,7 +119,7 @@ flowchart TD ko_t["PREPARE_KICKOFF (theirs)
PrepareKickoffTheirsStep: non-keepers to own half,
outside the centre circle"] pe_o["PREPARE_PENALTY (ours)
PreparePenaltyOursStep: kicker to the penalty mark,
others on a line behind it"] pe_t["PREPARE_PENALTY (theirs)
PreparePenaltyTheirsStep: keeper to our goal line centre,
others behind the penalty mark"] - fk_o["DIRECT_FREE or INDIRECT_FREE (ours)
DirectFreeOursStep: nearest robot becomes kicker,
others stop"] + fk_o["DIRECT_FREE or INDIRECT_FREE (ours)
DirectFreeOursStep: nearest robot takes the kick,
others stop"] fk_t["DIRECT_FREE or INDIRECT_FREE (theirs)
DirectFreeTheirsStep: clear robots out of keep-out"] bp_o["BALL_PLACEMENT (ours)
BallPlacementOursStep: closest robot carries ball to the spot,
others clear"] bp_t["BALL_PLACEMENT (theirs)
BallPlacementTheirsStep: clear away from ball and target"] @@ -140,6 +140,16 @@ flowchart TD sel --> resume ``` +## After the tactics: team-level ball handling + +Two passes run in live play on the commands every tactic returned, so they apply to all strategies. +`engine/ball_release.py` kicks a ball that cannot be held longer (carry limit, or pinned by an enemy). +`engine/ball_roles.py` then settles who deals with the ball: the first robot a free ball rolls to +meets it, a robot about to be passed to stops and faces the ball (`ctx.expected_receivers`), and of +the robots driving at the ball (`ctx.ball_claims`, set by `go_to_ball` and pressers) one carries on +and the rest cover it. A tactic's command for a robot can be replaced here: their trace is `ball[id]` +or `release[id]`. + ## Writing a Tactic Lessons from bugs that recurred (mostly `SwitchOfPlayTactic`, `tactics/switch_of_play.py`): @@ -223,7 +233,7 @@ kernel invariants. Give its partitioner pure-function tests in `tests/strategy/t Saved, so stalls are recorded (`--no-save` cannot see them). A stall is a bug to fix before anything else. 3. **Matches:** `tools/evaluation/evaluate.py ` (see [Evaluating a strategy](#evaluating-a-strategy)): - is it better than the pool's champion, worse, or not clearly either? Several candidates go in + is it better than the champion in `tools/evaluation/reference/opponents.json`, worse, or not clearly either? Several candidates go in one call. A strict round-robin (`round_robin.py --strict --reuse`) is the check for stalls and the occasional health check of the whole catalog, no longer the way to judge one change. @@ -234,15 +244,15 @@ changes and run one round-robin over the batch. **`--reuse`** takes a match's result from `replays/match_cache/` when nothing it runs has changed since it was stored, so after a change to one strategy only its matches play, one per other config (21 of 231 with 22 configs). What counts as -"runs" is `utama_core/replay/fingerprint.py`'s: the factory's own module, every module that -imports (`strategy/pickers.py` and the tactics among them, whole files), and the shared code and -environment (planner, referee, runner, simulator build, packages, CPU). Editing `pickers.py` +"runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that +imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole +files), and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing `pickers.py` reruns every config that imports it, which is most of them; changing shared code reruns everything, correctly. Each run replays 5% of what it would reuse (`--spot-check`) and compares; a difference evicts the records, says the fingerprint missed a dependency, and fails the run. Use `--reuse` on every run. -**What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against the champion of the reference pool. A round-robin's W-D-L is a diagnostic. +**What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against the champion of the reference opponents. A round-robin's W-D-L is a diagnostic. Everything in [Reading a tournament run](#reading-a-tournament-run) explains a result; none of it is a target. Don't tune a threshold until results move: a change needs a reason in game terms. Two round-robins of near-identical code agree @@ -252,7 +262,7 @@ because the code is near-identical. ### Evaluating a strategy `tools/evaluation/evaluate.py CANDIDATE [CANDIDATE ...]` answers one question per candidate: is -it stronger than the champion of a fixed reference pool, in goals, under the realistic sim noise? +it stronger than the champion of a fixed set of reference opponents, in goals, under the realistic sim noise? The flowchart contrasts it with the round-robin, which answers a different question. @@ -266,7 +276,7 @@ flowchart TD end subgraph ev["evaluate.py: is this candidate stronger than the champion?"] - e1["Pool pool_v1.json: champion, six opponents,
three held-out opponents, sim noise"] + e1["Reference opponents.json: champion, six opponents,
three held-out opponents; world and robots, sim noise"] e2["Round k, noise seed k
candidate and champion each play every opponent"] e7["Every match appended to the ledger
replays/eval/ledger.jsonl"] e3{"P(candidate stronger), paired
with the champion's results"} @@ -282,10 +292,11 @@ flowchart TD end ``` -- **The pool** (`tools/evaluation/pools/pool_v1.json`): a champion, six opponents chosen for - spread of styles, three held-out opponents and the sim noise. It changes only on purpose, as - a new version, so a result means the same thing next month; it does not follow the latest - standings. +- **The reference opponents** (`tools/evaluation/reference/opponents.json`): a champion, six + opponents chosen for spread of styles and three held-out opponents. The simulated world and + robots are `world.json` and `robots.json` in the same folder (`sim_settings.py` loads them). + It changes only on purpose, so a result means the same thing next month; it does not follow + the latest standings. - **Rounds.** In round k every candidate plays each opponent and the champion once, and the champion plays each opponent, all with noise seed k and the side under test in the same colour (the noise is drawn per colour and robot, so one seed can favour a colour by half a goal). A @@ -307,10 +318,10 @@ flowchart TD evaluate.py and round-robins, keyed by the code that played it. A match is never played twice; the champion's matches are played once per seed and reused by every candidate, and editing a strategy starts its record afresh. Replays are not kept, except during a `--explain` run (rerun one with `round_robin.py --pair - A B --sim-noise` and the pool's noise with that seed). + A B --sim-noise reference:`). - **Before promoting** a candidate called better, run `evaluate.py --held-out`: it must not - be clearly worse against opponents never used for selection. Then edit the pool's champion by - hand. Check its per-opponent table: a candidate far better against one opponent and worse + be clearly worse against opponents never used for selection. Then edit the champion in + `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse against the rest is a matchup, not a better strategy. - **Pictures** (`evaluate.py --explain`, `tools/evaluation/explain.py`): for each candidate, where both strategies' robots stand with and without the ball, their shots for and against, @@ -342,7 +353,7 @@ reaches `main` by pull request: `pickers.py` or an existing tactic: the opponents run those. To improve a tactic, copy it into a new module and change the copy; making the improvement everyone's is a human change. Your strategy's and tactics' code may not reach outside its module: no import-time effects, - no module-level state (keep state in the factory's closure), no imports of another strategy, + no module-level state (keep state inside `build`), no imports of another strategy, no changing attributes of what it imports. CI checks all of this statically, from `main`'s copy of the checker; the reviewer still reads the diff. Tests import pickers from your module directly, not through `kernel_strategy.py`. @@ -413,14 +424,14 @@ whoever runs it. - **Sim noise** (`rsoccer_simulator/src/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded command latency per robot, kick speed and direction noise (a per-robot offset plus kick-to-kick spread), two-phase ball friction (slide after a kick, then roll), per-robot - speed, acceleration and braking limits applied to the commands the sim acts on (hardware caps, + speed and braking limits applied to the commands the sim acts on (hardware caps, the 4 m/s^2 command cap, no per-match acceleration draw, below any planner), the physics substep count, and vision noise and dropped detections, all off by default. Ball friction, kick direction and substeps need a robosim binary built from `vendor/rSim` (`vendor/rSim/FORK_NOTES.md`); with the stock binary they raise. Draws depend on the seed, team colour and robot id only, so every pairing in a run gets the same physics and A/B comparisons stay paired; the same seed replays a match exactly. Settings and draws go into each replay (`columnar_reader.load_sim_noise`) and `summary.json`, and into the match key only when set. - Ranges come from `docs/sim_realism.md` Phase 1; until then the knobs have no calibrated values. + Ranges and their sources are in `tools/evaluation/reference/world.json` (the Phase 1 numbers are in `docs/sim_realism.md`). - **`tools/replay_trace.py REPLAY.npz T0 T1`** — text trace of a window: referee command and why it changed, ball, nearest robot per side. The first look at a stall or a voided restart. - **`tools/repro_from_replay.py`** — reload a replay's field state at time *t* into a fresh headless @@ -492,7 +503,7 @@ The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, ` placement geometry under the referee override). `tools/moments.py capture REPLAY --t S --name ... --check ... --note "..." [--out PATH]` saves the state; `play JSON --seeds 0-4` must fail on at least 4 of 5 before the fix (`--against REF` plays the code at REF beside it; `--events` - lists referee changes, fouls, keep-out entries and kicks; `--strategy scratch.py:factory` + lists referee changes, fouls, keep-out entries and kicks; `--strategy scratch.py:function` tries a strategy from a scratch file). Its note names the fix; if the fix is not in the same change, set `"known_failure": ""` (a strict xfail). diff --git a/docs/roadmap.md b/docs/roadmap.md index ea025971..e1890507 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -32,7 +32,7 @@ entry by its title, not its number. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). - **`metric_correlation.py` reads `.npz`**. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). -- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed, versioned pool (`tools/evaluation/pools/pool_v1.json`: champion, six opponents, three held-out opponents, seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. +- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. @@ -262,8 +262,8 @@ entry by its title, not its number. scorecard and the analysis in-repo) and Phase 1 (league ranges from the 2025-26 official logs) are done; Phase 2's knobs are built — `SimNoise` seeds latency, kick speed and direction spread, two-phase ball friction, per-robot acceleration limits and vision - noise/dropouts per match, and is wired through `run_match`, `evaluate.py` and `pool_v1` - (the v3 ranges; the 2026-10-17 round-robin played them as `v3_seed2`). A sensitivity sweep + noise/dropouts per match, and is wired through `run_match`, `evaluate.py` and the reference + `world.json` (its values differ from the v3 ranges the 2026-10-17 round-robin played as `v3_seed2`). A sensitivity sweep was run (results in `sim_realism.md`). Still open: the scorecard's remaining gaps (sim keepers save about twice as many good chances, and sim shots almost never go wide), the 2022-24 held-out check, choosing which knobs become the diff --git a/docs/strategies.md b/docs/strategies.md index 2be50fb1..f4173857 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -8,7 +8,7 @@ Run: - `pixi run python tools/evaluation/round_robin.py [name ...]` — full-match round-robin (two halves of 300 s of playing time) over every config (or the named ones). Common flags: `--reuse`, `--strict`, `--pair A B` (one match); `--help` lists all. - `pixi run python tools/evaluation/evaluate.py ` — judges a candidate against the champion - of the reference pool (`tools/evaluation/pools/pool_v1.json`). The way to judge a strategy. + of the reference opponents (`tools/evaluation/reference/opponents.json`). The way to judge a strategy. - `pixi run python tools/debug_match.py --strategy --opponent [--dump-ticks PATH]` — one instrumented matchup. @@ -36,7 +36,7 @@ strategies named plays these. **Retired** (2026-10-10): the bottom ten of the 2026-10-05 round-robin. Left out of a round-robin unless named (`RETIRED` in `tools/evaluation/round_robin.py`). Their code stays: kept strategies and tests build on some of them. A retired strategy comes back by being judged -with `evaluate.py` against the pool. +with `evaluate.py` against the reference opponents. | Strategy | Description | |---|---| @@ -53,7 +53,7 @@ with `evaluate.py` against the pool. `default`: Everyone runs `PassAndShootTactic`; only 2 robots are ever commanded (see bugs). Excluded from round-robin discovery. -Strategies are judged with `evaluate.py` against the reference pool `pool_v1` +Strategies are judged with `evaluate.py` against the reference opponents (`tools/evaluation/reference/`) (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). The round-robin results below are a snapshot of the catalog, not the verdict on any one strategy. @@ -98,7 +98,7 @@ bugs" refer to them — read them with `git log -p -- docs/strategies.md`. Still ## Updating this file -- New factory → add a row with a one-line description to the round-robin table. +- New strategy → add a row with a one-line description to the round-robin table. - New tournament → replace the matching results table (one table per tournament type) and record the run directory; don't append narrative. Findings belong in commit messages. - Strategy abandoned after losing → add it to `RETIRED` and move its row to the retired table. diff --git a/docs/tools.md b/docs/tools.md index dadd333c..8e5096f0 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -127,6 +127,7 @@ described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). | `tools/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | | `tools/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | | `tools/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/convert_ssl_log.py` | +| `tools/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field_sessions.json` allows, and prints how well runs, days and radios agree. | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | | `examples/demo_dribbler_test.py` | One robot dribbling round a rectangle on the Exhibition Road field | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index ee6f775f..aeec5213 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -3,9 +3,10 @@ Run: pixi run python tools/evaluation/evaluate.py CANDIDATE [CANDIDATE ...] [flags] - --pool PATH the reference pool (default tools/evaluation/pools/pool_v1.json): the - champion, the opponents, the held-out opponents and the sim noise - --held-out play the pool's held-out opponents instead (the check before promoting) + --opponents PATH the champion, opponents and held-out opponents (default + tools/evaluation/reference/opponents.json). The sim is always the reference + world and robots (reference/world.json, reference/robots.json) + --held-out play the held-out opponents instead (the check before promoting) --baseline NAME compare against this strategy instead of the champion: a new version against the one it changes. The baseline takes the champion's role, the champion joins the opponents, and a baseline from the pool leaves them @@ -44,12 +45,11 @@ A fixture already in the ledger is never played again, so the champion's matches are played once per seed and reused by every candidate. Replays are not kept: a match is a pure function -of its fixture, so `round_robin.py --pair A B --sim-noise` with the pool's noise and the seed -plays it again. +of its fixture, so `round_robin.py --pair A B --sim-noise reference:` plays it again. Promoting is a decision, not a side effect: a candidate called better should pass `--held-out` (it must not lose clearly to opponents never used for selection) before you set it as the -pool's champion by hand. +champion by hand in `reference/opponents.json`. """ from __future__ import annotations @@ -73,13 +73,17 @@ _resolve_config_names, _run_metadata, ) +from tools.evaluation.sim_settings import ( # noqa: E402 + DEFAULT_OPPONENTS, + load_opponents, + reference_noise, +) from utama_core.analysis import ratings # noqa: E402 from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 from utama_core.replay import eval_ledger # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise # noqa: E402 -DEFAULT_POOL = Path(__file__).with_name("pools") / "pool_v1.json" PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 @@ -133,7 +137,7 @@ def play(a: str, b: str, seed: int, noise: dict, run_dir: Path, keep: bool = Fal def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("candidates", nargs="+") - parser.add_argument("--pool", type=Path, default=DEFAULT_POOL) + parser.add_argument("--opponents", type=Path, default=DEFAULT_OPPONENTS) parser.add_argument("--held-out", action="store_true") parser.add_argument("--baseline") parser.add_argument("--max-rounds", type=int, default=MAX_ROUNDS) @@ -153,7 +157,7 @@ def main() -> None: opponents.append(pool_champion) # against a baseline, the champion is one more opponent opponents = [o for o in opponents if o != champion] # a baseline from the pool leaves its seat candidates = [c for c in _resolve_config_names(args.candidates) if c != champion] - noise = SimNoise.from_dict(pool["sim_noise"]).to_dict() + noise = SimNoise.from_dict(reference_noise()).to_dict() noise.pop("seed", None) graph = CodeGraph() @@ -168,7 +172,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: run_dir = Path(REPLAY_BASE_PATH) / run_id # replay files must sit directly under replays/ run_dir.mkdir(parents=True, exist_ok=True) print( - f"Pool v{pool['version']}{' (held out)' if args.held_out else ''}: " + f"{'Held-out opponents' if args.held_out else 'Opponents'}: " f"{'baseline' if args.baseline else 'champion'} {_short_name(champion)}; " f"opponents {', '.join(_short_name(o) for o in opponents)}; environment {env}\n" ) @@ -240,7 +244,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: { "run_id": run_id, "run": _run_metadata(), - "pool": str(args.pool), + "opponents": str(args.opponents), "held_out": args.held_out, "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": args.max_rounds}, diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index fc43998d..ab0a8e0c 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -46,7 +46,7 @@ # despite the name, it isn't a competitive team — it's the kernel's minimal # single-tactic smoke-test scaffold (see its docstring), used across the test # suite with as few as zero outfield robots, and plays a real match with 3 of 5 -# outfield robots never issued a command. Every other factory is playable here; +# outfield robots never issued a command. Every other strategy is playable here; # which ones a round-robin plays by default is round_robin.RETIRED's business. _CONFIG_NAMES = [ name @@ -132,7 +132,7 @@ def run_match( fuzz_interval_s: tuple[float, float] = (25.0, 45.0), sim_noise: Optional[SimNoise] = None, ) -> MatchResult: - """Play one match between two kernel-strategy factories, until the referee calls full + """Play one match between two strategies, until the referee calls full time (two halves of the profile's `half_duration_seconds` of playing time, the clock stopped whenever no team may play the ball) or `duration_seconds` of sim time pass, whichever is first. The cap only ends a match that can't finish: two 300 s halves took diff --git a/tools/evaluation/pools/pool_v1.json b/tools/evaluation/pools/pool_v1.json deleted file mode 100644 index febf8859..00000000 --- a/tools/evaluation/pools/pool_v1.json +++ /dev/null @@ -1,30 +0,0 @@ -{ - "version": 1, - "note": "Chosen 2026-10-17 from the 12 strategies of tournament_20261016_201213 for spread of styles, not standings. Change it only on purpose, as pool_v2.json: ratings are comparable within one pool version.", - "champion": "split_shape", - "opponents": [ - "clear_danger", - "decoy_and_overload", - "counter_flow", - "high_press", - "tiki_taka_plus", - "press_and_pass" - ], - "held_out": [ - "overload_press", - "score_aware_counter_flow", - "give_and_go_solo" - ], - "sim_noise": { - "latency_s": [0.03, 0.15], - "kick_speed_offset_sd": 0.2, - "kick_speed_sd": 0.45, - "vision": {"x_stddev": 0.0007, "y_stddev": 0.0007, "th_stddev_deg": 0.3}, - "vanishing": 0.005, - "ball_roll_decel": [0.27, 0.33], - "ball_slide_decel": [2.5, 4.0], - "kick_angle_offset_sd_deg": 1.5, - "kick_angle_sd_deg": 3.0, - "max_accel": [1.5, 3.5] - } -} diff --git a/tools/evaluation/reference/opponents.json b/tools/evaluation/reference/opponents.json new file mode 100644 index 00000000..09045804 --- /dev/null +++ b/tools/evaluation/reference/opponents.json @@ -0,0 +1,17 @@ +{ + "note": "Chosen 2026-10-17 from the 12 strategies of tournament_20261016_201213 for spread of styles, not standings. Change it only on purpose: ratings are comparable within one set of opponents.", + "champion": "split_shape", + "opponents": [ + "clear_danger", + "decoy_and_overload", + "counter_flow", + "high_press", + "tiki_taka_plus", + "press_and_pass" + ], + "held_out": [ + "overload_press", + "score_aware_counter_flow", + "give_and_go_solo" + ] +} diff --git a/tools/evaluation/reference/robots.json b/tools/evaluation/reference/robots.json new file mode 100644 index 00000000..7d255014 --- /dev/null +++ b/tools/evaluation/reference/robots.json @@ -0,0 +1,15 @@ +{ + "note": "What the simulated robots can do: assumed good, at league level, not noise-free. Never our current robots' measurements: their shortfalls are the control layer's job. Top speed and the 4 m/s^2 acceleration cap are RSIM_PARAMS. A change here starts a new evaluation environment and replays the ledger.", + "values": { + "kick_speed_offset_sd": 0.2, + "kick_speed_sd": 0.45, + "kick_angle_offset_sd_deg": 1.5, + "kick_angle_sd_deg": 3.0 + }, + "sources": { + "kick_speed_offset_sd": "League logs, docs/sim_realism.md: team median kick speeds 4.1 to 6.3 m/s.", + "kick_speed_sd": "League logs, docs/sim_realism.md: within-team SD about 0.45 m/s.", + "kick_angle_offset_sd_deg": "Chosen with kick_angle_sd_deg to match real pass completion, docs/sim_realism.md: 0.80 at 1 degree, 0.39 at 6, real 0.50.", + "kick_angle_sd_deg": "As kick_angle_offset_sd_deg." + } +} diff --git a/tools/evaluation/reference/world.json b/tools/evaluation/reference/world.json new file mode 100644 index 00000000..3220a7e4 --- /dev/null +++ b/tools/evaluation/reference/world.json @@ -0,0 +1,17 @@ +{ + "note": "What the simulated world does, whichever robots play in it: measured, each number with its source. Would better robots change it? If so it belongs in robots.json. A change here starts a new evaluation environment and replays the ledger.", + "values": { + "latency_s": [0.05, 0.09], + "vision": {"x_stddev": 0.0007, "y_stddev": 0.0007, "th_stddev_deg": 0.3}, + "vanishing": 0.005, + "ball_roll_decel": [0.20, 0.33], + "ball_slide_decel": [2.5, 4.0] + }, + "sources": { + "latency_s": "Field logs (tools/field_physics.py, tools/field_sessions.json): command to vision about 50 to 60 ms on 2026-10-28 (2 radios, wired vision), 80 to 88 ms on 2026-10-27 (one calibration run). The range spans both.", + "vision": "League logs, docs/sim_realism.md: robot noise 0.4 to 1 mm, heading 0.2 to 0.3 degrees. Our lab's ball at rest measures 0.3 to 0.7 mm.", + "vanishing": "League logs, docs/sim_realism.md: 0.1 to 0.9% of detections missing.", + "ball_roll_decel": "Spans our carpet, about 0.20 m/s^2 (2026-10-28, 43 kicks, tools/field_physics.py), to the league's, about 0.29 (docs/sim_realism.md) and a little above.", + "ball_slide_decel": "docs/sim_realism.md, unchanged from the 2026-10-17 settings." + } +} diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index 5d613894..e51b5bea 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -19,7 +19,8 @@ --both-sides play each pair twice, sides swapped --control-scheme NAME planner (fpp, trajsample, ...) --fuzz-restarts SEED inject random legal restarts; --fuzz-interval LO HI sets the gap - --sim-noise JSON seeded sim noise for every match: a SimNoise as inline JSON or a file + --sim-noise SPEC seeded sim noise for every match: reference[:seed] (reference/world.json + and robots.json), or a SimNoise as inline JSON or a file --match-seconds S match length in sim seconds (default 1200) --max-workers N, --sequential, --no-save, -v/--verbose, -h/--help @@ -107,6 +108,7 @@ _stats_to_dict, ) from tools.evaluation.match import run_match as _lib_run_match +from tools.evaluation.sim_settings import sim_noise_from_spec from utama_core.analysis import ratings, restart_outcomes, turnover_breakdown from utama_core.analysis.strategy_table import strategy_table from utama_core.config.settings import REPLAY_BASE_PATH @@ -312,16 +314,16 @@ def main() -> None: fuzz_interval_s = (float(args[idx + 1]), float(args[idx + 2])) args = args[:idx] + args[idx + 3 :] - # `--sim-noise JSON` plays every match with the same seeded latency, kick speed and direction - # noise, ball friction, per-robot motion limits and vision noise: a `SimNoise` as inline JSON or - # a path to a JSON file, e.g. '{"seed": 1, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.3}' + # `--sim-noise SPEC` plays every match with the same seeded latency, kick speed and direction + # noise, ball friction, per-robot motion limits and vision noise: `reference` or `reference:` + # (`reference/world.json` and `robots.json`), or a `SimNoise` as inline JSON or a path to a JSON + # file, e.g. '{"seed": 1, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.3}' # (field list in `SimNoise`'s docstring). Every pairing gets the same # draws (they depend on colour and robot id, not strategy), so standings stay paired. sim_noise: Optional[SimNoise] = None if "--sim-noise" in args: idx = args.index("--sim-noise") - spec = args[idx + 1] - sim_noise = SimNoise.from_dict(json.loads(Path(spec).read_text() if Path(spec).is_file() else spec)) + sim_noise = sim_noise_from_spec(args[idx + 1]) args = args[:idx] + args[idx + 2 :] sim_noise_dict = sim_noise.to_dict() if sim_noise is not None else None diff --git a/tools/evaluation/sim_settings.py b/tools/evaluation/sim_settings.py new file mode 100644 index 00000000..ef89c53f --- /dev/null +++ b/tools/evaluation/sim_settings.py @@ -0,0 +1,42 @@ +"""What the reference evaluation plays: the opponents, and the simulated world and robots. + +`reference/opponents.json` is who a candidate is judged against. `reference/world.json` is the +measured world, `reference/robots.json` the robots, assumed good. They live in a subdirectory +because `replay/fingerprint.py` hashes data files beside `match.py`: choosing a new champion must +not rerun every cached match. World and robots enter the matches together as one `SimNoise`. +""" + +from __future__ import annotations + +import json +from pathlib import Path + +from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + +REFERENCE_DIR = Path(__file__).with_name("reference") +DEFAULT_OPPONENTS = REFERENCE_DIR / "opponents.json" +_REFERENCE_SPEC = "reference" + + +def _values(name: str) -> dict: + return json.loads((REFERENCE_DIR / f"{name}.json").read_text())["values"] + + +def load_opponents(path: Path = DEFAULT_OPPONENTS) -> dict: + return json.loads(Path(path).read_text()) + + +def reference_noise(seed: int = 0) -> dict: + """The reference world and robots as a `SimNoise` dict, played with `seed`.""" + world, robots = _values("world"), _values("robots") + both = set(world) & set(robots) + assert not both, f"set in both world.json and robots.json: {sorted(both)}" + return {**world, **robots, "seed": seed} + + +def sim_noise_from_spec(spec: str) -> SimNoise: + """`round_robin.py --sim-noise`'s argument: `reference`, `reference:`, a JSON file or inline JSON.""" + name, _, seed = spec.partition(":") + if name == _REFERENCE_SPEC: + return SimNoise.from_dict(reference_noise(int(seed) if seed else 0)) + return SimNoise.from_dict(json.loads(Path(spec).read_text() if Path(spec).is_file() else spec)) diff --git a/tools/moments.py b/tools/moments.py index 408920e7..f5987337 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -33,7 +33,7 @@ does something else, the ball goes elsewhere, or our robot never gets there. Hand-made moments: `new` writes a template (both teams in a fixed formation, ours on the right, -the pool's noise with seed 1, source null) to edit by hand; `save` and `load` refuse an +the reference noise with seed 1, source null) to edit by hand; `save` and `load` refuse an invalid one, naming each problem (ids, field lines, check and strategy names). List our side's fouls in a round-robin run, as starting points, each with the referee command @@ -75,6 +75,7 @@ import sys import tempfile from collections import Counter +from functools import partial from pathlib import Path from typing import Callable, Optional @@ -323,7 +324,7 @@ def template( seconds: float = DEFAULT_SECONDS, ) -> Moment: """A hand-made moment: both teams in a fixed formation (ours yellow on the right, facing left), - the given ball and referee command, the reference pool's noise with seed 1, source null.""" + the given ball and referee command, the reference noise with seed 1, source null.""" from utama_core.replay.scenario import RobotState ours = [(4.0, 0.0), (2.2, 1.2), (2.2, -1.2), (1.0, 2.0), (1.0, -2.0), (0.6, 0.0)] @@ -333,7 +334,8 @@ def robots(positions, facing): RobotState(id=i, x=x, y=y, orientation=facing, vx=0.0, vy=0.0) for i, (x, y) in enumerate(positions) ) - pool = json.loads((REPO_ROOT / "tools" / "evaluation" / "pools" / "pool_v1.json").read_text()) + from tools.evaluation.sim_settings import reference_noise + scenario = Scenario( sim_time=0.0, ball_x=ball[0], @@ -352,7 +354,7 @@ def robots(positions, facing): checks=list(checks), strategy=_full_name(strategy), seconds=seconds, - sim_noise={**pool["sim_noise"], "seed": 1}, + sim_noise=reference_noise(seed=1), ) diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index d6c453ad..2e264a2d 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -430,6 +430,7 @@ def to_json(self, path: Union[str, Path]) -> None: # tools/metric_correlation.py's `_PASS_RELEASE_MPS`, which itself matches # this file's own `_SHOT_LOCK_RELEASE_MPS`). _PASS_RELEASE_MPS = 1.0 +_MIN_PASS_M = 0.5 # 90% of overload_press's "148 passes" per match were shorter (2026-11-09) # Hysteresis band around the attacking-third boundary (half_length + # _SHOT_ATTACKING_THIRD_M) so oscillation on that line doesn't double-count # entries. Matches tools/metric_correlation.py's `_ENTRY_HYSTERESIS_M`. @@ -915,12 +916,18 @@ def _update_possession_events( # holder's -- this is the passer->receiver vector a # completed pass measures distance/progress over. previous_position = self._poss_robot_position + # Two teammates side by side trading "nearest robot" is not a pass. + is_pass = ( + previous_position is None or previous_position.distance_to(nearest_robot_position) >= _MIN_PASS_M + ) if self._poss_side == nearest_side == "friendly": - self._completed_passes += 1 - self._record_pass_quality(previous_position, nearest_robot_position, own_goal_sign, "friendly") + if is_pass: + self._completed_passes += 1 + self._record_pass_quality(previous_position, nearest_robot_position, own_goal_sign, "friendly") elif self._poss_side == nearest_side == "enemy": - self._enemy_completed_passes += 1 - self._record_pass_quality(previous_position, nearest_robot_position, own_goal_sign, "enemy") + if is_pass: + self._enemy_completed_passes += 1 + self._record_pass_quality(previous_position, nearest_robot_position, own_goal_sign, "enemy") elif self._poss_side == "friendly" and nearest_side != "friendly": self._turnovers += 1 elif self._poss_side == "enemy" and nearest_side != "enemy": diff --git a/utama_core/tests/engine/test_match_stats.py b/utama_core/tests/engine/test_match_stats.py index cb3ccc2f..acb14eb4 100644 --- a/utama_core/tests/engine/test_match_stats.py +++ b/utama_core/tests/engine/test_match_stats.py @@ -799,3 +799,18 @@ def test_motion_planning_collision_and_clearance_tracking(tmp_path): assert data["opponent_overlap_ticks"] == 0 assert data["opponent_overlap_incidents"] == 0 assert data["worst_clearance_m"] == pytest.approx(-0.08, abs=1e-3) + + +@pytest.mark.parametrize("receiver_x, counted", [(0.49, 0), (0.5, 1)]) +def test_a_handoff_between_adjacent_teammates_is_not_a_pass(receiver_x, counted): + acc = MatchStatsAccumulator() + friendly1 = {1: _robot(1, 0.0, 0.0, True), 3: _robot(3, 5.0, 5.0, True)} + friendly2 = {1: _robot(1, 5.0, 5.0, True), 3: _robot(3, receiver_x, 0.0, True)} + enemy = {2: _robot(2, -5.0, -5.0, False)} + + acc.record_tick(_poss_frame((0.0, 0.0), (0.0, 0.0), friendly1, enemy)) + acc.record_tick(_poss_frame((receiver_x, 0.0), (0.0, 0.0), friendly2, enemy)) + + stats = acc.finalize() + assert stats.completed_passes == counted + assert len(stats.pass_distances_m) == counted From 7af415d95fa855b66d2d820d39771775aa7d78b4 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:52 +0000 Subject: [PATCH 05/59] strategy: name each strategy after its module A strategy is now strategy/.py with one build(outfield_robot_ids, motion_controller), called everywhere. strategy/catalog.py finds them, so a new strategy is a new file; kernel_strategy.py and the build_*_kernel_strategy factories are gone. Names in old replays and summaries still resolve through catalog.plain_name. fingerprint.py still reads the removed registry until the next commit. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- AGENTS.md | 13 ++-- README.md | 2 +- docs/README.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 24 +++---- ...stigation_default_vs_lowblock_stalemate.md | 2 +- docs/strategies.md | 4 +- docs/tactic_model_design_decisions.md | 2 +- tools/check_strategy_branch.py | 51 +++---------- tools/debug_match.py | 12 ++-- tools/evaluation/match.py | 30 ++++---- tools/evaluation/round_robin.py | 23 +++--- tools/metric_correlation.py | 3 +- tools/moments.py | 35 +++++---- tools/motion_planning_benchmark.py | 2 +- tools/plan_trace.py | 3 +- tools/repro_from_replay.py | 19 ++--- tools/signal_report.py | 5 +- utama_core/analysis/goal_ledger.py | 3 +- utama_core/analysis/motion_stats.py | 5 +- utama_core/analysis/plan_snapshot.py | 3 +- utama_core/analysis/strategy_table.py | 3 +- utama_core/analysis/turnover_breakdown.py | 3 +- utama_core/dashboard/views/tournament.py | 3 +- utama_core/engine/abstract_strategy.py | 16 ++--- utama_core/engine/strategy.py | 8 +-- utama_core/replay/scenario.py | 5 +- utama_core/strategy/catalog.py | 28 ++++++++ utama_core/strategy/clear_danger.py | 33 ++++----- utama_core/strategy/clear_press_plus.py | 35 +++++---- utama_core/strategy/counter_flow.py | 31 ++++---- utama_core/strategy/counter_press.py | 31 ++++---- utama_core/strategy/decoy_and_overload.py | 25 +++---- utama_core/strategy/default.py | 23 +++--- utama_core/strategy/give_and_go_solo.py | 25 +++---- utama_core/strategy/high_line_zone.py | 31 ++++---- utama_core/strategy/high_press.py | 25 +++---- utama_core/strategy/kernel_strategy.py | 72 ------------------- utama_core/strategy/low_block.py | 25 +++---- utama_core/strategy/overload_flow.py | 31 ++++---- utama_core/strategy/overload_press.py | 33 ++++----- utama_core/strategy/press_and_pass.py | 25 +++---- utama_core/strategy/press_trigger_flow.py | 31 ++++---- .../strategy/score_aware_counter_flow.py | 31 ++++---- utama_core/strategy/score_aware_zone_flow.py | 33 ++++----- utama_core/strategy/shadow_switch.py | 29 ++++---- utama_core/strategy/split_shape.py | 23 +++--- utama_core/strategy/switch_of_play.py | 29 ++++---- utama_core/strategy/three_slot.py | 31 ++++---- utama_core/strategy/tiki_taka.py | 31 ++++---- utama_core/strategy/tiki_taka_plus.py | 35 +++++---- utama_core/strategy/zone_fluid.py | 31 ++++---- .../abstract_strategy/test_assertions.py | 4 +- utama_core/tests/analysis/test_pitch_maps.py | 6 +- .../tests/analysis/test_signal_report.py | 10 +-- utama_core/tests/analysis/test_triage.py | 2 +- .../custom_referee/test_restart_fuzzer.py | 2 +- .../tests/dashboard/test_tournament_view.py | 8 +-- .../tests/engine/test_all_strategy_configs.py | 56 ++++++--------- utama_core/tests/engine/test_all_tactics.py | 4 +- .../engine/test_check_strategy_branch.py | 53 +++----------- utama_core/tests/engine/test_explain.py | 10 +-- .../tests/engine/test_kernel_strategy.py | 6 +- .../test_kernel_strategy_debug_status.py | 8 +-- .../test_kickoff_goalkeeper_exemption.py | 6 +- .../engine/test_pass_and_score_pass_exec.py | 2 +- .../tests/engine/test_referee_override.py | 4 +- .../test_referee_overrides_customization.py | 4 +- .../tests/engine/test_tournament_cli_args.py | 26 +++---- .../tests/engine/test_tournament_match_end.py | 6 +- .../tests/engine/test_tournament_reuse.py | 14 ++-- .../tests/engine/test_tournament_summary.py | 36 +++++----- .../free_kick_defender_dodges_into_ball.json | 2 +- .../free_kick_robot_drives_in_at_start.json | 2 +- ...acement_corner_robot_drives_onto_ball.json | 2 +- .../placement_in_corner_traps_defender.json | 2 +- .../placement_robot_drives_in_mid_pitch.json | 2 +- .../tests/moments/test_moment_authoring.py | 20 +++--- utama_core/tests/moments/test_play_options.py | 23 +++--- .../_kernel_test_strategies.py | 6 +- .../tests/referee/wandering_strategy.py | 2 +- utama_core/tests/replay/test_scenario.py | 4 +- .../tests/strategy/test_carrier_allocation.py | 8 +-- .../strategy/test_friendly_closer_to_ball.py | 2 +- .../strategy/test_overload_flow_streak.py | 8 +-- .../teleport_position_accuracy_test.py | 4 +- .../test_ball_placement_rsim.py | 4 +- .../strategy_runner/test_change_of_ends.py | 7 +- .../tests/strategy_runner/test_exp_ball.py | 6 +- .../test_goalkeeper_stability.py | 10 +-- .../strategy_runner/test_match_state_reset.py | 4 +- .../strategy_runner/test_referee_rsim.py | 6 +- .../strategy_runner/test_replace_strategy.py | 2 +- .../strategy_runner/test_rsim_formations.py | 4 +- .../test_strategy_control_scheme.py | 24 +++---- 94 files changed, 633 insertions(+), 846 deletions(-) create mode 100644 utama_core/strategy/catalog.py delete mode 100644 utama_core/strategy/kernel_strategy.py diff --git a/AGENTS.md b/AGENTS.md index 879dc753..7f01cf5b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -75,13 +75,12 @@ One term per thing; reuse these instead of coining new ones. `MatchLog`, `AbstractStrategy`, referee-override plumbing. Strategy-dev work touches this rarely, mostly to add a new primitive, not a new strategy. Named `engine/`, not `kernel/`, specifically to avoid colliding with "kernel strategy" — the model's own established - vocabulary (every factory is `build_*_kernel_strategy`, e.g. `build_tiki_taka_kernel_strategy`) - — so "where do I find the kernel strategies" unambiguously means `strategy/` below, not here. + vocabulary — so "where do I find the kernel strategies" unambiguously means `strategy/` below, not here. - `utama_core/strategy/` — the actual strategies people write, run, and compare - (`build_*_kernel_strategy` factories — `tiki_taka`, `counter_flow`, etc.), one module per - strategy (`strategy/.py`, with the pickers only it uses) plus `pickers.py` for helpers - shared by several; `kernel_strategy.py` re-exports every factory, so a new strategy must be - imported there to be discovered. This is where day-to-day strategy-dev edits land. + (`tiki_taka`, `counter_flow`, etc.), one module per strategy (`strategy/.py`, with one + `build(outfield_robot_ids, motion_controller)` and the pickers only it uses) plus `pickers.py` + for helpers shared by several. The module's name is the strategy's name and `catalog.py` finds + them, so a new strategy is a new file. This is where day-to-day strategy-dev edits land. - `utama_core/tactics/` — reusable `Tactic` implementations (`GiveAndGoTactic`, `PressAndContainTactic`, ...) that strategies compose. - `utama_core/skills/` — lower-level per-robot primitives (`go_to_ball`, `block_attacker`, @@ -167,7 +166,7 @@ need most: Read it when designing or debugging a strategy, and before adding a metric; they are diagnostics, not objectives. - `docs/strategies.md` — strategy catalog: status, description, and real round-robin - results per `build_*_kernel_strategy` factory. + results per strategy. - `utama_core/tests/engine/` and `utama_core/tests/strategy_runner/` — the real tactic-kernel test surface; everywhere else is largely infrastructure (motion planning, vision, controllers) that predates and sits below the kernel model. diff --git a/README.md b/README.md index 05147fda..3b8e019b 100644 --- a/README.md +++ b/README.md @@ -44,7 +44,7 @@ Coding agents: read [AGENTS.md](AGENTS.md) first (`CLAUDE.md` is a symlink to it Everything lives under `utama_core/`: -- `strategy/`: the strategies (one module per `build_*_kernel_strategy` factory, re-exported by `kernel_strategy.py`) +- `strategy/`: the strategies (one module each, named after the strategy) - `tactics/`, `skills/`, `shared/`: reusable tactics, per-robot skills, and geometry they share - `engine/`: the tactic-kernel infrastructure (`Strategy`, `Tactic`, `TickContext`, `MatchLog`, referee overrides) - `custom_referee/`: the in-process referee (rules, state machine, restart positioning, profiles) diff --git a/docs/README.md b/docs/README.md index b09709a0..f2ec71cb 100644 --- a/docs/README.md +++ b/docs/README.md @@ -27,7 +27,7 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f ## Current results -- [strategies.md](strategies.md): the strategy catalog: every `build_*_kernel_strategy`, its status, and its latest round-robin results. +- [strategies.md](strategies.md): the strategy catalog: every strategy, its status, and its latest round-robin results. - [pitch_zones.md](pitch_zones.md): names for the parts of the pitch (thirds, wings, centre, the box, danger), with a diagram. - [signals.md](signals.md): every signal recorded about how a strategy plays, grouped by question, with reference ranges and what an off value means. - [signal_report.md](signal_report.md): figures of the main signals for every strategy in the latest full round-robin. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index d4e89840..1115efdf 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -5,8 +5,8 @@ Context for work under `utama_core/engine/`, `utama_core/tactics/`, `utama_core/ root `AGENTS.md`. Design rationale and rejected alternatives: `docs/tactic_model_design_decisions.md` — read it before proposing a change to the kernel's shape. -`engine/` is the scheduler/protocol infra; `strategy/` holds the `build_*_kernel_strategy` -factories (one module per strategy, `kernel_strategy.py` re-exporting them), where day-to-day +`engine/` is the scheduler/protocol infra; `strategy/` holds the strategies (one module +each, named after the strategy, with one `build`), where day-to-day strategy edits land. (`engine/` was renamed from `kernel/` so it can't be confused with "kernel strategy", the model's own term.) @@ -174,7 +174,7 @@ A strategy is a combination of existing tactics plus a partitioner that decides each gets. Most new strategies need no new tactic. When one does, add it as a new module in `tactics/` (on a strategy branch, never by changing an existing tactic: see below). -How a strategy composes tactics, using `build_split_shape_kernel_strategy`: two tactic slots and +How a strategy composes tactics, using `split_shape`: two tactic slots and one hand-written partitioner that switches on which side has the ball. ```mermaid @@ -210,11 +210,10 @@ flowchart TD split --> validate ``` -**Writing one.** Add `strategy/.py` with `build__kernel_strategy(outfield_robot_ids)`, -returning a `Strategy(tactics={...}, partitioner=...)`, and the pickers only it uses; then import -the factory in `strategy/kernel_strategy.py`. Every `build_*_kernel_strategy` that module -re-exports is discovered by name (`match`), so it joins round-robins and `evaluate.py` as -`` (a test fails if a factory is defined but not re-exported). Reuse the shared partitioner +**Writing one.** Add `strategy/.py` with `build(outfield_robot_ids, motion_controller)`, +returning a `Strategy(tactics={...}, partitioner=...)`, and the pickers only it uses. The file is +all it takes: `strategy/catalog.py` finds it, so it joins round-robins and `evaluate.py` as +``. Reuse the shared partitioner pieces in `strategy/pickers.py` rather than re-deriving them: - `friendly_closer_to_ball(game)` — the possession edge. True/False is a clear edge; None is a near-tie or unreadable state, where a sticky picker keeps its previous split. @@ -269,7 +268,7 @@ The flowchart contrasts it with the round-robin, which answers a different quest ```mermaid flowchart TD subgraph rr["round_robin.py: is the whole catalog healthy?"] - r1["Every build_*_kernel_strategy config plays
every other once (one full match per pair)"] + r1["Every strategy plays
every other once (one full match per pair)"] r2["Stall and error check
--strict fails on a stall"] r3["Standings in summary.json
not a verdict on any one strategy"] r1 --> r2 --> r3 @@ -348,15 +347,14 @@ reaches `main` by pull request: `docs/strategies.md`. CI fails a `strategy/*` pull request that changes anything else (`tools/check_strategy_branch.py`, run from `main`'s copy). Anything else it needs, such as a skill or an engine primitive, is a separate change on an ordinary branch. -3. Leave the opponents as they are on `main`: either add new strategy modules (plus their import - lines in `kernel_strategy.py`) or change exactly one existing strategy, never both, and never - `pickers.py` or an existing tactic: the opponents run those. To improve a tactic, copy it into +3. Leave the opponents as they are on `main`: either add new strategy modules or change exactly one existing strategy, never both, and never + `pickers.py`, `catalog.py` or an existing tactic: the opponents run those. To improve a tactic, copy it into a new module and change the copy; making the improvement everyone's is a human change. Your strategy's and tactics' code may not reach outside its module: no import-time effects, no module-level state (keep state inside `build`), no imports of another strategy, no changing attributes of what it imports. CI checks all of this statically, from `main`'s copy of the checker; the reviewer still reads the diff. Tests import pickers from your module - directly, not through `kernel_strategy.py`. + directly. 4. Write, test and evaluate it as above, and record the round-robin in `docs/strategies.md`. `git add` new files before `pixi run lint`: it checks tracked files only. Before waiting on a `--reuse` round-robin, read the "N reused ... M to play" line it prints: M much larger diff --git a/docs/investigation_default_vs_lowblock_stalemate.md b/docs/investigation_default_vs_lowblock_stalemate.md index 89678e43..d1f43e1f 100644 --- a/docs/investigation_default_vs_lowblock_stalemate.md +++ b/docs/investigation_default_vs_lowblock_stalemate.md @@ -38,4 +38,4 @@ Root-cause chain: 4. **Kickoff ceremony for sim matches** — done: `match.py` starts matches with a real `PREPARE_KICKOFF_*`. `StrategyRunner` itself still defaults to `FORCE_START` in sim modes. -Reproduce with `pixi run python tools/debug_match.py --strategy build_default_kernel_strategy --opponent build_low_block_kernel_strategy --dump-ticks ticks.jsonl` (per-tick dump) and render windows with `utama_core/analysis/render_window.py`. +Reproduce with `pixi run python tools/debug_match.py --strategy default --opponent low_block --dump-ticks ticks.jsonl` (per-tick dump) and render windows with `utama_core/analysis/render_window.py`. diff --git a/docs/strategies.md b/docs/strategies.md index f4173857..c2364eb3 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -1,7 +1,7 @@ # Strategy catalog -Every `build_*_kernel_strategy` factory in `utama_core/strategy/` (one module each, re-exported by `kernel_strategy.py`), whether a -round-robin plays it, and the latest results. Short config names drop `build_`/`_kernel_strategy`. +Every strategy in `utama_core/strategy/` (one module each, named after the strategy), whether a +round-robin plays it, and the latest results. Run: diff --git a/docs/tactic_model_design_decisions.md b/docs/tactic_model_design_decisions.md index 62316bc4..81029b95 100644 --- a/docs/tactic_model_design_decisions.md +++ b/docs/tactic_model_design_decisions.md @@ -87,7 +87,7 @@ and removed as duplicated machinery. Consequences, each learned from a bug: **§10. `AbstractStrategy` is kernel-native** (BT/py_trees removed: `087ee4b`, `960662c`, `48affd6`). `StrategyRunner` drives it unchanged; it builds the `Strategy` in -`load_motion_controller()` because `build_kernel_strategy(motion_controller)` needs the +`load_motion_controller()` because `build(motion_controller)` needs the controller but not `game`. **§13. Referee restarts are handled before any Tactic ticks** (`engine/referee_override.py`). diff --git a/tools/check_strategy_branch.py b/tools/check_strategy_branch.py index 22a4f382..0de78253 100644 --- a/tools/check_strategy_branch.py +++ b/tools/check_strategy_branch.py @@ -13,8 +13,8 @@ 2. **Opponents.** Every other strategy must run the base branch's code, so the round-robin plays the same opponents as on `main`. A branch either adds new strategy modules or changes exactly one existing one, never both; it never changes or deletes `pickers.py` (shared by most - strategies) or deletes a strategy; in `kernel_strategy.py` it only adds imports from the - modules it adds; and in `tactics/` it only adds new modules, since the existing tactics are + strategies) or `catalog.py` (which finds them) or deletes a strategy; and in `tactics/` it only + adds new modules, since the existing tactics are what the opponents run (to improve one, copy it into a new module). 3. **Reach.** A new or changed strategy or tactic module can't affect anything outside itself: no import-time effects or hazards (`utama_core/replay/fingerprint.py`'s `_import_time_effects` and `_hazards`: @@ -47,7 +47,7 @@ STRATEGY_DIR = "utama_core/strategy/" TACTICS_DIR = "utama_core/tactics/" -REGISTRY = STRATEGY_DIR + "kernel_strategy.py" +CATALOG = STRATEGY_DIR + "catalog.py" PICKERS = STRATEGY_DIR + "pickers.py" PACKAGE_INIT = STRATEGY_DIR + "__init__.py" _FINGERPRINT = Path("utama_core/replay/fingerprint.py") @@ -83,7 +83,7 @@ def _module_name(path: str) -> str: def opponent_problems(changes: dict[str, str]) -> list[str]: """Check 2's file rules, from `changed_files`.""" - strategy = {p: s for p, s in changes.items() if p.startswith(STRATEGY_DIR) and p.endswith(".py") and p != REGISTRY} + strategy = {p: s for p, s in changes.items() if p.startswith(STRATEGY_DIR) and p.endswith(".py")} problems = [f"{p}: deletes a strategy module" for p, s in strategy.items() if s == "D"] problems += [ f"{p}: changes an existing tactic, which the opponents run; copy it into a new module instead" @@ -92,6 +92,8 @@ def opponent_problems(changes: dict[str, str]) -> list[str]: ] if PICKERS in strategy: problems.append(f"{PICKERS}: shared by most strategies, so changing it changes the opponents") + if CATALOG in strategy: + problems.append(f"{CATALOG}: every strategy is found through it, so changing it changes the opponents") if PACKAGE_INIT in strategy: problems.append(f"{PACKAGE_INIT}: every strategy runs it, so changing it changes the opponents") problems += [ @@ -99,7 +101,9 @@ def opponent_problems(changes: dict[str, str]) -> list[str]: ] added = sorted(p for p, s in strategy.items() if s == "A") # anything but an addition or a deletion changes an existing strategy, a type change included - modified = sorted(p for p, s in strategy.items() if s not in ("A", "D") and p not in (PICKERS, PACKAGE_INIT)) + modified = sorted( + p for p, s in strategy.items() if s not in ("A", "D") and p not in (PICKERS, CATALOG, PACKAGE_INIT) + ) if added and modified: problems.append(f"adds {', '.join(added)} and also changes {', '.join(modified)}: do one or the other") elif len(modified) > 1: @@ -107,38 +111,6 @@ def opponent_problems(changes: dict[str, str]) -> list[str]: return problems -def registry_problems(old_source: str, new_source: str, added_modules: set[str]) -> list[str]: - """Check 2's `kernel_strategy.py` rule: the old statements unchanged and in order, plus only - `from import ...` statements, which may not rebind a name the registry - already has (that would replace an opponent's factory) or rename what they import.""" - old_tree = ast.parse(old_source) - old = [ast.dump(s) for s in old_tree.body] - bound = {n.id for n in ast.walk(old_tree) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Store)} - bound |= { - a.asname or a.name for n in ast.walk(old_tree) if isinstance(n, (ast.Import, ast.ImportFrom)) for a in n.names - } - new = ast.parse(new_source).body - problems, i = [], 0 - for stmt in new: - if i < len(old) and ast.dump(stmt) == old[i]: - i += 1 - elif not (isinstance(stmt, ast.ImportFrom) and stmt.module in added_modules): - problems.append( - f"{REGISTRY} line {stmt.lineno}: only imports from the modules this branch adds may be added" - ) - else: - for a in stmt.names: - if a.asname or a.name in bound: - problems.append( - f"{REGISTRY} line {stmt.lineno}: imports {a.name}" - + (f" as {a.asname}" if a.asname else "") - + ", which would rebind or rename a name the registry has" - ) - if i < len(old): - problems.append(f"{REGISTRY}: changes or removes an existing statement") - return problems - - def _load_fingerprint(path: Path = _FINGERPRINT): # By path, not as `utama_core.replay.fingerprint`: the package's __init__ needs numpy, which # CI's plain python3 lacks. Check 1 has passed by now, so this is the base branch's file. @@ -322,13 +294,10 @@ def main(argv: list[str] | None = None) -> int: return 1 problems = opponent_problems(changes) - added = {_module_name(p) for p, s in changes.items() if s == "A" and p.startswith(STRATEGY_DIR)} - if REGISTRY in changes: - problems += registry_problems(_git("show", f"{args.base}:{REGISTRY}"), Path(REGISTRY).read_text(), added) fingerprint = _load_fingerprint() for path, status in sorted(changes.items()): code = path.startswith((STRATEGY_DIR, TACTICS_DIR)) and path.endswith(".py") - if status != "D" and code and path != REGISTRY: + if status != "D" and code: problems += reach_problems(path, Path(path).read_text(), fingerprint) if problems: print("This strategy branch could change its opponents or the evaluation:") diff --git a/tools/debug_match.py b/tools/debug_match.py index 8aaa45a5..e7dcd2d4 100644 --- a/tools/debug_match.py +++ b/tools/debug_match.py @@ -1,8 +1,8 @@ """debug_match.py — one-off ad hoc match runner for tactic debugging. Run: - pixi run python tools/debug_match.py --strategy build_counter_flow_kernel_strategy \\ - --opponent build_high_press_kernel_strategy --duration 90 --headless + pixi run python tools/debug_match.py --strategy counter_flow \\ + --opponent high_press --duration 90 --headless Replaces the pattern of hand-writing a fresh `StrategyRunner(...)` block per bug (`trace_relay_stall.py`, `trace_finish_detail.py`, `check_keeper.py`, @@ -53,7 +53,7 @@ from utama_core.engine.match_log import load_jsonl from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner -from utama_core.strategy import kernel_strategy +from utama_core.strategy import catalog class _TargetRecorder: @@ -146,10 +146,8 @@ def main() -> None: ) args = parser.parse_args() - build_a = getattr(kernel_strategy, args.strategy) - build_b = getattr(kernel_strategy, args.opponent) - strategy_a = AbstractStrategy(build_kernel_strategy=build_a(OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build_kernel_strategy=build_b(OUTFIELD_ROBOT_IDS)) + strategy_a = AbstractStrategy(build=catalog.builder(args.strategy, OUTFIELD_ROBOT_IDS)) + strategy_b = AbstractStrategy(build=catalog.builder(args.opponent, OUTFIELD_ROBOT_IDS)) referee = CustomReferee.from_profile_name( "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index ab0a8e0c..73ae2bb8 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -3,7 +3,7 @@ Why this exists: `round_robin.py`'s `run_match` and the since-retired `full_match_tournament.py`'s `run_match_cell` were ~80% identical code (build -two strategies from kernel_strategy factory names, construct a referee with +two strategies from their names, construct a referee with the right kickoff-team/initial-command, wire up match_log/stats/replay paths, build and step a `StrategyRunner`, read back the score) that had drifted into two independent copies differing only in a few real parameters (duration, @@ -36,30 +36,29 @@ ) from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner -from utama_core.strategy import kernel_strategy +from utama_core.strategy import catalog +from utama_core.strategy.catalog import plain_name N_OUTFIELD = 5 # + 1 goalkeeper per side OUTFIELD_ROBOT_IDS = tuple(range(1, N_OUTFIELD + 1)) TICKS_PER_SECOND = 60 # matches rsim's default step rate -# build_default_kernel_strategy is excluded from the auto-discovered catalog: +# default is excluded from the auto-discovered catalog: # despite the name, it isn't a competitive team — it's the kernel's minimal # single-tactic smoke-test scaffold (see its docstring), used across the test # suite with as few as zero outfield robots, and plays a real match with 3 of 5 # outfield robots never issued a command. Every other strategy is playable here; # which ones a round-robin plays by default is round_robin.RETIRED's business. -_CONFIG_NAMES = [ - name - for name in dir(kernel_strategy) - if name.startswith("build_") - and name.endswith("_kernel_strategy") - and callable(getattr(kernel_strategy, name)) - and name != "build_default_kernel_strategy" -] +_CONFIG_NAMES = [name for name in catalog.names() if name != "default"] def _short_name(config_name: str) -> str: - return config_name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config_name) + + +def _load_strategy(config_name: str) -> AbstractStrategy: + """A strategy by name.""" + return AbstractStrategy(build=catalog.builder(config_name, OUTFIELD_ROBOT_IDS)) def _stats_to_dict(stats) -> dict: @@ -179,11 +178,8 @@ def run_match( """ enable_sim_reuse() - build_a = getattr(kernel_strategy, config_a_name) - build_b = getattr(kernel_strategy, config_b_name) - - strategy_a = AbstractStrategy(build_kernel_strategy=build_a(OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build_kernel_strategy=build_b(OUTFIELD_ROBOT_IDS)) + strategy_a = _load_strategy(config_a_name) + strategy_b = _load_strategy(config_b_name) # "simulation" profile's kickoff_team defaults to "yellow"; override it to # "blue" when B kicks off. Neither CustomReferee.from_profile_name nor diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index e51b5bea..9588d0de 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -30,7 +30,7 @@ `build_*_kernel_strategy` factories in `utama_core.strategy.kernel_strategy`, runs one `StrategyRunner` match (6v6: 1 goalkeeper + 5 outfield robots per side — enough for every factory's minimum, including the `min_attack=2` -configs and `build_three_slot_kernel_strategy`'s three concurrent slots), +configs and `three_slot`'s three concurrent slots), steps it until `CustomReferee` calls full time, and records the final score from its scoreboard. @@ -115,21 +115,22 @@ from utama_core.replay import eval_ledger, match_cache from utama_core.replay.fingerprint import CodeGraph, match_key from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.strategy.catalog import plain_name # Left out of a round-robin unless named: the bottom ten of the 2026-10-05 full round-robin # (docs/strategies.md). Their code stays, since kept strategies and tests build on some of them. # Named here, outside the match cache key, so retiring one reruns nothing. RETIRED = { - "build_tiki_taka_kernel_strategy", - "build_counter_press_kernel_strategy", - "build_high_line_zone_kernel_strategy", - "build_three_slot_kernel_strategy", - "build_switch_of_play_kernel_strategy", - "build_low_block_kernel_strategy", - "build_zone_fluid_kernel_strategy", - "build_score_aware_zone_flow_kernel_strategy", - "build_overload_flow_kernel_strategy", - "build_shadow_switch_kernel_strategy", + "tiki_taka", + "counter_press", + "high_line_zone", + "three_slot", + "switch_of_play", + "low_block", + "zone_fluid", + "score_aware_zone_flow", + "overload_flow", + "shadow_switch", } # A full match, as the rulebook has it: two halves of 300 s of playing time, the clock stopped diff --git a/tools/metric_correlation.py b/tools/metric_correlation.py index 80debc3b..a73901dd 100644 --- a/tools/metric_correlation.py +++ b/tools/metric_correlation.py @@ -133,6 +133,7 @@ from utama_core.replay.columnar_reader import load_columnar_replay # noqa: E402 from utama_core.replay.entities import ReplayMetadata # noqa: E402 from utama_core.replay.replay_player import _load_replay # noqa: E402 +from utama_core.strategy.catalog import plain_name # --- Sampling --------------------------------------------------------------- _SAMPLE_HZ = 10.0 @@ -579,7 +580,7 @@ def compute_frame_metrics(replay_path: Path, referee_events: list[dict]) -> dict def _match_tag(config_a: str, config_b: str) -> str: def short(name: str) -> str: - return name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(name) return f"{short(config_a)}_vs_{short(config_b)}" diff --git a/tools/moments.py b/tools/moments.py index f5987337..60cc6e11 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -55,7 +55,7 @@ `AGAINST_DIR`, to remove with `git worktree remove --force`), look at its events (referee changes, fouls, keep-out entries, kicks, closest approaches), or try a scratch strategy file's factory: pixi run python tools/moments.py play --seeds 0-4 [--against HEAD~3] [--events] - pixi run python tools/moments.py play --strategy path/to/scratch.py:build_my_kernel_strategy + pixi run python tools/moments.py play --strategy path/to/scratch.py:my """ from __future__ import annotations @@ -95,9 +95,10 @@ _referee_command_at, scenario_from_replay, ) +from utama_core.strategy.catalog import plain_name MOMENTS_DIR = REPO_ROOT / "utama_core" / "tests" / "moments" -DEFAULT_OPPONENT = "build_split_shape_kernel_strategy" +DEFAULT_OPPONENT = "split_shape" DEFAULT_SECONDS = 3.0 # Rulebook distances (`custom_referee/rules/keep_out_rule.py`, `robot_stop_speed_rule.py`). @@ -140,13 +141,11 @@ class Moment: def short_name(name: str) -> str: - return name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(name) def _full_name(name: str) -> str: - if name == "all" or name.startswith("build_") or _is_file_spec(name): - return name - return f"build_{name}_kernel_strategy" + return name if name == "all" or _is_file_spec(name) else plain_name(name) def _is_file_spec(name: str) -> bool: @@ -223,7 +222,7 @@ def save(m: Moment, path: Optional[Path] = None) -> Path: def catalog() -> list[str]: - """The round-robin's strategies: every factory `kernel_strategy.py` re-exports, minus the + """The round-robin's strategies: every strategy in the catalog, minus the retired ones.""" from tools.evaluation.round_robin import _CONFIG_NAMES, RETIRED @@ -233,9 +232,9 @@ def catalog() -> list[str]: def _referee_behaviour(name: str) -> tuple: """What decides a strategy's robots during a restart: its referee overrides and its goalkeeper tactic. Strategies equal here move identically while the override holds.""" - from utama_core.strategy import kernel_strategy + from utama_core.strategy.catalog import builder - strategy = getattr(kernel_strategy, name)(OUTFIELD_ROBOT_IDS)(None) + strategy = builder(name, OUTFIELD_ROBOT_IDS)(None) overrides = tuple( sorted((c.name, getattr(f, "__qualname__", repr(f))) for c, f in strategy.referee_overrides.items()) ) @@ -576,15 +575,15 @@ def events(ticks: list[Tick], we_are_yellow: bool = True) -> list[str]: def factory_for(name: str) -> Callable: - """The strategy factory a name means: a catalog `build_*_kernel_strategy`, or `PATH.py:FACTORY`, - a factory in a scratch file imported as it is (so a tactic can be tried without a repo change).""" - from utama_core.strategy import kernel_strategy + """`f(outfield_robot_ids)` -> `AbstractStrategy`'s first argument, for a catalog strategy or for + `PATH.py:FUNCTION`, a `build(outfield_robot_ids, motion_controller)` in a scratch file imported as + it is (so a tactic can be tried without a repo change).""" + from utama_core.strategy import catalog if not _is_file_spec(name): - try: - return getattr(kernel_strategy, name) - except AttributeError: - raise MomentError(f"unknown strategy {short_name(name)!r}") from None + if plain_name(name) not in catalog.names(): + raise MomentError(f"unknown strategy {short_name(name)!r}") + return partial(catalog.builder, name) path, _, func = name.rpartition(":") if not Path(path).is_file(): raise MomentError(f"{name}: no such file {path}") @@ -594,7 +593,7 @@ def factory_for(name: str) -> Callable: factory = getattr(module, func, None) if not callable(factory): raise MomentError(f"{name}: {path} has no factory {func!r}") - return factory + return lambda outfield_robot_ids: partial(factory, outfield_robot_ids) def label(name: str) -> str: @@ -614,7 +613,7 @@ def play(m: Moment, strategy: str) -> list[Tick]: from utama_core.run import StrategyRunner def side(name: str) -> AbstractStrategy: - return AbstractStrategy(build_kernel_strategy=factory_for(name)(OUTFIELD_ROBOT_IDS)) + return AbstractStrategy(build=factory_for(name)(OUTFIELD_ROBOT_IDS)) referee = CustomReferee.from_profile_name( "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index dd06e2a3..5ceb96c1 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -666,7 +666,7 @@ def build(motion_controller: MotionController) -> KernelStrategy: ctx=TickContext(motion_controller=motion_controller), ) - return AbstractStrategy(build_kernel_strategy=build, exp_ball=False) + return AbstractStrategy(build=build, exp_ball=False) class _ControllerTimer: diff --git a/tools/plan_trace.py b/tools/plan_trace.py index 13540669..c89ccb65 100644 --- a/tools/plan_trace.py +++ b/tools/plan_trace.py @@ -34,6 +34,7 @@ from utama_core.analysis.plan_snapshot import game_from_scenario # noqa: E402 from utama_core.analysis.plan_trace import plan_findings, plan_trace # noqa: E402 from utama_core.replay.scenario import scenario_from_replay # noqa: E402 +from utama_core.strategy.catalog import plain_name def replay_game_at(replay: Path, side: str): @@ -91,7 +92,7 @@ def main() -> None: REPO_ROOT / "replays" / "plan_trace" / f"{args.replay.stem}_{args.t0:g}-{args.t1:g}_{args.side}{args.robot}.png" ) config = first.config_a_name if args.side == "friendly" else first.config_b_name - short = (config or "?").removeprefix("build_").removesuffix("_kernel_strategy") + short = plain_name((config or "?")) title = f"planned {args.side} {short}, robot {args.robot}, t = {args.t0:g} to {args.t1:g} s" trace = plan_trace( diff --git a/tools/repro_from_replay.py b/tools/repro_from_replay.py index 71b80fb5..3febb847 100644 --- a/tools/repro_from_replay.py +++ b/tools/repro_from_replay.py @@ -45,7 +45,7 @@ --t 260 --duration 15 --control-scheme trajsample \\ --trace-out /tmp/repro_trace.jsonl -`--strategy` / `--opponent` take the short name of a `build_*_kernel_strategy` factory in +`--strategy` / `--opponent` take the name of a strategy in `utama_core/strategy/` (e.g. `clear_press_plus`, `counter_flow`), the same names as the replay's `summary.json` config names. The trace shows the tactics those strategies use, not the strategy names (e.g. `decoy_and_overload.*` keys come from a strategy's DecoyOverloadTactic). @@ -100,7 +100,7 @@ class name (e.g. "DecoyOverloadTactic"), on a release why, else null. Written wh from utama_core.replay.scenario import Scenario, apply_scenario, scenario_from_replay from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner -from utama_core.strategy import kernel_strategy +from utama_core.strategy import catalog _STILL_STALLED_WINDOW_S = 10.0 _STILL_STALLED_THRESHOLD_M = 0.05 # 5 cm @@ -114,11 +114,8 @@ def _resolve_config_name(explicit: Optional[str], from_scenario: Optional[str], f"given and the replay's directory has no summary.json (or no matching entry) to derive it from. " f"Pass --strategy/--opponent explicitly." ) - if not name.startswith("build_"): - name = f"build_{name}" - if not name.endswith("_kernel_strategy"): - name = f"{name}_kernel_strategy" - if not hasattr(kernel_strategy, name): + name = catalog.plain_name(name) + if name not in catalog.names(): raise SystemExit( f"Unknown strategy config {name!r} (from {'CLI override' if explicit else 'replay metadata'})." ) @@ -251,7 +248,7 @@ def main() -> None: "--strategy", default=None, help="override the friendly (config_a) strategy: the short name (e.g. clear_press_plus) or the factory " - "name (e.g. build_clear_press_plus_kernel_strategy); default: the replay's summary.json", + "name (e.g. clear_press_plus); default: the replay's summary.json", ) parser.add_argument( "--opponent", @@ -286,10 +283,8 @@ def main() -> None: strategy_a_name = _resolve_config_name(args.strategy, scenario.config_a_name, "friendly") strategy_b_name = _resolve_config_name(args.opponent, scenario.config_b_name, "enemy") - build_a = getattr(kernel_strategy, strategy_a_name) - build_b = getattr(kernel_strategy, strategy_b_name) - strategy_a = AbstractStrategy(build_kernel_strategy=build_a(OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build_kernel_strategy=build_b(OUTFIELD_ROBOT_IDS)) + strategy_a = AbstractStrategy(build=catalog.builder(strategy_a_name, OUTFIELD_ROBOT_IDS)) + strategy_b = AbstractStrategy(build=catalog.builder(strategy_b_name, OUTFIELD_ROBOT_IDS)) referee = CustomReferee.from_profile_name( "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 diff --git a/tools/signal_report.py b/tools/signal_report.py index 15249ba5..47871986 100644 --- a/tools/signal_report.py +++ b/tools/signal_report.py @@ -41,6 +41,7 @@ from utama_core.analysis import turnover_breakdown # noqa: E402 from utama_core.analysis.strategy_table import strategy_table # noqa: E402 +from utama_core.strategy.catalog import plain_name INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" FOR, AGAINST = "#2a78d6", "#eb6834" # categorical slots 1 and 2 @@ -66,7 +67,7 @@ def short(name: str) -> str: - return name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(name) def points(row: dict) -> float: @@ -310,7 +311,7 @@ def _fouls_per_match(summary: dict, table: dict) -> dict[str, dict[str, float]]: out: dict[str, dict[str, float]] = {n: {} for n in table} for rule, info in summary["fouls"].items(): for key, count in info["by_tactic"].items(): - strategy = f"build_{key.split('/')[0]}_kernel_strategy" + strategy = key.split("/")[0] if strategy in table: out[strategy][rule] = out[strategy].get(rule, 0.0) + count / table[strategy]["matches"] return out diff --git a/utama_core/analysis/goal_ledger.py b/utama_core/analysis/goal_ledger.py index d2ac23b1..f22c40ec 100644 --- a/utama_core/analysis/goal_ledger.py +++ b/utama_core/analysis/goal_ledger.py @@ -61,6 +61,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.referee.referee_command import RefereeCommand as C from utama_core.replay.columnar_reader import load_columnar_replay +from utama_core.strategy.catalog import plain_name WINDOW_S = 10.0 FOLD_S = 1.5 @@ -268,7 +269,7 @@ def run_labels(run_dir: Path) -> dict[str, tuple[str, str]]: def _short(config: str) -> str: """A config's name in replay file names (`match._short_name`).""" - return config.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config) def situation_type(situation: Optional[dict], side: str) -> str: diff --git a/utama_core/analysis/motion_stats.py b/utama_core/analysis/motion_stats.py index 8d068d41..651a5839 100644 --- a/utama_core/analysis/motion_stats.py +++ b/utama_core/analysis/motion_stats.py @@ -13,6 +13,7 @@ import numpy as np from utama_core.config.physical_constants import ROBOT_RADIUS +from utama_core.strategy.catalog import plain_name def _count_incidents(d_pairs: np.ndarray) -> int: @@ -196,8 +197,8 @@ def enrich_tournament_directory(tournament_dir: Union[str, Path]) -> None: summary = json.load(f) for result in summary.get("results", []): - cfg_a = result["config_a"].removeprefix("build_").removesuffix("_kernel_strategy") - cfg_b = result["config_b"].removeprefix("build_").removesuffix("_kernel_strategy") + cfg_a = plain_name(result["config_a"]) + cfg_b = plain_name(result["config_b"]) tag = f"{cfg_a}_vs_{cfg_b}" if tag in stats_updates: m = stats_updates[tag] diff --git a/utama_core/analysis/plan_snapshot.py b/utama_core/analysis/plan_snapshot.py index 8726b7bf..3ff5f323 100644 --- a/utama_core/analysis/plan_snapshot.py +++ b/utama_core/analysis/plan_snapshot.py @@ -38,6 +38,7 @@ _keeps_off_ball, ) from utama_core.replay.scenario import Scenario, scenario_from_replay +from utama_core.strategy.catalog import plain_name # Same ink and palette as tools/signal_report.py (FOR = friendly, AGAINST = enemy). INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" @@ -179,7 +180,7 @@ def _stadium(a: np.ndarray, b: np.ndarray, r: float, n: int = 24) -> np.ndarray: def _short(config_name: Optional[str]) -> str: if not config_name: return "?" - return config_name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config_name) def style_axes(ax): diff --git a/utama_core/analysis/strategy_table.py b/utama_core/analysis/strategy_table.py index 9ee2ded9..f1bd40a1 100644 --- a/utama_core/analysis/strategy_table.py +++ b/utama_core/analysis/strategy_table.py @@ -10,11 +10,12 @@ from typing import Optional from utama_core.analysis import chances +from utama_core.strategy.catalog import plain_name def _short_name(config_name: str) -> str: """A config's name in replay file names (mirrors `tools/evaluation/match._short_name`).""" - return config_name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config_name) def strategy_table( diff --git a/utama_core/analysis/turnover_breakdown.py b/utama_core/analysis/turnover_breakdown.py index 82845b3d..61c85cae 100644 --- a/utama_core/analysis/turnover_breakdown.py +++ b/utama_core/analysis/turnover_breakdown.py @@ -50,6 +50,7 @@ from utama_core.engine.match_stats import _POSSESSION_RADIUS_M, MatchStatsAccumulator from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.replay_player import load_frames_in_range +from utama_core.strategy.catalog import plain_name LIVE = {RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START} # Restarts that hand the ball to blue (the enemy). Kickoffs are excluded: blue kicks off @@ -431,7 +432,7 @@ def report(run_name: str, results: list[dict], summary: dict) -> str: recorded = {f"{r['config_a']}_vs_{r['config_b']}": (r["stats"] or {}).get("turnovers") for r in summary["results"]} def short(name: str) -> str: - return name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(name) recorded = {"_vs_".join(short(p) for p in k.split("_vs_")): v for k, v in recorded.items()} mismatches = [ diff --git a/utama_core/dashboard/views/tournament.py b/utama_core/dashboard/views/tournament.py index 70882e2b..c0b43cf4 100644 --- a/utama_core/dashboard/views/tournament.py +++ b/utama_core/dashboard/views/tournament.py @@ -17,6 +17,7 @@ from utama_core.config.settings import REPLAY_BASE_PATH from utama_core.dashboard.server import DashboardServer +from utama_core.strategy.catalog import plain_name def attach(server: DashboardServer) -> None: @@ -47,7 +48,7 @@ def _load_runs() -> List[dict]: def _short(config: str) -> str: - return config.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config) def _replay_path(run_dir: Path, result: dict) -> Optional[str]: diff --git a/utama_core/engine/abstract_strategy.py b/utama_core/engine/abstract_strategy.py index 27c961a6..bf1e3d43 100644 --- a/utama_core/engine/abstract_strategy.py +++ b/utama_core/engine/abstract_strategy.py @@ -57,8 +57,8 @@ class AbstractStrategy: """Kernel-tactic strategy base class, driven by `StrategyRunner`. Args: - build_kernel_strategy: called once, from `load_motion_controller`, as - `build_kernel_strategy(motion_controller) -> Strategy`. + build: called once, from `load_motion_controller`, as + `build(motion_controller) -> Strategy`. Deferred to a factory (rather than passed pre-built) only because `AbstractStrategy.__init__` itself runs before `StrategyRunner` has injected anything — `Strategy.__init__` never reads `game`, only @@ -82,10 +82,10 @@ class AbstractStrategy: the kernel `Strategy` in `load_motion_controller` (see `Strategy.referee_overrides`'s setter docstring for why this is a post-construction assignment rather than a constructor kwarg on - `build_kernel_strategy` itself). + `build` itself). control_scheme: optional name of the preferred motion control scheme to use (e.g. 'trajsample', 'fpp', 'dwa', 'pid'). If omitted, defaults to - class attribute `control_scheme` or `build_kernel_strategy.control_scheme`, + class attribute `control_scheme` or `build.control_scheme`, falling back to StrategyRunner's default ("fpp"). """ @@ -93,21 +93,21 @@ class attribute `control_scheme` or `build_kernel_strategy.control_scheme`, def __init__( self, - build_kernel_strategy, + build, goalkeeper_id: int = 0, exp_ball: bool = True, referee_overrides: Optional[dict[RefereeCommand, RefereeActionOverride]] = None, control_scheme: Optional[str] = None, ): self.exp_ball = exp_ball - self._build_kernel_strategy = build_kernel_strategy + self._build = build self._kernel_strategy: Optional[KernelSchedulerStrategy] = None self._goalkeeper_id = goalkeeper_id self._referee_overrides = referee_overrides self.control_scheme = ( control_scheme if control_scheme is not None - else getattr(self, "control_scheme", None) or getattr(build_kernel_strategy, "control_scheme", None) + else getattr(self, "control_scheme", None) or getattr(build, "control_scheme", None) ) ### These attributes are set by the StrategyRunner before the strategy is run. ### @@ -178,7 +178,7 @@ def load_motion_controller(self, motion_controller: MotionController): kernel `Strategy` (see class docstring for why this, not `load_game`, is the right timing).""" self.motion_controller = motion_controller - self._kernel_strategy = self._build_kernel_strategy(motion_controller) + self._kernel_strategy = self._build(motion_controller) if self._referee_overrides: self._kernel_strategy.referee_overrides = self._referee_overrides self._kernel_strategy.set_goalkeeper(self._goalkeeper_id) diff --git a/utama_core/engine/strategy.py b/utama_core/engine/strategy.py index a0ad75f4..8dacec2b 100644 --- a/utama_core/engine/strategy.py +++ b/utama_core/engine/strategy.py @@ -195,8 +195,8 @@ def __init__( # Optional structured intention/trace log — assigned post-construction # by `StrategyRunner` (see its `match_log_path` param), not threaded - # through every `build_*_kernel_strategy` factory's constructor - # signature, since none of them currently take anything beyond + # through every strategy's `build` signature, since none of them + # currently take anything beyond # `motion_controller`. `None` disables it entirely. The setter below # also pushes it into `self._ctx.match_log`, the one instance shared # by every tactic/skill invoked this tick, so assigning it here is @@ -214,7 +214,7 @@ def referee_overrides(self, value: dict[RefereeCommand, RefereeActionOverride]) Assigned post-construction the same way `match_log` is — `AbstractStrategy.__init__` runs before `load_motion_controller` builds the kernel `Strategy` via each - `build_kernel_strategy(motion_controller)` factory, none of which know about + `build(motion_controller)` factory, none of which know about `referee_overrides`, so `AbstractStrategy.load_motion_controller` sets this right after construction instead of threading a new constructor kwarg through every existing factory. @@ -235,7 +235,7 @@ def set_goalkeeper(self, robot_id: int, tactic: Optional[Tactic] = None) -> None Assigned post-construction the same way `match_log`/`referee_overrides` are — `AbstractStrategy` knows `goalkeeper_id` independently of - whichever `build_kernel_strategy` factory built this `Strategy`, so + whichever `build` factory built this `Strategy`, so this is the one place a caller needs to touch, not a constructor param threaded through every factory. diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index ec0a282b..04cd524c 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -96,6 +96,7 @@ from utama_core.entities.game import Ball, Game, GameFrame, GameHistory, Robot from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.replay_player import _load_replay, load_frames_in_range +from utama_core.strategy.catalog import plain_name logger = logging.getLogger(__name__) @@ -146,7 +147,7 @@ class Scenario: enemy_robots: tuple[RobotState, ...] referee_command: Optional[RefereeCommand] source_replay: Path - config_a_name: Optional[str] = None # e.g. "build_high_line_zone_kernel_strategy" (friendly) + config_a_name: Optional[str] = None # e.g. "high_line_zone" (friendly) config_b_name: Optional[str] = None # enemy frame_ts: float = field(default=0.0) # the actual frame's `ts`, may differ slightly from requested sim_time @@ -154,7 +155,7 @@ class Scenario: def _short_name(config_name: str) -> str: """Mirror `tournament._short_name` without importing the CLI script as a module (it's a root-level script, not a package).""" - return config_name.removeprefix("build_").removesuffix("_kernel_strategy") + return plain_name(config_name) def _robot_states(robots: dict, turn: bool = False) -> tuple[RobotState, ...]: diff --git a/utama_core/strategy/catalog.py b/utama_core/strategy/catalog.py new file mode 100644 index 00000000..b05ad837 --- /dev/null +++ b/utama_core/strategy/catalog.py @@ -0,0 +1,28 @@ +"""The strategies: a module in this package with one `build(outfield_robot_ids, motion_controller)`. + +The module's name is the strategy's name, so a new strategy is a new file and nothing else. +""" + +from __future__ import annotations + +from functools import partial +from importlib import import_module +from pathlib import Path +from typing import Callable + +_PACKAGE = Path(__file__).parent + + +def names() -> list[str]: + """Every strategy, found from source: importing them all would run every module's import-time code.""" + return sorted(p.stem for p in _PACKAGE.glob("*.py") if "\ndef build(" in p.read_text()) + + +def builder(name: str, outfield_robot_ids: tuple[int, ...]) -> Callable: + """`AbstractStrategy`'s first argument for strategy `name`.""" + return partial(import_module(f"utama_core.strategy.{plain_name(name)}").build, outfield_robot_ids) + + +def plain_name(name: str) -> str: + """`name`, also accepting the `build__kernel_strategy` of replays recorded before 2026-11-10.""" + return name.removeprefix("build_").removesuffix("_kernel_strategy") diff --git a/utama_core/strategy/clear_danger.py b/utama_core/strategy/clear_danger.py index cbb9e4b3..6ae0253b 100644 --- a/utama_core/strategy/clear_danger.py +++ b/utama_core/strategy/clear_danger.py @@ -1,4 +1,4 @@ -"""The `clear_danger` kernel strategy: `build_clear_danger_kernel_strategy` and the pickers only it uses.""" +"""The `clear_danger` kernel strategy: `clear_danger` and the pickers only it uses.""" from __future__ import annotations @@ -97,7 +97,7 @@ def _clear_danger_picker( return {} -def build_clear_danger_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Safety-valve team: counter_flow's postures plus a danger-clearance valve. Four concurrent slots — `GiveAndGoTactic` ("attack"), @@ -110,23 +110,20 @@ def build_clear_danger_kernel_strategy(outfield_robot_ids: tuple[int, ...]): kick sites aim at the enemy goal), so pinned-deep teams can only shadow/mark/block and wait. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "clear": ClearBallTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_clear_danger_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "clear": ClearBallTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_clear_danger_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/clear_press_plus.py b/utama_core/strategy/clear_press_plus.py index 5257f813..9d9c4d5e 100644 --- a/utama_core/strategy/clear_press_plus.py +++ b/utama_core/strategy/clear_press_plus.py @@ -1,4 +1,4 @@ -"""The `clear_press_plus` kernel strategy: `build_clear_press_plus_kernel_strategy` and the pickers only it uses.""" +"""The `clear_press_plus` kernel strategy: `clear_press_plus` and the pickers only it uses.""" from __future__ import annotations @@ -97,7 +97,7 @@ def _clear_press_plus_picker( return {} -def build_clear_press_plus_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """`clear_danger` plus `tiki_taka_plus`'s final-third overload handoff. Five concurrent slots -- `GiveAndGoTactic` ("attack"), @@ -108,24 +108,21 @@ def build_clear_press_plus_kernel_strategy(outfield_robot_ids: tuple[int, ...]): duet once the ball reaches the final third, the same swap `tiki_taka_plus` validated on `tiki_taka`'s base. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "clear": ClearBallTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_clear_press_plus_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "overload": DecoyOverloadTactic(), + "clear": ClearBallTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_clear_press_plus_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/counter_flow.py b/utama_core/strategy/counter_flow.py index 0ae47fd3..66f5b6cd 100644 --- a/utama_core/strategy/counter_flow.py +++ b/utama_core/strategy/counter_flow.py @@ -1,4 +1,4 @@ -"""The `counter_flow` kernel strategy: `build_counter_flow_kernel_strategy` and the pickers only it uses.""" +"""The `counter_flow` kernel strategy: `counter_flow` and the pickers only it uses.""" from __future__ import annotations @@ -102,7 +102,7 @@ def _counter_flow_picker( return {} -def build_counter_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Direct answer to tiki_taka: our own give-and-go attack, our own press on the ball, a space-denying screen everywhere else. @@ -117,22 +117,19 @@ def build_counter_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): of trying to dodge it, and uses tiki_taka's own proven-undefeated attack engine rather than a fresh pattern. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_counter_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_counter_flow_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/counter_press.py b/utama_core/strategy/counter_press.py index 03009ca6..61e15291 100644 --- a/utama_core/strategy/counter_press.py +++ b/utama_core/strategy/counter_press.py @@ -1,4 +1,4 @@ -"""The `counter_press` kernel strategy: `build_counter_press_kernel_strategy` and the pickers only it uses.""" +"""The `counter_press` kernel strategy: `counter_press` and the pickers only it uses.""" from __future__ import annotations @@ -63,7 +63,7 @@ def _counter_press_picker( return {} -def build_counter_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """High-intensity transition team: smother the ball where it was lost, then switch the play to the weak side at full commitment. @@ -76,22 +76,19 @@ def build_counter_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): three-role switch (carrier/pivot/runner) needs at least 3 robots, hence the 4+1 split. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": SwitchOfPlayTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_counter_press_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": SwitchOfPlayTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_counter_press_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/decoy_and_overload.py b/utama_core/strategy/decoy_and_overload.py index 5cb00ea9..a4797f8d 100644 --- a/utama_core/strategy/decoy_and_overload.py +++ b/utama_core/strategy/decoy_and_overload.py @@ -1,4 +1,4 @@ -"""The `decoy_and_overload` kernel strategy: `build_decoy_and_overload_kernel_strategy` and the pickers only it uses.""" +"""The `decoy_and_overload` kernel strategy: `decoy_and_overload` and the pickers only it uses.""" from __future__ import annotations @@ -10,30 +10,27 @@ from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic -def build_decoy_and_overload_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory exercising `DecoyOverloadTactic`. Wires `DecoyOverloadTactic` ("attack") and `ShadowAndMarkTactic` ("defense"), split by `fixed_ratio_picker` with `min_attack=2` — `DecoyOverloadTactic` hard-requires at least 2 robots (a decoy and an overloader) the same way `PassAndShootTactic` does, so it needs the - same floor `build_low_block_kernel_strategy` gives that tactic. Attack + same floor `low_block` gives that tactic. Attack fraction left at a plain 0.5 split (possession-agnostic) since nothing about the lure/overload pattern is more or less urgent when the opponent has the ball, unlike the press/shadow pairings above. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": DecoyOverloadTactic(), "defense": ShadowAndMarkTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.5, min_attack=2), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": DecoyOverloadTactic(), "defense": ShadowAndMarkTactic()}, + partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.5, min_attack=2), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/default.py b/utama_core/strategy/default.py index 8b6286c8..b67495b3 100644 --- a/utama_core/strategy/default.py +++ b/utama_core/strategy/default.py @@ -1,4 +1,4 @@ -"""The `default` kernel strategy: `build_default_kernel_strategy` and the pickers only it uses.""" +"""The `default` kernel strategy: `default` and the pickers only it uses.""" from __future__ import annotations @@ -8,7 +8,7 @@ from utama_core.tactics.pass_and_shoot import PassAndShootTactic -def build_default_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Minimal, single-tactic-pool `Strategy` factory: everyone attacks. Only one real multi-robot tactic exists so far (`pass_and_shoot`), so @@ -18,18 +18,15 @@ def build_default_kernel_strategy(outfield_robot_ids: tuple[int, ...]): Callers with more than one outfield tactic should build their own `Strategy` with a real `Picker` instead of using this helper. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"pass_and_shoot": PassAndShootTactic()}, - partitioner=KernelSchedulerStrategy.single_tactic_picker(lambda game, active: "pass_and_shoot"), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"pass_and_shoot": PassAndShootTactic()}, + partitioner=KernelSchedulerStrategy.single_tactic_picker(lambda game, active: "pass_and_shoot"), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/give_and_go_solo.py b/utama_core/strategy/give_and_go_solo.py index 4e6fdb59..283a2ee3 100644 --- a/utama_core/strategy/give_and_go_solo.py +++ b/utama_core/strategy/give_and_go_solo.py @@ -1,4 +1,4 @@ -"""The `give_and_go_solo` kernel strategy: `build_give_and_go_solo_kernel_strategy` and the pickers only it uses.""" +"""The `give_and_go_solo` kernel strategy: `give_and_go_solo` and the pickers only it uses.""" from __future__ import annotations @@ -8,28 +8,25 @@ from utama_core.tactics.give_and_go import GiveAndGoTactic -def build_give_and_go_solo_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Single-tactic `Strategy` factory: the entire outfield pool always runs `GiveAndGoTactic`, no defense slot at all. Mirrors - `build_default_kernel_strategy`'s shape (single Tactic, no real + `default`'s shape (single Tactic, no real allocation decision, via `single_tactic_picker`) but for the newer passing tactic — useful as an isolated benchmark/eval config when testing `GiveAndGoTactic` in isolation matters more than realistic match posture (e.g. tuning `_MAX_HOPS_PER_POSSESSION` or the support-scoring weights without a defensive Tactic's behaviour as a confound). - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": GiveAndGoTactic()}, - partitioner=KernelSchedulerStrategy.single_tactic_picker(lambda game, active: "attack"), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": GiveAndGoTactic()}, + partitioner=KernelSchedulerStrategy.single_tactic_picker(lambda game, active: "attack"), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/high_line_zone.py b/utama_core/strategy/high_line_zone.py index 74d2d690..ba42604d 100644 --- a/utama_core/strategy/high_line_zone.py +++ b/utama_core/strategy/high_line_zone.py @@ -1,4 +1,4 @@ -"""The `high_line_zone` kernel strategy: `build_high_line_zone_kernel_strategy` and the pickers only it uses.""" +"""The `high_line_zone` kernel strategy: `high_line_zone` and the pickers only it uses.""" from __future__ import annotations @@ -97,7 +97,7 @@ def _high_line_zone_picker( return {} -def build_high_line_zone_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Zone-defense team built to deny tiki_taka's give-and-go trio the 1v1s it's designed around, switching the ball past its thin 2-robot cover. @@ -110,22 +110,19 @@ def build_high_line_zone_kernel_strategy(outfield_robot_ids: tuple[int, ...]): defense is always just 2 robots — an imbalance is easy to create); the final third hands off to the overload duet to finish. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "switch": SwitchOfPlayTactic(), - "overload": DecoyOverloadTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_high_line_zone_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "switch": SwitchOfPlayTactic(), + "overload": DecoyOverloadTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_high_line_zone_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/high_press.py b/utama_core/strategy/high_press.py index b14397c7..51648ed0 100644 --- a/utama_core/strategy/high_press.py +++ b/utama_core/strategy/high_press.py @@ -1,4 +1,4 @@ -"""The `high_press` kernel strategy: `build_high_press_kernel_strategy` and the pickers only it uses.""" +"""The `high_press` kernel strategy: `high_press` and the pickers only it uses.""" from __future__ import annotations @@ -10,10 +10,10 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic -def build_high_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory: an aggressive, *non-reactive* posture — most of the pool commits forward regardless of who has the - ball, unlike `build_press_and_pass_kernel_strategy`'s possession-edge + ball, unlike `press_and_pass`'s possession-edge split. Wires the same `GiveAndGoTactic`/`PressAndContainTactic` pair as that config, but the two are not interchangeable: the point here is to demonstrate that the same Tactic set can be driven by a mechanically @@ -21,18 +21,15 @@ def build_high_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): scheduling *policy* is what varies between example strategies, not just the Tactic roster. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": GiveAndGoTactic(), "defense": PressAndContainTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.8), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": GiveAndGoTactic(), "defense": PressAndContainTactic()}, + partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.8), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/kernel_strategy.py b/utama_core/strategy/kernel_strategy.py deleted file mode 100644 index 4ad83506..00000000 --- a/utama_core/strategy/kernel_strategy.py +++ /dev/null @@ -1,72 +0,0 @@ -"""Kernel `Strategy` factories — `build_kernel_strategy(motion_controller) -> Strategy` -callables suitable for `AbstractStrategy`'s constructor argument of the same name. - -See `utama_core.engine.abstract_strategy.AbstractStrategy` for the class that -consumes these and drives them under `StrategyRunner`. - -Each factory lives in its own module, `utama_core/strategy/.py`, next to the pickers only it -uses; helpers shared by more than one strategy are in `pickers.py`. This module only re-exports them, so -`from utama_core.strategy.kernel_strategy import build_X_kernel_strategy` and `dir(kernel_strategy)` -discovery keep working. The private pickers re-exported below are the ones tests import. -""" - -# ruff: noqa: F401 - -from utama_core.strategy.clear_danger import ( - _clear_danger_picker, - build_clear_danger_kernel_strategy, -) -from utama_core.strategy.clear_press_plus import ( - _clear_press_plus_picker, - build_clear_press_plus_kernel_strategy, -) -from utama_core.strategy.counter_flow import ( - _counter_flow_picker, - build_counter_flow_kernel_strategy, -) -from utama_core.strategy.counter_press import ( - _counter_press_picker, - build_counter_press_kernel_strategy, -) -from utama_core.strategy.decoy_and_overload import ( - build_decoy_and_overload_kernel_strategy, -) -from utama_core.strategy.default import build_default_kernel_strategy -from utama_core.strategy.give_and_go_solo import build_give_and_go_solo_kernel_strategy -from utama_core.strategy.high_line_zone import build_high_line_zone_kernel_strategy -from utama_core.strategy.high_press import build_high_press_kernel_strategy -from utama_core.strategy.low_block import build_low_block_kernel_strategy -from utama_core.strategy.overload_flow import build_overload_flow_kernel_strategy -from utama_core.strategy.overload_press import build_overload_press_kernel_strategy -from utama_core.strategy.pickers import ( - carrier_first, - fixed_ratio_picker, - friendly_closer_to_ball, - reset_closer_to_ball_state, -) -from utama_core.strategy.press_and_pass import build_press_and_pass_kernel_strategy -from utama_core.strategy.press_trigger_flow import ( - build_press_trigger_flow_kernel_strategy, -) -from utama_core.strategy.score_aware_counter_flow import ( - build_score_aware_counter_flow_kernel_strategy, -) -from utama_core.strategy.score_aware_zone_flow import ( - build_score_aware_zone_flow_kernel_strategy, -) -from utama_core.strategy.shadow_switch import build_shadow_switch_kernel_strategy -from utama_core.strategy.split_shape import build_split_shape_kernel_strategy -from utama_core.strategy.switch_of_play import build_switch_of_play_kernel_strategy -from utama_core.strategy.three_slot import ( - _three_way_picker, - build_three_slot_kernel_strategy, -) -from utama_core.strategy.tiki_taka import ( - _tiki_taka_picker, - build_tiki_taka_kernel_strategy, -) -from utama_core.strategy.tiki_taka_plus import build_tiki_taka_plus_kernel_strategy -from utama_core.strategy.zone_fluid import ( - _zone_flow_picker, - build_zone_fluid_kernel_strategy, -) diff --git a/utama_core/strategy/low_block.py b/utama_core/strategy/low_block.py index 3bfc016d..279442f9 100644 --- a/utama_core/strategy/low_block.py +++ b/utama_core/strategy/low_block.py @@ -1,4 +1,4 @@ -"""The `low_block` kernel strategy: `build_low_block_kernel_strategy` and the pickers only it uses.""" +"""The `low_block` kernel strategy: `low_block` and the pickers only it uses.""" from __future__ import annotations @@ -10,9 +10,9 @@ from utama_core.tactics.pass_and_shoot import PassAndShootTactic -def build_low_block_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory: a conservative, defense-heavy - counterpart to `build_high_press_kernel_strategy` — most of the pool + counterpart to `high_press` — most of the pool stays back regardless of possession (floored at `min_attack=2`, since `PassAndShootTactic` hard-requires at least 2 robots). Wires `PassAndShootTactic` ("attack") and `DefenseTactic` ("defense"), the @@ -20,18 +20,15 @@ def build_low_block_kernel_strategy(outfield_robot_ids: tuple[int, ...]): they were designed to be (§1/§2's original pairing) rather than the newer, more elaborate Tactics used elsewhere in this file. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": PassAndShootTactic(), "defense": DefenseTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.2, min_attack=2), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": PassAndShootTactic(), "defense": DefenseTactic()}, + partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.2, min_attack=2), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/overload_flow.py b/utama_core/strategy/overload_flow.py index be1559f5..c886e7ff 100644 --- a/utama_core/strategy/overload_flow.py +++ b/utama_core/strategy/overload_flow.py @@ -1,4 +1,4 @@ -"""The `overload_flow` kernel strategy: `build_overload_flow_kernel_strategy` and the pickers only it uses.""" +"""The `overload_flow` kernel strategy: `overload_flow` and the pickers only it uses.""" from __future__ import annotations @@ -119,7 +119,7 @@ def _allocate( return {} -def build_overload_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """`zone_fluid` with a possession-*duration*-aware give-and-go attacker count: 3 attackers as usual, growing to 4 only once the possession edge has held for a sustained window (`_POSSESSION_STREAK_TICKS`), instead of @@ -132,21 +132,18 @@ def build_overload_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): attacker-count decision differs, so any observed difference from plain `zone_fluid` is attributable to the streak requirement alone. - Returns a `build_kernel_strategy(motion_controller)` callable suitable + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_overload_flow_picker(), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "givego": GiveAndGoTactic(), + "overload": DecoyOverloadTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_overload_flow_picker(), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/overload_press.py b/utama_core/strategy/overload_press.py index 402ad69e..c6b1e446 100644 --- a/utama_core/strategy/overload_press.py +++ b/utama_core/strategy/overload_press.py @@ -1,4 +1,4 @@ -"""The `overload_press` kernel strategy: `build_overload_press_kernel_strategy` and the pickers only it uses.""" +"""The `overload_press` kernel strategy: `overload_press` and the pickers only it uses.""" from __future__ import annotations @@ -96,7 +96,7 @@ def _overload_press_picker( return {} -def build_overload_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Numbers-overload team built to beat tiki_taka's shot-line-only shadow defense, with a direct pre-press counter for the transition window. @@ -108,23 +108,20 @@ def build_overload_press_kernel_strategy(outfield_robot_ids: tuple[int, ...]): the ball; on loss, the whole team goes direct via the counter rather than building a press, to hit before tiki_taka's own 3-press organizes. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "overload": DecoyOverloadTactic(), - "switch": SwitchOfPlayTactic(), - "counter": LeadAndSupportTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_overload_press_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "overload": DecoyOverloadTactic(), + "switch": SwitchOfPlayTactic(), + "counter": LeadAndSupportTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_overload_press_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/press_and_pass.py b/utama_core/strategy/press_and_pass.py index 6d45d7b0..e8520bed 100644 --- a/utama_core/strategy/press_and_pass.py +++ b/utama_core/strategy/press_and_pass.py @@ -1,4 +1,4 @@ -"""The `press_and_pass` kernel strategy: `build_press_and_pass_kernel_strategy` and the pickers only it uses.""" +"""The `press_and_pass` kernel strategy: `press_and_pass` and the pickers only it uses.""" from __future__ import annotations @@ -54,28 +54,25 @@ def _press_and_pass_split_picker( return partition -def build_press_and_pass_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory exercising the newer tactics. Wires `GiveAndGoTactic` ("attack") and `PressAndContainTactic` ("defense") as two concurrently active slots, split by `_press_and_pass_split_picker`. Sibling to - `build_split_shape_kernel_strategy`, same shape, different tactic pair — + `split_shape`, same shape, different tactic pair — lets the give-and-go/press-and-contain tactics be driven end to end via `StrategyRunner` instead of only unit-level `tick()` calls. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": GiveAndGoTactic(), "defense": PressAndContainTactic()}, - partitioner=_press_and_pass_split_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": GiveAndGoTactic(), "defense": PressAndContainTactic()}, + partitioner=_press_and_pass_split_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/press_trigger_flow.py b/utama_core/strategy/press_trigger_flow.py index 04d01969..a3fbce72 100644 --- a/utama_core/strategy/press_trigger_flow.py +++ b/utama_core/strategy/press_trigger_flow.py @@ -1,4 +1,4 @@ -"""The `press_trigger_flow` kernel strategy: `build_press_trigger_flow_kernel_strategy` and the pickers only it uses.""" +"""The `press_trigger_flow` kernel strategy: `press_trigger_flow` and the pickers only it uses.""" from __future__ import annotations @@ -87,7 +87,7 @@ def _press_trigger_flow_picker( return {} -def build_press_trigger_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """`counter_flow` with a zone-triggered all-in press: the usual 3-press/ 2-block split everywhere, except an all-in press (every free robot) when the ball is lost in our own third specifically. See the @@ -99,22 +99,19 @@ def build_press_trigger_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...] own-third press commitment differs, so any observed difference from plain `counter_flow` is attributable to the zone-triggered press alone. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_press_trigger_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_press_trigger_flow_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/score_aware_counter_flow.py b/utama_core/strategy/score_aware_counter_flow.py index d2ccae48..37130089 100644 --- a/utama_core/strategy/score_aware_counter_flow.py +++ b/utama_core/strategy/score_aware_counter_flow.py @@ -1,4 +1,4 @@ -"""The `score_aware_counter_flow` kernel strategy: `build_score_aware_counter_flow_kernel_strategy` and the pickers only it uses.""" +"""The `score_aware_counter_flow` kernel strategy: `score_aware_counter_flow` and the pickers only it uses.""" from __future__ import annotations @@ -97,7 +97,7 @@ def _score_aware_counter_flow_picker( return {} -def build_score_aware_counter_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """`counter_flow` (the catalog's only undefeated strategy) with the same scoreline-aware attack-commitment shift `score_aware_zone_flow` validated on a weaker base. Same three tactics/slots as `counter_flow` @@ -105,21 +105,18 @@ def build_score_aware_counter_flow_kernel_strategy(outfield_robot_ids: tuple[int same sticky possession-edge hysteresis -- only the picker's late-game attack-count decision differs. See `_score_aware_counter_flow_picker`. - Returns a `build_kernel_strategy(motion_controller)` callable suitable + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_score_aware_counter_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "press": PressAndContainTactic(), + "block": BlockShapeTactic(), + }, + partitioner=_score_aware_counter_flow_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/score_aware_zone_flow.py b/utama_core/strategy/score_aware_zone_flow.py index f87a06da..28683eda 100644 --- a/utama_core/strategy/score_aware_zone_flow.py +++ b/utama_core/strategy/score_aware_zone_flow.py @@ -1,4 +1,4 @@ -"""The `score_aware_zone_flow` kernel strategy: `build_score_aware_zone_flow_kernel_strategy` and the pickers only it uses.""" +"""The `score_aware_zone_flow` kernel strategy: `score_aware_zone_flow` and the pickers only it uses.""" from __future__ import annotations @@ -96,8 +96,8 @@ def _score_aware_zone_flow_picker( return {} -def build_score_aware_zone_flow_kernel_strategy(outfield_robot_ids: tuple[int, ...]): - """Zone-flow team (see `build_zone_fluid_kernel_strategy`) with one added +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: + """Zone-flow team (see `zone_fluid`) with one added decision input nothing else in the catalog uses: the scoreline. Late in a half, the give-and-go attack/defense split shrinks when we're ahead (protect the lead) and grows when we're behind (chase the game), instead @@ -107,21 +107,18 @@ def build_score_aware_zone_flow_kernel_strategy(outfield_robot_ids: tuple[int, . results is attributable to the new score-aware allocation, not a different tactic set. - Returns a `build_kernel_strategy(motion_controller)` callable suitable + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_score_aware_zone_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "givego": GiveAndGoTactic(), + "overload": DecoyOverloadTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_score_aware_zone_flow_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/shadow_switch.py b/utama_core/strategy/shadow_switch.py index 31678410..739552c7 100644 --- a/utama_core/strategy/shadow_switch.py +++ b/utama_core/strategy/shadow_switch.py @@ -1,4 +1,4 @@ -"""The `shadow_switch` kernel strategy: `build_shadow_switch_kernel_strategy` and the pickers only it uses.""" +"""The `shadow_switch` kernel strategy: `shadow_switch` and the pickers only it uses.""" from __future__ import annotations @@ -87,7 +87,7 @@ def _shadow_switch_picker( return {} -def build_shadow_switch_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Switch-of-play attack with man-marking cover -- a tactic pairing never tried elsewhere in the catalog (`high_line_zone` paired the switch with a zone screen; `tiki_taka`/`tiki_taka_plus` paired shadow-and-mark with @@ -99,21 +99,18 @@ def build_shadow_switch_kernel_strategy(outfield_robot_ids: tuple[int, ...]): on a 3/2 split with sticky possession-edge hysteresis, matching the settling time the switch relay needs. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "switch": SwitchOfPlayTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_shadow_switch_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "switch": SwitchOfPlayTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_shadow_switch_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/split_shape.py b/utama_core/strategy/split_shape.py index 37f0548b..1c198cd9 100644 --- a/utama_core/strategy/split_shape.py +++ b/utama_core/strategy/split_shape.py @@ -1,4 +1,4 @@ -"""The `split_shape` kernel strategy: `build_split_shape_kernel_strategy` and the pickers only it uses.""" +"""The `split_shape` kernel strategy: `split_shape` and the pickers only it uses.""" from __future__ import annotations @@ -61,7 +61,7 @@ def _possession_split_picker( return partition -def build_split_shape_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) split-shape `Strategy` factory. Wires `LeadAndSupportTactic` ("attack") and `ShadowAndMarkTactic` @@ -69,18 +69,15 @@ def build_split_shape_kernel_strategy(outfield_robot_ids: tuple[int, ...]): `_possession_split_picker`. This is the concrete forcing case the design doc's §7 deferral was waiting on — see §11 for the full rationale. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": LeadAndSupportTactic(), "defense": ShadowAndMarkTactic()}, - partitioner=_possession_split_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": LeadAndSupportTactic(), "defense": ShadowAndMarkTactic()}, + partitioner=_possession_split_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/switch_of_play.py b/utama_core/strategy/switch_of_play.py index 78a9d540..d00d1ce5 100644 --- a/utama_core/strategy/switch_of_play.py +++ b/utama_core/strategy/switch_of_play.py @@ -1,4 +1,4 @@ -"""The `switch_of_play` kernel strategy: `build_switch_of_play_kernel_strategy` and the pickers only it uses.""" +"""The `switch_of_play` kernel strategy: `switch_of_play` and the pickers only it uses.""" from __future__ import annotations @@ -10,7 +10,7 @@ from utama_core.tactics.switch_of_play import SwitchOfPlayTactic -def build_switch_of_play_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory exercising `SwitchOfPlayTactic`. Wires `SwitchOfPlayTactic` ("attack") and `DefenseTactic` ("defense"), @@ -18,25 +18,22 @@ def build_switch_of_play_kernel_strategy(outfield_robot_ids: tuple[int, ...]): carrier/pivot/runner relay needs 3 robots to actually exercise the "switch" leg (the pivot outlet) rather than silently degrading to its 2-robot direct-pass fallback every tick, the same floor rationale - `build_low_block_kernel_strategy` gives `PassAndShootTactic` and - `build_decoy_and_overload_kernel_strategy` gives `DecoyOverloadTactic`. + `low_block` gives `PassAndShootTactic` and + `decoy_and_overload` gives `DecoyOverloadTactic`. Attack fraction left at a plain 0.5 split (possession-agnostic), same as - `build_decoy_and_overload_kernel_strategy` — nothing about reading the + `decoy_and_overload` — nothing about reading the weak side and relaying the ball across it is more or less urgent when the opponent has the ball. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": SwitchOfPlayTactic(), "defense": DefenseTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.5, min_attack=3), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={"attack": SwitchOfPlayTactic(), "defense": DefenseTactic()}, + partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.5, min_attack=3), + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/three_slot.py b/utama_core/strategy/three_slot.py index be505437..e5f03a09 100644 --- a/utama_core/strategy/three_slot.py +++ b/utama_core/strategy/three_slot.py @@ -1,4 +1,4 @@ -"""The `three_slot` kernel strategy: `build_three_slot_kernel_strategy` and the pickers only it uses.""" +"""The `three_slot` kernel strategy: `three_slot` and the pickers only it uses.""" from __future__ import annotations @@ -68,7 +68,7 @@ def _three_way_picker( return partition -def build_three_slot_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory running three concurrent Tactic slots at once: `PressAndContainTactic` ("press"), `ShadowAndMarkTactic` ("mark"), and `GiveAndGoTactic` ("attack"). Distinct in kind from every @@ -77,22 +77,19 @@ def build_three_slot_kernel_strategy(outfield_robot_ids: tuple[int, ...]): kernel has always structurally supported (`_validate_partition` iterates `partition.items()` generically) but nothing had tested until now. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "press": PressAndContainTactic(), - "mark": ShadowAndMarkTactic(), - "attack": GiveAndGoTactic(), - }, - partitioner=_three_way_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "press": PressAndContainTactic(), + "mark": ShadowAndMarkTactic(), + "attack": GiveAndGoTactic(), + }, + partitioner=_three_way_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/tiki_taka.py b/utama_core/strategy/tiki_taka.py index 22bf9af1..99ce4eba 100644 --- a/utama_core/strategy/tiki_taka.py +++ b/utama_core/strategy/tiki_taka.py @@ -1,4 +1,4 @@ -"""The `tiki_taka` kernel strategy: `build_tiki_taka_kernel_strategy` and the pickers only it uses.""" +"""The `tiki_taka` kernel strategy: `tiki_taka` and the pickers only it uses.""" from __future__ import annotations @@ -71,7 +71,7 @@ def _tiki_taka_picker( return {} -def build_tiki_taka_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Real possession-play team: give-and-go build-up, press on loss, shadow-and-mark cover behind every attack. @@ -85,22 +85,19 @@ def build_tiki_taka_kernel_strategy(outfield_robot_ids: tuple[int, ...]): setup-then-shoot, which the match-stuck investigation showed cannot complete under contest. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "press": PressAndContainTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_tiki_taka_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "press": PressAndContainTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_tiki_taka_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/tiki_taka_plus.py b/utama_core/strategy/tiki_taka_plus.py index 618baed5..f1c71a47 100644 --- a/utama_core/strategy/tiki_taka_plus.py +++ b/utama_core/strategy/tiki_taka_plus.py @@ -1,4 +1,4 @@ -"""The `tiki_taka_plus` kernel strategy: `build_tiki_taka_plus_kernel_strategy` and the pickers only it uses.""" +"""The `tiki_taka_plus` kernel strategy: `tiki_taka_plus` and the pickers only it uses.""" from __future__ import annotations @@ -38,7 +38,7 @@ # add the one wrinkle it doesn't have -- a distinct final-third finishing # move. `_zone_flow_picker` already validated handing the attacking slot # from `GiveAndGoTactic` to `DecoyOverloadTactic`'s two-role duet once the -# ball crosses into the final third (see `build_zone_fluid_kernel_strategy`); +# ball crosses into the final third (see `zone_fluid`); # this grafts that same handoff onto tiki_taka's stronger 3/2 base shape # instead of `zone_fluid`'s weaker one. # @@ -117,7 +117,7 @@ def _tiki_taka_plus_picker( return {} -def build_tiki_taka_plus_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """`tiki_taka` with a final-third finishing wrinkle: same give-and-go build-up and press-on-loss engine, but the attacking slot hands off to `DecoyOverloadTactic`'s two-role duet once the ball reaches the final @@ -141,23 +141,20 @@ def build_tiki_taka_plus_kernel_strategy(outfield_robot_ids: tuple[int, ...]): added" section for the full writeup, including the caveat that one 40-match run isn't yet enough to rule out variance at this sample size. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "press": PressAndContainTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_tiki_taka_plus_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "attack": GiveAndGoTactic(), + "overload": DecoyOverloadTactic(), + "press": PressAndContainTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_tiki_taka_plus_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/strategy/zone_fluid.py b/utama_core/strategy/zone_fluid.py index 730a0dcd..6585755c 100644 --- a/utama_core/strategy/zone_fluid.py +++ b/utama_core/strategy/zone_fluid.py @@ -1,4 +1,4 @@ -"""The `zone_fluid` kernel strategy: `build_zone_fluid_kernel_strategy` and the pickers only it uses.""" +"""The `zone_fluid` kernel strategy: `zone_fluid` and the pickers only it uses.""" from __future__ import annotations @@ -69,7 +69,7 @@ def _zone_flow_picker( return {} -def build_zone_fluid_kernel_strategy(outfield_robot_ids: tuple[int, ...]): +def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """Zone-adaptive team: the attacking pattern itself changes with ball position, the first strategy in the catalog with two concurrent ATTACK- tagged slots that the picker chooses between — exactly the use the closed @@ -83,22 +83,19 @@ def build_zone_fluid_kernel_strategy(outfield_robot_ids: tuple[int, ...]): duet replaces the trio, luring the last line out of position instead of passing into it. - Returns a `build_kernel_strategy(motion_controller)` + Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. """ - def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_zone_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) - - return _build + ctx = TickContext(motion_controller=motion_controller) + return KernelSchedulerStrategy( + tactics={ + "givego": GiveAndGoTactic(), + "overload": DecoyOverloadTactic(), + "defense": ShadowAndMarkTactic(), + }, + partitioner=_zone_flow_picker, + outfield_robot_ids=outfield_robot_ids, + ctx=ctx, + ) diff --git a/utama_core/tests/abstract_strategy/test_assertions.py b/utama_core/tests/abstract_strategy/test_assertions.py index 0891bc38..8f7afcef 100644 --- a/utama_core/tests/abstract_strategy/test_assertions.py +++ b/utama_core/tests/abstract_strategy/test_assertions.py @@ -11,7 +11,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.engine.abstract_strategy import AbstractStrategy, SpaceRequirements from utama_core.entities.game.field import Field, FieldBounds -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder def make_dummy_game(field_bounds): @@ -22,7 +22,7 @@ class _Game: def _strategy(min_bb) -> AbstractStrategy: - strategy = AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(())) + strategy = AbstractStrategy(build=builder("default", ())) strategy.get_min_bounding_req = lambda: min_bb return strategy diff --git a/utama_core/tests/analysis/test_pitch_maps.py b/utama_core/tests/analysis/test_pitch_maps.py index b7f34e98..3f0d097a 100644 --- a/utama_core/tests/analysis/test_pitch_maps.py +++ b/utama_core/tests/analysis/test_pitch_maps.py @@ -139,7 +139,7 @@ def test_position_grid_shares_sum_to_one_and_means_are_per_robot(): def _views(): - names = ["build_a_kernel_strategy", "build_b_kernel_strategy"] + names = ["a", "b"] shots = [{"x": 2.0, "y": 0.5, "scored": True, "own": True}, {"x": -1.0, "y": 0.0, "scored": False, "own": False}] fouls = [{"x": 1.0, "y": -1.0, "rule": "crashing"}, {"x": -2.0, "y": 1.0, "rule": "double_touch"}] views = [] @@ -178,13 +178,13 @@ def test_rule_colours_take_fixed_slots_in_rank_order(): def test_zone_findings_are_six_descriptive_shares_per_strategy_in_the_pitch_zone_names(): # Common frame: the strategy attacks +x, thirds at x = -1.5 and +1.5 m (docs/pitch_zones.md). view = pm.MatchView( - strategy="build_a_kernel_strategy", + strategy="a", pos_x=np.array([-2.0, 0.0, 2.0, 2.5]), pos_y=np.zeros(4), pos_in=np.array([True, True, True, False]), # three in possession, one out pos_robot=np.array([1, 2, 3, 1]), ) - findings = pm.zone_findings([view], ["build_a_kernel_strategy"], {"in possession": "a.png"}) + findings = pm.zone_findings([view], ["a"], {"in possession": "a.png"}) assert len(findings) == 6 assert all(f.kind == "zone_share" and f.threshold is None and f.replay is None for f in findings) diff --git a/utama_core/tests/analysis/test_signal_report.py b/utama_core/tests/analysis/test_signal_report.py index 6807f9b3..266781c2 100644 --- a/utama_core/tests/analysis/test_signal_report.py +++ b/utama_core/tests/analysis/test_signal_report.py @@ -3,8 +3,8 @@ def _result(a: str, b: str, score_a: int, score_b: int) -> dict: return { - "config_a": f"build_{a}_kernel_strategy", - "config_b": f"build_{b}_kernel_strategy", + "config_a": a, + "config_b": b, "score_a": score_a, "score_b": score_b, "stats": {"shots": {"friendly": 2, "enemy": 1}, "pass_progress_m": [1.5], "enemy_pass_progress_m": [0.2]}, @@ -44,9 +44,9 @@ def test_build_writes_every_figure(tmp_path): "shot_quality.png", "signals.png", ] - assert table["build_x_kernel_strategy"]["chances"]["regain_to_shot"] == 1.0 + assert table["x"]["chances"]["regain_to_shot"] == 1.0 # Shots faced are the other side's shots: x (config_a, friendly) faced the enemy's 1, y faced 2. - assert table["build_x_kernel_strategy"]["shots_faced"] == 1 - assert table["build_y_kernel_strategy"]["shots_faced"] == 2 + assert table["x"]["shots_faced"] == 1 + assert table["y"]["shots_faced"] == 2 rows = markdown(table).splitlines() assert rows[2].startswith("| `x` | 3.00 | 1.0 | 0.0 | 2.0 | 1.0 | 50% | 0% |") diff --git a/utama_core/tests/analysis/test_triage.py b/utama_core/tests/analysis/test_triage.py index 073593ff..0c1d2563 100644 --- a/utama_core/tests/analysis/test_triage.py +++ b/utama_core/tests/analysis/test_triage.py @@ -10,7 +10,7 @@ from utama_core.analysis import matches as match_files from utama_core.analysis.findings import Finding -A, B, C = "build_alpha_kernel_strategy", "build_beta_kernel_strategy", "build_gamma_kernel_strategy" +A, B, C = "alpha", "beta", "gamma" def _finding(kind, value, *, robots=(1,), t0=0.0, t1=10.0, message=None): diff --git a/utama_core/tests/custom_referee/test_restart_fuzzer.py b/utama_core/tests/custom_referee/test_restart_fuzzer.py index a310ff6d..4a66a1c0 100644 --- a/utama_core/tests/custom_referee/test_restart_fuzzer.py +++ b/utama_core/tests/custom_referee/test_restart_fuzzer.py @@ -33,7 +33,7 @@ from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) diff --git a/utama_core/tests/dashboard/test_tournament_view.py b/utama_core/tests/dashboard/test_tournament_view.py index 0eaec05d..35a0b34f 100644 --- a/utama_core/tests/dashboard/test_tournament_view.py +++ b/utama_core/tests/dashboard/test_tournament_view.py @@ -20,8 +20,8 @@ def test_each_match_carries_the_path_of_its_replay_when_the_file_exists(tmp_path run = _write_run( tmp_path, [ - {"config_a": "build_low_block_kernel_strategy", "config_b": "build_three_slot_kernel_strategy"}, - {"config_a": "build_tiki_taka_kernel_strategy", "config_b": "build_counter_flow_kernel_strategy"}, + {"config_a": "low_block", "config_b": "three_slot"}, + {"config_a": "tiki_taka", "config_b": "counter_flow"}, ], ) (run / "low_block_vs_three_slot.npz").write_bytes(b"") @@ -37,8 +37,8 @@ def test_replays_with_side_and_kickoff_tags_are_found(tmp_path, monkeypatch): tmp_path, [ { - "config_a": "build_a_kernel_strategy", - "config_b": "build_b_kernel_strategy", + "config_a": "a", + "config_b": "b", "a_is_right": False, "a_kicks_off": True, } diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index 014b557a..04375990 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -1,5 +1,5 @@ -"""Comprehensive, table-driven tests over every `build_*_kernel_strategy` factory -re-exported by `utama_core/strategy/kernel_strategy.py`. +"""Comprehensive, table-driven tests over every strategy +in `utama_core/strategy/`. Replaces the earlier one-file-per-config pattern (`test_split_shape_kernel_strategy.py`, `test_press_and_pass_kernel_strategy.py`, `test_high_press_kernel_strategy.py`, @@ -11,7 +11,7 @@ suite over `_CONFIGS` gives the same coverage without the duplication. Does not replace `test_kernel_strategy.py` (tests the `AbstractStrategy` -adapter/blackboard wiring itself, via `build_default_kernel_strategy` as one +adapter/blackboard wiring itself, via `default` as one convenient example config — not "does this config's partition behave correctly") or `test_kernel_strategy_debug_status.py` (tests `debug_status()` mechanics specifically). Picker-level unit tests that don't need rsim at all @@ -29,38 +29,22 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.strategy import Strategy from utama_core.entities.data.object import TeamType -from utama_core.strategy import kernel_strategy -from utama_core.strategy.kernel_strategy import ( - _clear_danger_picker, - _clear_press_plus_picker, - _counter_flow_picker, - _counter_press_picker, - _three_way_picker, - _tiki_taka_picker, - _zone_flow_picker, - build_clear_danger_kernel_strategy, - build_counter_press_kernel_strategy, - build_decoy_and_overload_kernel_strategy, - build_give_and_go_solo_kernel_strategy, - build_high_press_kernel_strategy, - build_low_block_kernel_strategy, - build_press_and_pass_kernel_strategy, - build_split_shape_kernel_strategy, - build_three_slot_kernel_strategy, - build_tiki_taka_kernel_strategy, - build_zone_fluid_kernel_strategy, - fixed_ratio_picker, -) +from utama_core.strategy import catalog +from utama_core.strategy.catalog import builder +from utama_core.strategy.clear_danger import _clear_danger_picker +from utama_core.strategy.clear_press_plus import _clear_press_plus_picker +from utama_core.strategy.counter_flow import _counter_flow_picker +from utama_core.strategy.counter_press import _counter_press_picker +from utama_core.strategy.pickers import fixed_ratio_picker +from utama_core.strategy.three_slot import _three_way_picker +from utama_core.strategy.tiki_taka import _tiki_taka_picker +from utama_core.strategy.zone_fluid import _zone_flow_picker _OUTFIELD_IDS = (1, 2, 3, 4, 5) -# Every factory `kernel_strategy` re-exports, as round-robins discover them, so a new strategy is -# covered without editing this file (a strategy branch can't: see tools/check_strategy_branch.py). -_CONFIGS = [ - pytest.param(getattr(kernel_strategy, name), id=name.removeprefix("build_").removesuffix("_kernel_strategy")) - for name in sorted(dir(kernel_strategy)) - if name.startswith("build_") and name.endswith("_kernel_strategy") and name != "build_default_kernel_strategy" -] +# Every strategy, as round-robins discover them, so a new one is covered without editing this +# file (a strategy branch can't: see tools/check_strategy_branch.py). +_CONFIGS = [pytest.param(name, id=name) for name in catalog.names() if name != "default"] @pytest.fixture @@ -69,8 +53,8 @@ def make_runner(): made = [] - def _make(build_kernel_strategy_factory): - strategy = AbstractStrategy(build_kernel_strategy=build_kernel_strategy_factory(_OUTFIELD_IDS)) + def _make(name): + strategy = AbstractStrategy(build=catalog.builder(name, _OUTFIELD_IDS)) r = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -127,7 +111,7 @@ def test_fixed_ratio_picker_high_press_split(): def test_fixed_ratio_picker_low_block_split_respects_min_attack_floor(): """attack_fraction=0.2 on 5 robots rounds to 1, but PassAndShootTactic hard-requires >=2 (it unconditionally reads robot_ids[1]) — min_attack=2 - floors the split rather than letting `build_low_block_kernel_strategy` + floors the split rather than letting `low_block` crash the tactic it wires (the exact regression this test guards).""" picker = fixed_ratio_picker("attack", "defense", attack_fraction=0.2, min_attack=2) partition = picker( @@ -201,7 +185,7 @@ def test_three_way_picker_falls_back_to_attack_when_press_and_mark_inapplicable( def test_give_and_go_solo_always_assigns_everyone_to_attack(make_runner): - runner = make_runner(build_give_and_go_solo_kernel_strategy) + runner = make_runner("give_and_go_solo") runner.step_once() partition = runner.my.strategy._kernel_strategy.active_partition assert partition == {"attack": frozenset(_OUTFIELD_IDS)} diff --git a/utama_core/tests/engine/test_all_tactics.py b/utama_core/tests/engine/test_all_tactics.py index 839b7ffc..69991268 100644 --- a/utama_core/tests/engine/test_all_tactics.py +++ b/utama_core/tests/engine/test_all_tactics.py @@ -8,7 +8,7 @@ near-identical boilerplate around a real `StrategyRunner`/rsim fixture. A single parametrized suite over `_TACTIC_CASES` below gives the same coverage without the duplication, and — concretely — would have caught -`PassAndShootTactic`'s `robot_ids[1]` crash (see `build_low_block_kernel_strategy` +`PassAndShootTactic`'s `robot_ids[1]` crash (see `low_block` in `strategy/low_block.py`) automatically instead of requiring a bespoke test to notice a Tactic has an undeclared minimum robot count. @@ -627,7 +627,7 @@ def test_give_and_go_first_touch_never_shoots_solo_with_a_teammate_available(run ends up the only robot near the dead ball and re-touches it itself, which SSL's double-touch rule forbids for the whole window from NORMAL_START until some *other* robot touches the ball first. Found - live: `build_tiki_taka_kernel_strategy` vs `build_counter_press_kernel_strategy`, + live: `tiki_taka` vs `counter_press`, robot 1 shot from the kickoff spot on the very first tick with two idle teammates standing by, then re-collected its own dead ball ~3.5s later. diff --git a/utama_core/tests/engine/test_check_strategy_branch.py b/utama_core/tests/engine/test_check_strategy_branch.py index b334ba0e..f56ac841 100644 --- a/utama_core/tests/engine/test_check_strategy_branch.py +++ b/utama_core/tests/engine/test_check_strategy_branch.py @@ -19,7 +19,6 @@ opponent_problems, outside_allowlist, reach_problems, - registry_problems, ) REPO_ROOT = Path(__file__).resolve().parents[3] @@ -30,7 +29,6 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): outside_allowlist( [ "utama_core/strategy/new_idea.py", - "utama_core/strategy/kernel_strategy.py", "utama_core/tests/strategy/test_new_idea.py", "docs/strategies.md", ] @@ -71,11 +69,6 @@ def _git(repo, *args): subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], cwd=repo, check=True) -REGISTRY_SRC = ( - '"""Factories."""\n' - "from utama_core.strategy.a import build_a_kernel_strategy\n" - "from utama_core.strategy.b import build_b_kernel_strategy\n" -) STRATEGY_SRC = ( "from utama_core.strategy.pickers import helper\n\n\ndef build_{n}_kernel_strategy(ids):\n return helper(ids)\n" ) @@ -86,7 +79,7 @@ def repo(tmp_path, monkeypatch): _git(tmp_path, "init", "-q", "-b", "main") s = tmp_path / "utama_core/strategy" s.mkdir(parents=True) - (s / "kernel_strategy.py").write_text(REGISTRY_SRC) + (s / "catalog.py").write_text("def names():\n return []\n") (s / "pickers.py").write_text("def helper(ids):\n return ids\n") for n in "ab": (s / f"{n}.py").write_text(STRATEGY_SRC.format(n=n)) @@ -115,22 +108,19 @@ def test_tuning_one_strategy_passes(repo): assert main(["--base", "main"]) == 0 -def test_adding_a_strategy_and_its_import_passes(repo): - registry = REGISTRY_SRC + "from utama_core.strategy.c import build_c_kernel_strategy\n" +def test_adding_a_strategy_passes(repo): _commit( repo, - {"utama_core/strategy/c.py": STRATEGY_SRC.format(n="c"), "utama_core/strategy/kernel_strategy.py": registry}, + {"utama_core/strategy/c.py": STRATEGY_SRC.format(n="c")}, ) assert main(["--base", "main"]) == 0 def test_adding_a_strategy_and_weakening_another_fails(repo): - registry = REGISTRY_SRC + "from utama_core.strategy.c import build_c_kernel_strategy\n" _commit( repo, { "utama_core/strategy/c.py": STRATEGY_SRC.format(n="c"), - "utama_core/strategy/kernel_strategy.py": registry, "utama_core/strategy/b.py": STRATEGY_SRC.format(n="b").replace("helper(ids)", "[]"), }, ) @@ -139,14 +129,12 @@ def test_adding_a_strategy_and_weakening_another_fails(repo): def test_adding_a_tactic_and_a_strategy_that_uses_it_passes(repo): tactic = "from utama_core.tactics.press import PressTactic\n\n\nclass FastPress(PressTactic):\n reach = 2\n" - registry = REGISTRY_SRC + "from utama_core.strategy.c import build_c_kernel_strategy\n" - strategy = "from utama_core.tactics.fast_press import FastPress\n\n\ndef build_c_kernel_strategy(ids):\n return FastPress()\n" + strategy = "from utama_core.tactics.fast_press import FastPress\n\n\ndef c(ids):\n return FastPress()\n" _commit( repo, { "utama_core/tactics/fast_press.py": tactic, "utama_core/strategy/c.py": strategy, - "utama_core/strategy/kernel_strategy.py": registry, }, ) assert main(["--base", "main"]) == 0 @@ -214,28 +202,9 @@ def test_tests_and_the_catalog_do_not_count_as_strategies(): assert opponent_problems(changes) == [] -def test_registry_may_only_gain_imports_from_added_modules(): - added = {"utama_core.strategy.c"} - new_import = "from utama_core.strategy.c import build_c_kernel_strategy\n" - # isort may put the new import anywhere. - first = REGISTRY_SRC.replace('"""Factories."""\n', '"""Factories."""\n' + new_import) - assert registry_problems(REGISTRY_SRC, first, added) == [] - assert registry_problems(REGISTRY_SRC, REGISTRY_SRC + new_import, set()) - repointed = REGISTRY_SRC.replace("strategy.b import", "strategy.c import") - assert registry_problems(REGISTRY_SRC, repointed, added) - assert registry_problems(REGISTRY_SRC, REGISTRY_SRC + "build_b_kernel_strategy = None\n", added) - - -def test_an_added_module_may_not_rebind_or_rename_a_registry_name(): - added = {"utama_core.strategy.c"} - # placed after b's import, this would replace the opponent b's factory with c's code - shadow = REGISTRY_SRC + "from utama_core.strategy.c import build_b_kernel_strategy\n" - assert registry_problems(REGISTRY_SRC, shadow, added) - renamed = REGISTRY_SRC + "from utama_core.strategy.c import build_c_kernel_strategy as build_a_kernel_strategy\n" - assert registry_problems(REGISTRY_SRC, renamed, added) - - -# --- reach ------------------------------------------------------------------------------------ +def test_changing_the_catalog_fails(repo): + _commit(repo, {"utama_core/strategy/catalog.py": "def names():\n return ['a']\n"}) + assert main(["--base", "main"]) == 1 @pytest.fixture(scope="module") @@ -255,7 +224,7 @@ def test_a_plain_strategy_reaches_nothing(fingerprint): "from utama_core.tactics import press\n\n\ndef build(ids):\n press.TABLE['k'] = 0\n", "from utama_core.tactics import press\n\n\ndef build(ids):\n setattr(press, 'reach', 0)\n", # Reaching another strategy, the opponent. - "from utama_core.strategy.tiki_taka import build_tiki_taka_kernel_strategy\n", + "from utama_core.strategy.tiki_taka import tiki_taka\n", "import utama_core.strategy.tiki_taka\n", # Import-time effects and hazards. "import sys\n\nsys.path.append('x')\n", @@ -298,9 +267,7 @@ def test_setting_attributes_on_its_own_objects_is_fine(fingerprint): assert reach_problems("s.py", local, fingerprint) == [] -@pytest.mark.parametrize( - "body", ["from .tiki_taka import build_tiki_taka_kernel_strategy\n", "from . import tiki_taka\n"] -) +@pytest.mark.parametrize("body", ["from .tiki_taka import tiki_taka\n", "from . import tiki_taka\n"]) def test_a_relative_import_of_another_strategy_is_reported(fingerprint, body): assert reach_problems("utama_core/strategy/c.py", body, fingerprint) assert reach_problems("utama_core/strategy/c.py", "from .pickers import helper\n", fingerprint) == [] @@ -312,7 +279,7 @@ def test_every_existing_strategy_passes_the_reach_check(fingerprint): failing = { p.name for p in (REPO_ROOT / "utama_core/strategy").glob("*.py") - if p.name not in ("__init__.py", "kernel_strategy.py", "pickers.py") + if p.name not in ("__init__.py", "catalog.py", "pickers.py") and reach_problems(p.name, p.read_text(), fingerprint) } assert failing == set() diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index 78ff6ab7..b727a8f2 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -20,8 +20,8 @@ ) CAND, CHAMP, OPP1, OPP2 = ( - "build_cand_kernel_strategy", - "build_champ_kernel_strategy", + "cand", + "champ", "build_opp1_kernel_strategy", "build_opp2_kernel_strategy", ) @@ -133,12 +133,12 @@ def test_paired_difference_uses_same_opponent_seed_and_colour(run_dir, tmp_path) def test_explain_refuses_when_a_side_has_no_replay(run_dir, tmp_path): with pytest.raises(FileNotFoundError): - explain.explain(run_dir, "build_nobody_kernel_strategy", CHAMP, tmp_path / "out", workers=1) + explain.explain(run_dir, "nobody", CHAMP, tmp_path / "out", workers=1) def test_evaluate_explain_is_off_by_default(): - assert evaluate.build_parser().parse_args(["build_x_kernel_strategy"]).explain is False - assert evaluate.build_parser().parse_args(["build_x_kernel_strategy", "--explain"]).explain is True + assert evaluate.build_parser().parse_args(["x"]).explain is False + assert evaluate.build_parser().parse_args(["x", "--explain"]).explain is True def test_an_explain_failure_never_escapes(monkeypatch, tmp_path): diff --git a/utama_core/tests/engine/test_kernel_strategy.py b/utama_core/tests/engine/test_kernel_strategy.py index 2be40aaf..70f228e1 100644 --- a/utama_core/tests/engine/test_kernel_strategy.py +++ b/utama_core/tests/engine/test_kernel_strategy.py @@ -13,14 +13,14 @@ import pytest from utama_core.engine.abstract_strategy import AbstractStrategy -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder @pytest.fixture def kernel_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy((1, 2))) + strategy = AbstractStrategy(build=builder("default", (1, 2))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -65,7 +65,7 @@ def test_kernel_strategy_is_built_by_load_motion_controller_alone(): """Direct unit-level check (no rsim, no full runner) that `AbstractStrategy` doesn't need `load_game` at all to build its `Strategy` — only `load_motion_controller`, called with a bare stand-in object.""" - strategy = AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy((1, 2))) + strategy = AbstractStrategy(build=builder("default", (1, 2))) assert strategy._kernel_strategy is None strategy.load_motion_controller(motion_controller=object()) diff --git a/utama_core/tests/engine/test_kernel_strategy_debug_status.py b/utama_core/tests/engine/test_kernel_strategy_debug_status.py index 07aefc69..7aa47943 100644 --- a/utama_core/tests/engine/test_kernel_strategy_debug_status.py +++ b/utama_core/tests/engine/test_kernel_strategy_debug_status.py @@ -11,14 +11,14 @@ from utama_core.engine.abstract_strategy import AbstractStrategy, robot_steps from utama_core.engine.tactic import TacticTag from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.strategy.kernel_strategy import build_split_shape_kernel_strategy +from utama_core.strategy.catalog import builder @pytest.fixture def split_shape_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -84,7 +84,7 @@ def test_debug_status_leaves_out_a_goalkeeper_whose_robot_is_not_on_the_field(): phantom "goalkeeper" row for a robot ID that is not there.""" from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((0, 1)), goalkeeper_id=15) + strategy = AbstractStrategy(build=builder("split_shape", (0, 1)), goalkeeper_id=15) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, my_team_is_right=True, mode="rsim", exp_friendly=2, exp_enemy=0 ) @@ -105,7 +105,7 @@ def _refereed_runner(command, notifier=None): referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=6, n_robots_blue=3) if notifier is not None: referee.attach_dashboard_notifier(notifier) - strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) return StrategyRunner( strategy=strategy, my_team_is_yellow=True, diff --git a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py index d77812c0..e671cd28 100644 --- a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py +++ b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py @@ -30,7 +30,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.strategy.kernel_strategy import build_split_shape_kernel_strategy +from utama_core.strategy.catalog import builder def _set_referee_command( @@ -62,7 +62,7 @@ def _set_referee_command( def split_shape_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -87,7 +87,7 @@ def nonzero_keeper_runner(): from utama_core.run.strategy_runner import StrategyRunner strategy = AbstractStrategy( - build_kernel_strategy=build_split_shape_kernel_strategy((0, 1, 2, 4, 5)), + build=builder("split_shape", (0, 1, 2, 4, 5)), goalkeeper_id=3, ) runner = StrategyRunner( diff --git a/utama_core/tests/engine/test_pass_and_score_pass_exec.py b/utama_core/tests/engine/test_pass_and_score_pass_exec.py index 930d82e4..3e49363a 100644 --- a/utama_core/tests/engine/test_pass_and_score_pass_exec.py +++ b/utama_core/tests/engine/test_pass_and_score_pass_exec.py @@ -4,7 +4,7 @@ hop at a receiver for 4+ seconds after two enemies settled onto the direct carrier-receiver line, producing a highly interceptable pass every tick with no way for the caller to notice and abandon early — see -`build_tiki_taka_kernel_strategy` vs `build_counter_press_kernel_strategy`, +`tiki_taka` vs `counter_press`, t≈23s, `give_and_go.pass_target` locked on receiver 3 while enemies 1/5 sat ~0.15m off the direct line (well inside `segment_blocked`'s own default clearance). diff --git a/utama_core/tests/engine/test_referee_override.py b/utama_core/tests/engine/test_referee_override.py index a88a305c..6fa31bcf 100644 --- a/utama_core/tests/engine/test_referee_override.py +++ b/utama_core/tests/engine/test_referee_override.py @@ -35,14 +35,14 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.strategy.kernel_strategy import build_split_shape_kernel_strategy +from utama_core.strategy.catalog import builder @pytest.fixture def split_shape_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, diff --git a/utama_core/tests/engine/test_referee_overrides_customization.py b/utama_core/tests/engine/test_referee_overrides_customization.py index 584efbac..4eb795e7 100644 --- a/utama_core/tests/engine/test_referee_overrides_customization.py +++ b/utama_core/tests/engine/test_referee_overrides_customization.py @@ -51,7 +51,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.strategy.kernel_strategy import build_split_shape_kernel_strategy +from utama_core.strategy.catalog import builder from .test_referee_override import ( # noqa: F401 (re-used fixture helper) _set_referee_command, @@ -194,7 +194,7 @@ def kickoff_override(game, motion_controller): return {1: _SENTINEL_COMMAND} strategy = AbstractStrategy( - build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5)), + build=builder("split_shape", (1, 2, 3, 4, 5)), referee_overrides={RefereeCommand.PREPARE_KICKOFF_YELLOW: kickoff_override}, ) runner = StrategyRunner( diff --git a/utama_core/tests/engine/test_tournament_cli_args.py b/utama_core/tests/engine/test_tournament_cli_args.py index 1c1d469b..2432d12a 100644 --- a/utama_core/tests/engine/test_tournament_cli_args.py +++ b/utama_core/tests/engine/test_tournament_cli_args.py @@ -45,8 +45,8 @@ def _fake_run_match( "--fuzz-interval", "5", "10", - "build_low_block_kernel_strategy", - "build_tiki_taka_kernel_strategy", + "low_block", + "tiki_taka", ], ) @@ -80,8 +80,8 @@ def _fake_run_match( [ "tournament.py", "--sequential", - "build_low_block_kernel_strategy", - "build_tiki_taka_kernel_strategy", + "low_block", + "tiki_taka", ], ) @@ -117,7 +117,7 @@ def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): tournament.main() - assert calls == [("build_tiki_taka_kernel_strategy", "build_low_block_kernel_strategy")] + assert calls == [("tiki_taka", "low_block")] def test_help_prints_usage_and_plays_nothing(monkeypatch, capsys): @@ -140,20 +140,20 @@ def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): calls.append((config_a_name, config_b_name)) return _stub_result(config_a_name, config_b_name) - names = ["build_a_kernel_strategy", "build_b_kernel_strategy", "build_c_kernel_strategy"] + names = ["a", "b", "c"] monkeypatch.setattr(tournament, "run_match", _fake_run_match) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr(tournament, "_CONFIG_NAMES", names) - monkeypatch.setattr(tournament, "RETIRED", {"build_c_kernel_strategy"}) + monkeypatch.setattr(tournament, "RETIRED", {"c"}) monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save"]) tournament.main() - assert calls == [("build_a_kernel_strategy", "build_b_kernel_strategy")] + assert calls == [("a", "b")] calls.clear() monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "c"]) tournament.main() - assert calls == [("build_a_kernel_strategy", "build_c_kernel_strategy")] + assert calls == [("a", "c")] def test_sim_noise_parsed_and_passed_to_run_match_and_summary(tmp_path, monkeypatch): @@ -174,8 +174,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): "--sequential", "--sim-noise", '{"seed": 3, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.2}', - "build_low_block_kernel_strategy", - "build_tiki_taka_kernel_strategy", + "low_block", + "tiki_taka", ], ) @@ -216,8 +216,8 @@ def put(self, _key, _record): "--reuse", "--match-seconds", "300", - "build_low_block_kernel_strategy", - "build_tiki_taka_kernel_strategy", + "low_block", + "tiki_taka", ], ) diff --git a/utama_core/tests/engine/test_tournament_match_end.py b/utama_core/tests/engine/test_tournament_match_end.py index a41bb73f..1dac918d 100644 --- a/utama_core/tests/engine/test_tournament_match_end.py +++ b/utama_core/tests/engine/test_tournament_match_end.py @@ -36,9 +36,7 @@ def close(self): def test_a_match_ends_at_full_time_not_at_the_sim_time_cap(monkeypatch): monkeypatch.setattr(match, "StrategyRunner", _FakeRunner) - result = match.run_match( - "build_tiki_taka_kernel_strategy", "build_low_block_kernel_strategy", duration_seconds=1200.0 - ) + result = match.run_match("tiki_taka", "low_block", duration_seconds=1200.0) assert _FakeRunner.last.ticks == _FakeRunner.full_time_ticks assert (result.score_a, result.score_b) == (2, 1) @@ -48,6 +46,6 @@ def test_the_cap_still_ends_a_match_that_never_reaches_full_time(monkeypatch): monkeypatch.setattr(_FakeRunner, "full_time_ticks", 10**9) monkeypatch.setattr(match, "StrategyRunner", _FakeRunner) - match.run_match("build_tiki_taka_kernel_strategy", "build_low_block_kernel_strategy", duration_seconds=1.0) + match.run_match("tiki_taka", "low_block", duration_seconds=1.0) assert _FakeRunner.last.ticks == match.TICKS_PER_SECOND diff --git a/utama_core/tests/engine/test_tournament_reuse.py b/utama_core/tests/engine/test_tournament_reuse.py index 02a8b90e..e88ddbc3 100644 --- a/utama_core/tests/engine/test_tournament_reuse.py +++ b/utama_core/tests/engine/test_tournament_reuse.py @@ -30,7 +30,7 @@ def get(self, key, default=None): def rig(tmp_path, monkeypatch): rig = type("Rig", (), {})() rig.played = [] - rig.version = {f"build_{c}_kernel_strategy": 0 for c in _CONFIGS} + rig.version = {c: 0 for c in _CONFIGS} rig.score = {} # pair -> score_a, to make a replay disagree with its stored record rig.cache = MatchCache(tmp_path / "cache") rig.on_play = None @@ -84,13 +84,13 @@ def test_a_second_run_reuses_every_stored_match_and_reports_the_same_results(rig def test_after_one_config_changes_only_its_matches_play(rig): rig.run("--spot-check", "0") - rig.version["build_low_block_kernel_strategy"] += 1 + rig.version["low_block"] += 1 rig.run("--spot-check", "0") assert sorted(rig.played) == [ - ("build_high_press_kernel_strategy", "build_low_block_kernel_strategy"), - ("build_low_block_kernel_strategy", "build_tiki_taka_kernel_strategy"), + ("high_press", "low_block"), + ("low_block", "tiki_taka"), ] @@ -120,16 +120,14 @@ def test_a_match_is_stored_only_if_its_key_is_unchanged_when_it_finishes(rig): # match (high_press vs low_block, sorted pairs played in order) leaves that match's key as it # was: it is stored. Both tiki_taka matches finish under a changed key: neither is. def edit(): - rig.version["build_tiki_taka_kernel_strategy"] = 9 + rig.version["tiki_taka"] = 9 rig.on_play = edit rig.run("--spot-check", "0") stored = [json.loads(p.read_text())["result"] for p in rig.cache.root.rglob("*.json")] - assert [(r["config_a"], r["config_b"]) for r in stored] == [ - ("build_high_press_kernel_strategy", "build_low_block_kernel_strategy") - ] + assert [(r["config_a"], r["config_b"]) for r in stored] == [("high_press", "low_block")] def test_reuse_with_no_save_is_refused(monkeypatch): diff --git a/utama_core/tests/engine/test_tournament_summary.py b/utama_core/tests/engine/test_tournament_summary.py index 8e9f52fe..001826cb 100644 --- a/utama_core/tests/engine/test_tournament_summary.py +++ b/utama_core/tests/engine/test_tournament_summary.py @@ -4,8 +4,8 @@ def _result(a: str, b: str, score_a: int, score_b: int) -> dict: return { - "config_a": f"build_{a}_kernel_strategy", - "config_b": f"build_{b}_kernel_strategy", + "config_a": a, + "config_b": b, "score_a": score_a, "score_b": score_b, "stats": { @@ -29,7 +29,7 @@ def test_strategy_table_reads_each_side_from_its_own_perspective(): results, real_losses_by_match={"x_vs_y": {"tackled": 3, "foul": 1}, "y_vs_x": {"pass_intercepted": 6}} ) - x = table["build_x_kernel_strategy"] + x = table["x"] assert (x["matches"], x["wins"], x["draws"], x["losses"]) == (2, 1, 1, 0) assert (x["goals_for"], x["goals_against"]) == (2, 1) assert x["shots"] == 3 + 1 # friendly in x_vs_y, enemy in y_vs_x @@ -39,7 +39,7 @@ def test_strategy_table_reads_each_side_from_its_own_perspective(): assert (x["matches_as_a"], x["real_losses_as_a"]) == (1, 4) assert x["real_loss_kinds_as_a"] == {"tackled": 3, "foul": 1} - y = table["build_y_kernel_strategy"] + y = table["y"] assert (y["wins"], y["draws"], y["losses"]) == (0, 1, 1) assert (y["matches_as_a"], y["real_losses_as_a"]) == (1, 6) @@ -60,12 +60,12 @@ def test_strategy_table_reads_chances_and_pass_progress_for_both_sides(): table = strategy_table([a, b], chances_by_match={"x_vs_y": record}) - x, y = table["build_x_kernel_strategy"]["chances"], table["build_y_kernel_strategy"]["chances"] + x, y = table["x"]["chances"], table["y"]["chances"] assert (x["matches"], x["shots"], x["conversion"], x["save_rate"]) == (1, 2, 0.5, 1.0) assert (y["matches"], y["shots"], y["save_rate"], y["danger_s_per_match"]) == (1, 1, 0.5, 8.0) - assert table["build_x_kernel_strategy"]["pass_progress_m"] == 1.0 - assert table["build_x_kernel_strategy"]["forward_pass_share"] == 0.5 - assert table["build_y_kernel_strategy"]["pass_progress_m"] == -1.0 + assert table["x"]["pass_progress_m"] == 1.0 + assert table["x"]["forward_pass_share"] == 0.5 + assert table["y"]["pass_progress_m"] == -1.0 def test_strategy_table_counts_stalled_matches_for_both_sides(): @@ -78,15 +78,15 @@ def test_strategy_table_counts_stalled_matches_for_both_sides(): table = strategy_table([stalled, backstop, _result("y", "z", 2, 0)]) - assert table["build_x_kernel_strategy"]["stalled"] == 2 - assert table["build_x_kernel_strategy"]["wins"] == 1 - assert table["build_y_kernel_strategy"]["stalled"] == 1 - assert table["build_z_kernel_strategy"]["stalled"] == 1 + assert table["x"]["stalled"] == 2 + assert table["x"]["wins"] == 1 + assert table["y"]["stalled"] == 1 + assert table["z"]["stalled"] == 1 def test_strategy_table_without_replays_leaves_real_losses_empty(): table = strategy_table([_result("x", "y", 1, 1)]) - assert table["build_x_kernel_strategy"]["matches_as_a"] == 0 + assert table["x"]["matches_as_a"] == 0 def test_foul_table_attributes_each_side_to_its_own_strategy(): @@ -97,8 +97,8 @@ def foul(rule, side, tactic, inferred=False): results = [ { - "config_a": "build_alpha_kernel_strategy", - "config_b": "build_beta_kernel_strategy", + "config_a": "alpha", + "config_b": "beta", "stats": { "fouls": [ foul("excessive_dribbling", "friendly", "lure"), @@ -108,7 +108,7 @@ def foul(rule, side, tactic, inferred=False): ] }, }, - {"config_a": "build_beta_kernel_strategy", "config_b": "build_alpha_kernel_strategy", "stats": None}, + {"config_a": "beta", "config_b": "alpha", "stats": None}, ] table = foul_table(results) @@ -151,6 +151,6 @@ def test_ratings_table_ranks_by_goal_margin_with_an_sd(): from tools.evaluation.round_robin import _ratings table = _ratings([_result("x", "y", 3, 0), _result("y", "z", 2, 0), _result("x", "z", 4, 1)]) - x, z = table["build_x_kernel_strategy"], table["build_z_kernel_strategy"] - assert x["strength"] > table["build_y_kernel_strategy"]["strength"] > z["strength"] + x, z = table["x"], table["z"] + assert x["strength"] > table["y"]["strength"] > z["strength"] assert x["sd"] > 0 diff --git a/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json b/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json index e62c3030..05a91a30 100644 --- a/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json +++ b/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json @@ -6,7 +6,7 @@ "t": 254.65 }, "strategy": "all", - "opponent": "build_split_shape_kernel_strategy", + "opponent": "split_shape", "seconds": 2.0, "checks": [ "keeps_clear" diff --git a/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json b/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json index fb7d4496..5621dc02 100644 --- a/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json +++ b/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json @@ -6,7 +6,7 @@ "t": 155.3 }, "strategy": "all", - "opponent": "build_overload_press_kernel_strategy", + "opponent": "overload_press", "seconds": 3.0, "checks": [ "keep_out", diff --git a/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json b/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json index 2e464005..468b80b8 100644 --- a/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json +++ b/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json @@ -6,7 +6,7 @@ "t": 333.5 }, "strategy": "all", - "opponent": "build_press_trigger_flow_kernel_strategy", + "opponent": "press_trigger_flow", "seconds": 3.0, "checks": [ "keeps_clear", diff --git a/utama_core/tests/moments/placement_in_corner_traps_defender.json b/utama_core/tests/moments/placement_in_corner_traps_defender.json index aba4a11d..c94a5a8c 100644 --- a/utama_core/tests/moments/placement_in_corner_traps_defender.json +++ b/utama_core/tests/moments/placement_in_corner_traps_defender.json @@ -6,7 +6,7 @@ "t": 163.0 }, "strategy": "all", - "opponent": "build_give_and_go_solo_kernel_strategy", + "opponent": "give_and_go_solo", "seconds": 3.0, "checks": [ "keeps_clear", diff --git a/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json b/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json index 3e695571..034d32a9 100644 --- a/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json +++ b/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json @@ -6,7 +6,7 @@ "t": 122.5 }, "strategy": "all", - "opponent": "build_score_aware_counter_flow_kernel_strategy", + "opponent": "score_aware_counter_flow", "seconds": 3.0, "checks": [ "keeps_clear" diff --git a/utama_core/tests/moments/test_moment_authoring.py b/utama_core/tests/moments/test_moment_authoring.py index 57e09ec5..18869c6e 100644 --- a/utama_core/tests/moments/test_moment_authoring.py +++ b/utama_core/tests/moments/test_moment_authoring.py @@ -91,9 +91,9 @@ def test_a_real_rule_name_and_star_are_valid_checks(): def test_unknown_strategy_and_opponent_are_named(): with pytest.raises(moments.MomentError, match=r"unknown strategy 'nope'"): - moments.validate(dataclasses.replace(_template(), strategy="build_nope_kernel_strategy")) + moments.validate(dataclasses.replace(_template(), strategy="nope")) with pytest.raises(moments.MomentError, match=r"unknown opponent 'nope'"): - moments.validate(dataclasses.replace(_template(), opponent="build_nope_kernel_strategy")) + moments.validate(dataclasses.replace(_template(), opponent="nope")) def test_seconds_must_be_positive(): @@ -153,8 +153,8 @@ def foul(t, side="friendly", rule="keep_out"): results = [ { - "config_a": "build_a_kernel_strategy", - "config_b": "build_b_kernel_strategy", + "config_a": "a", + "config_b": "b", "stats": {"fouls": [foul(1.0), foul(5.0), foul(12.0), foul(20.0), foul(6.0, side="enemy")]}, } ] @@ -181,9 +181,7 @@ def test_our_fouls_names_the_match_replay_relative_to_the_repo(tmp_path): import json row = {"rule": "keep_out", "sim_time": 3.0, "side": "friendly", "robot_id": 1, "tactic": "X"} - results = [ - {"config_a": "build_a_kernel_strategy", "config_b": "build_b_kernel_strategy", "stats": {"fouls": [row]}} - ] + results = [{"config_a": "a", "config_b": "b", "stats": {"fouls": [row]}}] (tmp_path / "summary.json").write_text(json.dumps({"results": results})) (fouls,) = moments.our_fouls(tmp_path) assert fouls["replay"] is None # no a_vs_b replay in the run dir @@ -206,9 +204,7 @@ def test_our_fouls_without_a_match_log_has_no_command(tmp_path): import json row = {"rule": "keep_out", "sim_time": 3.0, "side": "friendly", "robot_id": 1, "tactic": "X"} - results = [ - {"config_a": "build_a_kernel_strategy", "config_b": "build_b_kernel_strategy", "stats": {"fouls": [row]}} - ] + results = [{"config_a": "a", "config_b": "b", "stats": {"fouls": [row]}}] (tmp_path / "summary.json").write_text(json.dumps({"results": results})) (fouls,) = moments.our_fouls(tmp_path) assert fouls["command"] is None and fouls["restart"] is None @@ -217,8 +213,8 @@ def test_our_fouls_without_a_match_log_has_no_command(tmp_path): def _foul_row(config_a, rule, restart=None, tactic="X"): return { - "config_a": f"build_{config_a}_kernel_strategy", - "config_b": "build_b_kernel_strategy", + "config_a": config_a, + "config_b": "b", "rule": rule, "tactic": tactic, "restart": restart, diff --git a/utama_core/tests/moments/test_play_options.py b/utama_core/tests/moments/test_play_options.py index c6d1768e..01f21aad 100644 --- a/utama_core/tests/moments/test_play_options.py +++ b/utama_core/tests/moments/test_play_options.py @@ -84,24 +84,19 @@ def test_events_of_nothing_is_nothing(): assert moments.events([]) == [] -def test_factory_for_resolves_a_catalog_name_to_its_factory(): - from utama_core.strategy import kernel_strategy +def test_factory_for_resolves_a_catalog_name_to_its_builder(): + from utama_core.strategy.split_shape import build - factory = moments.factory_for("build_split_shape_kernel_strategy") - assert factory is kernel_strategy.build_split_shape_kernel_strategy + assert moments.factory_for("split_shape")((1, 2)).func is build -def test_factory_for_imports_a_factory_from_a_scratch_file(tmp_path): +def test_factory_for_imports_a_build_from_a_scratch_file(tmp_path): scratch = tmp_path / "mine.py" - scratch.write_text( - "from utama_core.strategy import kernel_strategy\n\n" - "def build_mine_kernel_strategy(ids):\n" - " return kernel_strategy.build_split_shape_kernel_strategy(ids)\n" - ) - name = f"{scratch}:build_mine_kernel_strategy" - assert callable(moments.factory_for(name)(moments.OUTFIELD_ROBOT_IDS)) + scratch.write_text("def mine(ids, motion_controller):\n return ids, motion_controller\n") + name = f"{scratch}:mine" + assert moments.factory_for(name)(moments.OUTFIELD_ROBOT_IDS)("mc") == (moments.OUTFIELD_ROBOT_IDS, "mc") assert moments._full_name(name) == name - assert moments.label(name) == "mine:build_mine_kernel_strategy" + assert moments.label(name) == "mine:mine" def test_factory_for_names_a_missing_file_a_missing_factory_and_an_unknown_strategy(tmp_path): @@ -112,4 +107,4 @@ def test_factory_for_names_a_missing_file_a_missing_factory_and_an_unknown_strat with pytest.raises(moments.MomentError, match="has no factory 'build_x'"): moments.factory_for(f"{scratch}:build_x") with pytest.raises(moments.MomentError, match="unknown strategy 'nope'"): - moments.factory_for("build_nope_kernel_strategy") + moments.factory_for("nope") diff --git a/utama_core/tests/motion_planning/_kernel_test_strategies.py b/utama_core/tests/motion_planning/_kernel_test_strategies.py index f9d55eab..0df6c86f 100644 --- a/utama_core/tests/motion_planning/_kernel_test_strategies.py +++ b/utama_core/tests/motion_planning/_kernel_test_strategies.py @@ -77,7 +77,7 @@ def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: ctx=ctx, ) - return AbstractStrategy(build_kernel_strategy=_build, exp_ball=False) + return AbstractStrategy(build=_build, exp_ball=False) def single_robot_go_to_point_strategy( @@ -143,7 +143,7 @@ def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: ctx=ctx, ) - return AbstractStrategy(build_kernel_strategy=_build, exp_ball=False) + return AbstractStrategy(build=_build, exp_ball=False) @dataclass @@ -224,7 +224,7 @@ def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: ctx=ctx, ) - return AbstractStrategy(build_kernel_strategy=_build, exp_ball=False) + return AbstractStrategy(build=_build, exp_ball=False) __all__ = [ diff --git a/utama_core/tests/referee/wandering_strategy.py b/utama_core/tests/referee/wandering_strategy.py index 886b97da..3bfe1668 100644 --- a/utama_core/tests/referee/wandering_strategy.py +++ b/utama_core/tests/referee/wandering_strategy.py @@ -114,7 +114,7 @@ def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: ctx=ctx, ) - return AbstractStrategy(build_kernel_strategy=_build) + return AbstractStrategy(build=_build) __all__ = ["WanderingTactic", "wandering_strategy"] diff --git a/utama_core/tests/replay/test_scenario.py b/utama_core/tests/replay/test_scenario.py index e74a194c..61a5877e 100644 --- a/utama_core/tests/replay/test_scenario.py +++ b/utama_core/tests/replay/test_scenario.py @@ -18,7 +18,7 @@ from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.scenario import RobotState, Scenario, apply_scenario -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.team_controller.src.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, @@ -29,7 +29,7 @@ def _idle_strategy() -> AbstractStrategy: - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(())) + return AbstractStrategy(build=builder("default", ())) class _ApplyScenarioTestManager(AbstractTestManager): diff --git a/utama_core/tests/strategy/test_carrier_allocation.py b/utama_core/tests/strategy/test_carrier_allocation.py index 9ee78133..8f35af8e 100644 --- a/utama_core/tests/strategy/test_carrier_allocation.py +++ b/utama_core/tests/strategy/test_carrier_allocation.py @@ -1,7 +1,7 @@ from types import SimpleNamespace from utama_core.entities.data.object import TeamType -from utama_core.strategy.kernel_strategy import _clear_press_plus_picker +from utama_core.strategy.clear_press_plus import _clear_press_plus_picker def _final_third_game(carrier_id): @@ -49,7 +49,7 @@ def test_a_free_kick_kicker_standing_at_the_ball_goes_first(): # kick the kicker stood 0.11 m from the ball without dribbler contact, went to # "block"/"switch", and the overload decoy had to cross the field to it -- # no kick for 10 s. Within kick reach of a still ball counts as holding it. - from utama_core.strategy.kernel_strategy import carrier_first + from utama_core.strategy.pickers import carrier_first assert carrier_first(_free_kick_game(kicker_dist=0.12), frozenset(range(1, 6)))[0] == 5 @@ -59,7 +59,7 @@ def test_a_kicker_that_nudged_its_own_free_kick_ball_still_goes_first(): # the ball at 0.21 m/s, it lost the carrier spot to the lowest ids, walked off, # and the unkicked ball (moved 4.5 cm, never in play) sat for 10 s. A ball under # the 0.3 m/s dead-ball speed is still one the kicker can simply take. - from utama_core.strategy.kernel_strategy import carrier_first + from utama_core.strategy.pickers import carrier_first assert carrier_first(_free_kick_game(kicker_dist=0.11, ball_speed=0.21), frozenset(range(1, 6)))[0] == 5 assert carrier_first(_free_kick_game(kicker_dist=0.11, ball_speed=0.29), frozenset(range(1, 6)))[0] == 5 @@ -67,7 +67,7 @@ def test_a_kicker_that_nudged_its_own_free_kick_ball_still_goes_first(): def test_a_robot_short_of_kick_reach_or_beaten_to_the_ball_is_not_first(): - from utama_core.strategy.kernel_strategy import carrier_first + from utama_core.strategy.pickers import carrier_first assert carrier_first(_free_kick_game(kicker_dist=0.30), frozenset(range(1, 6)))[0] == 1 assert carrier_first(_free_kick_game(kicker_dist=0.12, enemy_dist=0.11), frozenset(range(1, 6)))[0] == 1 diff --git a/utama_core/tests/strategy/test_friendly_closer_to_ball.py b/utama_core/tests/strategy/test_friendly_closer_to_ball.py index 834e3bef..a8424911 100644 --- a/utama_core/tests/strategy/test_friendly_closer_to_ball.py +++ b/utama_core/tests/strategy/test_friendly_closer_to_ball.py @@ -3,7 +3,7 @@ import pytest from utama_core.entities.data.object import TeamType -from utama_core.strategy.kernel_strategy import ( +from utama_core.strategy.pickers import ( friendly_closer_to_ball, reset_closer_to_ball_state, ) diff --git a/utama_core/tests/strategy/test_overload_flow_streak.py b/utama_core/tests/strategy/test_overload_flow_streak.py index eb2ef924..e2a053de 100644 --- a/utama_core/tests/strategy/test_overload_flow_streak.py +++ b/utama_core/tests/strategy/test_overload_flow_streak.py @@ -7,17 +7,15 @@ from unittest.mock import MagicMock from utama_core.strategy import overload_flow -from utama_core.strategy.overload_flow import ( - _POSSESSION_STREAK_TICKS, - build_overload_flow_kernel_strategy, -) +from utama_core.strategy.catalog import builder +from utama_core.strategy.overload_flow import _POSSESSION_STREAK_TICKS _ROBOTS = frozenset({1, 2, 3, 4, 5}) _TACTICS = frozenset({"givego", "overload", "defense"}) def _picker(): - return build_overload_flow_kernel_strategy((1, 2, 3, 4, 5))(MagicMock())._partitioner + return builder("overload_flow", (1, 2, 3, 4, 5))(MagicMock())._partitioner def test_each_strategy_counts_its_own_possession_streak(monkeypatch): diff --git a/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py b/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py index 3ca2bae1..a3b065d9 100644 --- a/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py +++ b/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py @@ -10,7 +10,7 @@ from utama_core.entities.game import Game from utama_core.entities.game.field import FieldBounds from utama_core.run import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.team_controller.src.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, @@ -34,7 +34,7 @@ def _idle_strategy() -> AbstractStrategy: """Minimal kernel strategy that does nothing — used when we only care about game state.""" - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(())) + return AbstractStrategy(build=builder("default", ())) class _TeleportAccuracyTestManager(AbstractTestManager): diff --git a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py b/utama_core/tests/strategy_runner/test_ball_placement_rsim.py index ebfc3617..556c5d22 100644 --- a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py +++ b/utama_core/tests/strategy_runner/test_ball_placement_rsim.py @@ -58,7 +58,7 @@ from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.team_controller.src.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, @@ -100,7 +100,7 @@ def _make_runner(referee: CustomReferee) -> StrategyRunner: `AbstractStrategy`'s goalkeeper pinning is irrelevant to this test. """ return StrategyRunner( - strategy=AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy((0, 1))), + strategy=AbstractStrategy(build=builder("default", (0, 1))), my_team_is_yellow=True, my_team_is_right=True, mode="rsim", diff --git a/utama_core/tests/strategy_runner/test_change_of_ends.py b/utama_core/tests/strategy_runner/test_change_of_ends.py index 2c91e017..b4e4fa99 100644 --- a/utama_core/tests/strategy_runner/test_change_of_ends.py +++ b/utama_core/tests/strategy_runner/test_change_of_ends.py @@ -18,7 +18,7 @@ from utama_core.global_utils.math_utils import in_field_bounds from utama_core.run import StrategyRunner from utama_core.run.strategy_runner import _turned -from utama_core.strategy import kernel_strategy +from utama_core.strategy.catalog import builder N_OUTFIELD = 2 HALF_S = 3.0 @@ -27,12 +27,11 @@ def test_the_teams_play_the_second_half_from_the_other_end(headless): - build = kernel_strategy.build_tiki_taka_kernel_strategy profile = load_profile("simulation") profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, half_duration_seconds=HALF_S)) runner = StrategyRunner( - strategy=AbstractStrategy(build_kernel_strategy=build(tuple(range(1, N_OUTFIELD + 1)))), - opp_strategy=AbstractStrategy(build_kernel_strategy=build(tuple(range(1, N_OUTFIELD + 1)))), + strategy=AbstractStrategy(build=builder("tiki_taka", tuple(range(1, N_OUTFIELD + 1)))), + opp_strategy=AbstractStrategy(build=builder("tiki_taka", tuple(range(1, N_OUTFIELD + 1)))), my_team_is_yellow=True, my_team_is_right=True, mode="rsim", diff --git a/utama_core/tests/strategy_runner/test_exp_ball.py b/utama_core/tests/strategy_runner/test_exp_ball.py index 21647dd1..3732fbfb 100644 --- a/utama_core/tests/strategy_runner/test_exp_ball.py +++ b/utama_core/tests/strategy_runner/test_exp_ball.py @@ -15,7 +15,7 @@ from utama_core.entities.game import Game from utama_core.entities.game.field import FieldBounds from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.team_controller.src.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, @@ -32,11 +32,11 @@ def _idle_with_ball_strategy() -> AbstractStrategy: - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(()), exp_ball=True) + return AbstractStrategy(build=builder("default", ()), exp_ball=True) def _idle_no_ball_strategy() -> AbstractStrategy: - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(()), exp_ball=False) + return AbstractStrategy(build=builder("default", ()), exp_ball=False) # --------------------------------------------------------------------------- diff --git a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py index 4a946b76..00e1f8c6 100644 --- a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py +++ b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py @@ -27,14 +27,14 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner -from utama_core.strategy import kernel_strategy +from utama_core.strategy.catalog import builder N_OUTFIELD = 5 OUTFIELD_ROBOT_IDS = tuple(range(1, N_OUTFIELD + 1)) # Same pairing that surfaced the bug live. -_BUILD_A = kernel_strategy.build_counter_flow_kernel_strategy -_BUILD_B = kernel_strategy.build_tiki_taka_kernel_strategy +_NAME_A = "counter_flow" +_NAME_B = "tiki_taka" def test_goalkeeper_converges_on_static_target_without_oscillating(headless): @@ -42,8 +42,8 @@ def test_goalkeeper_converges_on_static_target_without_oscillating(headless): keeper's target is provably fixed) — the keeper must settle to a steady y-position, not oscillate around it. """ - strategy_a = AbstractStrategy(build_kernel_strategy=_BUILD_A(OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build_kernel_strategy=_BUILD_B(OUTFIELD_ROBOT_IDS)) + strategy_a = AbstractStrategy(build=builder(_NAME_A, OUTFIELD_ROBOT_IDS)) + strategy_b = AbstractStrategy(build=builder(_NAME_B, OUTFIELD_ROBOT_IDS)) profile = load_profile("simulation") profile = dataclasses.replace( diff --git a/utama_core/tests/strategy_runner/test_match_state_reset.py b/utama_core/tests/strategy_runner/test_match_state_reset.py index 44540052..b3674c32 100644 --- a/utama_core/tests/strategy_runner/test_match_state_reset.py +++ b/utama_core/tests/strategy_runner/test_match_state_reset.py @@ -5,7 +5,7 @@ from utama_core.run.strategy_runner import StrategyRunner from utama_core.shared import pass_and_score_geometry from utama_core.skills.src import shielding -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.tests.shared.test_pass_and_score_geometry import _visual_game from utama_core.tests.skills.test_shielding import _shielding @@ -15,7 +15,7 @@ def test_a_new_runner_starts_with_no_robot_holding_or_committed(): assert _shielding(shielding.COMMIT_RANGE - 0.005) is False # committed runner = StrategyRunner( - strategy=AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy((1, 2, 3, 4, 5))), + strategy=AbstractStrategy(build=builder("default", (1, 2, 3, 4, 5))), my_team_is_yellow=True, my_team_is_right=True, mode="rsim", diff --git a/utama_core/tests/strategy_runner/test_referee_rsim.py b/utama_core/tests/strategy_runner/test_referee_rsim.py index d08eff75..889e9507 100644 --- a/utama_core/tests/strategy_runner/test_referee_rsim.py +++ b/utama_core/tests/strategy_runner/test_referee_rsim.py @@ -56,7 +56,7 @@ from utama_core.run.strategy_runner import StrategyRunner from utama_core.skills.src.go_to_ball import go_to_ball from utama_core.skills.src.utils.move_utils import empty_command -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.team_controller.src.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, @@ -79,7 +79,7 @@ def _idle_strategy() -> AbstractStrategy: """Kernel strategy with an empty outfield pool — does nothing; the referee override layer (`Strategy.tick()`'s `RefereeOverride`) handles all motion during override commands regardless of the tactic roster.""" - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(()), exp_ball=True) + return AbstractStrategy(build=builder("default", ()), exp_ball=True) @dataclass @@ -126,7 +126,7 @@ def _build(motion_controller: MotionController) -> KernelSchedulerStrategy: ctx=ctx, ) - return AbstractStrategy(build_kernel_strategy=_build) + return AbstractStrategy(build=_build) # --------------------------------------------------------------------------- diff --git a/utama_core/tests/strategy_runner/test_replace_strategy.py b/utama_core/tests/strategy_runner/test_replace_strategy.py index 9e5805fa..37c595b5 100644 --- a/utama_core/tests/strategy_runner/test_replace_strategy.py +++ b/utama_core/tests/strategy_runner/test_replace_strategy.py @@ -28,7 +28,7 @@ def build(motion_controller) -> Strategy: kernel.tick = lambda game: ticks.append(game.referee.referee_command) or tick(game) return kernel - return AbstractStrategy(build_kernel_strategy=build) + return AbstractStrategy(build=build) @pytest.fixture diff --git a/utama_core/tests/strategy_runner/test_rsim_formations.py b/utama_core/tests/strategy_runner/test_rsim_formations.py index d6d23ef5..790ff2d3 100644 --- a/utama_core/tests/strategy_runner/test_rsim_formations.py +++ b/utama_core/tests/strategy_runner/test_rsim_formations.py @@ -8,7 +8,7 @@ from utama_core.entities.game.field import FieldBounds from utama_core.global_utils.mapping_utils import map_left_right_to_colors from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, @@ -21,7 +21,7 @@ def _idle_strategy() -> AbstractStrategy: """Minimal kernel strategy used only to drive runner lifecycle.""" - return AbstractStrategy(build_kernel_strategy=build_default_kernel_strategy(()), exp_ball=True) + return AbstractStrategy(build=builder("default", ()), exp_ball=True) class _CaptureFirstFrameManager(AbstractTestManager): diff --git a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py b/utama_core/tests/strategy_runner/test_strategy_control_scheme.py index 165547a2..9a730947 100644 --- a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py +++ b/utama_core/tests/strategy_runner/test_strategy_control_scheme.py @@ -12,12 +12,12 @@ TrajectorySamplingController, ) from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.kernel_strategy import build_default_kernel_strategy +from utama_core.strategy.catalog import builder from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy def _dummy_factory(motion_controller): - return build_default_kernel_strategy((1, 2))(motion_controller) + return builder("default", (1, 2))(motion_controller) class _CustomSchemeStrategy(AbstractStrategy): @@ -26,27 +26,27 @@ class _CustomSchemeStrategy(AbstractStrategy): def test_abstract_strategy_control_scheme_precedence(): # 1. Default when unset is None - s_default = AbstractStrategy(build_kernel_strategy=_dummy_factory) + s_default = AbstractStrategy(build=_dummy_factory) assert s_default.control_scheme is None # 2. Inherited from factory attribute factory_with_scheme = lambda mc: _dummy_factory(mc) # noqa: E731 factory_with_scheme.control_scheme = "trajsample" - s_factory = AbstractStrategy(build_kernel_strategy=factory_with_scheme) + s_factory = AbstractStrategy(build=factory_with_scheme) assert s_factory.control_scheme == "trajsample" # 3. Inherited from class attribute - s_class = _CustomSchemeStrategy(build_kernel_strategy=_dummy_factory) + s_class = _CustomSchemeStrategy(build=_dummy_factory) assert s_class.control_scheme == "dwa" # 4. Constructor argument overrides class attribute and factory attribute - s_override = _CustomSchemeStrategy(build_kernel_strategy=factory_with_scheme, control_scheme="pid") + s_override = _CustomSchemeStrategy(build=factory_with_scheme, control_scheme="pid") assert s_override.control_scheme == "pid" def test_strategy_runner_resolves_strategy_control_scheme(): # Friendly strategy requests 'trajsample' - strat = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="trajsample") + strat = AbstractStrategy(build=_dummy_factory, control_scheme="trajsample") runner = StrategyRunner( strategy=strat, my_team_is_yellow=True, @@ -77,7 +77,7 @@ def test_strategy_runner_defaults_to_fpp_when_unspecified(): def test_strategy_runner_explicit_override_takes_precedence(): # Strategy declares 'trajsample', but runner explicitly passes 'dwa' - strat = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="trajsample") + strat = AbstractStrategy(build=_dummy_factory, control_scheme="trajsample") runner = StrategyRunner( strategy=strat, my_team_is_yellow=True, @@ -94,8 +94,8 @@ def test_strategy_runner_explicit_override_takes_precedence(): def test_strategy_runner_asymmetric_pvp_control_schemes(): # Friendly uses 'trajsample', opponent uses 'dwa' - strat_a = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="trajsample") - strat_b = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="dwa") + strat_a = AbstractStrategy(build=_dummy_factory, control_scheme="trajsample") + strat_b = AbstractStrategy(build=_dummy_factory, control_scheme="dwa") runner = StrategyRunner( strategy=strat_a, @@ -114,8 +114,8 @@ def test_strategy_runner_asymmetric_pvp_control_schemes(): def test_strategy_runner_opp_explicit_override(): # Friendly uses 'trajsample', opponent strategy declares 'dwa', but opp_control_scheme overrides to 'pid' - strat_a = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="trajsample") - strat_b = AbstractStrategy(build_kernel_strategy=_dummy_factory, control_scheme="dwa") + strat_a = AbstractStrategy(build=_dummy_factory, control_scheme="trajsample") + strat_b = AbstractStrategy(build=_dummy_factory, control_scheme="dwa") runner = StrategyRunner( strategy=strat_a, From 119e1fdce066dfe088583c862daa119a7e9d25ff Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:55 +0000 Subject: [PATCH 06/59] evaluation: .strategy files, a frozen baseline and one fingerprint for both A .strategy file is one strategy with the whole utama_core package at one commit, playing in its own process. evaluate.py --frozen REF plays the champion and opponents from such files, so a shared-code change moves only the candidate. An identity match, one side bundled, was byte-for-byte equal to the normal match. A player's fingerprint is now the closure of its code plus compiled files, with no name in it, computed the same way for a file and for code, and the ledger is keyed by it. Code behind the process boundary leaves the environment, so a skills edit replays no match between two files. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- AGENTS.md | 10 + docs/STRATEGY_DEVELOPMENT.md | 7 + docs/tools.md | 5 +- tools/build_strategy.py | 31 ++ tools/evaluation/evaluate.py | 47 ++- tools/evaluation/match.py | 10 +- tools/evaluation/round_robin.py | 19 +- utama_core/bundle/__init__.py | 1 + utama_core/bundle/archive.py | 34 +++ utama_core/bundle/host.py | 190 ++++++++++++ utama_core/bundle/strategy_file.py | 246 ++++++++++++++++ utama_core/bundle/wire.py | 101 +++++++ utama_core/replay/eval_ledger.py | 23 +- utama_core/replay/fingerprint.py | 148 +++++----- utama_core/tests/bundle/__init__.py | 0 utama_core/tests/bundle/test_strategy_file.py | 276 ++++++++++++++++++ utama_core/tests/engine/test_evaluate.py | 65 ++++- utama_core/tests/replay/test_fingerprint.py | 254 ++++++++-------- 18 files changed, 1203 insertions(+), 264 deletions(-) create mode 100644 tools/build_strategy.py create mode 100644 utama_core/bundle/__init__.py create mode 100644 utama_core/bundle/archive.py create mode 100644 utama_core/bundle/host.py create mode 100644 utama_core/bundle/strategy_file.py create mode 100644 utama_core/bundle/wire.py create mode 100644 utama_core/tests/bundle/__init__.py create mode 100644 utama_core/tests/bundle/test_strategy_file.py diff --git a/AGENTS.md b/AGENTS.md index 7f01cf5b..30d3ff3b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -61,6 +61,16 @@ One term per thing; reuse these instead of coining new ones. `analysis/ratings.py`) over every match in the ledger (`replays/eval/ledger.jsonl`). Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. +- **Strategy file / frozen baseline** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a + zip of one strategy and the whole `utama_core` package at one commit; it plays in its own process, game frames in and + robot commands out, simulation only. `evaluate.py CANDIDATE --frozen REF` plays the champion and the opponents from + such files of commit REF (the frozen baseline, kept in `replays/eval/frozen/`), so a change to shared code moves only + the candidate. The referee and the simulator stay today's for both sides. A file is a player like any strategy name wherever one is named (`evaluate.py`, `round_robin.py`, `opponents.json`), with the same replays, stats and logs. Its fingerprint is computed like the code's, so a file and the code it was built from are one player in the ledger. +- **World / robot capability** — simulator settings fall into two kinds: the world (ball + friction, vision noise and dropouts, latency) comes from measurements; robot capability (kick, + dribbler, motors) is assumed good at league level, and real robots' shortfalls are compensated + in the control layer. The test: would better robots change it? `tools/evaluation/reference/ + world.json`, `robots.json`; field sessions in `tools/field_sessions.json`. - **Situation / goal ledger** — a situation starts when a restart goes live or a side wins the ball in open play; the goal ledger (`utama_core/analysis/goal_ledger.py`) gives each goal to the latest situation less than 10 s before it, so goals per match = Σ situations per match × diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 1115efdf..5b82221c 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -322,6 +322,13 @@ flowchart TD be clearly worse against opponents never used for selection. Then edit the champion in `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse against the rest is a matchup, not a better strategy. +- **A change to shared code** (skills, tactics, motion, engine) moves every strategy, so a normal run compares + worse with worse as easily as better with better. `evaluate.py --frozen v2.5.0` plays the champion and + the opponents from `.strategy` files of that commit (`replays/eval/frozen/`, built once) and the candidate from + the working tree. A bundled match equals the same match run normally, frame for frame. The referee and the + simulator are today's for both sides, so a frozen side meets rule changes it was not written for. A file and + the same code are one player in the ledger, and matches between two files are replayed only when the referee, + the simulator or the match runner change: a skills or tactics edit reruns only the candidate's matches. - **Pictures** (`evaluate.py --explain`, `tools/evaluation/explain.py`): for each candidate, where both strategies' robots stand with and without the ball, their shots for and against, their fouls by rule, and a `summary.json` of the numbers behind them, written to diff --git a/docs/tools.md b/docs/tools.md index 8e5096f0..5f5fc270 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -32,8 +32,9 @@ Every script in the repository, by what it is for. Run them from the repository | Script | Purpose | |---|---| -| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every strategy config against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the evaluation ledger. `--pair A B` plays one match; `--reuse` replays only matches whose code changed, plus a 5% spot-check of reused ones; `summary.json`'s `reuse.mismatches` lists any that came out different, which means a match no longer replays exactly. `--sim-noise JSON` (inline or a file) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | -| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed reference pool (`tools/evaluation/pools/pool_v1.json`), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the pool's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every strategy config against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the evaluation ledger. `--pair A B` plays one match; `--reuse` replays only matches whose code changed, plus a 5% spot-check of reused ones; `summary.json`'s `reuse.mismatches` lists any that came out different, which means a match no longer replays exactly. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | +| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | | `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | diff --git a/tools/build_strategy.py b/tools/build_strategy.py new file mode 100644 index 00000000..aaec9bf6 --- /dev/null +++ b/tools/build_strategy.py @@ -0,0 +1,31 @@ +"""Pack one strategy and the code it runs on into a `.strategy` file. + + pixi run python tools/build_strategy.py split_shape split_shape.strategy + pixi run python tools/build_strategy.py split_shape frozen.strategy --ref v2.5.0 + +Without `--ref` it takes the working tree as it stands, uncommitted changes included. +""" + +import argparse +import sys +from pathlib import Path + +REPO_ROOT = Path(__file__).resolve().parents[1] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from utama_core.bundle.strategy_file import build # noqa: E402 + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("strategy", help="strategy name, e.g. split_shape") + parser.add_argument("output", type=Path) + parser.add_argument("--ref", help="git commit to pack (default: the working tree)") + args = parser.parse_args() + path = build(args.strategy, args.output, args.ref) + print(f"{path}: {path.stat().st_size / 1e6:.2f} MB") + + +if __name__ == "__main__": + main() diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index aeec5213..f53d25fc 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -9,7 +9,11 @@ --held-out play the held-out opponents instead (the check before promoting) --baseline NAME compare against this strategy instead of the champion: a new version against the one it changes. The baseline takes the champion's role, the - champion joins the opponents, and a baseline from the pool leaves them + champion joins the opponents, and a baseline among the opponents leaves them + --frozen REF judge today's code against the past: the champion and every opponent are + played from `.strategy` files of git commit REF (built once, kept in + replays/eval/frozen/), the candidates from the working tree. The check for a + change to shared code, which otherwise moves both sides of every match --max-rounds N rounds before a candidate is called undecided (default 6) --max-workers N matches at once (default 8) --explain also write on-pitch pictures of each candidate against the champion to @@ -79,6 +83,7 @@ reference_noise, ) from utama_core.analysis import ratings # noqa: E402 +from utama_core.bundle.strategy_file import frozen # noqa: E402 from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 from utama_core.replay import eval_ledger # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 @@ -87,6 +92,7 @@ PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 +FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the ledger def round_fixtures(candidates: list[str], champion: str, opponents: list[str], k: int) -> list[tuple[str, str, int]]: @@ -140,6 +146,7 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("--opponents", type=Path, default=DEFAULT_OPPONENTS) parser.add_argument("--held-out", action="store_true") parser.add_argument("--baseline") + parser.add_argument("--frozen", metavar="REF", help="champion and opponents from this git commit (see above)") parser.add_argument("--max-rounds", type=int, default=MAX_ROUNDS) parser.add_argument("--max-workers", type=int, default=min(8, max(1, (os.cpu_count() or 1) - 1))) parser.add_argument("--explain", action="store_true", help="also write on-pitch pictures per candidate (see above)") @@ -149,13 +156,15 @@ def build_parser() -> argparse.ArgumentParser: def main() -> None: args = build_parser().parse_args() - pool = json.loads(args.pool.read_text()) - champion = _resolve_config_names([args.baseline or pool["champion"]])[0] - opponents = _resolve_config_names(pool["held_out"] if args.held_out else pool["opponents"]) - pool_champion = _resolve_config_names([pool["champion"]])[0] - if champion != pool_champion: - opponents.append(pool_champion) # against a baseline, the champion is one more opponent - opponents = [o for o in opponents if o != champion] # a baseline from the pool leaves its seat + reference = load_opponents(args.opponents) + champion = _resolve_config_names([args.baseline or reference["champion"]])[0] + opponents = _resolve_config_names(reference["held_out"] if args.held_out else reference["opponents"]) + reference_champion = _resolve_config_names([reference["champion"]])[0] + if champion != reference_champion: + opponents.append(reference_champion) # against a baseline, the champion is one more opponent + opponents = [o for o in opponents if o != champion] # a baseline among the opponents leaves its seat + if args.frozen: + champion, *opponents = [frozen(n, args.frozen, FROZEN_DIR).as_posix() for n in [champion, *opponents]] candidates = [c for c in _resolve_config_names(args.candidates) if c != champion] noise = SimNoise.from_dict(reference_noise()).to_dict() noise.pop("seed", None) @@ -163,10 +172,15 @@ def main() -> None: graph = CodeGraph() env = eval_ledger.environment(graph, duration_seconds=MAX_MATCH_SECONDS, sim_noise=noise) fps = {n: graph.strategy_fingerprint(n)[:16] for n in {*candidates, champion, *opponents}} + for c in list(candidates): + twin = next((r for r in [champion, *opponents] if fps[r] == fps[c]), None) + if twin is not None: + print(f"{_short_name(c)} is skipped: it is the same code as {_short_name(twin)}") + candidates.remove(c) def fixture_id(f: tuple[str, str, int]) -> str: a, b, seed = f - return eval_ledger.fixture_id(env, a, fps[a], b, fps[b], seed) + return eval_ledger.fixture_id(env, fps[a], fps[b], seed) run_id = datetime.now(timezone.utc).strftime("eval_%Y%m%d_%H%M%S") run_dir = Path(REPLAY_BASE_PATH) / run_id # replay files must sit directly under replays/ @@ -184,7 +198,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: for k in range(1, args.max_rounds + 1): if not open_: break - ledger = eval_ledger.load(env) + ledger = eval_ledger.load(env, fps=fps) todo = [f for f in round_fixtures(open_, champion, opponents, k) if fixture_id(f) not in ledger] reused += len(round_fixtures(open_, champion, opponents, k)) - len(todo) futures = {executor.submit(play, *f, noise, run_dir, args.explain): f for f in todo} @@ -201,7 +215,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: ) fit = _fit(env, fps, {*open_, champion, *opponents}) - ledger = _up_to_round(eval_ledger.load(env), k) + ledger = _up_to_round(eval_ledger.load(env, fps=fps), k) for c in list(open_): margin, sd = ratings.paired_difference(*paired(ledger, fps, c, champion, opponents), fit.noise_sd) p = ratings.p_positive(margin, sd) @@ -217,7 +231,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: shutil.rmtree(run_dir, ignore_errors=True) # this run's own scratch dir; results are in the ledger final = _fit(env, fps, {*candidates, champion, *opponents}) - ledger = eval_ledger.load(env) + ledger = eval_ledger.load(env, fps=fps) print(f"Verdicts ({played} matches played, {reused} reused from the ledger):") for c in candidates: r = report[c] @@ -230,8 +244,10 @@ def fixture_id(f: tuple[str, str, int]) -> str: for o, row in r["per_opponent"].items(): name = o if o == "head-to-head" else _short_name(o) print(f" {name:<26} {row['candidate']:>+12} {row['champion']:>+12} {row['matches']:>8}") - if r["verdict"] == "better" and not args.held_out: - print(f" -> next: evaluate.py {_short_name(c)} --held-out, then set it as the pool's champion") + if r["verdict"] == "better" and not args.held_out and not args.frozen: + print( + f" -> next: evaluate.py {_short_name(c)} --held-out, then set it as champion in reference/opponents.json" + ) print("\nStrengths (goals per match, ± SD):") for n in sorted(final.names, key=lambda n: -final.strength(n)[0]): m, sd = final.strength(n) @@ -246,6 +262,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: "run": _run_metadata(), "opponents": str(args.opponents), "held_out": args.held_out, + "frozen": args.frozen, "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": args.max_rounds}, "candidates": report, @@ -276,7 +293,7 @@ def _fit(env: str, fps: dict[str, str], players: set[str]) -> ratings.Ratings: """Ratings over every ledger match in `env` between `players` at their current code.""" matches = [ (e["a"], e["b"], e["score_a"] - e["score_b"]) - for e in eval_ledger.load(env).values() + for e in eval_ledger.load(env, fps=fps).values() if e["a"] in players and e["b"] in players and fps.get(e["a"]) == e["a_fp"] and fps.get(e["b"]) == e["b_fp"] ] return ratings.fit(matches, names=sorted(players)) diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index 73ae2bb8..dd5c5969 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -24,6 +24,7 @@ from pathlib import Path from typing import Optional +from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy from utama_core.custom_referee import CustomReferee from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee @@ -53,11 +54,15 @@ def _short_name(config_name: str) -> str: + if config_name.endswith(SUFFIX): + return Path(config_name).stem return plain_name(config_name) def _load_strategy(config_name: str) -> AbstractStrategy: - """A strategy by name.""" + """A strategy by name, or a `.strategy` file by path.""" + if config_name.endswith(SUFFIX): + return BundledStrategy(config_name) return AbstractStrategy(build=catalog.builder(config_name, OUTFIELD_ROBOT_IDS)) @@ -252,6 +257,9 @@ def run_match( stats = runner.match_stats.finalize() if runner.match_stats is not None else None finally: runner.close() + for strategy in (strategy_a, strategy_b): + if isinstance(strategy, BundledStrategy): + strategy.close() return MatchResult( config_a=config_a_name, diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index 9588d0de..5cd98d0a 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -111,6 +111,7 @@ from tools.evaluation.sim_settings import sim_noise_from_spec from utama_core.analysis import ratings, restart_outcomes, turnover_breakdown from utama_core.analysis.strategy_table import strategy_table +from utama_core.bundle.strategy_file import SUFFIX from utama_core.config.settings import REPLAY_BASE_PATH from utama_core.replay import eval_ledger, match_cache from utama_core.replay.fingerprint import CodeGraph, match_key @@ -762,20 +763,14 @@ def _store_played( def _resolve_config_names(requested_names: list[str]) -> list[str]: - """Factory names for `requested_names`, each given with or without the - `build_`/`_kernel_strategy` wrapping, in catalog order.""" - requested = set(requested_names) - config_names = [ - name - for name in _CONFIG_NAMES - if name in requested or name.removeprefix("build_").removesuffix("_kernel_strategy") in requested - ] - unmatched = requested - { - n for name in config_names for n in (name, name.removeprefix("build_").removesuffix("_kernel_strategy")) - } + """The strategies named, in catalog order, then any `.strategy` files as given.""" + files = [name for name in requested_names if name.endswith(SUFFIX)] + requested = {plain_name(name) for name in requested_names if name not in files} + config_names = [name for name in _CONFIG_NAMES if name in requested] + unmatched = requested - set(config_names) if unmatched: raise SystemExit(f"Unknown config name(s): {sorted(unmatched)}. Available: {sorted(_CONFIG_NAMES)}") - return config_names + return config_names + files def _run_metadata() -> dict: diff --git a/utama_core/bundle/__init__.py b/utama_core/bundle/__init__.py new file mode 100644 index 00000000..3dd1b18b --- /dev/null +++ b/utama_core/bundle/__init__.py @@ -0,0 +1 @@ +"""`.strategy` files: one strategy and the exact code it runs on, played in its own process.""" diff --git a/utama_core/bundle/archive.py b/utama_core/bundle/archive.py new file mode 100644 index 00000000..f889cad3 --- /dev/null +++ b/utama_core/bundle/archive.py @@ -0,0 +1,34 @@ +"""A `.strategy` file on disk: standard library only, so fingerprinting doesn't import a strategy.""" + +from __future__ import annotations + +import hashlib +import json +import os +import shutil +import tempfile +import zipfile +from pathlib import Path + +SUFFIX = ".strategy" +_CACHE = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "utama" / "strategies" + + +def unpack(path: Path) -> Path: + """The file's unpacked directory, shared by every process that plays the same bytes.""" + root = _CACHE / hashlib.sha256(path.read_bytes()).hexdigest()[:16] + if root.exists(): + return root + _CACHE.mkdir(parents=True, exist_ok=True) + partial = Path(tempfile.mkdtemp(dir=_CACHE)) + with zipfile.ZipFile(path) as archive: + archive.extractall(partial) + try: + partial.rename(root) + except OSError: # another match unpacked it first + shutil.rmtree(partial) + return root + + +def read_manifest(root: Path) -> dict: + return json.loads((root / "manifest.json").read_text()) diff --git a/utama_core/bundle/host.py b/utama_core/bundle/host.py new file mode 100644 index 00000000..4524ab0d --- /dev/null +++ b/utama_core/bundle/host.py @@ -0,0 +1,190 @@ +"""The process a `.strategy` file runs in: game frames in on stdin, robot commands out on stdout. + +Run as `python -m utama_core.bundle.host` from an unpacked bundle, so `utama_core` is the bundle's own +copy. This file and `wire.py` are the current ones even in a bundle of an older commit; the rest is +that commit's code. +""" + +from __future__ import annotations + +import dataclasses +import json +import os +import sys + +from utama_core.bundle import wire +from utama_core.config.enums import Mode +from utama_core.config.field_params import FieldBounds, FieldDimensions +from utama_core.config.settings import MAX_GAME_HISTORY +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.engine.match_log import MatchLog +from utama_core.entities.data.referee import RefereeData +from utama_core.entities.data.vector import Vector2D, Vector3D +from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot +from utama_core.entities.game.team_info import TeamInfo +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.entities.referee.stage import Stage +from utama_core.motion_planning.src.common.control_schemes import CONTROL_SCHEME_MAP + + +class _CommandRecorder: + """Stands in for the robot controller: `AbstractStrategy.step` fills it, the host sends it.""" + + keeps_kickers_charged = False + + def __init__(self) -> None: + self.commands: dict[str, list] = {} + + def add_robot_commands(self, command, robot_id: int) -> None: + self.commands[str(robot_id)] = [ + float(command.local_forward_vel), + float(command.local_left_vel), + float(command.angular_vel), + bool(command.kick), + bool(command.chip), + bool(command.dribble), + ] + + def send_robot_commands(self) -> None: + pass + + +def _robot(values: list) -> Robot: + rid, is_friendly, has_ball, p, v, a, orientation = values + return Robot(rid, is_friendly, has_ball, Vector2D(*p), Vector2D(*v), Vector2D(*a), orientation) + + +def _referee(data: dict | None) -> RefereeData | None: + if data is None: + return None + next_command = data.pop("next_command") + return RefereeData( + **{ + **data, + "referee_command": RefereeCommand[data["referee_command"]], + "stage": Stage[data["stage"]], + "blue_team": TeamInfo(**data["blue_team"]), + "yellow_team": TeamInfo(**data["yellow_team"]), + "designated_position": None if data["designated_position"] is None else tuple(data["designated_position"]), + "next_command": None if next_command is None else RefereeCommand[next_command], + } + ) + + +def decode_frame(data: dict) -> GameFrame: + ball = data["ball"] + return GameFrame( + ts=data["ts"], + my_team_is_yellow=data["my_team_is_yellow"], + my_team_is_right=data["my_team_is_right"], + friendly_robots={values[0]: _robot(values) for values in data["friendly_robots"]}, + enemy_robots={values[0]: _robot(values) for values in data["enemy_robots"]}, + ball=None if ball is None else Ball(Vector3D(*ball[0]), Vector3D(*ball[1]), Vector3D(*ball[2])), + referee=_referee(data["referee"]), + ) + + +def decode_field(data: dict) -> Field: + return Field( + data["my_team_is_right"], + FieldDimensions(**data["dims"]), + FieldBounds(tuple(data["top_left"]), tuple(data["bottom_right"])), + data["defense_area_rules"], + ) + + +def _drain(log) -> list: + """What the strategy logged since the last call, as `[event class name, fields]`.""" + if log is None: + return [] + out = [] + for event in log._events: + fields = dataclasses.asdict(event) + if "tag" in fields: + fields["tag"] = fields["tag"].value + out.append([type(event).__name__, fields]) + log._events.clear() + return out + + +def _slot_status(strategy) -> dict: + return { + tactic_id: {"robots": list(info["robots"]), "committed": bool(info["committed"]), "tag": info["tag"].value} + for tactic_id, info in strategy._kernel_strategy.slot_status(strategy.game).items() + } + + +def _partition(strategy) -> dict: + kernel = strategy._kernel_strategy + return { + "partition": {tactic_id: list(robots) for tactic_id, robots in kernel.active_partition.items()}, + "names": {tactic_id: type(kernel._tactics[tactic_id]).__name__ for tactic_id in kernel.active_partition}, + } + + +_QUERIES = { + "slot_status": _slot_status, + "partition": _partition, + "debug_status": lambda strategy: {str(rid): row for rid, row in strategy.debug_status().items()}, +} + + +def _controller(setup: dict): + """The motion controller as the runner configured its own.""" + scheme = next(c for c in CONTROL_SCHEME_MAP.values() if c.__name__ == setup["controller"]) + controller = scheme(Mode(setup["mode"]), None) + controller.pose_ahead.latency_s = setup["latency_s"] + controller.robot_carry = {int(rid): tuple(carry) for rid, carry in setup["robot_carry"].items()} + return controller + + +def _builder(manifest: dict): + """`AbstractStrategy`'s first argument. The file's own code decides how: files of commits from + before `strategy/catalog.py` have `kernel_strategy.build__kernel_strategy` instead.""" + ids = tuple(manifest["outfield_ids"]) + name = manifest["strategy"] + try: + from utama_core.strategy.catalog import builder + except ModuleNotFoundError: + from utama_core.strategy import kernel_strategy + + return getattr(kernel_strategy, f"build_{name}_kernel_strategy")(ids) + return builder(name, ids) + + +def main() -> None: + # Strategy code that prints must not corrupt the channel. + replies = os.fdopen(os.dup(1), "wb") + os.dup2(2, 1) + requests = sys.stdin.buffer + + with open("manifest.json") as f: + manifest = json.load(f) + strategy = AbstractStrategy(_builder(manifest)) + recorder = _CommandRecorder() + strategy.load_robot_controller(recorder) + wire.send(replies, {"control_scheme": strategy.control_scheme}) + + log = None + while (message := wire.receive(requests)) is not None: + kind = message["type"] + if kind == "setup": + strategy.load_motion_controller(_controller(message)) + elif kind == "game": + history = GameHistory(MAX_GAME_HISTORY) + strategy.load_game(Game(history, decode_frame(message["frame"]), field=decode_field(message["field"]))) + elif kind == "match_log": + log = MatchLog() + strategy._kernel_strategy.match_log = log + elif kind == "frame": + strategy.game.add_game_frame(decode_frame(message["frame"])) + elif kind == "tick": + recorder.commands = {} + strategy.step() + wire.send(replies, {"commands": recorder.commands, "events": _drain(log)}) + elif kind == "query": + wire.send(replies, _QUERIES[message["name"]](strategy)) + + +if __name__ == "__main__": + main() diff --git a/utama_core/bundle/strategy_file.py b/utama_core/bundle/strategy_file.py new file mode 100644 index 00000000..18222198 --- /dev/null +++ b/utama_core/bundle/strategy_file.py @@ -0,0 +1,246 @@ +"""Building, unpacking and playing `.strategy` files. + +A `.strategy` file is a zip of the `utama_core` package at one commit plus a manifest naming the +strategy. It plays in its own process (`host.py`), so it keeps its own skills, tactics and motion code +while the runner around it changes: a frozen opponent, or one somebody else wrote. + +It is plain Python and runs with this machine's rights. Isolate a file you did not build before +playing it. +""" + +from __future__ import annotations + +import json +import os +import platform +import subprocess +import sys +import tarfile +import weakref +import zipfile +from io import BytesIO +from pathlib import Path +from typing import Optional + +from utama_core.bundle import wire +from utama_core.bundle.archive import SUFFIX, read_manifest, unpack +from utama_core.config.enums import Mode +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.engine.match_log import IntentionEvent, TraceEvent +from utama_core.engine.tactic import TacticTag +from utama_core.entities.data.command import RobotCommand + +FORMAT_VERSION = 1 +_REPO = Path(__file__).resolve().parents[2] +_OWN_CODE = Path(__file__).resolve().parent + + +def _wanted(path: str) -> bool: + return path.startswith("utama_core/") and not path.startswith("utama_core/tests/") and "__pycache__" not in path + + +def _worktree_files() -> dict[str, bytes]: + listed = subprocess.run( + ["git", "ls-files", "-co", "--exclude-standard", "utama_core"], + cwd=_REPO, + capture_output=True, + text=True, + check=True, + ).stdout.splitlines() + return {p: (_REPO / p).read_bytes() for p in listed if _wanted(p) and (_REPO / p).is_file()} + + +def _commit_files(ref: str) -> dict[str, bytes]: + archive = subprocess.run(["git", "archive", ref, "utama_core"], cwd=_REPO, capture_output=True, check=True).stdout + with tarfile.open(fileobj=BytesIO(archive)) as tar: + return {m.name: tar.extractfile(m).read() for m in tar if m.isfile() and _wanted(m.name)} + + +def _commit_of(ref: str) -> str: + # `^{commit}`: on its own an annotated tag resolves to the tag object, which is no commit. + return subprocess.run( + ["git", "rev-parse", f"{ref}^{{commit}}"], cwd=_REPO, capture_output=True, text=True, check=True + ).stdout.strip() + + +def build(strategy: str, output: Path, ref: Optional[str] = None, outfield_ids: tuple = (1, 2, 3, 4, 5)) -> Path: + """Write `output`. `ref` is a git commit; None takes the working tree as it stands. + + Same inputs, same bytes, so a file's hash identifies what it plays.""" + files = _commit_files(ref) if ref else _worktree_files() + if f"utama_core/strategy/{strategy}.py" not in files: + raise ValueError(f"no strategy {strategy} in utama_core/strategy/ at {ref or 'the working tree'}") + + # Git has no compiled planner or simulator, at any commit: take this machine's. + for path in sorted((_REPO / "utama_core").rglob("*.so")): + relative = path.relative_to(_REPO).as_posix() + if _wanted(relative): + files[relative] = path.read_bytes() + # Always this version: an older commit has none. + for path in sorted(_OWN_CODE.glob("*.py")): + files[path.relative_to(_REPO).as_posix()] = path.read_bytes() + + manifest = { + "format": FORMAT_VERSION, + "strategy": strategy, + "outfield_ids": list(outfield_ids), + "commit": _commit_of(ref or "HEAD"), + "working_tree": ref is None, + "python": f"{sys.version_info.major}.{sys.version_info.minor}", + "platform": f"{sys.platform}-{platform.machine()}", + } + files["manifest.json"] = json.dumps(manifest, indent=2, sort_keys=True).encode() + + output.parent.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED, compresslevel=9) as archive: + for name in sorted(files): + info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0)) + info.compress_type = zipfile.ZIP_DEFLATED + info.external_attr = 0o644 << 16 + archive.writestr(info, files[name]) + return output + + +def frozen(strategy: str, ref: str, directory: Path) -> Path: + """`strategy` as it was at `ref`, built the first time and kept: a file that is never rebuilt is + a fixed baseline, whatever happens to the planner binary or this package later.""" + path = directory / f"{strategy}@{_commit_of(ref)[:8]}{SUFFIX}" + if not path.exists(): + partial = build(strategy, path.with_suffix(".partial"), ref) + partial.rename(path) + return path + + +def _stop(process: subprocess.Popen) -> None: + try: + process.stdin.close() + except BrokenPipeError: # it has already gone + pass + try: + process.wait(timeout=10) + except subprocess.TimeoutExpired: + process.kill() + process.wait() + process.stdout.close() + + +class _RemoteKernel: + """What `StrategyRunner` reads off a kernel `Strategy` (match log, slots, partition, keeper), answered + by the file's process, so stats, fouls, intentions and the dashboard work as for any strategy.""" + + def __init__(self, owner: "BundledStrategy"): + self._owner = owner + self._match_log = None + self._tactics: dict = {} + + @property + def match_log(self): + return self._match_log + + @match_log.setter + def match_log(self, log) -> None: + self._match_log = log + if log is not None: + self._owner._send({"type": "match_log"}) + + def record(self, events: list) -> None: + for name, fields in events: + if name == "IntentionEvent": + fields = {**fields, "tag": TacticTag(fields["tag"]), "robot_ids": tuple(fields["robot_ids"])} + self._match_log._events.append(IntentionEvent(**fields)) + else: + self._match_log._events.append(TraceEvent(**fields)) + + def slot_status(self, game) -> dict: + return self._owner._query("slot_status") + + @property + def active_partition(self) -> dict: + reply = self._owner._query("partition") + # The runner names a tactic by `type(kernel._tactics[id]).__name__`. + self._tactics = {tactic_id: type(name, (), {})() for tactic_id, name in reply["names"].items()} + return reply["partition"] + + @property + def _pinned_robot_id(self) -> int: + return self._owner._goalkeeper_id + + +class BundledStrategy(AbstractStrategy): + """A `.strategy` file, as `StrategyRunner` drives any strategy.""" + + def __init__(self, path: str | Path): + super().__init__(build=None) + self.path = Path(path) + root = unpack(self.path) + self.manifest = read_manifest(root) + if self.manifest["format"] != FORMAT_VERSION: + raise ValueError(f"{path}: format {self.manifest['format']}, this code reads {FORMAT_VERSION}") + self._process = subprocess.Popen( + [sys.executable, "-m", "utama_core.bundle.host"], + cwd=root, + env={**os.environ, "PYTHONPATH": str(root)}, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + ) + self.close = weakref.finalize(self, _stop, self._process) + self.control_scheme = self._reply()["control_scheme"] + self._kernel_strategy = _RemoteKernel(self) + self._sent_frame = None + + def _send(self, message: dict) -> None: + wire.send(self._process.stdin, message) + + def _reply(self): + reply = wire.receive(self._process.stdout) + if reply is None: + raise RuntimeError(f"{self.path}: its process stopped (exit code {self._process.wait()})") + return reply + + def load_motion_controller(self, motion_controller) -> None: + if motion_controller.mode == Mode.REAL: + raise ValueError("A .strategy file plays in simulation only for now") + self.motion_controller = motion_controller + self._send( + { + "type": "setup", + "controller": type(motion_controller).__name__, + "mode": motion_controller.mode.value, + "latency_s": motion_controller.pose_ahead.latency_s, + "robot_carry": {str(rid): list(carry) for rid, carry in motion_controller.robot_carry.items()}, + } + ) + + def load_game(self, game) -> None: + super().load_game(game) + self._sent_frame = game._current_game_standard_frame + self._send( + {"type": "game", "frame": wire.encode_frame(self._sent_frame), "field": wire.encode_field(game.field)} + ) + + def _sync(self) -> None: + """The file's process sees the frame this side sees now, before it is asked anything: the + runner reads which tactics are committed after a new frame and before stepping.""" + frame = self.game._current_game_standard_frame + if frame is not self._sent_frame: + self._send({"type": "frame", "frame": wire.encode_frame(frame)}) + self._sent_frame = frame + + def _query(self, name: str): + self._sync() + self._send({"type": "query", "name": name}) + return self._reply() + + def step(self) -> None: + self._sync() + self._send({"type": "tick"}) + reply = self._reply() + self._kernel_strategy.record(reply["events"]) + for robot_id in self.game.friendly_robots: + values = reply["commands"].get(str(robot_id)) + if values is not None: + self.robot_controller.add_robot_commands(RobotCommand(*values), robot_id) + self.robot_controller.send_robot_commands() + + def debug_status(self) -> dict[int, list[str]]: + return {int(robot_id): row for robot_id, row in self._query("debug_status").items()} diff --git a/utama_core/bundle/wire.py b/utama_core/bundle/wire.py new file mode 100644 index 00000000..2f3fe292 --- /dev/null +++ b/utama_core/bundle/wire.py @@ -0,0 +1,101 @@ +"""What crosses the process boundary of a `.strategy` file: length-prefixed JSON. + +Standard library only, and it reads frames by attribute: this file ships inside every bundle and +must work with the entity classes of whichever commit the bundle holds. JSON and not pickle because +the runner must be able to read what a bundle sends without running anything it says. A Python float +survives JSON exactly, so a bundled match can equal the same match run in one process. +""" + +from __future__ import annotations + +import json +import struct +from typing import Any, BinaryIO, Optional + +_HEADER = struct.Struct(" None: + data = json.dumps(message, separators=(",", ":")).encode() + stream.write(_HEADER.pack(len(data)) + data) + stream.flush() + + +def receive(stream: BinaryIO) -> Optional[Any]: + """The next message, or None when the other side has gone.""" + header = stream.read(_HEADER.size) + if len(header) < _HEADER.size: + return None + (length,) = _HEADER.unpack(header) + data = stream.read(length) + if len(data) < length: + return None + return json.loads(data) + + +def _vector(vector) -> list[float]: + return [float(vector.x), float(vector.y)] + ([float(vector.z)] if hasattr(vector, "z") else []) + + +def _robot(robot) -> list: + return [ + int(robot.id), + bool(robot.is_friendly), + bool(robot.has_ball), + _vector(robot.p), + _vector(robot.v), + _vector(robot.a), + float(robot.orientation), + ] + + +def _team(team) -> dict: + return dict(vars(team)) + + +def _referee(referee) -> Optional[dict]: + if referee is None: + return None + return { + "source_identifier": referee.source_identifier, + "time_sent": referee.time_sent, + "time_received": referee.time_received, + "referee_command": referee.referee_command.name, + "referee_command_timestamp": referee.referee_command_timestamp, + "stage": referee.stage.name, + "stage_time_left": referee.stage_time_left, + "blue_team": _team(referee.blue_team), + "yellow_team": _team(referee.yellow_team), + "designated_position": referee.designated_position, + "blue_team_on_positive_half": referee.blue_team_on_positive_half, + "next_command": None if referee.next_command is None else referee.next_command.name, + "current_action_time_remaining": referee.current_action_time_remaining, + "match_type": referee.match_type, + "status_message": referee.status_message, + } + + +def encode_frame(frame) -> dict: + """A `GameFrame`, without the referee's raw `game_events`: no strategy reads them.""" + ball = frame.ball + return { + "ts": float(frame.ts), + "my_team_is_yellow": bool(frame.my_team_is_yellow), + "my_team_is_right": bool(frame.my_team_is_right), + "friendly_robots": [_robot(robot) for robot in frame.friendly_robots.values()], + "enemy_robots": [_robot(robot) for robot in frame.enemy_robots.values()], + "ball": None if ball is None else [_vector(ball.p), _vector(ball.v), _vector(ball.a)], + "referee": _referee(frame.referee), + } + + +def encode_field(field) -> dict: + dims = field._field_dims + bounds = field._field_bounds + return { + "my_team_is_right": field.my_team_is_right, + "dims": {name: getattr(dims, name) for name in dims.__dataclass_fields__}, + "top_left": list(bounds.top_left), + "bottom_right": list(bounds.bottom_right), + "defense_area_rules": field._defense_area_rules, + } diff --git a/utama_core/replay/eval_ledger.py b/utama_core/replay/eval_ledger.py index 96cc5627..b27a1207 100644 --- a/utama_core/replay/eval_ledger.py +++ b/utama_core/replay/eval_ledger.py @@ -8,9 +8,10 @@ - **Environment** (`environment`): the shared code and machine (`fingerprint.base_fingerprint` of the match runner), the match length, the planner and the sim noise without its seed. Matches from different environments are never mixed: a planner or sim change replays all. -- **Player**: a strategy name and its `fingerprint.strategy_fingerprint`. Editing a strategy - makes it a new player; its old matches stay in the file but no longer count. -- **Fixture** (`fixture_id`): environment, both players, sides and seed. An rsim match is a +- **Player**: the `fingerprint.strategy_fingerprint` of its code, with the name it had when it + played as a label. Editing a strategy makes it a new player; its old matches stay in the file + but no longer count. +- **Fixture** (`fixture_id`): environment, both fingerprints, sides and seed. An rsim match is a pure function of it, so a fixture already in the ledger is never played again. """ @@ -48,9 +49,10 @@ def environment( )[:16] -def fixture_id(env: str, a: str, a_fp: str, b: str, b_fp: str, seed: Optional[int]) -> str: - """config_a is always yellow and starts on the right, kicking off (`match.run_match`'s defaults).""" - return _digest([env, a, a_fp, b, b_fp, json.dumps(seed)])[:16] +def fixture_id(env: str, a_fp: str, b_fp: str, seed: Optional[int]) -> str: + """config_a is always yellow and starts on the right, kicking off (`match.run_match`'s defaults). + Fingerprints, not names: a `.strategy` file and the same code in the repo are one player.""" + return _digest([env, a_fp, b_fp, json.dumps(seed)])[:16] def entry(env: str, graph: CodeGraph, result: dict, seed: Optional[int], source: str) -> dict: @@ -59,7 +61,7 @@ def entry(env: str, graph: CodeGraph, result: dict, seed: Optional[int], source: a_fp, b_fp = graph.strategy_fingerprint(a)[:16], graph.strategy_fingerprint(b)[:16] shots = (result.get("stats") or {}).get("shots") or {} return { - "fixture": fixture_id(env, a, a_fp, b, b_fp, seed), + "fixture": fixture_id(env, a_fp, b_fp, seed), "env": env, "a": a, "a_fp": a_fp, @@ -84,9 +86,11 @@ def append(entries: Iterable[dict], path: Path = LEDGER_PATH) -> None: f.flush() -def load(env: str, path: Path = LEDGER_PATH) -> dict[str, dict]: +def load(env: str, path: Path = LEDGER_PATH, fps: Optional[dict[str, str]] = None) -> dict[str, dict]: """The ledger's entries for `env`, by fixture id (the last one wins if a fixture was played - twice).""" + twice). With `fps` (name -> fingerprint), a player it knows goes by that name, whatever the + name was when the match was played.""" + names = {fp: name for name, fp in (fps or {}).items()} out: dict[str, dict] = {} if not path.exists(): return out @@ -96,5 +100,6 @@ def load(env: str, path: Path = LEDGER_PATH) -> dict[str, dict]: except json.JSONDecodeError: continue # a torn last line from a crash if e.get("env") == env: + e["a"], e["b"] = names.get(e["a_fp"], e["a"]), names.get(e["b_fp"], e["b"]) out[e["fixture"]] = e return out diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index 51b19336..edd19110 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -3,24 +3,21 @@ An rsim match is a pure function of the code each side runs, the pairing and the run settings (`docs/STRATEGY_DEVELOPMENT.md`, "Determinism"). This module names that code: -- `strategy_fingerprint(config)`: one `build_*_kernel_strategy` factory. `kernel_strategy.py` - only re-exports the factories; the module it imports each from counts as a whole file, - with every repo module that imports in turn (function-level imports included, the shared - `strategy/pickers.py` and the tactics among them). Editing one strategy's module leaves - the other configs' fingerprints alone; editing `pickers.py` moves every config that - imports it. -- `base_fingerprint(entry)`: everything both sides share, from the module that plays the - match (`tools.evaluation.match`): runner, planner, referee, sim wrapper, the rsim subprocess script, the files - next to that code (referee profiles), both pixi environments (every installed package's - name, version and build), the installed robosim binary, the CPU model and the - environment variables that change numerics. +- `strategy_fingerprint(config)`: one player, a strategy in the catalog or a `.strategy` file: + every repo module its code imports (function-level imports included, the shared + `strategy/pickers.py`, the tactics, the planner) and the non-code files next to them (the + compiled planner among them). Its name is not part of it, so a file and the code it was built + from are the same player, while a file built from other code is not. Editing one strategy's + module leaves the other players alone; editing `pickers.py` moves every player that imports it. +- `base_fingerprint(entry)`: what the match process runs whoever plays, from the module that plays + the match (`tools.evaluation.match`): runner, referee, sim wrapper, the rsim subprocess script, the + files next to that code (referee profiles), both pixi environments (every installed package's + name, version and build), the installed robosim binary, the CPU model and the environment + variables that change numerics. Not the code behind the process boundary (`PLAYER_SIDE`): a + `.strategy` file brings its own, so editing a skill replays no match between two files. - `match_key(...)`: those fingerprints plus every run setting. -`kernel_strategy.py` imports every strategy module, and they run in every match whichever -config is playing, so a module only one config uses still runs its import-time code in every -match. A module whose -import-time code can change something outside itself (`_import_time_effects`) is moved -into the base. `audit()` lists every place the code reaches outside the import graph +`audit()` lists every place the code reaches outside the import graph (environment, files, subprocesses, dynamic imports, module-level state); `tests/replay/test_fingerprint.py` pins that list, so a new one fails a test until someone decides how it enters the fingerprint. @@ -46,9 +43,30 @@ from typing import Iterable, Optional REPO_ROOT = Path(__file__).resolve().parents[2] -KERNEL_STRATEGY = "utama_core.strategy.kernel_strategy" +STRATEGY_PACKAGE = "utama_core.strategy" ROUND_ROBIN_ENTRY = "tools.evaluation.match" +# Behind the process boundary: a player's own code, which a `.strategy` file carries a copy of. +PLAYER_SIDE = ( + STRATEGY_PACKAGE, + "utama_core.tactics", + "utama_core.skills", + "utama_core.motion_planning", + "utama_core.engine", + "utama_core.shared.pass_and_score_geometry", +) +# The parts of those the match process runs itself, whoever plays: looking a strategy up, the base +# class a `.strategy` file's proxy inherits, and the log and stats it writes. +RUNNER_SIDE = ( + "utama_core.strategy.catalog", + "utama_core.engine.abstract_strategy", + "utama_core.engine.match_log", + "utama_core.engine.match_stats", + "utama_core.engine.tactic", +) +# Part of every player though no strategy imports it: where a side's motion controller comes from. +PLAYER_ROOTS = ("utama_core.motion_planning.src.common.control_schemes",) + # Code that runs but is not imported: `robosim_wrapper.py` starts it as a script in the # `robosim` pixi environment. SUBPROCESS_SCRIPTS = ("utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_subprocess",) @@ -119,6 +137,14 @@ def source(self) -> bytes: return self.path.read_bytes() if self.path is not None else b"" +def _within(module: str, packages: Iterable[str]) -> bool: + return any(module == p or module.startswith(p + ".") for p in packages) + + +def _is_player_side(module: str) -> bool: + return _within(module, PLAYER_SIDE) and not _within(module, RUNNER_SIDE) + + class CodeGraph: """The repo's import graph, parsed from source (nothing is imported). A snapshot: each file is read once, so build a new one after editing code.""" @@ -233,74 +259,39 @@ def data_files(self, names: Iterable[str]) -> list[str]: rows.append(f"{p.relative_to(self.root).as_posix()} {_sha(p.read_bytes())}") return sorted(rows) - # --- kernel_strategy.py, the registry of factories ---------------------------------- - - @cached_property - def factory_modules(self) -> dict[str, str]: - """Each `build_*_kernel_strategy` the registry re-exports -> the repo module that - defines it.""" - mod = self.module(KERNEL_STRATEGY) - found = {} - for stmt in mod.tree.body: - if not isinstance(stmt, ast.ImportFrom): - continue - source = self._resolve_from(mod, stmt) - home = self.module(source) if source is not None else None - if home is None or home.tree is None: - continue - defined = {s.name for s in home.tree.body if isinstance(s, ast.FunctionDef)} - for alias in stmt.names: - name = alias.asname or alias.name - if name.startswith("build_") and name.endswith("_kernel_strategy") and alias.name in defined: - found[name] = source - return found - - def factory_module(self, config: str) -> str: - if config not in self.factory_modules: - raise KeyError(f"{config} is not a factory {KERNEL_STRATEGY} re-exports") - return self.factory_modules[config] - - # --- what both sides share ---------------------------------------------------------- - - def kernel_import_closure(self) -> set[str]: - """Every repo module `import kernel_strategy` runs, whichever config plays.""" - return self.closure([KERNEL_STRATEGY]) - {KERNEL_STRATEGY} - - def ambient_modules(self) -> dict[str, list[str]]: - """Modules kernel_strategy imports whose import-time code can reach outside them - (module name -> what it does). They run in every match, so they join the base.""" - found = {} - for name in sorted(self.kernel_import_closure()): - mod = self.module(name) - if mod.tree is None: - continue - effects = [e for stmt in mod.tree.body for e in _import_time_effects(stmt)] - if effects: - found[name] = effects - return found + # --- what a player runs, and what every match runs ------------------------------------ def base_modules(self, entries: Iterable[str]) -> set[str]: - entries = list(entries) - cut = {KERNEL_STRATEGY} - mods = self.closure(entries + list(SUBPROCESS_SCRIPTS), cut=cut) - cut - # The entries only look factories up by name. Shared code that imports kernel_strategy - # could call any factory or helper it re-exports, so every strategy module is then shared. - if any(KERNEL_STRATEGY in self.imports(m) for m in mods - set(entries)): - mods |= self.closure([KERNEL_STRATEGY]) - return mods | self.closure(self.ambient_modules()) + roots = list(entries) + list(SUBPROCESS_SCRIPTS) + cut = {m for m in self.closure(roots) if _is_player_side(m)} + return self.closure(roots, cut=cut) - cut def strategy_modules(self, config: str) -> set[str]: - return self.closure([self.factory_module(config)]) + module = f"{STRATEGY_PACKAGE}.{config}" + if self.module(module) is None: + raise KeyError(f"no strategy {config} in {self.root}") + return self.closure([module, *PLAYER_ROOTS]) def strategy_fingerprint(self, config: str) -> str: key = ("strategy", config) if key not in self._fingerprints: - mods = self.strategy_modules(config) - self._fingerprints[key] = _digest( - ["factory", config, self.factory_module(config), "files"] + self.file_digests(mods) - ) + if config.endswith(".strategy"): + self._fingerprints[key] = self._file_fingerprint(config) + else: + mods = self.strategy_modules(config) + self._fingerprints[key] = _digest( + ["player", "files"] + self.file_digests(mods) + ["data"] + self.data_files(mods) + ) return self._fingerprints[key] + def _file_fingerprint(self, path: str) -> str: + """The same function over the file's own copy of the repo. The host and the manifest it adds are + outside every closure, so a file and the code it was built from fingerprint the same.""" + from utama_core.bundle.archive import read_manifest, unpack + + root = unpack(self.root / path) + return CodeGraph(root).strategy_fingerprint(read_manifest(root)["strategy"]) + def base_fingerprint(self, entries: Iterable[str]) -> str: key = ("base", tuple(entries)) if key not in self._fingerprints: @@ -523,15 +514,8 @@ def match_key( [ "round-robin match", graph.base_fingerprint([ROUND_ROBIN_ENTRY]), - config_a, graph.strategy_fingerprint(config_a), - config_b, graph.strategy_fingerprint(config_b), json.dumps(settings, sort_keys=True), ] ) - - -def config_names(graph: CodeGraph) -> list[str]: - """The round-robin's configs, as `match._CONFIG_NAMES` finds them, from source.""" - return sorted(n for n in graph.factory_modules if n != "build_default_kernel_strategy") diff --git a/utama_core/tests/bundle/__init__.py b/utama_core/tests/bundle/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/utama_core/tests/bundle/test_strategy_file.py b/utama_core/tests/bundle/test_strategy_file.py new file mode 100644 index 00000000..0af1fc23 --- /dev/null +++ b/utama_core/tests/bundle/test_strategy_file.py @@ -0,0 +1,276 @@ +import dataclasses +import json +import subprocess +import zipfile +from pathlib import Path + +import pytest + +from tools.evaluation import match, round_robin +from utama_core.bundle import archive, host, strategy_file, wire +from utama_core.config.enums import Mode +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.engine.match_log import MatchLog +from utama_core.entities.data.referee import RefereeData +from utama_core.entities.data.vector import Vector2D, Vector3D +from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot +from utama_core.entities.game.team_info import TeamInfo +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.entities.referee.stage import Stage +from utama_core.motion_planning.src.common.control_schemes import get_control_scheme +from utama_core.replay.fingerprint import CodeGraph +from utama_core.strategy import catalog + +STRATEGY = "split_shape" + + +def _robot(rid: int, friendly: bool, x: float, y: float) -> Robot: + return Robot(rid, friendly, False, Vector2D(x, y), Vector2D(0.1, -0.2), Vector2D(0.0, 0.3), 0.1 + rid / 3) + + +def _frame(ts: float = 1.0) -> GameFrame: + referee = RefereeData( + source_identifier=None, + time_sent=ts, + time_received=ts, + referee_command=RefereeCommand.NORMAL_START, + referee_command_timestamp=0.0, + stage=Stage.NORMAL_FIRST_HALF, + stage_time_left=120.0, + blue_team=TeamInfo("blue", score=2, yellow_card_times=[3]), + yellow_team=TeamInfo("yellow", goalkeeper=0), + designated_position=(0.5, -0.25), + next_command=RefereeCommand.STOP, + ) + return GameFrame( + ts=ts, + my_team_is_yellow=True, + my_team_is_right=True, + friendly_robots={i: _robot(i, True, 1.0 + i / 7, i / 3 - 0.5) for i in range(6)}, + enemy_robots={i: _robot(i, False, -1.0 - i / 7, 0.5 - i / 3) for i in range(6)}, + ball=Ball(Vector3D(0.2, 0.1, 0.0), Vector3D(1 / 3, 0.0, 0.0), Vector3D(0.0, 0.0, 0.0)), + referee=referee, + ) + + +def _field() -> Field: + return host.decode_field( + { + "my_team_is_right": True, + "dims": { + "full_field_half_length": 4.5, + "full_field_half_width": 3.0, + "half_defense_area_depth": 0.5, + "half_defense_area_width": 1.0, + "half_goal_width": 0.5, + "center_circle_radius": 0.5, + "goal_depth": 0.18, + }, + "top_left": [-4.5, 3.0], + "bottom_right": [4.5, -3.0], + "defense_area_rules": True, + } + ) + + +def _over_the_wire(data): + return json.loads(json.dumps(data)) + + +def test_a_frame_comes_back_with_every_float_exact(): + frame = _frame() + decoded = host.decode_frame(_over_the_wire(wire.encode_frame(frame))) + assert [ + (r.id, r.is_friendly, r.has_ball, r.p, r.v, r.a, r.orientation) for r in decoded.friendly_robots.values() + ] == [(r.id, r.is_friendly, r.has_ball, r.p, r.v, r.a, r.orientation) for r in frame.friendly_robots.values()] + assert list(decoded.enemy_robots) == list(frame.enemy_robots) + assert (decoded.ball.p, decoded.ball.v, decoded.ball.a) == (frame.ball.p, frame.ball.v, frame.ball.a) + assert decoded.ts == frame.ts + + +def test_a_frame_comes_back_with_the_whole_referee(): + referee = host.decode_frame(_over_the_wire(wire.encode_frame(_frame()))).referee + assert referee.referee_command == RefereeCommand.NORMAL_START + assert referee.next_command == RefereeCommand.STOP + assert referee.stage == Stage.NORMAL_FIRST_HALF + assert referee.designated_position == (0.5, -0.25) + assert (referee.blue_team.score, referee.blue_team.yellow_card_times) == (2, [3]) + + +def test_a_frame_without_ball_or_referee_survives(): + frame = dataclasses.replace(_frame(), ball=None, referee=None) + decoded = host.decode_frame(_over_the_wire(wire.encode_frame(frame))) + assert decoded.ball is None and decoded.referee is None + + +def test_the_same_code_builds_the_same_bytes(tmp_path): + first = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + second = strategy_file.build(STRATEGY, tmp_path / "b.strategy") + assert first.read_bytes() == second.read_bytes() + + +def test_a_bundle_holds_its_code_and_no_tests(tmp_path): + path = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + with zipfile.ZipFile(path) as archive: + names = set(archive.namelist()) + manifest = json.loads(archive.read("manifest.json")) + assert {"utama_core/bundle/host.py", "utama_core/strategy/split_shape.py"} <= names + assert not any(name.startswith("utama_core/tests/") for name in names) + assert manifest["strategy"] == STRATEGY and manifest["format"] == strategy_file.FORMAT_VERSION + + +def test_a_strategy_that_does_not_exist_is_refused(tmp_path): + with pytest.raises(ValueError, match="nobody"): + strategy_file.build("nobody", tmp_path / "a.strategy") + + +def test_a_frozen_file_is_named_after_its_commit_and_never_rebuilt(tmp_path): + first = strategy_file.frozen(STRATEGY, "HEAD", tmp_path) + assert first.name == f"split_shape@{strategy_file._commit_of('HEAD')[:8]}.strategy" + first.write_bytes(b"kept") + assert strategy_file.frozen(STRATEGY, "HEAD", tmp_path).read_bytes() == b"kept" + + +def test_an_annotated_tag_resolves_to_its_commit(tmp_path, monkeypatch): + git = ["git", "-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false"] + subprocess.run([*git, "init", "-q"], cwd=tmp_path, check=True) + subprocess.run([*git, "commit", "-q", "--allow-empty", "-m", "x"], cwd=tmp_path, check=True) + subprocess.run([*git, "tag", "-a", "v1", "-m", "x"], cwd=tmp_path, check=True) + commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, capture_output=True, text=True).stdout.strip() + monkeypatch.setattr(strategy_file, "_REPO", tmp_path) + assert strategy_file._commit_of("v1") == commit + + +def _rewritten(source: Path, output: Path, member: str, change) -> Path: + with zipfile.ZipFile(source) as old, zipfile.ZipFile(output, "w") as new: + for name in old.namelist(): + data = old.read(name) + new.writestr(name, change(data) if name == member else data) + return output + + +def test_a_file_and_the_code_it_was_built_from_are_the_same_player(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + path = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + graph = CodeGraph() + assert graph.strategy_fingerprint(path.as_posix()) == graph.strategy_fingerprint(STRATEGY) + + +def test_what_a_file_adds_around_the_code_is_not_part_of_the_player(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + path = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + other = _rewritten(path, tmp_path / "b.strategy", "utama_core/bundle/host.py", lambda d: d + b"\nX = 1\n") + graph = CodeGraph() + assert graph.strategy_fingerprint(other.as_posix()) == graph.strategy_fingerprint(path.as_posix()) + + +@pytest.mark.parametrize( + "member", + [ + "utama_core/strategy/split_shape.py", + "utama_core/skills/src/go_to_ball.py", + "utama_core/motion_planning/src/common/control_schemes.py", + ], +) +def test_a_file_of_different_code_is_a_different_player(tmp_path, monkeypatch, member): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + path = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + other = _rewritten(path, tmp_path / "b.strategy", member, lambda d: d + b"\nX = 1\n") + graph = CodeGraph() + assert graph.strategy_fingerprint(other.as_posix()) != graph.strategy_fingerprint(path.as_posix()) + + +def test_a_frozen_player_and_the_same_strategy_today_get_different_match_tags(): + assert match._short_name("replays/eval/frozen/split_shape@09493fd2.strategy") == "split_shape@09493fd2" + assert match._short_name(STRATEGY) == "split_shape" + + +class _Commands: + keeps_kickers_charged = False + + def __init__(self): + self.sent = {} + + def add_robot_commands(self, command, robot_id): + self.sent[robot_id] = command + + def send_robot_commands(self): + pass + + +def _run(strategy) -> list[dict]: + """Three ticks; the second and third depend on what the strategy kept from the first.""" + controller = _Commands() + strategy.load_robot_controller(controller) + strategy.load_motion_controller(get_control_scheme("fpp")(Mode.RSIM, None)) + game = Game(GameHistory(20), _frame(), field=_field()) + strategy.load_game(game) + out = [] + for tick in range(3): + game.add_game_frame(_frame(1.0 + (tick + 1) / 60)) + controller.sent = {} + strategy.step() + out.append(dict(controller.sent)) + return out + + +def test_a_bundled_strategy_sends_exactly_the_commands_of_the_same_strategy_in_process(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + bundled = strategy_file.BundledStrategy(strategy_file.build(STRATEGY, tmp_path / "a.strategy")) + in_process = AbstractStrategy(catalog.builder(STRATEGY, (1, 2, 3, 4, 5))) + assert _run(bundled) == _run(in_process) + + +def _observed(strategy, path) -> dict: + """Everything the runner reads from a strategy, one tick of each kind.""" + controller = _Commands() + strategy.load_robot_controller(controller) + strategy.load_motion_controller(get_control_scheme("fpp")(Mode.RSIM, None)) + log = MatchLog() + kernel = strategy._kernel_strategy + kernel.match_log = log + game = Game(GameHistory(20), _frame(), field=_field()) + strategy.load_game(game) + seen = {"commands": [], "committed": [], "partition": [], "names": [], "status": []} + for tick in range(4): + game.add_game_frame(_frame(1.0 + (tick + 1) / 60)) + # The runner's order: committed tactics are read on the new frame, before the step. + seen["committed"].append( + {tid: sorted(info["robots"]) for tid, info in kernel.slot_status(game).items() if info["committed"]} + ) + controller.sent = {} + strategy.step() + seen["commands"].append(dict(controller.sent)) + partition = kernel.active_partition + seen["partition"].append({tid: sorted(robots) for tid, robots in partition.items()}) + seen["names"].append({tid: type(kernel._tactics[tid]).__name__ for tid in partition}) + seen["status"].append(strategy.debug_status()) + log.to_jsonl(path) + seen["log"] = Path(path).read_text() + seen["keeper"] = kernel._pinned_robot_id if hasattr(kernel, "_pinned_robot_id") else None + return seen + + +def test_the_runner_reads_the_same_from_a_bundled_strategy_as_from_the_same_strategy_in_process(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + bundled = strategy_file.BundledStrategy(strategy_file.build(STRATEGY, tmp_path / "a.strategy")) + in_process = AbstractStrategy(catalog.builder(STRATEGY, (1, 2, 3, 4, 5))) + seen_bundled = _observed(bundled, tmp_path / "bundled.jsonl") + seen_in_process = _observed(in_process, tmp_path / "in_process.jsonl") + assert seen_bundled["log"] # the comparison below must not pass on two empty logs + assert seen_bundled == seen_in_process + + +def test_a_strategy_file_is_named_like_any_strategy(): + names = round_robin._resolve_config_names(["split_shape", "replays/x@abc.strategy"]) + assert names == [STRATEGY, "replays/x@abc.strategy"] + + +def test_a_bundle_whose_process_died_says_so(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + bundled = strategy_file.BundledStrategy(strategy_file.build(STRATEGY, tmp_path / "a.strategy")) + bundled._process.kill() + bundled._process.wait() + with pytest.raises((RuntimeError, BrokenPipeError), match="exit code|Broken pipe"): + bundled._send({"type": "tick"}) + bundled._reply() diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index cc67208b..6d02e127 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -1,3 +1,5 @@ +import pytest + from tools.evaluation import evaluate from utama_core.replay import eval_ledger @@ -38,8 +40,17 @@ def test_ledger_round_trip_keeps_the_last_entry_per_fixture_and_skips_torn_lines def test_fixture_id_depends_on_seed_and_code(): f = eval_ledger.fixture_id - assert f("e", "x", "1", "y", "2", 1) != f("e", "x", "1", "y", "2", 2) - assert f("e", "x", "1", "y", "2", 1) != f("e", "x", "9", "y", "2", 1) + assert f("e", "1", "2", 1) != f("e", "1", "2", 2) + assert f("e", "1", "2", 1) != f("e", "9", "2", 1) + + +def test_a_ledger_player_goes_by_this_runs_name_for_the_same_code(tmp_path): + """A frozen file and the same code in the repo are one player, whichever played the match.""" + path = tmp_path / "ledger.jsonl" + row = {"env": "e", "fixture": "f", "a": "split_shape", "a_fp": "1", "b": "other", "b_fp": "2"} + eval_ledger.append([row], path) + loaded = eval_ledger.load("e", path, fps={"frozen/split_shape@abc.strategy": "1"}) + assert (loaded["f"]["a"], loaded["f"]["b"]) == ("frozen/split_shape@abc.strategy", "other") def test_per_opponent_compares_only_matches_with_the_same_seed_and_colour(): @@ -80,21 +91,43 @@ def test_a_verdict_after_round_k_ignores_later_seeds_already_in_the_ledger(): assert list(evaluate._up_to_round(ledger, 1)) == ["1"] -def test_pools_are_valid_and_load_cleanly(): +def test_the_reference_opponents_load(): + from tools.evaluation.sim_settings import load_opponents + + reference = load_opponents() + assert reference["champion"] and reference["opponents"] and reference["held_out"] + + +def test_the_reference_world_and_robots_make_one_valid_sim_noise(): + from tools.evaluation.sim_settings import reference_noise + from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + + noise = SimNoise.from_dict(reference_noise(seed=3)) + assert noise.seed == 3 + assert noise.latency_estimate_s == pytest.approx(0.07) + + +def test_every_reference_setting_names_its_source(): import json - from pathlib import Path + from tools.evaluation.sim_settings import REFERENCE_DIR + + for name in ("world", "robots"): + data = json.loads((REFERENCE_DIR / f"{name}.json").read_text()) + assert set(data["sources"]) == set(data["values"]), name + + +def test_the_reference_sim_does_not_draw_robot_motor_limits(): + """Acceleration is the command cap; a per-match draw would be a robot capability as noise.""" + from tools.evaluation.sim_settings import reference_noise from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise - pools_dir = Path(__file__).resolve().parents[3] / "tools" / "evaluation" / "pools" - pool_files = list(pools_dir.glob("pool_v*.json")) - assert len(pool_files) >= 1 # pool_v1.json - - for path in pool_files: - data = json.loads(path.read_text()) - assert "version" in data and "champion" in data and "opponents" in data - assert "held_out" in data and "sim_noise" in data - assert len(data["opponents"]) > 0 - assert len(data["held_out"]) > 0 - noise = SimNoise.from_dict(data["sim_noise"]) - assert noise.vanishing >= 0 + assert not SimNoise.from_dict(reference_noise()).motion_limits + + +def test_sim_noise_spec_forms(): + from tools.evaluation.sim_settings import sim_noise_from_spec + + assert sim_noise_from_spec("reference").seed == 0 + assert sim_noise_from_spec("reference:7").seed == 7 + assert sim_noise_from_spec('{"seed": 2, "kick_speed_sd": 0.3}').kick_speed_sd == 0.3 diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index a9f2f7e0..2691c432 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -1,8 +1,7 @@ """`utama_core.replay.fingerprint`: which edits change which fingerprints. -Most tests build a small repo in `tmp_path` with the real layout (a `kernel_strategy.py` -registry, one module per strategy and a shared `pickers.py`, tactic modules, a planner the -runner imports, `tools/evaluation/match.py`), edit one file, and check exactly the +Most tests build a small repo in `tmp_path` with the real layout (one module per strategy and +a shared `pickers.py`, tactic modules, a planner the runner imports, `tools/evaluation/match.py`), edit one file, and check exactly the fingerprints that should move do. The rest run against this repo itself.""" from __future__ import annotations @@ -14,21 +13,12 @@ from utama_core.replay import fingerprint as fp from utama_core.replay.fingerprint import ( - KERNEL_STRATEGY, REPO_ROOT, ROUND_ROBIN_ENTRY, CodeGraph, - config_names, match_key, ) - -REGISTRY = '''\ -"""Factories.""" - -from utama_core.strategy.a import build_a_kernel_strategy -from utama_core.strategy.b import build_b_kernel_strategy -from utama_core.strategy.c import build_c_kernel_strategy -''' +from utama_core.strategy import catalog PICKERS = """\ _MARGIN = 0.05 # used by the shared helper @@ -45,7 +35,7 @@ def _shared_helper(x): from utama_core.tactics.attack import AttackTactic -def build_a_kernel_strategy(ids): +def a(ids): return [AttackTactic(), _shared_helper(1)] """ @@ -65,7 +55,7 @@ def _b_picker(x): return _shared_helper(x) * _ONLY_B -def build_b_kernel_strategy(ids): +def b(ids): return [DefendTactic(), _b_picker(2)] """ @@ -76,14 +66,14 @@ def build_b_kernel_strategy(ids): from utama_core.tactics.unused import UnusedTactic -def build_c_kernel_strategy(ids): +def c(ids): # no helper, no tactic of its own return [len(ids)] """ FILES = { "tools/evaluation/__init__.py": "", - "tools/evaluation/match.py": "from utama_core.run.runner import run\nfrom utama_core.strategy import kernel_strategy\n", + "tools/evaluation/match.py": "from utama_core.run.runner import run\nfrom utama_core.strategy import catalog\n", "utama_core/__init__.py": '__version__ = "1.0.0"\n', "utama_core/run/__init__.py": "", "utama_core/run/runner.py": "from ..planning import planner\nfrom utama_core.profiles import loader\n\n\ndef run():\n" @@ -94,7 +84,7 @@ def build_c_kernel_strategy(ids): "utama_core/profiles/loader.py": "def load():\n return open('sim.yaml').read()\n", "utama_core/profiles/sim.yaml": "speed: 1\n", "utama_core/strategy/__init__.py": "", - "utama_core/strategy/kernel_strategy.py": REGISTRY, + "utama_core/strategy/catalog.py": "def names():\n return []\n", "utama_core/strategy/pickers.py": PICKERS, "utama_core/strategy/a.py": STRATEGY_A, "utama_core/strategy/b.py": STRATEGY_B, @@ -109,7 +99,7 @@ def build_c_kernel_strategy(ids): "utama_core/tactics/unused.py": 'class UnusedTactic:\n pass\n\n\nif __name__ == "__main__":\n print(1)\n', "utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py": "import json\n", } -CONFIGS = ["build_a_kernel_strategy", "build_b_kernel_strategy", "build_c_kernel_strategy"] +CONFIGS = ["a", "b", "c"] @pytest.fixture @@ -140,53 +130,36 @@ def _changed_after(root: Path, rel: str, old: str, new: str) -> set[str]: return {k for k in before if before[k] != after[k]} -def _short(changed: set[str]) -> set[str]: - return {c.removeprefix("build_").removesuffix("_kernel_strategy") for c in changed} - - -KS = "utama_core/strategy/kernel_strategy.py" PICKERS_PY = "utama_core/strategy/pickers.py" A_PY, B_PY, C_PY = ("utama_core/strategy/a.py", "utama_core/strategy/b.py", "utama_core/strategy/c.py") def test_editing_one_strategy_changes_only_that_config(repo): - assert _short(_changed_after(repo, C_PY, "return [len(ids)]", "return [len(ids) + 1]")) == {"c"} - assert _short(_changed_after(repo, A_PY, "AttackTactic(), ", "AttackTactic(), 0, ")) == {"a"} + assert (_changed_after(repo, C_PY, "return [len(ids)]", "return [len(ids) + 1]")) == {"c"} + assert (_changed_after(repo, A_PY, "AttackTactic(), ", "AttackTactic(), 0, ")) == {"a"} def test_editing_a_constant_or_state_in_one_strategy_changes_only_that_config(repo): - assert _short(_changed_after(repo, B_PY, "_ONLY_B = 3", "_ONLY_B = 4")) == {"b"} - assert _short(_changed_after(repo, B_PY, "_streak = 0", "_streak = 5")) == {"b"} + assert (_changed_after(repo, B_PY, "_ONLY_B = 3", "_ONLY_B = 4")) == {"b"} + assert (_changed_after(repo, B_PY, "_streak = 0", "_streak = 5")) == {"b"} def test_editing_the_shared_pickers_changes_the_configs_that_import_them(repo): - assert _short(_changed_after(repo, PICKERS_PY, "return x + _MARGIN", "return x - _MARGIN")) == {"a", "b"} - assert _short(_changed_after(repo, PICKERS_PY, "_MARGIN = 0.05", "_MARGIN = 0.06")) == {"a", "b"} - - -def test_the_registry_is_not_part_of_any_strategy_fingerprint(repo): - assert _changed_after(repo, KS, '"""Factories."""', '"""Factories."""\n_EDITED = 1') == set() - - -def test_pointing_a_factory_at_another_module_changes_that_config(repo): - (repo / "utama_core/strategy/c2.py").write_text(STRATEGY_C) - changed = _changed_after( - repo, KS, "from utama_core.strategy.c import build_c", "from utama_core.strategy.c2 import build_c" - ) - assert _short(changed) == {"c"} + assert (_changed_after(repo, PICKERS_PY, "return x + _MARGIN", "return x - _MARGIN")) == {"a", "b"} + assert (_changed_after(repo, PICKERS_PY, "_MARGIN = 0.05", "_MARGIN = 0.06")) == {"a", "b"} def test_editing_a_tactic_changes_exactly_the_configs_that_import_it(repo): rel = "utama_core/tactics/attack.py" - assert _short(_changed_after(repo, rel, "return kick()", "return kick() + 1")) == {"a"} + assert (_changed_after(repo, rel, "return kick()", "return kick() + 1")) == {"a"} def test_a_function_level_import_is_followed(repo): - assert _short(_changed_after(repo, "utama_core/skills/aim.py", "return 0", "return 1")) == {"a"} + assert (_changed_after(repo, "utama_core/skills/aim.py", "return 0", "return 1")) == {"a"} def test_an_imported_tactic_counts_even_if_the_strategy_never_uses_it(repo): - assert _short(_changed_after(repo, "utama_core/tactics/unused.py", "pass", "x = 1")) == {"c"} + assert (_changed_after(repo, "utama_core/tactics/unused.py", "pass", "x = 1")) == {"c"} def test_a_tactic_no_strategy_imports_changes_nothing(repo): @@ -194,27 +167,6 @@ def test_a_tactic_no_strategy_imports_changes_nothing(repo): assert _changed_after(repo, "utama_core/tactics/orphan.py", "pass", "x = 1") == set() -def test_import_time_effects_move_a_module_into_the_base(repo): - # `unused` runs in every match (strategy c imports it, and kernel_strategy imports c): once - # its import-time code can reach outside it, it is part of what every match runs. - rel = "utama_core/tactics/unused.py" - assert _short( - _changed_after(repo, rel, "class UnusedTactic:", "import sys\nsys.path.append('x')\n\n\nclass UnusedTactic:") - ) == {"base", "c"} - assert "utama_core.tactics.unused" in CodeGraph(repo).ambient_modules() - assert _short(_changed_after(repo, rel, "pass", "y = 2")) == {"base", "c"} - - -def test_import_time_effects_in_a_strategy_module_move_it_into_the_base(repo): - changed = _changed_after(repo, A_PY, "\n\ndef build_a", "\nREGISTRY = {}\nREGISTRY.update(a=1)\n\n\ndef build_a") - assert _short(changed) == {"base", "a"} - assert "utama_core.strategy.a" in CodeGraph(repo).ambient_modules() - - -def test_a_main_guard_is_not_an_import_time_effect(repo): - assert CodeGraph(repo).ambient_modules() == {} - - def test_editing_shared_infrastructure_changes_the_base_and_every_match_key(repo): g = CodeGraph(repo) keys = {(a, b): match_key(g, a, b, duration_seconds=65.0) for a in CONFIGS for b in CONFIGS if a < b} @@ -224,17 +176,42 @@ def test_editing_shared_infrastructure_changes_the_base_and_every_match_key(repo assert all(match_key(g, a, b, duration_seconds=65.0) != k for (a, b), k in keys.items()) -def test_shared_code_importing_kernel_strategy_puts_every_strategy_module_in_the_base(repo): - rel = "utama_core/planning/planner.py" +def _runner_also_imports(repo: Path, module: str) -> None: + path = repo / "utama_core/run/runner.py" + path.write_text(f"import {module}\n" + path.read_text()) + + +def _add(repo: Path, rel: str, text: str) -> None: path = repo / rel - path.write_text("from utama_core.strategy.kernel_strategy import _shared_helper\n\n\n" + path.read_text()) - assert _changed_after(repo, B_PY, "_ONLY_B = 3", "_ONLY_B = 4") == {"base", "build_b_kernel_strategy"} - assert _changed_after(repo, PICKERS_PY, "_MARGIN = 0.05", "_MARGIN = 0.06") == { - "base", - "build_a_kernel_strategy", - "build_b_kernel_strategy", - } - assert _changed_after(repo, KS, '"""Factories."""', '"""Factories."""\n_EDITED = 1') == {"base"} + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text) + + +def test_import_time_effects_stay_with_the_strategy_that_imports_them(repo): + # Only the two strategies playing are imported, so nothing else can see them. + rel = "utama_core/tactics/unused.py" + assert _changed_after( + repo, rel, "class UnusedTactic:", "import sys\nsys.path.append('x')\n\n\nclass UnusedTactic:" + ) == {"c"} + + +def test_code_behind_the_process_boundary_is_the_players_even_if_the_runner_imports_it(repo): + # A skills edit must not replay matches between two `.strategy` files, which carry their own. + _runner_also_imports(repo, "utama_core.skills.aim") + assert _changed_after(repo, "utama_core/skills/aim.py", "return 0", "return 1") == {"a"} + + +def test_what_the_match_process_runs_itself_stays_in_the_base(repo): + _add(repo, "utama_core/engine/__init__.py", "") + _add(repo, "utama_core/engine/match_log.py", "LIMIT = 1\n") + _runner_also_imports(repo, "utama_core.engine.match_log") + assert _changed_after(repo, "utama_core/engine/match_log.py", "LIMIT = 1", "LIMIT = 2") == {"base"} + + +def test_a_compiled_planner_counts_for_the_players_that_load_it_and_not_the_base(repo): + _add(repo, "utama_core/skills/_planner.so", "version 1") + _runner_also_imports(repo, "utama_core.skills.aim") + assert _changed_after(repo, "utama_core/skills/_planner.so", "version 1", "version 2") == {"a"} def test_the_rsim_subprocess_script_and_data_files_are_in_the_base(repo): @@ -308,62 +285,78 @@ def graph() -> CodeGraph: return CodeGraph(REPO_ROOT) -def test_configs_found_from_source_match_the_round_robin(graph): - from tools.evaluation import match +def _players() -> list[str]: + return catalog.names() - assert config_names(graph) == sorted(match._CONFIG_NAMES) +def test_editing_one_real_strategy_does_not_change_another_configs_fingerprint(graph): + """The point of one module per strategy: a strategy's fingerprint reaches its own module and + the shared pickers, never a sibling strategy's module.""" + modules = {c: f"utama_core.strategy.{c}" for c in _players()} + for config, module in modules.items(): + assert graph.strategy_modules(config) & set(modules.values()) == {module}, config + assert graph.strategy_fingerprint("tiki_taka") != graph.strategy_fingerprint("counter_press") -def test_every_factory_defined_in_the_strategy_package_is_re_exported(graph): - """A factory nobody re-exports from `kernel_strategy` is never discovered, so it would silently - never play.""" - import ast - defined = set() - for path in (REPO_ROOT / "utama_core" / "strategy").glob("*.py"): - for stmt in ast.parse(path.read_text()).body: - if ( - isinstance(stmt, ast.FunctionDef) - and stmt.name.startswith("build_") - and stmt.name.endswith("_kernel_strategy") - ): - defined.add(stmt.name) - assert defined == set(graph.factory_modules) +def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): + """Independent of the static analysis: build every `Strategy` and check the module of each + tactic object it holds is in that player's fingerprinted modules.""" + for config in _players(): + strategy = catalog.builder(config, (1, 2, 3, 4, 5))(None) + modules = {type(t).__module__ for t in strategy._tactics.values()} + assert modules <= graph.strategy_modules(config), (config, modules - graph.strategy_modules(config)) -def test_every_factory_is_defined_in_its_own_module_named_after_it(graph): - for config, module in graph.factory_modules.items(): - short = config.removeprefix("build_").removesuffix("_kernel_strategy") - assert module == f"utama_core.strategy.{short}", (config, module) +# Imported by the runner only to reset their per-match state, so a strategy that doesn't import +# them isn't affected by them, and the one that does has them in its own closure. +_RUNNER_ONLY_RESETS = { + "utama_core.shared.pass_and_score_geometry", + "utama_core.skills.src.shielding", + "utama_core.strategy.pickers", +} -def test_editing_one_real_strategy_does_not_change_another_configs_fingerprint(graph): - """The point of one module per strategy: a strategy's fingerprint reaches its own module and - the shared pickers, never a sibling strategy's module.""" - modules = {c: graph.strategy_modules(c) for c in config_names(graph)} - strategy_modules = {m for c in modules for m in (graph.factory_module(c),)} - for config, reached in modules.items(): - assert reached & strategy_modules == {graph.factory_module(config)}, config - for pair_a, pair_b in [("tiki_taka", "counter_press"), ("clear_danger", "overload_flow")]: - a, b = (f"build_{n}_kernel_strategy" for n in (pair_a, pair_b)) - assert graph.strategy_fingerprint(a) != graph.strategy_fingerprint(b) - assert graph.factory_module(a) not in graph.strategy_modules(b) - - -def test_every_tactic_a_factory_builds_is_in_its_closure(graph): - """Independent of the static analysis: build every config's `Strategy` and check the - module of each tactic object it holds is in that config's fingerprinted modules.""" - from utama_core.strategy import kernel_strategy - - for config in config_names(graph): - strategy = getattr(kernel_strategy, config)((1, 2, 3, 4, 5))(None) - modules = {type(t).__module__ for t in strategy._tactics.values()} - allowed = graph.strategy_modules(config) | graph.base_modules([ROUND_ROBIN_ENTRY]) - assert modules <= allowed, (config, modules - allowed) +def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): + """Otherwise an edit there would change a match and no fingerprint at all.""" + roots = [ROUND_ROBIN_ENTRY, *fp.SUBPROCESS_SCRIPTS] + resets = graph.closure(_RUNNER_ONLY_RESETS) + taken_out = graph.closure(roots) - graph.base_modules([ROUND_ROBIN_ENTRY]) - resets + for config in _players(): + assert taken_out <= graph.strategy_modules(config), (config, taken_out - graph.strategy_modules(config)) + + +# Every place the match process calls into `PLAYER_SIDE`. A new one fails this test: is it behind +# the boundary (then a `.strategy` file must do it in its own process), or `RUNNER_SIDE`? +_RUNNER_REACHES_INTO_PLAYER_SIDE = { + "tools.evaluation.match": {"utama_core.engine", "utama_core.strategy"}, # builds the code-named ones + "utama_core.bundle.strategy_file": {"utama_core.engine"}, + "utama_core.run.side_runtime": {"utama_core.engine", "utama_core.motion_planning"}, + "utama_core.run.strategy_runner": { + "utama_core.engine", + "utama_core.motion_planning", # builds a controller; a file's process builds its own + "utama_core.shared.pass_and_score_geometry", # reset + "utama_core.skills", # reset + "utama_core.strategy", # reset + }, + "utama_core.team_controller.src.controllers.real.real_robot_controller": {"utama_core.skills"}, # real only + "utama_core.tests.common.abstract_test_manager": {"utama_core.engine"}, # a type +} + + +def test_the_match_process_reaches_into_player_side_code_only_where_listed(graph): + found: dict[str, set[str]] = {} + for module in graph.base_modules([ROUND_ROBIN_ENTRY]): + if module in fp.RUNNER_SIDE: + continue + for target in graph.imports(module): + package = next((p for p in fp.PLAYER_SIDE if target == p or target.startswith(p + ".")), None) + if package is not None and target not in fp.RUNNER_SIDE: + found.setdefault(module, set()).add(package) + assert found == _RUNNER_REACHES_INTO_PLAYER_SIDE -def test_the_tactics_kernel_strategy_imports_are_outside_the_base(graph): - """Otherwise a tactic edit would rerun every match: the per-config split is the point.""" +def test_the_tactics_are_outside_the_base(graph): + """Otherwise a tactic edit would rerun every match: the per-player split is the point.""" base = graph.base_modules([ROUND_ROBIN_ENTRY]) for name in ("give_and_go", "press_and_contain", "shadow_and_mark", "switch_of_play", "defense"): assert f"utama_core.tactics.{name}" not in base @@ -382,25 +375,28 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): # the environment into the sim subprocess -> ENV_PREFIXES covers the numerics ones. # opens files: profile_loader reads profiles/*.yaml -> data_files. The rest write a # match's outputs (match log, stats, replays, a camera run's game log) or read old ones for -# analysis, never during play. robot_profile reads config/robots/*.json only when an +# analysis, never during play; catalog reads strategy sources to list the names; archive reads +# a .strategy file, which is the fingerprint's own input. robot_profile reads config/robots/*.json only when an # example asks for a real robot's profile (`load_profile`), and profiles act on real robots # only, so no match result depends on them. # subprocess: robosim_wrapper starts robosim_subprocess.py in the robosim pixi env -> # SUBPROCESS_SCRIPTS, and environment_pin's robosim env listing and binary hashes. # game_log_writer asks git for the commit it records, only for a camera run's game log # (never in rsim), so no match result depends on it. -# getattr on a module by computed name: tools.evaluation.match looks a factory up by name -> -# the config names are the fingerprint's own inputs. +# dynamic import: catalog.builder imports the strategy module of a name -> that module is the +# fingerprint's own input. # module-level state: code in the closure, so already hashed; its values must not carry # from one match to the next in a worker, which the cache's replay spot-check verifies. # possession/shield state: reset in StrategyRunner.__init__; the planner's _PERP_ROTATIONS: a memo of # pure values; robosim_wrapper's idle sims: a fresh native world per start. AUDIT = { "environment": [ + "utama_core.bundle.archive", + "utama_core.bundle.strategy_file", "utama_core.config.settings", "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", ], - "getattr on a module by computed name": ["tools.evaluation.match"], + "dynamic import": ["utama_core.strategy.catalog"], "module-level state": [ "utama_core.motion_planning.src.fastpathplanning.planner", "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", @@ -409,6 +405,8 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "utama_core.strategy.pickers", ], "opens files": [ + "utama_core.bundle.archive", + "utama_core.bundle.strategy_file", "utama_core.custom_referee.profiles.profile_loader", "utama_core.engine.match_log", "utama_core.engine.match_stats", @@ -416,9 +414,11 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "utama_core.replay.columnar_writer", "utama_core.replay.game_log_writer", "utama_core.replay.replay_writer", + "utama_core.strategy.catalog", "utama_core.team_controller.src.controllers.common.robot_profile", ], "subprocess": [ + "utama_core.bundle.strategy_file", "utama_core.replay.game_log_writer", "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", ], @@ -426,7 +426,7 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): def test_every_reach_outside_the_import_graph_is_accounted_for(graph): - everything = graph.base_modules([ROUND_ROBIN_ENTRY]) | graph.closure([KERNEL_STRATEGY]) + everything = graph.base_modules([ROUND_ROBIN_ENTRY]) | {m for c in _players() for m in graph.strategy_modules(c)} assert graph.audit(everything) == AUDIT From bcbbe2c4b0d9cb4e6b83180ff4eda9f99a22bd3f Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Tue, 10 Nov 2026 17:08:58 +0000 Subject: [PATCH 07/59] bundle: let a .strategy file drive real robots Send per-robot kick bend and bias to the file's process, apply the kicker-charge step on the runner side, and let a run name the robots it has. Unit tested; not yet run on the field. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- AGENTS.md | 2 +- utama_core/bundle/host.py | 4 +- utama_core/bundle/strategy_file.py | 19 ++++--- utama_core/tests/bundle/test_strategy_file.py | 50 +++++++++++++++++++ 4 files changed, 65 insertions(+), 10 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 30d3ff3b..d447924a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -63,7 +63,7 @@ One term per thing; reuse these instead of coining new ones. (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. - **Strategy file / frozen baseline** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a zip of one strategy and the whole `utama_core` package at one commit; it plays in its own process, game frames in and - robot commands out, simulation only. `evaluate.py CANDIDATE --frozen REF` plays the champion and the opponents from + robot commands out, in simulation or on real robots (`BundledStrategy(path, robot_ids)`). `evaluate.py CANDIDATE --frozen REF` plays the champion and the opponents from such files of commit REF (the frozen baseline, kept in `replays/eval/frozen/`), so a change to shared code moves only the candidate. The referee and the simulator stay today's for both sides. A file is a player like any strategy name wherever one is named (`evaluate.py`, `round_robin.py`, `opponents.json`), with the same replays, stats and logs. Its fingerprint is computed like the code's, so a file and the code it was built from are one player in the ledger. - **World / robot capability** — simulator settings fall into two kinds: the world (ball diff --git a/utama_core/bundle/host.py b/utama_core/bundle/host.py index 4524ab0d..11761501 100644 --- a/utama_core/bundle/host.py +++ b/utama_core/bundle/host.py @@ -135,13 +135,15 @@ def _controller(setup: dict): controller = scheme(Mode(setup["mode"]), None) controller.pose_ahead.latency_s = setup["latency_s"] controller.robot_carry = {int(rid): tuple(carry) for rid, carry in setup["robot_carry"].items()} + controller.kick_bend = {int(rid): bend for rid, bend in setup["kick_bend"].items()} + controller.kick_bias = {int(rid): bias for rid, bias in setup["kick_bias"].items()} return controller def _builder(manifest: dict): """`AbstractStrategy`'s first argument. The file's own code decides how: files of commits from before `strategy/catalog.py` have `kernel_strategy.build__kernel_strategy` instead.""" - ids = tuple(manifest["outfield_ids"]) + ids = tuple(map(int, sys.argv[1:])) or tuple(manifest["outfield_ids"]) # the run's robots, if it named them name = manifest["strategy"] try: from utama_core.strategy.catalog import builder diff --git a/utama_core/bundle/strategy_file.py b/utama_core/bundle/strategy_file.py index 18222198..1573229d 100644 --- a/utama_core/bundle/strategy_file.py +++ b/utama_core/bundle/strategy_file.py @@ -24,7 +24,6 @@ from utama_core.bundle import wire from utama_core.bundle.archive import SUFFIX, read_manifest, unpack -from utama_core.config.enums import Mode from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.match_log import IntentionEvent, TraceEvent from utama_core.engine.tactic import TacticTag @@ -169,7 +168,9 @@ def _pinned_robot_id(self) -> int: class BundledStrategy(AbstractStrategy): """A `.strategy` file, as `StrategyRunner` drives any strategy.""" - def __init__(self, path: str | Path): + def __init__(self, path: str | Path, outfield_robot_ids: Optional[tuple[int, ...]] = None): + """`outfield_robot_ids`: the robots this run has, if not the ones the file was built for + (a field day rarely has five).""" super().__init__(build=None) self.path = Path(path) root = unpack(self.path) @@ -177,7 +178,7 @@ def __init__(self, path: str | Path): if self.manifest["format"] != FORMAT_VERSION: raise ValueError(f"{path}: format {self.manifest['format']}, this code reads {FORMAT_VERSION}") self._process = subprocess.Popen( - [sys.executable, "-m", "utama_core.bundle.host"], + [sys.executable, "-m", "utama_core.bundle.host", *map(str, outfield_robot_ids or ())], cwd=root, env={**os.environ, "PYTHONPATH": str(root)}, stdin=subprocess.PIPE, @@ -198,8 +199,6 @@ def _reply(self): return reply def load_motion_controller(self, motion_controller) -> None: - if motion_controller.mode == Mode.REAL: - raise ValueError("A .strategy file plays in simulation only for now") self.motion_controller = motion_controller self._send( { @@ -208,6 +207,8 @@ def load_motion_controller(self, motion_controller) -> None: "mode": motion_controller.mode.value, "latency_s": motion_controller.pose_ahead.latency_s, "robot_carry": {str(rid): list(carry) for rid, carry in motion_controller.robot_carry.items()}, + "kick_bend": {str(rid): bend for rid, bend in motion_controller.kick_bend.items()}, + "kick_bias": {str(rid): bias for rid, bias in motion_controller.kick_bias.items()}, } ) @@ -236,10 +237,12 @@ def step(self) -> None: self._send({"type": "tick"}) reply = self._reply() self._kernel_strategy.record(reply["events"]) + commands = {int(robot_id): RobotCommand(*values) for robot_id, values in reply["commands"].items()} + if self._kicker_charge is not None: # needs the robot controller, which stays on this side + commands = self._kicker_charge.apply(self.game, commands) for robot_id in self.game.friendly_robots: - values = reply["commands"].get(str(robot_id)) - if values is not None: - self.robot_controller.add_robot_commands(RobotCommand(*values), robot_id) + if robot_id in commands: + self.robot_controller.add_robot_commands(commands[robot_id], robot_id) self.robot_controller.send_robot_commands() def debug_status(self) -> dict[int, list[str]]: diff --git a/utama_core/tests/bundle/test_strategy_file.py b/utama_core/tests/bundle/test_strategy_file.py index 0af1fc23..872a13f6 100644 --- a/utama_core/tests/bundle/test_strategy_file.py +++ b/utama_core/tests/bundle/test_strategy_file.py @@ -1,6 +1,7 @@ import dataclasses import json import subprocess +import sys import zipfile from pathlib import Path @@ -221,6 +222,55 @@ def test_a_bundled_strategy_sends_exactly_the_commands_of_the_same_strategy_in_p assert _run(bundled) == _run(in_process) +def _setup_of(strategy, mode=Mode.REAL) -> dict: + sent = [] + strategy._send = sent.append + controller = get_control_scheme("fpp")(mode, None) + controller.kick_bend, controller.kick_bias = {1: 0.5}, {2: -0.25} + controller.robot_carry = {3: (0.3, 0.6)} + controller.pose_ahead.latency_s = 0.079 + strategy.load_motion_controller(controller) + return sent[0] + + +def test_real_robots_kick_calibration_reaches_the_files_controller(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + strategy = strategy_file.BundledStrategy(strategy_file.build(STRATEGY, tmp_path / "a.strategy")) + send = strategy._send + setup = _setup_of(strategy) + strategy._send = send # for close() + controller = host._controller(wire_round_trip(setup)) + assert controller.mode == Mode.REAL + assert (controller.kick_bend, controller.kick_bias) == ({1: 0.5}, {2: -0.25}) + assert controller.robot_carry == {3: (0.3, 0.6)} + assert controller.pose_ahead.latency_s == 0.079 + + +def wire_round_trip(message: dict) -> dict: + return json.loads(json.dumps(message)) + + +class _KeepsCharged(_Commands): + keeps_kickers_charged = True + + +def test_a_real_robots_kicker_charge_is_applied_to_a_files_commands(tmp_path, monkeypatch): + """The charge step needs the real controller, so it stays with the runner: same commands as in process.""" + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + monkeypatch.setattr(sys.modules[__name__], "_Commands", _KeepsCharged) + bundled = strategy_file.BundledStrategy(strategy_file.build(STRATEGY, tmp_path / "a.strategy")) + in_process = AbstractStrategy(catalog.builder(STRATEGY, (1, 2, 3, 4, 5))) + assert _run(bundled) == _run(in_process) + assert bundled._kicker_charge is not None + + +def test_a_file_can_play_with_the_robots_a_run_has(tmp_path, monkeypatch): + monkeypatch.setattr(archive, "_CACHE", tmp_path / "cache") + path = strategy_file.build(STRATEGY, tmp_path / "a.strategy") + bundled = strategy_file.BundledStrategy(path, (1, 2)) + assert _run(bundled) == _run(AbstractStrategy(catalog.builder(STRATEGY, (1, 2)))) + + def _observed(strategy, path) -> dict: """Everything the runner reads from a strategy, one tick of each kind.""" controller = _Commands() From e16649d532649f670da411df8593456683293509 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Wed, 11 Nov 2026 00:34:14 +0000 Subject: [PATCH 08/59] tools: one tool per question, stalls in the ledger, a cheap health check - docs/strategy_tools_plan.md: which tool answers which question, the remaining steps, and the screen's proposed pass mark (not yet agreed). tools.md opens with a "Which tool?" table; simulator realism tools get their own section; debugging starts at triage.py; --reuse counts fixed. - Ledger entries record each match's stalls; evaluate.py reports them with coverage (the watchdog sees config_a only; old entries unknown). Verdicts are unchanged. - round_robin.py --vs-champion: each strategy once against the champion (12 matches, not 66), reference noise seed 2 by default so those are evaluate.py's round-2 fixtures. - tools/sim_setup.py: one way to load a strategy (catalog name, .strategy file, PATH.py:FUNCTION) and set up an rsim match, used by repro_from_replay, moments, debug_match and main.py. match.py is untouched, so cached matches and the ledger stay valid. - main.py: fix its strategy loading (it failed on import). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- docs/README.md | 1 + docs/STRATEGY_DEVELOPMENT.md | 23 ++- docs/strategy_tools_plan.md | 148 ++++++++++++++++++ docs/tools.md | 43 ++++- main.py | 20 +-- tools/debug_match.py | 41 ++--- tools/evaluation/evaluate.py | 58 ++++++- tools/evaluation/round_robin.py | 43 ++++- tools/moments.py | 59 ++----- tools/repro_from_replay.py | 31 +--- tools/sim_setup.py | 99 ++++++++++++ utama_core/replay/eval_ledger.py | 25 ++- utama_core/tests/engine/test_evaluate.py | 106 +++++++++++++ .../engine/test_tournament_vs_champion.py | 110 +++++++++++++ utama_core/tests/test_main_entry.py | 20 +++ utama_core/tests/tools/test_sim_setup.py | 63 ++++++++ 16 files changed, 768 insertions(+), 122 deletions(-) create mode 100644 docs/strategy_tools_plan.md create mode 100644 tools/sim_setup.py create mode 100644 utama_core/tests/engine/test_tournament_vs_champion.py create mode 100644 utama_core/tests/test_main_entry.py create mode 100644 utama_core/tests/tools/test_sim_setup.py diff --git a/docs/README.md b/docs/README.md index f2ec71cb..34ce475f 100644 --- a/docs/README.md +++ b/docs/README.md @@ -35,6 +35,7 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f ## Open work - [roadmap.md](roadmap.md): larger open workstreams, and one-line pointers to finished ones. +- [strategy_tools_plan.md](strategy_tools_plan.md): design note, "one question, one tool": which strategy tool answers which question, what is planned and in what order, and the open names. - [sim_realism.md](sim_realism.md): how far rsim is from real matches, the realism scorecard, and the plan to close the gap with measured, randomized physics. - [in_house_vision.md](in_house_vision.md): our own vision stack for lab days (per-session tag calibration, tags on robots), the experiments that decide it, and the 2026-10-22 test day's vision findings. - [field_log_replay.md](field_log_replay.md): design for finding a moment in a field log and rerunning the decision code on its recorded inputs, and the physical setup's own errors (tag yaw and offset, kicker offset, cameras) as per-robot profiles. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 5b82221c..d3170c7b 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -242,7 +242,9 @@ changes and run one round-robin over the batch. **`--reuse`** takes a match's result from `replays/match_cache/` when nothing it runs has changed since it was stored, so after a change -to one strategy only its matches play, one per other config (21 of 231 with 22 configs). What counts as +to one strategy only its matches play, one per other config. A default round-robin plays the 12 configs +not in `RETIRED` (`tools/evaluation/round_robin.py`; the catalog has 22), so a change to one of them replays +11 of its 66 matches. Naming all 22 configs gives 21 of 231. What counts as "runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole files), and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing `pickers.py` @@ -318,6 +320,16 @@ flowchart TD the champion's matches are played once per seed and reused by every candidate, and editing a strategy starts its record afresh. Replays are not kept, except during a `--explain` run (rerun one with `round_robin.py --pair A B --sim-noise reference:`). +- **Stalls** are reported after each candidate's and the champion's verdict, for post-analysis only: + they never change a verdict or stop a run. "stalls checked in N of M ... (watchdog covers config_a + only)" counts the matches where the watchdog could see that side (`run/strategy_runner.py` records + stats for config_a only). A match where the side was config_b, or a ledger line from before stalls + were recorded, counts as unchecked; "unknown" means none was checked. The JSON report has them under + `candidates[...].stalls` and `champion_stalls`. +- **Health check.** After a shared-code change, `round_robin.py --vs-champion` plays each strategy once + against the champion (12 matches, not the 66 of a full round-robin), defaulting to `--sim-noise + reference:2` so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2. Read + its STALLS section; a strategy's verdict still comes from `evaluate.py`. - **Before promoting** a candidate called better, run `evaluate.py --held-out`: it must not be clearly worse against opponents never used for selection. Then edit the champion in `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse @@ -458,7 +470,7 @@ The same steps as a flowchart; the moment branch is the optional step 5. ```mermaid flowchart TD - find["1. Find it
moments.py fouls RUN_DIR --by strategy,rule
(without --by: each foul, with its time and tactic)"] + find["1. Find it
triage.py RUN_DIR --strategy NAME
(index.md, then findings.jsonl)"] look["2. Look at it
replay_trace.py REPLAY T0 T1 --events
repro_from_replay.py REPLAY --t S --summary IDS"] q{"Restart or placement geometry?
a field state alone decides it"} moment["Capture a moment
moments.py capture REPLAY --t S
play --seeds 0-4 must fail on 4 of 5"] @@ -474,8 +486,11 @@ flowchart TD The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, `pitch_maps.py`) write their flags as JSON with `--findings`: filter on that, open the picture to understand a flag, and never conclude from a picture alone. -1. **Find it.** `pixi run python tools/moments.py fouls replays/tournament_ --by strategy,rule` - counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball +1. **Find it.** `tools/triage.py` is the one starting point for "what went wrong in a run" (see the + start of this section). It flags thrashing and stalls, and restart geometry with `--restarts`. + Fouls are not in triage yet. To list our side's fouls by rule, use + `pixi run python tools/moments.py fouls replays/tournament_ --by strategy,rule`, after triage + and not instead of it. It counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball leaving the field, is a stoppage and left out unless `--include-stoppages`); without `--by` it lists each with its time, robot, tactic and the referee command then active (`--skip-own-restart` drops fouls during our own restarts; `--json` writes either form as JSON). diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md new file mode 100644 index 00000000..dd6a3173 --- /dev/null +++ b/docs/strategy_tools_plan.md @@ -0,0 +1,148 @@ +# Strategy tools: one question, one tool + +Design note, agreed after two review rounds. It says which tool answers which question, what +is planned and in what order, and what is still undecided. Items marked **planned** do not +exist yet. The current tools are in [tools.md](tools.md), and the "Which tool?" table there +links back here. + +## The problem + +- **Too many overlapping tools.** Several scripts answer the same question in slightly + different ways. A reader cannot tell which one to run first, or which result to believe. +- **The docs list scripts, not jobs.** `tools.md` says what each script is. It does not say + which question the script answers, so a reader has to work that out. +- **Runner set-up was written five times** (step 5 fixed four of them). Each of these builds its own strategy runner, + referee and dashboard: + `tools/evaluation/match.py`, `tools/debug_match.py`, `tools/repro_from_replay.py`, + `tools/moments.py` and `main.py`. + Only `match.py` loads `.strategy` files (`utama_core/bundle/`). The other four cannot run a + frozen baseline, so they cannot compare against one. + +## The question, the tool + +"Today" is a tool that exists. "Planned" is in the steps at the end. + +| Question | Tool | Status | +|---|---|---| +| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the ledger for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | +| Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | +| Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | +| What went wrong in these matches (bugs: thrashing, stalls, restart geometry)? | `tools/triage.py`, then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | +| Is this change worth evaluating? | A screen: short paired starts of one strategy against itself, at a git ref. Never a verdict. Never two different strategies. Never written to the ledger. It must report how often the change fired. See "The screen" below | Planned (step 6) | +| Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | +| Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | +| Is the simulator realistic? | Simulator tools: `realism_scorecard.py`, `physics_ranges.py`, `field_physics.py`, `robot_calibration.py`, `convert_ssl_log.py`. Not part of strategy development | Today | + +Notes on the table: + +- A round-robin answers "is the whole catalog healthy?". `evaluate.py` answers "is this candidate + stronger than the champion?". Keep the two apart in the docs and in the output. +- "Look closely" tools explain a result. They never judge one. + +## The screen (planned) + +The screen asks a narrower question than `evaluate.py`: "did this change do anything in +play?" It is for deciding whether a change is worth the cost of an evaluation. + +- It plays short paired starts of **one** strategy against **itself**, at two git refs: the + change and its base. The same starts and the same noise are used on both sides. +- It is never a verdict. Its output says where the change had an effect, not whether it helps. +- It never plays two different strategies, and its matches never go into the ledger. +- It must report how often the change fired (how many of the starts reached the code the change + touched). A screen that never fired says nothing. + +**Pass mark (proposed 2026-11-11, not yet agreed).** The screen is a filter in front of +`evaluate.py`, so its two errors cost different amounts. Screening out a change that would have won +loses an improvement for good. Letting a useless change through only costs one evaluation. The +pass mark guards the first error hard and asks only enough of the second to make the screen worth +running. + +Past verdicts are too few to judge it on: three `evaluate.py` runs on a change to one strategy +(`split_shape` against the frozen v2.5.0, 2026-11-10, all "better"); the other nine compare +different strategies, which the screen never does. So the validation set is built with known answers: + +- **Known worse:** 6 sabotages of the champion, each a small, plausible slip of the size a real change + makes (a pass gate a little too strict, a receiver who turns late, a marker 0.3 m off, a slower + restart, a shot threshold off, a missing keeper step-out). Each sabotage is confirmed worse by + `evaluate.py` first; one that `evaluate.py` cannot tell apart is not a known answer and is dropped. +- **Known better:** each confirmed sabotage reversed (base = sabotaged, change = the champion), plus + the three real "better" verdicts above. +- **Known nothing:** 3 changes that cannot alter play (a renamed variable, a reordered pure function, + a log line). + +The screen passes validation when all of these hold, on a design (number of starts, seconds per start, +the measure, the threshold) fixed before any of the cases are screened: + +1. **Never screens out a known better change.** Every one of them gets "worth evaluating". +2. **Screens out at least half of the known worse ones.** Below that it saves too little to be worth + running. +3. **Calls every known-nothing change "did not fire"**, or reports no difference on it. A difference + there means the screen measures noise. +4. **Repeatable:** screened again with other seeds, at least 9 cases in 10 get the same call. +5. **Cheap:** at most a fifth of the playing time of a 6-round `evaluate.py` run. + +If it fails, the design is changed once and the whole set is screened again. If it fails twice, the +screen is dropped and `evaluate.py` stays the only gate. Nothing is tuned after the results are in. + +**Why not the retired scenario bench.** The scenario bench (retired 2026-10-17) also started +matches from fixed states. It ranked *different* strategies. Its estimate was biased per +strategy, so the ranking failed: Spearman -0.09 against round-robin results (see +[roadmap.md](roadmap.md), "Strategy evaluation"; the retirement is in +[sim_realism.md](sim_realism.md), "Evaluation infrastructure"). The screen differs on both +points: it compares one strategy with itself, so per-strategy bias cancels, and it does not +rank anything. The screen is still a new mechanism, so it is built only after the scratch +validation. + +## Moments + +Regression moments are fixed-state checks of shared-code bugs (restart and placement geometry). +Changes planned for `tools/moments.py`: + +- **Drop `moments.py fouls`.** Its job moves into `tools/triage.py`, so there is one place to + find what went wrong in a run. +- **Drop `new` (hand-made templates).** Moments come from `capture`, from a replay. +- **Keep `--seeds`.** `play --seeds 0-4` is how a moment is checked (it must fail on 4 of 5 + seeds before the fix). +- **Fix `--against`.** Its worktree folder is a hard-coded dated name next to the repo + (`AGAINST_DIR = REPO_ROOT.parent / "moments-work-20261017" / "against"` in `tools/moments.py`). + Planned: a folder that is set in one place and does not carry a date. + +## Planned steps, in order + +1. **Fix `main.py`'s import.** Done: it loads strategies through `strategy/catalog.py`. Its runner set-up is still one of the five hand-built ones above. +2. **This note and the docs.** `docs/strategy_tools_plan.md`, the "Which tool?" table in + `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the `--reuse` counts. +3. **Stalls in the ledger.** Done. Stalls are recorded in `replays/eval/ledger.jsonl`, and `evaluate.py` + reports them with coverage: how many of the matches it used were checked for stalls. The + stall watchdog covers config_a only, so coverage is partial. Old ledger entries count as + **unknown, not clean**. +4. **`round_robin.py --vs-champion`.** Done. One match per strategy against the champion, plus + the champion against the first reference opponent, under reference noise seed 2 by default. + `evaluate.py` puts the side under test second in even rounds, so each (strategy, champion) + match is its round-2 fixture (not with `--frozen`, whose opponents are packed files). +5. **One shared match and runner construction** for the other tools. Done as `tools/sim_setup.py` + (`load_side`: a catalog name, a `.strategy` file or `PATH.py:FUNCTION`; `sim_runner`: the referee and + rsim runner), used by `repro_from_replay.py`, `moments.py` and `debug_match.py`; `main.py` loads its + strategies through it but keeps its own runner for the dashboard. So all four play `.strategy` files. + `match.py` is unchanged, and moves onto `sim_setup` with the next change that replays every match + anyway: editing `match.py`, or anything it imports, changes the + fingerprint of every cached match, so every match replays and the ledger is invalidated + (`utama_core/replay/fingerprint.py`). If it must change, batch it with other changes to shared + code and say so in the commit. +6. **The screen.** First validated in scratch code, against past `evaluate.py` verdicts, with the + pass mark agreed beforehand. Only then built in. Then a `compare.py` tool with two + subcommands, `verdict` (wraps `evaluate.py`) and `screen`, with no options shared between + them. Renames happen together with the merge they belong to, not before. + +Every step that changes shared code follows the rule in `docs/STRATEGY_DEVELOPMENT.md`: batch +such changes, and run one round-robin at the end. + +## Names considered (undecided) + +- **`drill`** for the screen: rejected as a name, because `examples/shooting_drill.py` already + uses "drill". +- **Triage**: `scan_replays.py` or `find_bugs.py`. Undecided. `triage.py` stays until then. +- **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Step 6 uses `compare.py` + as a placeholder. Undecided. + +Nothing above is decided by a name. Pick the name when the tool is merged, not before. diff --git a/docs/tools.md b/docs/tools.md index 5f5fc270..a20cb416 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -3,6 +3,23 @@ Every script in the repository, by what it is for. Run them from the repository root with `pixi run python `; each script's docstring has its full usage and flags. +## Which tool? + +Pick the tool by the question you have. Only tools that exist are named in this table. Items marked +*planned* are designed but not built: see [strategy_tools_plan.md](strategy_tools_plan.md), which also +says why the tools are split this way. + +| Question | Tool | +|---|---| +| Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` and the round-robin report them | +| Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion. The only verdict. Add `--held-out` before promoting | +| Does everything still run after a shared-code change? | `tools/evaluation/round_robin.py --vs-champion`: one match per strategy against the champion (12). The full round-robin (66) only occasionally. A round-robin is not an evaluation | +| What went wrong in these matches (thrashing, stalls, restart geometry)? | `tools/triage.py RUN_DIR --strategy NAME`, then the picture tools. It finds bugs, not why a strategy loses | +| Is this change worth evaluating? | *Planned:* a screen (short paired starts of one strategy against itself). Until it exists, `evaluate.py` | +| Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | +| Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | +| Is the simulator realistic? | [Simulator realism](#simulator-realism). Not strategy development | + ## pixi tasks `pixi run ` (defined in `pixi.toml`): @@ -32,8 +49,9 @@ Every script in the repository, by what it is for. Run them from the repository | Script | Purpose | |---|---| -| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every strategy config against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the evaluation ledger. `--pair A B` plays one match; `--reuse` replays only matches whose code changed, plus a 5% spot-check of reused ones; `summary.json`'s `reuse.mismatches` lists any that came out different, which means a match no longer replays exactly. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | -| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every config not in `RETIRED` (12 of the 22 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the evaluation ledger. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; `--reuse` replays only matches whose code changed, plus a 5% spot-check of reused ones; `summary.json`'s `reuse.mismatches` lists any that came out different, which means a match no longer replays exactly. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | +| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; ledger lines from before stalls were recorded count as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | | `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | @@ -49,7 +67,6 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | `tools/signal_report.py` | Figures of a round-robin's strategy signals for [signal_report.md](signal_report.md) | | `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for [signal_report.md](signal_report.md#on-the-pitch). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | | `utama_core/analysis/goal_ledger.py` | `python -m utama_core.analysis.goal_ledger `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | -| `utama_core/analysis/physics_ranges.py` | `python -m utama_core.analysis.physics_ranges --real --sim `: physics parameter ranges for the sim-realism plan ([sim_realism.md](sim_realism.md)): ball deceleration by speed and time since a kick, rolling-segment fits, robot speed, acceleration, braking and turn-rate percentiles per robot, and dropped detections, with spreads between matches, robots and teams | | `tools/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | ### Validation studies @@ -65,7 +82,6 @@ These check how far cheap metrics agree with round-robin results. They do not ju | Script | Purpose | |---|---| | `tools/convert_ssl_log.py` | Official RoboCup SSL game logs to replays in our format, so the analyses run on real matches: given logs, or `--corpus 2022-2026` to download and convert every published Division B match, deleting each raw log once converted (`--keep-raw` keeps it; downloads cut short are resumed; each conversion's memory is capped by `--max-memory-gb`). Also writes sidecars for measuring physics: the tracker's kicks and visibility, and with `--raw-vision` every raw camera detection; `--backfill-extras` adds them to matches already converted. What a converted match holds and its limits: [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md#real-matches) | -| `tools/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. See [sim_realism.md](sim_realism.md) | ## Debugging a match @@ -96,6 +112,21 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or Library helpers for the same job (`render_window`, `render_clip`, `MatchLog.trace()`) are described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). +## Simulator realism + +Is the simulator close to the real league, and are its physics settings measured? These tools judge +the simulator, not a strategy: none of them is part of strategy development. The plan and the +results are in [sim_realism.md](sim_realism.md). Their inputs are the official logs converted by +`tools/convert_ssl_log.py` (its kick and visibility sidecars, see [Real matches](#real-matches)) and +the field logs in `replays/field/`. + +| Script | Purpose | +|---|---| +| `tools/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. See [sim_realism.md](sim_realism.md) | +| `utama_core/analysis/physics_ranges.py` | `python -m utama_core.analysis.physics_ranges --real --sim `: physics parameter ranges for the sim-realism plan ([sim_realism.md](sim_realism.md)): ball deceleration by speed and time since a kick, rolling-segment fits, robot speed, acceleration, braking and turn-rate percentiles per robot, and dropped detections, with spreads between matches, robots and teams | +| `tools/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field_sessions.json` allows, and prints how well runs, days and radios agree. | +| `tools/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/convert_ssl_log.py` | + ## Architecture | Script | Purpose | @@ -112,7 +143,7 @@ described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). | Script | Purpose | |---|---| -| `main.py` | Watch one match in rsim with the referee and dashboard: `pixi run main [yellow] [blue]`, default `split_shape` vs `high_press` | +| `main.py` | Watch one match in rsim with the referee and dashboard: `pixi run main [yellow] [blue]`, default `split_shape` vs `high_press`. | | `examples/demo_custom_referee.py` | Every `CustomReferee` rule in a scripted scenario, in a pygame window; no simulator needed | | `examples/demo_referee_gui_rsim.py` | `CustomReferee` with the dashboard's referee tab, over rsim | | `examples/demo_referee_feedback_gui.py` | The referee UI's controller-feedback panel with fake feedback, no hardware | @@ -127,8 +158,6 @@ described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). | `examples/passing_rally.py` | `pass_receive.py`'s pair passing their way along the field in two lanes, turning round `TURN_M` from each end line, for ever (no shots) | | `tools/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | | `tools/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | -| `tools/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/convert_ssl_log.py` | -| `tools/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field_sessions.json` allows, and prints how well runs, days and radios agree. | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | | `examples/demo_dribbler_test.py` | One robot dribbling round a rectangle on the Exhibition Road field | diff --git a/main.py b/main.py index cdacbaaa..3154661e 100644 --- a/main.py +++ b/main.py @@ -4,6 +4,7 @@ Run: pixi run main # split_shape vs high_press pixi run main tiki_taka counter_flow # any two names from docs/strategies.md + pixi run main a.strategy high_press # or a .strategy file (tools/build_strategy.py) # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop Yellow (the first strategy) starts on the right and kicks off. For many matches with @@ -12,6 +13,7 @@ import argparse +from tools.sim_setup import N_ROBOTS, UnknownStrategy, load_side from utama_core.custom_referee import CustomReferee from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard @@ -19,17 +21,14 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner -from utama_core.strategy import kernel_strategy - -N_ROBOTS = 6 # per side: robot 0 keeps goal, robots 1-5 play outfield -OUTFIELD_ROBOT_IDS = tuple(range(1, N_ROBOTS)) def _strategy(name: str) -> AbstractStrategy: - build = getattr(kernel_strategy, f"build_{name}_kernel_strategy", None) - if build is None: - raise SystemExit(f"Unknown strategy {name!r}: see docs/strategies.md for the names") - return AbstractStrategy(build_kernel_strategy=build(OUTFIELD_ROBOT_IDS)) + """A strategy by name, a `.strategy` file or `PATH.py:FUNCTION`; otherwise exit with the names there are.""" + try: + return load_side(name) + except UnknownStrategy as e: + raise SystemExit(f"{e} (docs/strategies.md)") from None def main() -> None: @@ -37,6 +36,7 @@ def main() -> None: parser.add_argument("yellow", nargs="?", default="split_shape") parser.add_argument("blue", nargs="?", default="high_press") args = parser.parse_args() + yellow, blue = _strategy(args.yellow), _strategy(args.blue) # fail on a bad name before the dashboard starts profile = load_profile("simulation") referee = CustomReferee(profile, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) @@ -44,8 +44,8 @@ def main() -> None: referee_view.attach(server, referee, profile) runner = StrategyRunner( - strategy=_strategy(args.yellow), - opp_strategy=_strategy(args.blue), + strategy=yellow, + opp_strategy=blue, my_team_is_yellow=True, my_team_is_right=True, mode="rsim", diff --git a/tools/debug_match.py b/tools/debug_match.py index e7dcd2d4..9dc6c193 100644 --- a/tools/debug_match.py +++ b/tools/debug_match.py @@ -42,18 +42,10 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools.evaluation.match import ( - _CONFIG_NAMES, - N_OUTFIELD, - OUTFIELD_ROBOT_IDS, - TICKS_PER_SECOND, -) -from utama_core.custom_referee import CustomReferee -from utama_core.engine.abstract_strategy import AbstractStrategy +from tools.evaluation.match import TICKS_PER_SECOND +from tools.sim_setup import UnknownStrategy, load_side, sim_runner from utama_core.engine.match_log import load_jsonl -from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner -from utama_core.strategy import catalog class _TargetRecorder: @@ -114,8 +106,8 @@ def poses(robots): def main() -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("--strategy", required=True, choices=sorted(_CONFIG_NAMES)) - parser.add_argument("--opponent", required=True, choices=sorted(_CONFIG_NAMES)) + parser.add_argument("--strategy", required=True, help="a strategy name, a .strategy file or PATH.py:FUNCTION") + parser.add_argument("--opponent", required=True, help="the same kinds as --strategy") parser.add_argument("--duration", type=float, default=90.0, help="sim seconds (default 90)") parser.add_argument("--stop-on-goal", action="store_true", help="end the match as soon as either side scores") parser.add_argument( @@ -146,25 +138,14 @@ def main() -> None: ) args = parser.parse_args() - strategy_a = AbstractStrategy(build=catalog.builder(args.strategy, OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build=catalog.builder(args.opponent, OUTFIELD_ROBOT_IDS)) - - referee = CustomReferee.from_profile_name( - "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 - ) + try: + strategy_a, strategy_b = load_side(args.strategy), load_side(args.opponent) + except UnknownStrategy as e: + parser.error(str(e)) - runner = StrategyRunner( - strategy=strategy_a, - opp_strategy=strategy_b, - my_team_is_yellow=True, - my_team_is_right=True, - mode="rsim", - exp_friendly=N_OUTFIELD + 1, - exp_enemy=N_OUTFIELD + 1, - exp_ball=True, - referee=referee, - enable_vision_stream=False, - referee_initial_command=RefereeCommand.PREPARE_KICKOFF_YELLOW, + runner, _ = sim_runner( + strategy_a, + strategy_b, match_log_path=args.match_log, stats_path=args.stats_path, control_scheme=args.control_scheme, diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index f53d25fc..f1d57731 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -47,6 +47,11 @@ (correlation ~0.9): one goal better found every time in ~3 rounds, half a goal better 55%. Strengths printed at the end come from the ratings over all matches (`analysis/ratings.py`). +Stalls (the stall watchdog's `StallEvent`s, see `engine/match_stats.py`) are reported for +post-analysis only: each candidate's and the champion's stalls, and how many of their matches +were checked (the watchdog covers config_a only; ledger lines from before stalls were recorded +count as unchecked). They never change a verdict or stop a run. + A fixture already in the ledger is never played again, so the champion's matches are played once per seed and reused by every candidate. Replays are not kept: a match is a pure function of its fixture, so `round_robin.py --pair A B --sim-noise reference:` plays it again. @@ -136,10 +141,51 @@ def play(a: str, b: str, seed: int, noise: dict, run_dir: Path, keep: bool = Fal "config_b": result.config_b, "score_a": result.score_a, "score_b": result.score_b, - "stats": {"shots": (result.stats or {}).get("shots")}, + "stats": { + "shots": (result.stats or {}).get("shots"), + # config_a's stall watchdog; None when the match's stats were not collected + "stall_events": eval_ledger.stall_summary( + (result.stats or {}).get("stall_events") if result.stats is not None else None + ), + }, } +def stall_coverage(ledger: dict, fps: dict, side: str) -> dict: + """Stalls `side` was checked for over the ledger's matches at current code: the watchdog only + watches config_a, so a match counts as checked when `side` was config_a and its ledger line + has a stall record (None, an older line, is unknown). `total` counts every match of `side`.""" + checked, total, stalls = 0, 0, [] + for e in ledger.values(): + if side not in (e["a"], e["b"]): + continue + if e["a_fp"] != fps.get(e["a"]) or e["b_fp"] != fps.get(e["b"]): + continue + total += 1 + if e["a"] != side or e.get("stalls") is None: + continue + checked += 1 + stalls += [{"a": e["a"], "b": e["b"], "seed": e["seed"], **s} for s in e["stalls"]] + return {"checked": checked, "total": total, "stalls": stalls} + + +def stall_lines(cov: dict, name: str) -> list[str]: + """The printed stall report for one side's `stall_coverage`.""" + head = f"stalls checked in {cov['checked']} of {cov['total']} {name} matches (watchdog covers config_a only): " + if not cov["checked"]: + return [head + "unknown"] + if not cov["stalls"]: + return [head + "none"] + lines = [head + str(len(cov["stalls"]))] + for s in cov["stalls"]: + diagnosis = f" -- {s['diagnosis']}" if s.get("diagnosis") else "" + lines.append( + f" {_short_name(s['a'])} vs {_short_name(s['b'])} seed {s['seed']}: " + f"{s['kind']} at t={s['sim_time']:.1f}s{diagnosis}" + ) + return lines + + def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("candidates", nargs="+") @@ -240,14 +286,23 @@ def fixture_id(f: tuple[str, str, int]) -> str: f"margin {r['margin']:+.2f} ± {r['margin_sd']:.2f} goals/match after {r['rounds']} round(s)" ) r["per_opponent"] = _per_opponent(_up_to_round(ledger, r["rounds"]), fps, c, champion, opponents) + r["stalls"] = stall_coverage(_up_to_round(ledger, r["rounds"]), fps, c) print(f" {'opponent':<26} {'candidate GD':>12} {'champion GD':>12} {'matches':>8} (same seed and colour)") for o, row in r["per_opponent"].items(): name = o if o == "head-to-head" else _short_name(o) print(f" {name:<26} {row['candidate']:>+12} {row['champion']:>+12} {row['matches']:>8}") + for line in stall_lines(r["stalls"], "candidate"): + print(f" {line}") if r["verdict"] == "better" and not args.held_out and not args.frozen: print( f" -> next: evaluate.py {_short_name(c)} --held-out, then set it as champion in reference/opponents.json" ) + champion_stalls = None + if candidates: + rounds = max(report[c]["rounds"] for c in candidates) + champion_stalls = stall_coverage(_up_to_round(ledger, rounds), fps, champion) + for line in stall_lines(champion_stalls, "champion"): + print(line) print("\nStrengths (goals per match, ± SD):") for n in sorted(final.names, key=lambda n: -final.strength(n)[0]): m, sd = final.strength(n) @@ -266,6 +321,7 @@ def fixture_id(f: tuple[str, str, int]) -> str: "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": args.max_rounds}, "candidates": report, + "champion_stalls": champion_stalls, "strengths": {n: final.strength(n) for n in final.names}, "noise_sd": final.noise_sd, }, diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index 5cd98d0a..af09a1ff 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -11,6 +11,11 @@ Configs are short names (`tiki_taka`); none means every config not in RETIRED. Flags: --pair A B one match, A as config_a + --vs-champion the day-to-day health check: one match per active strategy against the + champion (reference/opponents.json), plus champion vs the first opponent; + --sim-noise defaults to reference:2: evaluate.py's round 2 puts the side + under test second, so (strategy, champion) are its champion-row fixtures + and land in the ledger. Not with --pair --reuse take unchanged matches from replays/match_cache/; check the "N reused ... M to play" line it prints before waiting on M --spot-check F with --reuse, replay this fraction of reused matches to verify @@ -108,7 +113,7 @@ _stats_to_dict, ) from tools.evaluation.match import run_match as _lib_run_match -from tools.evaluation.sim_settings import sim_noise_from_spec +from tools.evaluation.sim_settings import load_opponents, sim_noise_from_spec from utama_core.analysis import ratings, restart_outcomes, turnover_breakdown from utama_core.analysis.strategy_table import strategy_table from utama_core.bundle.strategy_file import SUFFIX @@ -173,6 +178,18 @@ def run_match( ) +def vs_champion_pairs(config_names: list[str], champion: str, first_opponent: str) -> list[tuple[str, str]]: + """`--vs-champion` fixtures: each other config as config_a against the champion as config_b, + then the champion as config_a against `first_opponent`. evaluate.py puts the side under test + second in even rounds, so with the default seed 2 each (strategy, champion) is its champion-row + fixture for a reference opponent; (champion, first_opponent) at seed 2 is not one of them.""" + if champion not in config_names: + raise ValueError(f"--vs-champion needs the champion {champion!r} among the configs") + if first_opponent not in config_names or first_opponent == champion: + raise ValueError(f"--vs-champion needs the first opponent {first_opponent!r} among the configs") + return [(name, champion) for name in sorted(config_names) if name != champion] + [(champion, first_opponent)] + + def main() -> None: # Optional CLI args: config names (with or without the `build_`/ # `_kernel_strategy` wrapping) to run instead of the full auto-discovered @@ -244,6 +261,12 @@ def main() -> None: args = [a for a in args if a not in ("--verbose", "-v")] both_sides = "--both-sides" in args args = [a for a in args if a != "--both-sides"] + # `--vs-champion`: the day-to-day health check (see the module docstring), one match per + # active strategy against the champion instead of every pair. + vs_champion = "--vs-champion" in args + args = [a for a in args if a != "--vs-champion"] + if vs_champion and "--pair" in args: + raise SystemExit("--vs-champion and --pair don't combine: --pair plays one named fixture") max_workers_override: int | None = None if "--max-workers" in args: idx = args.index("--max-workers") @@ -327,6 +350,11 @@ def main() -> None: idx = args.index("--sim-noise") sim_noise = sim_noise_from_spec(args[idx + 1]) args = args[:idx] + args[idx + 2 :] + elif vs_champion: + # evaluate.py's round-2 champion fixtures (see vs_champion_pairs), so these matches are in the ledger (`_append_to_ledger` + # keeps only seeded, unfuzzed matches for the ratings) and count toward the champion's rating. + sim_noise = sim_noise_from_spec("reference:2") + print("--vs-champion: --sim-noise not given, using reference:2 (evaluate.py's round-2 champion fixtures)") sim_noise_dict = sim_noise.to_dict() if sim_noise is not None else None match_seconds = MAX_MATCH_SECONDS @@ -357,7 +385,18 @@ def main() -> None: else: config_names = [name for name in _CONFIG_NAMES if name not in RETIRED] - base_pairs = list(itertools.combinations(sorted(config_names), 2)) + if vs_champion: + reference = load_opponents() + champion, first_opponent = ( + _resolve_config_names([reference["champion"]])[0], + _resolve_config_names([reference["opponents"][0]])[0], + ) + try: + base_pairs = vs_champion_pairs(config_names, champion, first_opponent) + except ValueError as e: + raise SystemExit(str(e)) + else: + base_pairs = list(itertools.combinations(sorted(config_names), 2)) # --both-sides plays (a, b) and (b, a) as distinct fixtures — see the # module docstring for why this is a real second data point (side- # dependent geometry) rather than a duplicate, unlike naively re-running diff --git a/tools/moments.py b/tools/moments.py index 60cc6e11..6787bcfb 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -65,7 +65,6 @@ os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") # before any import: hides pygame's banner import argparse import dataclasses -import importlib.util import json import math import os @@ -75,7 +74,6 @@ import sys import tempfile from collections import Counter -from functools import partial from pathlib import Path from typing import Callable, Optional @@ -83,6 +81,7 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) +from tools import sim_setup # noqa: E402 from tools.evaluation.match import ( # noqa: E402 N_OUTFIELD, OUTFIELD_ROBOT_IDS, @@ -95,7 +94,7 @@ _referee_command_at, scenario_from_replay, ) -from utama_core.strategy.catalog import plain_name +from utama_core.strategy.catalog import plain_name # noqa: E402 MOMENTS_DIR = REPO_ROOT / "utama_core" / "tests" / "moments" DEFAULT_OPPONENT = "split_shape" @@ -150,7 +149,7 @@ def _full_name(name: str) -> str: def _is_file_spec(name: str) -> bool: """`PATH.py:FACTORY`: a factory in a scratch file, not a catalog name.""" - return name.rpartition(":")[0].endswith(".py") + return sim_setup.is_file_spec(name) def to_dict(m: Moment) -> dict: @@ -575,25 +574,11 @@ def events(ticks: list[Tick], we_are_yellow: bool = True) -> list[str]: def factory_for(name: str) -> Callable: - """`f(outfield_robot_ids)` -> `AbstractStrategy`'s first argument, for a catalog strategy or for - `PATH.py:FUNCTION`, a `build(outfield_robot_ids, motion_controller)` in a scratch file imported as - it is (so a tactic can be tried without a repo change).""" - from utama_core.strategy import catalog - - if not _is_file_spec(name): - if plain_name(name) not in catalog.names(): - raise MomentError(f"unknown strategy {short_name(name)!r}") - return partial(catalog.builder, name) - path, _, func = name.rpartition(":") - if not Path(path).is_file(): - raise MomentError(f"{name}: no such file {path}") - spec = importlib.util.spec_from_file_location(f"scratch_{Path(path).stem}", path) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - factory = getattr(module, func, None) - if not callable(factory): - raise MomentError(f"{name}: {path} has no factory {func!r}") - return lambda outfield_robot_ids: partial(factory, outfield_robot_ids) + """`sim_setup.factory_for`, its errors as `MomentError`.""" + try: + return sim_setup.factory_for(name) + except sim_setup.UnknownStrategy as e: + raise MomentError(str(e)) from None def label(name: str) -> str: @@ -606,30 +591,20 @@ def label(name: str) -> str: def play(m: Moment, strategy: str) -> list[Tick]: """Play `m` with `strategy` on our side (yellow) for `m.seconds`.""" - from utama_core.custom_referee import CustomReferee - from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.replay.scenario import apply_scenario from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise - from utama_core.run import StrategyRunner - def side(name: str) -> AbstractStrategy: - return AbstractStrategy(build=factory_for(name)(OUTFIELD_ROBOT_IDS)) + def side(name: str): + try: + return sim_setup.load_side(name) + except sim_setup.UnknownStrategy as e: + raise MomentError(str(e)) from None - referee = CustomReferee.from_profile_name( - "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 - ) - runner = StrategyRunner( - strategy=side(strategy), - opp_strategy=side(m.opponent), - my_team_is_yellow=True, - my_team_is_right=True, - mode="rsim", - exp_friendly=N_OUTFIELD + 1, - exp_enemy=N_OUTFIELD + 1, - exp_ball=True, - referee=referee, - enable_vision_stream=False, + runner, referee = sim_setup.sim_runner( + side(strategy), + side(m.opponent), sim_noise=SimNoise.from_dict(m.sim_noise) if m.sim_noise else None, + initial_command=None, ) ticks = [] try: diff --git a/tools/repro_from_replay.py b/tools/repro_from_replay.py index 3febb847..b2d03e0c 100644 --- a/tools/repro_from_replay.py +++ b/tools/repro_from_replay.py @@ -92,14 +92,13 @@ class name (e.g. "DecoyOverloadTactic"), on a release why, else null. Written wh sys.path.insert(0, str(REPO_ROOT)) from tools.evaluation.match import N_OUTFIELD, OUTFIELD_ROBOT_IDS, TICKS_PER_SECOND -from utama_core.custom_referee import CustomReferee -from utama_core.engine.abstract_strategy import AbstractStrategy +from tools.sim_setup import load_side, sim_runner +from utama_core.bundle.strategy_file import SUFFIX from utama_core.engine.match_log import load_jsonl from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.columnar_reader import load_sim_noise from utama_core.replay.scenario import Scenario, apply_scenario, scenario_from_replay from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise -from utama_core.run import StrategyRunner from utama_core.strategy import catalog _STILL_STALLED_WINDOW_S = 10.0 @@ -114,6 +113,8 @@ def _resolve_config_name(explicit: Optional[str], from_scenario: Optional[str], f"given and the replay's directory has no summary.json (or no matching entry) to derive it from. " f"Pass --strategy/--opponent explicitly." ) + if name.endswith(SUFFIX): + return name name = catalog.plain_name(name) if name not in catalog.names(): raise SystemExit( @@ -283,28 +284,12 @@ def main() -> None: strategy_a_name = _resolve_config_name(args.strategy, scenario.config_a_name, "friendly") strategy_b_name = _resolve_config_name(args.opponent, scenario.config_b_name, "enemy") - strategy_a = AbstractStrategy(build=catalog.builder(strategy_a_name, OUTFIELD_ROBOT_IDS)) - strategy_b = AbstractStrategy(build=catalog.builder(strategy_b_name, OUTFIELD_ROBOT_IDS)) - - referee = CustomReferee.from_profile_name( - "simulation", n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1 - ) - - runner = StrategyRunner( - strategy=strategy_a, - opp_strategy=strategy_b, - my_team_is_yellow=True, - my_team_is_right=True, - mode="rsim", - exp_friendly=N_OUTFIELD + 1, - exp_enemy=N_OUTFIELD + 1, - exp_ball=True, - referee=referee, - enable_vision_stream=False, - referee_initial_command=RefereeCommand.PREPARE_KICKOFF_YELLOW, + runner, referee = sim_runner( + load_side(strategy_a_name), + load_side(strategy_b_name), + sim_noise=sim_noise, control_scheme=args.control_scheme, match_log_path=args.trace_out, - sim_noise=sim_noise, ) print(noise_line) diff --git a/tools/sim_setup.py b/tools/sim_setup.py new file mode 100644 index 00000000..ac7f30f1 --- /dev/null +++ b/tools/sim_setup.py @@ -0,0 +1,99 @@ +"""One way to load a strategy and set up a simulated match, for the tools that play from a position or +for a while (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`). + +- `load_side(name)`: a strategy by catalog name, a `.strategy` file by path, or `PATH.py:FUNCTION` (a + `build(outfield_robot_ids, motion_controller)` in a scratch file, to try a tactic without a repo change). +- `sim_runner(strategy, opponent, ...)`: the referee and the `StrategyRunner` for a 6-a-side rsim match, + our side yellow on the right, vision stream off. + +`tools/evaluation/match.py` still builds its own runner: it is part of every cached match's fingerprint +(`utama_core/replay/fingerprint.py`), so changing it replays every cached match and starts the +evaluation ledger afresh. Move it onto these helpers together with the next change that forces that anyway. +""" + +from __future__ import annotations + +import importlib.util +from functools import partial +from pathlib import Path +from typing import Callable, Optional + +from tools.evaluation.match import N_OUTFIELD, OUTFIELD_ROBOT_IDS +from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy +from utama_core.custom_referee import CustomReferee +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.run import StrategyRunner +from utama_core.strategy import catalog + +N_ROBOTS = N_OUTFIELD + 1 # per side, the goalkeeper included + + +class UnknownStrategy(ValueError): + """A strategy name that is neither in the catalog, a `.strategy` file nor `PATH.py:FUNCTION`.""" + + +def is_file_spec(name: str) -> bool: + """`PATH.py:FUNCTION`, a factory in a scratch file.""" + path, sep, func = name.rpartition(":") + return bool(sep) and path.endswith(".py") and bool(func) + + +def factory_for(name: str) -> Callable: + """`f(outfield_robot_ids)` -> `AbstractStrategy`'s `build`, for a catalog strategy or `PATH.py:FUNCTION` + (imported as it is).""" + if not is_file_spec(name): + if catalog.plain_name(name) not in catalog.names(): + raise UnknownStrategy(f"unknown strategy {name!r}; strategies: {', '.join(catalog.names())}") + return partial(catalog.builder, catalog.plain_name(name)) + path, _, func = name.rpartition(":") + if not Path(path).is_file(): + raise UnknownStrategy(f"{name}: no such file {path}") + spec = importlib.util.spec_from_file_location(f"scratch_{Path(path).stem}", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + factory = getattr(module, func, None) + if not callable(factory): + raise UnknownStrategy(f"{name}: {path} has no factory {func!r}") + return lambda outfield_robot_ids: partial(factory, outfield_robot_ids) + + +def load_side(name: str, outfield_robot_ids: tuple[int, ...] = OUTFIELD_ROBOT_IDS) -> AbstractStrategy: + """A strategy to play: a `.strategy` file by path, `PATH.py:FUNCTION`, or a catalog name.""" + if name.endswith(SUFFIX): + if not Path(name).is_file(): + raise UnknownStrategy(f"{name}: no such strategy file") + return BundledStrategy(name, outfield_robot_ids) + return AbstractStrategy(build=factory_for(name)(outfield_robot_ids)) + + +def sim_runner( + strategy: AbstractStrategy, + opponent: AbstractStrategy, + *, + sim_noise: Optional[SimNoise] = None, + initial_command: Optional[RefereeCommand] = RefereeCommand.PREPARE_KICKOFF_YELLOW, + **runner_kwargs, +) -> tuple[StrategyRunner, CustomReferee]: + """The referee ("simulation" profile) and a `StrategyRunner` for `strategy` (yellow, on the right) + against `opponent` in rsim. `initial_command=None` keeps the runner's own default. Other keyword + arguments go to `StrategyRunner` (`match_log_path`, `stats_path`, `control_scheme`, ...).""" + referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) + if initial_command is not None: + runner_kwargs["referee_initial_command"] = initial_command + runner = StrategyRunner( + strategy=strategy, + opp_strategy=opponent, + my_team_is_yellow=True, + my_team_is_right=True, + mode="rsim", + exp_friendly=N_ROBOTS, + exp_enemy=N_ROBOTS, + exp_ball=True, + referee=referee, + enable_vision_stream=False, + sim_noise=sim_noise, + **runner_kwargs, + ) + return runner, referee diff --git a/utama_core/replay/eval_ledger.py b/utama_core/replay/eval_ledger.py index b27a1207..4fb1d70c 100644 --- a/utama_core/replay/eval_ledger.py +++ b/utama_core/replay/eval_ledger.py @@ -2,7 +2,7 @@ `tools/evaluation/evaluate.py` and `round_robin.py` append one JSON line per match they play: the environment it ran in, both sides with the fingerprint of their code, the noise seed, the -score and the shots. A rating fit reads back the matches of one environment, so each result +score, the shots and the stall events. A rating fit reads back the matches of one environment, so each result counts in every later evaluation until the code that played it changes. - **Environment** (`environment`): the shared code and machine (`fingerprint.base_fingerprint` @@ -55,11 +55,28 @@ def fixture_id(env: str, a_fp: str, b_fp: str, seed: Optional[int]) -> str: return _digest([env, a_fp, b_fp, json.dumps(seed)])[:16] +def stall_summary(events: Optional[Iterable[dict]]) -> Optional[list[dict]]: + """A match's stall events as ledger rows (kind, sim time, and the diagnosis if there is one), + or None when the match's stats were not collected: unknown, which is not "no stalls". + The watchdog only watches config_a, so these are config_a's stalls.""" + if events is None: + return None + rows = [] + for e in events: + row = {"kind": e["kind"], "sim_time": e["sim_time"]} + if e.get("diagnosis"): + row["diagnosis"] = e["diagnosis"] + rows.append(row) + return rows + + def entry(env: str, graph: CodeGraph, result: dict, seed: Optional[int], source: str) -> dict: - """A ledger line for `result` (a `match.MatchResult` as a dict, with its stats).""" + """A ledger line for `result` (a `match.MatchResult` as a dict, with its stats). `stalls` is + config_a's stall events, or None when the match's stats do not say.""" a, b = result["config_a"], result["config_b"] a_fp, b_fp = graph.strategy_fingerprint(a)[:16], graph.strategy_fingerprint(b)[:16] - shots = (result.get("stats") or {}).get("shots") or {} + stats = result.get("stats") or {} + shots = stats.get("shots") or {} return { "fixture": fixture_id(env, a_fp, b_fp, seed), "env": env, @@ -72,6 +89,7 @@ def entry(env: str, graph: CodeGraph, result: dict, seed: Optional[int], source: "score_b": result["score_b"], "shots_a": shots.get("friendly"), "shots_b": shots.get("enemy"), + "stalls": stall_summary(stats.get("stall_events") if stats else None), "source": source, } @@ -100,6 +118,7 @@ def load(env: str, path: Path = LEDGER_PATH, fps: Optional[dict[str, str]] = Non except json.JSONDecodeError: continue # a torn last line from a crash if e.get("env") == env: + e.setdefault("stalls", None) # lines written before stalls were recorded: unknown e["a"], e["b"] = names.get(e["a_fp"], e["a"]), names.get(e["b_fp"], e["b"]) out[e["fixture"]] = e return out diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 6d02e127..aa0a6506 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -1,3 +1,5 @@ +import json + import pytest from tools.evaluation import evaluate @@ -131,3 +133,107 @@ def test_sim_noise_spec_forms(): assert sim_noise_from_spec("reference").seed == 0 assert sim_noise_from_spec("reference:7").seed == 7 assert sim_noise_from_spec('{"seed": 2, "kick_speed_sd": 0.3}').kick_speed_sd == 0.3 + + +class _Graph: + """Stands in for CodeGraph: entry() only asks for a strategy's fingerprint.""" + + def strategy_fingerprint(self, name): + return "fp-" + name + + +_FROZEN_EVENT = { + "kind": "COMMITTED_FROZEN", + "sim_time": 12.5, + "tick": 1250, + "referee_command": "NORMAL_START", + "duration_s": 9.0, + "tactic_ids": ["t1"], + "robot_ids": [1, 2], + "diagnosis": "ball held by enemy 3", +} + + +def _result(a, b, stats): + return {"config_a": a, "config_b": b, "score_a": 1, "score_b": 0, "stats": stats} + + +def test_entry_stores_the_stall_events_compactly(): + row = eval_ledger.entry("e", _Graph(), _result("c", "o", {"shots": {}, "stall_events": [_FROZEN_EVENT]}), 1, "run") + assert row["stalls"] == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5, "diagnosis": "ball held by enemy 3"}] + + +def test_entry_stores_an_empty_list_when_the_stats_show_no_stall(): + row = eval_ledger.entry("e", _Graph(), _result("c", "o", {"stall_events": []}), 1, "run") + assert row["stalls"] == [] + + +def test_entry_stores_none_when_stall_events_are_unknown(): + """No stats at all, or stats without the stall field: unknown, not 'no stalls'.""" + assert eval_ledger.entry("e", _Graph(), _result("c", "o", None), 1, "run")["stalls"] is None + assert eval_ledger.entry("e", _Graph(), _result("c", "o", {"shots": {}}), 1, "run")["stalls"] is None + + +def test_stall_summary_drops_the_detail_a_ledger_line_does_not_need(): + rows = eval_ledger.stall_summary([{**_FROZEN_EVENT, "diagnosis": ""}]) + assert rows == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5}] + assert json.loads(json.dumps(rows)) == rows + + +def test_an_old_ledger_line_without_stalls_reads_as_unknown(tmp_path): + path = tmp_path / "ledger.jsonl" + path.write_text(json.dumps({"env": "e", "fixture": "f", "a": "c", "a_fp": "1", "b": "o", "b_fp": "2"}) + "\n") + assert eval_ledger.load("e", path)["f"]["stalls"] is None + + +FPS = {"c": "fc", "o": "fo", "ch": "fch"} + + +def _ledger_row(a, b, stalls, fixture, seed=1, a_fp=None): + return { + "fixture": fixture, + "a": a, + "b": b, + "a_fp": a_fp or FPS[a], + "b_fp": FPS[b], + "seed": seed, + "stalls": stalls, + } + + +def test_stall_coverage_counts_only_matches_where_the_candidate_was_config_a(): + ledger = { + "1": _ledger_row("c", "o", [], "1"), # checked, no stalls + "2": _ledger_row("o", "c", None, "2"), # candidate as config_b: unchecked + "3": _ledger_row("c", "o", None, "3", seed=2), # reused old line: unknown, unchecked + "4": _ledger_row("o", "c", [{"kind": "RESTART_STALL", "sim_time": 5.0}], "4", seed=2), + } + cov = evaluate.stall_coverage(ledger, FPS, "c") + assert (cov["checked"], cov["total"]) == (1, 4) + assert cov["stalls"] == [] + + +def test_stall_coverage_lists_each_stall_with_its_match_seed_kind_and_time(): + ledger = { + "1": _ledger_row("c", "o", [{"kind": "RESTART_STALL", "sim_time": 5.0, "diagnosis": "ball in goal"}], "1") + } + cov = evaluate.stall_coverage(ledger, FPS, "c") + assert cov["checked"] == 1 and cov["total"] == 1 + assert cov["stalls"] == [ + {"a": "c", "b": "o", "seed": 1, "kind": "RESTART_STALL", "sim_time": 5.0, "diagnosis": "ball in goal"} + ] + + +def test_stall_coverage_ignores_matches_at_other_code_and_other_players(): + ledger = { + "1": _ledger_row("c", "o", [], "1", a_fp="old"), # the candidate's code has changed since + "2": _ledger_row("ch", "o", [], "2", a_fp="fch"), # the champion's match, not the candidate's + } + assert evaluate.stall_coverage(ledger, FPS, "c") == {"checked": 0, "total": 0, "stalls": []} + + +def test_stall_lines_say_none_only_when_checked_and_unknown_when_not(): + assert evaluate.stall_lines({"checked": 3, "total": 7, "stalls": []}, "candidate") == [ + "stalls checked in 3 of 7 candidate matches (watchdog covers config_a only): none" + ] + assert evaluate.stall_lines({"checked": 0, "total": 7, "stalls": []}, "candidate")[0].endswith(": unknown") diff --git a/utama_core/tests/engine/test_tournament_vs_champion.py b/utama_core/tests/engine/test_tournament_vs_champion.py new file mode 100644 index 00000000..7f3bceb4 --- /dev/null +++ b/utama_core/tests/engine/test_tournament_vs_champion.py @@ -0,0 +1,110 @@ +"""Tests for `round_robin.py --vs-champion`: the day-to-day health check, one match per active +strategy against the champion (see `docs/STRATEGY_DEVELOPMENT.md`). Pure, no sim: `run_match` is +stubbed and the catalog, retired set and opponents file are faked. +""" + +from __future__ import annotations + +import pytest + +from tools.evaluation import round_robin as tournament +from tools.evaluation.sim_settings import sim_noise_from_spec + + +def _stub_result(config_a_name, config_b_name, **_kwargs): + return tournament.MatchResult(config_a=config_a_name, config_b=config_b_name, score_a=1, score_b=0, stats=None) + + +def test_vs_champion_pairs_is_every_other_config_against_the_champion_then_champion_vs_first_opponent(): + names = ["b", "champ", "a", "d"] + + assert tournament.vs_champion_pairs(names, "champ", "a") == [ + ("a", "champ"), + ("b", "champ"), + ("d", "champ"), + ("champ", "a"), + ] + + +def test_vs_champion_pairs_plays_the_champion_only_as_config_b_except_its_own_match(): + pairs = tournament.vs_champion_pairs(["a", "b", "champ"], "champ", "b") + + assert [a for a, b in pairs if a == "champ"] == ["champ"] + assert all(b == "champ" for a, b in pairs if a != "champ") + + +def test_vs_champion_pairs_refuses_a_missing_champion_or_first_opponent(): + with pytest.raises(ValueError, match="champion"): + tournament.vs_champion_pairs(["a", "b"], "champ", "a") + with pytest.raises(ValueError, match="first opponent"): + tournament.vs_champion_pairs(["a", "champ"], "champ", "b") + + +def test_vs_champion_plays_active_strategies_against_champion_with_reference_seed_one(tmp_path, monkeypatch, capsys): + calls, ledger_calls = [], [] + + def _fake_run_match(config_a_name, config_b_name, **kwargs): + calls.append((config_a_name, config_b_name, kwargs.get("sim_noise"))) + return _stub_result(config_a_name, config_b_name) + + def _fake_append(results, run_id, match_seconds, control_scheme, fuzz_seed, sim_noise_dict): + ledger_calls.append((fuzz_seed, sim_noise_dict)) + + monkeypatch.setattr(tournament, "run_match", _fake_run_match) + monkeypatch.setattr(tournament, "_append_to_ledger", _fake_append) + monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) + monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "b", "c", "champ"]) + monkeypatch.setattr(tournament, "RETIRED", {"c"}) + monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a", "b"]}) + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--vs-champion"]) + + tournament.main() + + seeded = sim_noise_from_spec("reference:2") + assert calls == [("a", "champ", seeded), ("b", "champ", seeded), ("champ", "a", seeded)] + assert "reference:2" in capsys.readouterr().out + # Same conditions as evaluate.py's round-2 champion fixtures, so `_append_to_ledger` keeps these matches. + ((fuzz_seed, sim_noise_dict),) = ledger_calls + assert fuzz_seed is None + assert sim_noise_dict["seed"] == 2 + # Output still lands in replays/tournament_, which downstream tools read. + assert list(tmp_path.glob("tournament_*/summary.json")) + + +def test_noise_is_not_defaulted_outside_vs_champion_and_an_explicit_spec_wins(tmp_path, monkeypatch): + calls = [] + + def _fake_run_match(config_a_name, config_b_name, **kwargs): + calls.append(kwargs.get("sim_noise")) + return _stub_result(config_a_name, config_b_name) + + monkeypatch.setattr(tournament, "run_match", _fake_run_match) + monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) + monkeypatch.setattr(tournament, "_append_to_ledger", lambda *_a, **_k: None) + monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "champ"]) + monkeypatch.setattr(tournament, "RETIRED", set()) + monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a"]}) + + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "champ"]) + tournament.main() + assert calls == [None] + + calls.clear() + monkeypatch.setattr( + "sys.argv", + ["round_robin.py", "--sequential", "--vs-champion", "--sim-noise", "reference:7"], + ) + tournament.main() + assert calls == [sim_noise_from_spec("reference:7"), sim_noise_from_spec("reference:7")] + + +def test_vs_champion_with_pair_is_an_error_and_plays_nothing(tmp_path, monkeypatch): + def _no_match(*_args, **_kwargs): + raise AssertionError("--vs-champion with --pair must not play a match") + + monkeypatch.setattr(tournament, "run_match", _no_match) + monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--vs-champion", "--pair", "a", "b"]) + + with pytest.raises(SystemExit, match="--vs-champion and --pair"): + tournament.main() diff --git a/utama_core/tests/test_main_entry.py b/utama_core/tests/test_main_entry.py new file mode 100644 index 00000000..4e155413 --- /dev/null +++ b/utama_core/tests/test_main_entry.py @@ -0,0 +1,20 @@ +"""main.py resolves strategy names through the catalog; a bad name must fail with the valid ones listed.""" + +import pytest + +import main +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.strategy import catalog + + +def test_known_strategy_name_builds_an_abstract_strategy(): + assert isinstance(main._strategy("split_shape"), AbstractStrategy) + + +def test_unknown_strategy_name_exits_listing_catalog_names(): + with pytest.raises(SystemExit) as excinfo: + main._strategy("no_such_strategy") + message = str(excinfo.value) + assert "no_such_strategy" in message + assert "split_shape" in message + assert all(name in message for name in catalog.names()) diff --git a/utama_core/tests/tools/test_sim_setup.py b/utama_core/tests/tools/test_sim_setup.py new file mode 100644 index 00000000..3110a8ae --- /dev/null +++ b/utama_core/tests/tools/test_sim_setup.py @@ -0,0 +1,63 @@ +"""`tools/sim_setup.py`: which names load which strategy, and the runner it sets up.""" + +import pytest + +from tools import sim_setup +from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.entities.referee.referee_command import RefereeCommand + + +@pytest.mark.parametrize( + "name, expected", + [ + ("scratch/try.py:build_x", True), + ("/abs/path/try.py:build", True), + ("split_shape", False), + ("try.py:", False), # no factory named + ("try.txt:build", False), + ("a.strategy", False), + ], +) +def test_is_file_spec_needs_a_py_path_and_a_factory(name, expected): + assert sim_setup.is_file_spec(name) is expected + + +def test_a_catalog_name_loads_an_abstract_strategy(): + assert isinstance(sim_setup.load_side("split_shape"), AbstractStrategy) + + +def test_an_unknown_name_lists_the_catalog(): + with pytest.raises(sim_setup.UnknownStrategy, match="unknown strategy 'nope'; strategies: .*split_shape"): + sim_setup.load_side("nope") + + +def test_a_missing_strategy_file_is_named_not_treated_as_a_catalog_name(tmp_path): + with pytest.raises(sim_setup.UnknownStrategy, match="no such strategy file"): + sim_setup.load_side(str(tmp_path / "gone.strategy")) + + +def test_a_scratch_factory_gets_the_outfield_ids_first(tmp_path): + scratch = tmp_path / "try.py" + scratch.write_text("def build_x(ids, mc):\n return ids, mc\n") + assert sim_setup.factory_for(f"{scratch}:build_x")((1, 2))("mc") == ((1, 2), "mc") + + +def test_a_scratch_file_without_the_factory_is_named(tmp_path): + scratch = tmp_path / "try.py" + scratch.write_text("x = 1\n") + with pytest.raises(sim_setup.UnknownStrategy, match="has no factory 'build_x'"): + sim_setup.factory_for(f"{scratch}:build_x") + + +def test_sim_runner_plays_us_yellow_on_the_right_with_six_a_side(): + runner, referee = sim_setup.sim_runner( + sim_setup.load_side("split_shape"), + sim_setup.load_side("high_press"), + initial_command=RefereeCommand.STOP, + ) + try: + assert runner.my_team_is_yellow and runner.my_team_is_right + assert runner.exp_friendly == runner.exp_enemy == sim_setup.N_ROBOTS == 6 + assert runner.referee is referee + finally: + runner.close() From 5b623b0eaf11ef789f8790a582e572a065782e93 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Wed, 11 Nov 2026 00:34:18 +0000 Subject: [PATCH 09/59] strategy: skip short open-play passes, keep one attacker upfield in defence - Open-play passes go only to teammates at least 1.5 m away (MIN_OPEN_TEAMMATE_M, was 0.7): 28% of passes under 1.5 m were received against ~50% from 1.5-3.5 m; paired drills +1.7 +/- 0.6 points GD. GiveAndGoTactic uses the same constant. - Restarts keep the old 0.7 m minimum (RESTART_MIN_TEAMMATE_M): a free kick's receiver waits for a still ball, so short restart passes work. - split_shape, defending with four or more robots, keeps a second robot in attack holding space upfield (_defending_attack_count): +2.6 +/- 0.9 points scoring in paired drills, no more conceded, but +7.3 +/- 2.5 points more free kicks given away. Not yet judged by evaluate.py. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Fc3fwJXC1cohtBMpWGMjt3 --- utama_core/custom_referee/actions.py | 5 +++- utama_core/shared/pass_and_score_geometry.py | 16 ++++++++----- utama_core/strategy/split_shape.py | 11 ++++++++- utama_core/tactics/give_and_go.py | 4 ++-- .../tests/engine/test_give_and_go_tactic.py | 23 ++++++++++++++----- .../tests/strategy/test_split_shape_split.py | 20 ++++++++++++++++ 6 files changed, 63 insertions(+), 16 deletions(-) create mode 100644 utama_core/tests/strategy/test_split_shape_split.py diff --git a/utama_core/custom_referee/actions.py b/utama_core/custom_referee/actions.py index 9989c1c6..d9893f67 100644 --- a/utama_core/custom_referee/actions.py +++ b/utama_core/custom_referee/actions.py @@ -50,6 +50,9 @@ _WALL_FROM_BALL_M = BALL_KEEP_OUT_DISTANCE + 0.15 _STOP_FORMATION_SPEED_MPS = 1.2 # under RobotStopSpeedRule's limit +# A free kick's receiver stands waiting for a still ball: under 1 m it was received 53% of the time, +# as often as from 1.5 m to 2.5 m (2026-11-10), so restarts keep short passes that open play skips. +RESTART_MIN_TEAMMATE_M = 0.7 def _all_stop(blackboard) -> None: @@ -1073,7 +1076,7 @@ def _kick_target(self, game, kicker_id: int, ball_pos: Vector2D) -> tuple[Option Only the teammate is fixed: the heading follows it, once it is at any spot it was called to.""" target = self._target if target is None or target[0] != kicker_id or target[1].distance_to(ball_pos) > self._NEW_RESTART_M: - teammate = open_teammate(game, kicker_id, origin=ball_pos) + teammate = open_teammate(game, kicker_id, origin=ball_pos, min_distance=RESTART_MIN_TEAMMATE_M) spot = None if teammate is not None: point = game.friendly_robots[teammate].p diff --git a/utama_core/shared/pass_and_score_geometry.py b/utama_core/shared/pass_and_score_geometry.py index 56ac33b8..6ef0a309 100644 --- a/utama_core/shared/pass_and_score_geometry.py +++ b/utama_core/shared/pass_and_score_geometry.py @@ -805,7 +805,10 @@ def find_best_shot( # a robot touching the ball beside this one does not block a kick that leaves away from it. RELEASE_LANE_CLEARANCE = ROBOT_RADIUS + BALL_RADIUS + 0.05 _OWN_GOAL_RELEASE_MARGIN_M = 0.3 -_MIN_OPEN_TEAMMATE_M = 0.7 +# Nearer than this a full-power kick reaches the teammate before it can adjust: 28% of passes under +# 1.5 m were received against about 50% from 1.5 m to 3.5 m (3131 passes, 2026-11-10). Skipping them +# in paired drills: +1.7 +/- 0.6 points of goal difference and the ball 0.26 m further upfield. +MIN_OPEN_TEAMMATE_M = 1.5 # Further than this a full-power kick reached the teammate less than 45% of the time and left the # pitch more than 40%, against 52% and 30% from 1.5 m to 3.5 m (36 matches, 2026-11-09). MAX_OPEN_TEAMMATE_M = 3.5 @@ -829,7 +832,11 @@ def reaches_own_goal(game: Game, point: Vector2D, heading: float) -> bool: def open_teammate( - game: Game, robot_id: int, clearance: float = ROBOT_RADIUS + 0.15, origin: Optional[Vector2D] = None + game: Game, + robot_id: int, + clearance: float = ROBOT_RADIUS + 0.15, + origin: Optional[Vector2D] = None, + min_distance: float = MIN_OPEN_TEAMMATE_M, ) -> Optional[int]: """Id of the most advanced teammate in range of a kick down a clear lane, outside our own box. From `origin` for a robot not at the ball yet, otherwise from where the robot stands.""" @@ -838,10 +845,7 @@ def open_teammate( goal_x = enemy_goal_line(game)[0] best, best_to_goal = None, None for teammate_id, teammate in game.friendly_robots.items(): - if ( - teammate_id == robot_id - or not _MIN_OPEN_TEAMMATE_M <= position.distance_to(teammate.p) <= MAX_OPEN_TEAMMATE_M - ): + if teammate_id == robot_id or not min_distance <= position.distance_to(teammate.p) <= MAX_OPEN_TEAMMATE_M: continue if in_own_defense_area(game, teammate.p) or segment_blocked(position, teammate.p, enemies, clearance): continue diff --git a/utama_core/strategy/split_shape.py b/utama_core/strategy/split_shape.py index 1c198cd9..1ce25215 100644 --- a/utama_core/strategy/split_shape.py +++ b/utama_core/strategy/split_shape.py @@ -14,6 +14,15 @@ from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic +def _defending_attack_count(robots: int) -> int: + """Robots kept in "attack" while the enemy is nearer the ball: one goes to the ball and, from four + robots up, one more holds open space upfield. A ball won with nobody ahead of it led to a shot 3% + of the time, with four ahead 23% (2026-11-10 round-robin); in 684 paired 12 s drills from enemy + possession the second attacker scored +2.6 +/- 0.9 points more often, conceded no more (+0.3 +/- 0.7) + but gave away more free kicks (+7.3 +/- 2.5 points). Three robots keep all three back.""" + return robots // 2 if robots >= 4 else robots // 2 - 1 + + def _possession_split_picker( game: Game, free_robots: frozenset[RobotId], @@ -50,7 +59,7 @@ def _possession_split_picker( if "defense" not in available_tactic_ids: return {"attack": frozenset(ordered)} - attack_count = (len(ordered) + 1) // 2 + 1 if friendly_has_ball_edge else len(ordered) // 2 - 1 + attack_count = (len(ordered) + 1) // 2 + 1 if friendly_has_ball_edge else _defending_attack_count(len(ordered)) attack_count = max(0, min(len(ordered), attack_count)) partition = {} diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index d665b640..a06d2b8e 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -47,6 +47,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.shared.pass_and_score_geometry import ( + MIN_OPEN_TEAMMATE_M, ball_in_own_defense_area, ball_line_receive_point, carry_exhausted, @@ -157,7 +158,6 @@ def _best_receiver(game: Game, carrier_id: int, candidate_ids: tuple[int, ...]) return best_id -_MIN_SAFE_PASS_DISTANCE = 0.7 # metres — matches score_pass_setup's own min_pass_distance _SHOT_SWITCH_MARGIN = 0.15 # metres a new shot gap must beat the aimed-at one by; same as _pass_and_score's @@ -181,7 +181,7 @@ def _nearest_safe_receiver(game: Game, carrier_id: int, candidate_ids: tuple[int for candidate_id in candidate_ids: candidate_pos = game.friendly_robots[candidate_id].p dist = carrier_pos.distance_to(candidate_pos) - if dist < _MIN_SAFE_PASS_DISTANCE: + if dist < MIN_OPEN_TEAMMATE_M: continue if segment_blocked(carrier_pos, candidate_pos, enemies): continue diff --git a/utama_core/tests/engine/test_give_and_go_tactic.py b/utama_core/tests/engine/test_give_and_go_tactic.py index 0f426432..ad3d3fa8 100644 --- a/utama_core/tests/engine/test_give_and_go_tactic.py +++ b/utama_core/tests/engine/test_give_and_go_tactic.py @@ -36,7 +36,10 @@ from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import find_best_shot +from utama_core.shared.pass_and_score_geometry import ( + MIN_OPEN_TEAMMATE_M, + find_best_shot, +) from utama_core.tactics.give_and_go import ( _FIRST_TOUCH_FORCE_SHOT_TICKS, _MAX_FIRST_TOUCH_TICKS, @@ -44,6 +47,7 @@ _MAX_PASS_WAIT_TICKS, GiveAndGoMem, GiveAndGoTactic, + _nearest_safe_receiver, _relocate_target, ) @@ -209,7 +213,7 @@ def _fake_pass_exec(game, ctx, passer, receiver, kick_now=False): return {}, False, False monkeypatch.setattr("utama_core.tactics.give_and_go._pass_exec", _fake_pass_exec) - game = _make_game(carrier_pos=Vector2D(0.0, 0.0), teammate_pos=Vector2D(1.0, 1.0), enemy_pos=Vector2D(3.0, -2.5)) + game = _make_game(carrier_pos=Vector2D(0.0, 0.0), teammate_pos=Vector2D(1.5, 1.5), enemy_pos=Vector2D(3.0, -2.5)) ctx = TickContext(motion_controller=_PerRobotMotionController(), match_log=None) tactic = GiveAndGoTactic() mem = tactic.initial_mem() @@ -277,11 +281,11 @@ def test_first_touch_stuck_gives_up_after_max_first_touch_ticks(): assert mem.hop_count == 0 -def _make_open_lane_game(carrier_orientation: float) -> Game: +def _make_open_lane_game(carrier_orientation: float, teammate_pos: Vector2D = Vector2D(0.3, 0.3)) -> Game: """No enemies at all (shot lane always open — `find_best_shot` never returns None) and a teammate close enough to be a real ally but inside - `_MIN_SAFE_PASS_DISTANCE`, so `_nearest_safe_receiver` never selects it - (`dist < _MIN_SAFE_PASS_DISTANCE: continue`) -- `mem.receiver_id` stays + `MIN_OPEN_TEAMMATE_M`, so `_nearest_safe_receiver` never selects it + (`dist < MIN_OPEN_TEAMMATE_M: continue`) -- `mem.receiver_id` stays None forever without needing a blocked lane, isolating the `first_touch_stuck`/`force_shot` interaction from any pass mechanics. `carrier_orientation` lets a test aim the carrier at the enemy goal @@ -289,7 +293,6 @@ def _make_open_lane_game(carrier_orientation: float) -> Game: takes the immediate-`kick()` branch rather than `turn_on_spot`. """ carrier_pos = Vector2D(0.0, 0.0) - teammate_pos = Vector2D(0.3, 0.3) # well under _MIN_SAFE_PASS_DISTANCE (0.7m) friendly = { 1: Robot( id=1, @@ -695,3 +698,11 @@ def test_lone_carrier_switches_aim_when_the_keeper_clearly_opens_the_other_side( # The keeper steps 0.3 m toward the aimed-at corner: the other side is now far wider. first, after_step = _aimed_side([0.01, -0.3 if aims_low else 0.3]) assert first != after_step + + +@pytest.mark.parametrize("gap, chosen", [(MIN_OPEN_TEAMMATE_M - 0.05, False), (MIN_OPEN_TEAMMATE_M + 0.05, True)]) +def test_first_touch_pass_skips_a_teammate_too_near_to_adjust(gap, chosen): + """A first-touch pass goes to a teammate at least `MIN_OPEN_TEAMMATE_M` away: nearer, a + full-power kick arrives before the receiver can adjust (28% received under 1.5 m).""" + game = _make_open_lane_game(0.0, teammate_pos=Vector2D(gap, 0.0)) + assert (_nearest_safe_receiver(game, 1, (2,)) == 2) is chosen diff --git a/utama_core/tests/strategy/test_split_shape_split.py b/utama_core/tests/strategy/test_split_shape_split.py new file mode 100644 index 00000000..f102085b --- /dev/null +++ b/utama_core/tests/strategy/test_split_shape_split.py @@ -0,0 +1,20 @@ +"""`split_shape` keeps a second robot in attack while defending, from four outfield robots up, so a +won ball has someone upfield to go to.""" + +import pytest + +from utama_core.strategy import split_shape + +_TACTICS = frozenset({"attack", "defense"}) + + +@pytest.mark.parametrize("robots, attackers", [(5, 2), (4, 2), (3, 0)]) +def test_defending_keeps_a_second_attacker_from_four_robots(monkeypatch, robots, attackers): + monkeypatch.setattr(split_shape, "carrier_first", lambda game, free: sorted(free)) + monkeypatch.setattr(split_shape, "friendly_closer_to_ball", lambda game: False) + free = frozenset(range(1, robots + 1)) + + partition = split_shape._possession_split_picker(None, free, None, _TACTICS) + + assert len(partition.get("attack", ())) == attackers + assert partition.get("attack", frozenset()) | partition["defense"] == free From 3b5939f7166c857a1d4d0c4a6cf30e137fc73401 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Wed, 11 Nov 2026 09:47:43 +0000 Subject: [PATCH 10/59] examples: fix demos broken by the strategy renames - Four examples still passed AbstractStrategy(build_kernel_strategy=...), renamed to build= on this branch; two imported the removed utama_core.strategy.kernel_strategy, and demo_exhibition_road.py the long-deleted WanderingStrategy. They use catalog.builder and wandering_strategy now. - test_every_example_imports imports each example, so a removed module fails the suite (it failed on three demos before the fix). - round_robin.py and triage.py no longer describe build_*_kernel_strategy factories. Co-Authored-By: Claude Opus 5.5 --- examples/demo_dribbler_test.py | 2 +- examples/demo_exhibition_road.py | 8 ++++---- examples/demo_referee_gui_rsim.py | 8 ++++---- examples/demo_split_shape_match.py | 6 +++--- examples/shooting_drill.py | 2 +- tools/evaluation/round_robin.py | 8 ++++---- .../examples/test_examples_run_as_scripts.py | 16 ++++++++++++++++ 7 files changed, 33 insertions(+), 17 deletions(-) diff --git a/examples/demo_dribbler_test.py b/examples/demo_dribbler_test.py index 94882374..e0b428be 100644 --- a/examples/demo_dribbler_test.py +++ b/examples/demo_dribbler_test.py @@ -42,7 +42,7 @@ def _build_dribbler_kernel_strategy(motion_controller: MotionController) -> Kern def main() -> None: runner = StrategyRunner( - strategy=AbstractStrategy(build_kernel_strategy=_build_dribbler_kernel_strategy), + strategy=AbstractStrategy(build=_build_dribbler_kernel_strategy), my_team_is_yellow=MY_TEAM_IS_YELLOW, my_team_is_right=MY_TEAM_IS_RIGHT, mode="rsim", diff --git a/examples/demo_exhibition_road.py b/examples/demo_exhibition_road.py index 2127d4f4..b84125e9 100644 --- a/examples/demo_exhibition_road.py +++ b/examples/demo_exhibition_road.py @@ -12,7 +12,7 @@ with all rules enabled and human-operator auto-advance settings so a festival steward can control the game from the browser GUI. - 2v2 format: two yellow robots vs two blue robots, matching the small field. - - WanderingStrategy is used so robots visibly move and you can watch the + - wandering_strategy is used so robots visibly move and you can watch the RefereeOverride tree interrupt them when you issue commands from the dashboard. - The referee is attached to the browser dashboard at @@ -49,7 +49,7 @@ from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.run import StrategyRunner -from utama_core.tests.referee.wandering_strategy import WanderingStrategy +from utama_core.tests.referee.wandering_strategy import wandering_strategy # --------------------------------------------------------------------------- # Configuration @@ -122,8 +122,8 @@ def main() -> None: referee_view.attach(server, referee, _EXHIBITION_PROFILE) runner = StrategyRunner( - strategy=WanderingStrategy(field_dims=GREAT_EXHIBITION_FIELD_DIMS), - opp_strategy=WanderingStrategy(field_dims=GREAT_EXHIBITION_FIELD_DIMS), + strategy=wandering_strategy(tuple(range(N_ROBOTS)), GREAT_EXHIBITION_FIELD_DIMS), + opp_strategy=wandering_strategy(tuple(range(N_ROBOTS)), GREAT_EXHIBITION_FIELD_DIMS), my_team_is_yellow=MY_TEAM_IS_YELLOW, my_team_is_right=MY_TEAM_IS_RIGHT, mode="rsim", diff --git a/examples/demo_referee_gui_rsim.py b/examples/demo_referee_gui_rsim.py index 91c633f0..b9976d37 100644 --- a/examples/demo_referee_gui_rsim.py +++ b/examples/demo_referee_gui_rsim.py @@ -11,7 +11,7 @@ - Passes the referee to StrategyRunner via referee=. StrategyRunner calls referee.step() on every tick and handles ball teleports on STOP automatically — no patching required. - - build_tiki_taka_plus_kernel_strategy() builds the give-and-go + + - builder("tiki_taka_plus", ...) builds the give-and-go + final-third decoy-overload kernel strategy (see docs/strategies.md) so you can watch real tactic assignments in the dashboard's Live tab instead of an aimless wandering tactic, and watch @@ -39,7 +39,7 @@ from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.run import StrategyRunner -from utama_core.strategy.kernel_strategy import build_tiki_taka_plus_kernel_strategy +from utama_core.strategy.catalog import builder # --------------------------------------------------------------------------- # Configuration @@ -69,7 +69,7 @@ def main() -> None: outfield_robot_ids = tuple(range(1, N_ROBOTS)) runner = StrategyRunner( - strategy=AbstractStrategy(build_kernel_strategy=build_tiki_taka_plus_kernel_strategy(outfield_robot_ids)), + strategy=AbstractStrategy(build=builder("tiki_taka_plus", outfield_robot_ids)), my_team_is_yellow=MY_TEAM_IS_YELLOW, my_team_is_right=MY_TEAM_IS_RIGHT, mode="rsim", @@ -78,7 +78,7 @@ def main() -> None: exp_enemy=N_ROBOTS, referee=referee, # StrategyRunner drives referee.step() each tick show_live_status=True, - opp_strategy=AbstractStrategy(build_kernel_strategy=build_tiki_taka_plus_kernel_strategy(outfield_robot_ids)), + opp_strategy=AbstractStrategy(build=builder("tiki_taka_plus", outfield_robot_ids)), ) runner.run() diff --git a/examples/demo_split_shape_match.py b/examples/demo_split_shape_match.py index ad1ee16c..c4a53d20 100644 --- a/examples/demo_split_shape_match.py +++ b/examples/demo_split_shape_match.py @@ -29,14 +29,14 @@ from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.run import StrategyRunner -from utama_core.strategy.kernel_strategy import build_split_shape_kernel_strategy +from utama_core.strategy.catalog import builder DURATION_SECONDS = 90 def main(): - my_strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) - opp_strategy = AbstractStrategy(build_kernel_strategy=build_split_shape_kernel_strategy((1, 2, 3, 4, 5))) + my_strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + opp_strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) profile = load_profile("simulation") referee = CustomReferee(profile, n_robots_yellow=6, n_robots_blue=6) diff --git a/examples/shooting_drill.py b/examples/shooting_drill.py index b7e9f402..8d396994 100644 --- a/examples/shooting_drill.py +++ b/examples/shooting_drill.py @@ -269,7 +269,7 @@ def _build(motion_controller) -> KernelSchedulerStrategy: ) return AbstractStrategy( - build_kernel_strategy=_build, + build=_build, goalkeeper_id=robot_id if tactic_cls is None else _NO_ROBOT, ) diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index af09a1ff..3fcfd4c5 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -1,5 +1,5 @@ """round_robin.py (formerly smoke_tournament.py, before that tournament.py) — Round-robin every -`build_*_kernel_strategy` config against every other, one full match per pair +strategy (`utama_core/strategy/catalog.py`) against every other, one full match per pair (two halves, see `MAX_MATCH_SECONDS` below). This is the whole-catalog health and stall check; a single strategy is judged with `evaluate.py`. @@ -32,7 +32,7 @@ What this does -------------- Headless rsim, no external process required. For each distinct pair of the -`build_*_kernel_strategy` factories in `utama_core.strategy.kernel_strategy`, +strategies `utama_core/strategy/catalog.py` finds (one `strategy/.py` each), runs one `StrategyRunner` match (6v6: 1 goalkeeper + 5 outfield robots per side — enough for every factory's minimum, including the `min_attack=2` configs and `three_slot`'s three concurrent slots), @@ -191,8 +191,8 @@ def vs_champion_pairs(config_names: list[str], champion: str, first_opponent: st def main() -> None: - # Optional CLI args: config names (with or without the `build_`/ - # `_kernel_strategy` wrapping) to run instead of the full auto-discovered + # Optional CLI args: config names (plain, or the old `build__kernel_strategy` + # form, which `catalog.plain_name` still accepts) to run instead of the full auto-discovered # catalog — useful for a quick check of one or two configs without # waiting on every pair, e.g. `python tools/evaluation/round_robin.py default # low_block`. `--sequential` forces the old one-process-at-a-time loop diff --git a/utama_core/tests/examples/test_examples_run_as_scripts.py b/utama_core/tests/examples/test_examples_run_as_scripts.py index 7c71f4cd..20d40917 100644 --- a/utama_core/tests/examples/test_examples_run_as_scripts.py +++ b/utama_core/tests/examples/test_examples_run_as_scripts.py @@ -49,3 +49,19 @@ def test_the_field_example_holds_while_its_tactic_does_not_apply(): assert example._play_or_hold(None, robots, None, frozenset({"hold"})) == {"hold": robots} assert example._play_or_hold(None, robots, None, frozenset({"play", "hold"})) == {"play": robots} assert example._play_or_hold(None, frozenset(), None, frozenset({"play", "hold"})) == {} + + +@pytest.mark.parametrize("path", sorted(EXAMPLES.glob("*.py")), ids=lambda p: p.name) +def test_every_example_imports(path, tmp_path): + """Every example's imports resolve. Until 2026-11-11 two demos still imported the removed + `utama_core.strategy.kernel_strategy` (gone when strategies became `strategy/.py`) and one + the long-deleted `WanderingStrategy`, and nothing ran them.""" + code = ( + "import importlib.util, sys; " + f"sys.path.insert(0, {str(EXAMPLES)!r}); " + f"spec = importlib.util.spec_from_file_location('example_under_test', {str(path)!r}); " + "module = sys.modules['example_under_test'] = importlib.util.module_from_spec(spec); " + "spec.loader.exec_module(module)" + ) + done = subprocess.run([sys.executable, "-c", code], cwd=tmp_path, capture_output=True, text=True, timeout=120) + assert done.returncode == 0, done.stderr[-2000:] From a3f387e3e37117958f2a119374c8c8ed23d5d815 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Wed, 11 Nov 2026 09:48:01 +0000 Subject: [PATCH 11/59] tools: the screen, on trial; fouls move into triage; moments.py trimmed - tools/screen.py STRATEGY --base REF: one strategy now against itself at REF (a .strategy file) from the same 60 starts of 20 s of live play drawn from a run's replays, both against the base under the same noise. Reports how many starts fired (diverged), paired differences in goals and ball position, and a call by a rule fixed before any change was screened. Never writes the ledger; appends to replays/eval/screen_log.jsonl. Same code, file against code, never diverged on 3 real starts. - Pass mark (agreed 2026-11-11): a track record on real changes. The screen decides nothing until 8 clear evaluate.py verdicts with no "skip" on a better change and at least half of the worse ones skipped. - triage.py --fouls replaces moments.py fouls (utama_core/analysis/fouls.py). - moments.py: `new` and its template removed (moments come from replays); --against worktrees in -moments-against/, not a dated folder. - tools.md (also the five scripts it did not list), STRATEGY_DEVELOPMENT.md, the plan note and the glossary updated. Fingerprints of every strategy and the environment are unchanged, so no cached match or ledger entry is invalidated. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 7 +- docs/STRATEGY_DEVELOPMENT.md | 16 +- docs/strategy_tools_plan.md | 107 +++--- docs/tools.md | 14 +- tools/moments.py | 243 +----------- tools/screen.py | 346 ++++++++++++++++++ tools/triage.py | 54 ++- utama_core/analysis/fouls.py | 126 +++++++ utama_core/tests/analysis/test_fouls.py | 135 +++++++ .../tests/moments/test_moment_authoring.py | 181 +-------- .../moments/test_requires_and_outcomes.py | 4 +- utama_core/tests/tools/test_screen.py | 98 +++++ 12 files changed, 866 insertions(+), 465 deletions(-) create mode 100644 tools/screen.py create mode 100644 utama_core/analysis/fouls.py create mode 100644 utama_core/tests/analysis/test_fouls.py create mode 100644 utama_core/tests/tools/test_screen.py diff --git a/AGENTS.md b/AGENTS.md index d447924a..3c7a273a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -36,13 +36,18 @@ One term per thing; reuse these instead of coining new ones. verdict on a strategy; see Evaluation. - **Motion planning benchmark** — `tools/motion_planning_benchmark.py`: the planner alone on fixed scenarios. Unrelated to any strategy. -- **Moment / regression moment** — a field state (from a replay or by hand) that reproduced a +- **Moment / regression moment** — a field state (captured from a replay) that reproduced a bug, with a check of the right behaviour (`utama_core/tests/moments/*.json`, `tools/moments.py`). A cheap end-to-end check, run in `pixi run test`, that a fixed bug stays fixed; the unit test at the cause is the real protection. Not a ranking and not a gate on strategies. The workflow and the bugs found so far: `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure". - **Pitch zones** — defensive / middle / attacking third, left wing / centre / right wing, the box, danger: defined once, with a diagram, in `docs/pitch_zones.md`. Use those names. +- **Screen** — `tools/screen.py STRATEGY --base REF`: did a change to one strategy do anything in + play? Short paired starts of the strategy now against itself at REF, from live-play moments of a + run's replays; reports how often the change fired and a call by a fixed rule. Never a verdict, never + two strategies, never in the ledger. On trial until its calls match `evaluate.py`'s verdicts on real + changes (`docs/strategy_tools_plan.md`); until then evaluate whatever it says. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). - **Position map / shot map** — on-pitch pictures of a strategy over many matches, drawn by `tools/pitch_maps.py` (and `evaluate.py --explain` for a candidate against the champion), always diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index d3170c7b..ac5323f9 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -330,6 +330,13 @@ flowchart TD against the champion (12 matches, not the 66 of a full round-robin), defaulting to `--sim-noise reference:2` so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2. Read its STALLS section; a strategy's verdict still comes from `evaluate.py`. +- **Screen** (`tools/screen.py STRATEGY --base REF`, on trial): before an evaluation, did a change to one + strategy do anything in play? It plays the strategy now and as it was at REF from the same 60 starts of + 20 s of live play, drawn from a run's replays, against the base under the same noise, and reports how + often the two diverged ("fired") and the paired differences. Its call (`WORTH EVALUATING`, `SKIP: did + not fire`, `SKIP: fewer goals in the starts`) follows a rule fixed in advance; it never writes the + ledger and never compares two strategies. Until its track record is in + ([strategy_tools_plan.md](strategy_tools_plan.md), "The screen"), run `evaluate.py` whatever it says. - **Before promoting** a candidate called better, run `evaluate.py --held-out`: it must not be clearly worse against opponents never used for selection. Then edit the champion in `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse @@ -488,9 +495,8 @@ The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, ` 1. **Find it.** `tools/triage.py` is the one starting point for "what went wrong in a run" (see the start of this section). It flags thrashing and stalls, and restart geometry with `--restarts`. - Fouls are not in triage yet. To list our side's fouls by rule, use - `pixi run python tools/moments.py fouls replays/tournament_ --by strategy,rule`, after triage - and not instead of it. It counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball + For our side's fouls by rule, `pixi run python tools/triage.py replays/tournament_ --fouls --by + strategy,rule` counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball leaving the field, is a stoppage and left out unless `--include-stoppages`); without `--by` it lists each with its time, robot, tactic and the referee command then active (`--skip-own-restart` drops fouls during our own restarts; `--json` writes either form as JSON). @@ -537,8 +543,8 @@ for open play, go from the trace to the code and a unit test. A moment's `checks` are `tools/moments.py`'s `CHECKS` (`keeps_clear`, `stop_speed`) or referee rule names; its `requires` (`restart_lasts`, `robot_near_ball`) fail it with `did not arise` when the situation it tests never happened. A restart moment plays one strategy, since the referee override moves every outfield robot the same -way whatever the strategy. `tools/moments.py new NAME --command CMD ...` writes a hand-made field -state to edit. Moments are not a gate on strategies: they pin shared-code bugs. +way whatever the strategy. Moments are captured from replays (`capture`); hand-made templates +(`moments.py new`) were removed on 2026-11-11. Moments are not a gate on strategies: they pin shared-code bugs. | Symptom | Looked like | Cause | Fix | Test | |---|---|---|---|---| diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index dd6a3173..6820341d 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -1,6 +1,6 @@ # Strategy tools: one question, one tool -Design note, agreed after two review rounds. It says which tool answers which question, what +Design note, agreed after two review rounds; status updated 2026-11-11. It says which tool answers which question, what is planned and in what order, and what is still undecided. Items marked **planned** do not exist yet. The current tools are in [tools.md](tools.md), and the "Which tool?" table there links back here. @@ -15,8 +15,8 @@ links back here. referee and dashboard: `tools/evaluation/match.py`, `tools/debug_match.py`, `tools/repro_from_replay.py`, `tools/moments.py` and `main.py`. - Only `match.py` loads `.strategy` files (`utama_core/bundle/`). The other four cannot run a - frozen baseline, so they cannot compare against one. + Before step 5 only `match.py` loaded `.strategy` files (`utama_core/bundle/`), so the other four + could not run a frozen baseline. ## The question, the tool @@ -27,8 +27,8 @@ links back here. | Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the ledger for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | | Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | | Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | -| What went wrong in these matches (bugs: thrashing, stalls, restart geometry)? | `tools/triage.py`, then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | -| Is this change worth evaluating? | A screen: short paired starts of one strategy against itself, at a git ref. Never a verdict. Never two different strategies. Never written to the ledger. It must report how often the change fired. See "The screen" below | Planned (step 6) | +| What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/triage.py` (`--fouls` for our side's fouls), then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | +| Is this change worth evaluating? | `tools/screen.py`: short paired starts of one strategy against itself, at a git ref. Never a verdict. Never two different strategies. Never written to the ledger. Reports how often the change fired. See "The screen" below | Built 2026-11-11, on trial | | Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | | Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | | Is the simulator realistic? | Simulator tools: `realism_scorecard.py`, `physics_ranges.py`, `field_physics.py`, `robot_calibration.py`, `convert_ssl_log.py`. Not part of strategy development | Today | @@ -39,7 +39,7 @@ Notes on the table: stronger than the champion?". Keep the two apart in the docs and in the output. - "Look closely" tools explain a result. They never judge one. -## The screen (planned) +## The screen (built, on trial) The screen asks a narrower question than `evaluate.py`: "did this change do anything in play?" It is for deciding whether a change is worth the cost of an evaluation. @@ -51,38 +51,39 @@ play?" It is for deciding whether a change is worth the cost of an evaluation. - It must report how often the change fired (how many of the starts reached the code the change touched). A screen that never fired says nothing. -**Pass mark (proposed 2026-11-11, not yet agreed).** The screen is a filter in front of +**As built** (`tools/screen.py`, 2026-11-11). The design was fixed before any change was screened: + +- **Starts:** 60 moments of live play (NORMAL_START or FORCE_START), drawn uniformly at random from + the replays of a run in which the strategy played, so situations come as often as in matches. + 20 s each. Robots start from rest with fresh tactic memory. +- **Sides:** the change (the working tree) and the base (a `.strategy` file at REF, as `evaluate.py + --frozen` builds) each play our side against the base, under the reference world and robots with + one seed per start. +- **Fired:** the two starts diverged (a robot or the ball more than 1 µm apart). Checked: the same + code, file against code, never diverged on 3 starts; a strategy whose code is the same at both refs + is not played at all. +- **Call:** `SKIP: did not fire` if under 10% of starts fired; `SKIP: fewer goals in the starts` if, + over the fired starts, the goal difference (change minus base) is lower by more than 2 standard + errors; otherwise `WORTH EVALUATING`. +- **Cost:** about 30 minutes on 8 workers, against several hours for a 6-round `evaluate.py` run. +- Every run appends to `replays/eval/screen_log.jsonl` (commit, fingerprints of both sides, every + pair, the call), so its calls can be checked against verdicts later. + +**Pass mark: a track record on real changes (agreed 2026-11-11).** The screen is a filter in front of `evaluate.py`, so its two errors cost different amounts. Screening out a change that would have won -loses an improvement for good. Letting a useless change through only costs one evaluation. The -pass mark guards the first error hard and asks only enough of the second to make the screen worth -running. - -Past verdicts are too few to judge it on: three `evaluate.py` runs on a change to one strategy -(`split_shape` against the frozen v2.5.0, 2026-11-10, all "better"); the other nine compare -different strategies, which the screen never does. So the validation set is built with known answers: - -- **Known worse:** 6 sabotages of the champion, each a small, plausible slip of the size a real change - makes (a pass gate a little too strict, a receiver who turns late, a marker 0.3 m off, a slower - restart, a shot threshold off, a missing keeper step-out). Each sabotage is confirmed worse by - `evaluate.py` first; one that `evaluate.py` cannot tell apart is not a known answer and is dropped. -- **Known better:** each confirmed sabotage reversed (base = sabotaged, change = the champion), plus - the three real "better" verdicts above. -- **Known nothing:** 3 changes that cannot alter play (a renamed variable, a reordered pure function, - a log line). - -The screen passes validation when all of these hold, on a design (number of starts, seconds per start, -the measure, the threshold) fixed before any of the cases are screened: - -1. **Never screens out a known better change.** Every one of them gets "worth evaluating". -2. **Screens out at least half of the known worse ones.** Below that it saves too little to be worth - running. -3. **Calls every known-nothing change "did not fire"**, or reports no difference on it. A difference - there means the screen measures noise. -4. **Repeatable:** screened again with other seeds, at least 9 cases in 10 get the same call. -5. **Cheap:** at most a fifth of the playing time of a 6-round `evaluate.py` run. - -If it fails, the design is changed once and the whole set is screened again. If it fails twice, the -screen is dropped and `evaluate.py` stays the only gate. Nothing is tuned after the results are in. +loses an improvement for good. Letting a useless change through only costs one evaluation. Past verdicts +are too few to judge it on (three `evaluate.py` runs on a change to one strategy, all "better"), so it +is judged going forward: + +- On every real change to one strategy, run the screen first and keep its call, then run + `evaluate.py` as usual. **`evaluate.py` stays the only gate meanwhile:** the screen decides nothing. +- It earns the right to skip evaluations after **at least 8 real changes with a clear verdict** + (better or worse) where it **never** called "skip" on one `evaluate.py` called better, and would have + skipped **at least half** of those called worse. +- The rule above is not tuned during the trial. If it fails, it is changed once and the record starts + again; if it fails twice, the screen is dropped and `evaluate.py` stays the only gate. +- If the record grows too slowly, deliberate small mistakes in the champion (each confirmed worse by + `evaluate.py` first), their reversals and changes that cannot alter play can be added as known answers. **Why not the retired scenario bench.** The scenario bench (retired 2026-10-17) also started matches from fixed states. It ranked *different* strategies. Its estimate was biased per @@ -90,22 +91,20 @@ strategy, so the ranking failed: Spearman -0.09 against round-robin results (see [roadmap.md](roadmap.md), "Strategy evaluation"; the retirement is in [sim_realism.md](sim_realism.md), "Evaluation infrastructure"). The screen differs on both points: it compares one strategy with itself, so per-strategy bias cancels, and it does not -rank anything. The screen is still a new mechanism, so it is built only after the scratch -validation. +rank anything. It is still a new mechanism, so it decides nothing until its track record is in. ## Moments -Regression moments are fixed-state checks of shared-code bugs (restart and placement geometry). -Changes planned for `tools/moments.py`: +Regression moments are fixed-state checks of shared-code bugs (restart and placement geometry), +played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: -- **Drop `moments.py fouls`.** Its job moves into `tools/triage.py`, so there is one place to - find what went wrong in a run. -- **Drop `new` (hand-made templates).** Moments come from `capture`, from a replay. -- **Keep `--seeds`.** `play --seeds 0-4` is how a moment is checked (it must fail on 4 of 5 +- **`moments.py fouls` moved into `tools/triage.py --fouls`** (the code in + `utama_core/analysis/fouls.py`), so there is one place to find what went wrong in a run. +- **`new` (hand-made templates) removed.** Moments come from `capture`, from a replay. +- **`--seeds` kept.** `play --seeds 0-4` is how a moment is checked (it must fail on 4 of 5 seeds before the fix). -- **Fix `--against`.** Its worktree folder is a hard-coded dated name next to the repo - (`AGAINST_DIR = REPO_ROOT.parent / "moments-work-20261017" / "against"` in `tools/moments.py`). - Planned: a folder that is set in one place and does not carry a date. +- **`--against` fixed.** Its worktrees sit beside the repo in `-moments-against/`, set once in + `AGAINST_DIR`, no longer in a dated folder from one session. ## Planned steps, in order @@ -129,10 +128,12 @@ Changes planned for `tools/moments.py`: fingerprint of every cached match, so every match replays and the ledger is invalidated (`utama_core/replay/fingerprint.py`). If it must change, batch it with other changes to shared code and say so in the commit. -6. **The screen.** First validated in scratch code, against past `evaluate.py` verdicts, with the - pass mark agreed beforehand. Only then built in. Then a `compare.py` tool with two - subcommands, `verdict` (wraps `evaluate.py`) and `screen`, with no options shared between - them. Renames happen together with the merge they belong to, not before. +6. **The screen.** Built as `tools/screen.py` (2026-11-11), on trial: its calls are kept beside + `evaluate.py`'s verdicts on real changes until the track record above is in. Only if it passes, + a `compare.py` tool with two subcommands, `verdict` (wraps `evaluate.py`) and `screen`, with no + options shared between them. Renames happen together with the merge they belong to, not before. +7. **Triage takes the foul listing.** Done: `triage.py --fouls`; `moments.py` lost `fouls` and `new`, + and `--against` no longer uses a dated folder. Every step that changes shared code follows the rule in `docs/STRATEGY_DEVELOPMENT.md`: batch such changes, and run one round-robin at the end. @@ -140,7 +141,7 @@ such changes, and run one round-robin at the end. ## Names considered (undecided) - **`drill`** for the screen: rejected as a name, because `examples/shooting_drill.py` already - uses "drill". + uses "drill". The trial tool is `screen.py`; its final name comes with the `compare.py` merge. - **Triage**: `scan_replays.py` or `find_bugs.py`. Undecided. `triage.py` stays until then. - **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Step 6 uses `compare.py` as a placeholder. Undecided. diff --git a/docs/tools.md b/docs/tools.md index a20cb416..b7318c9d 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -14,8 +14,8 @@ says why the tools are split this way. | Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` and the round-robin report them | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion. The only verdict. Add `--held-out` before promoting | | Does everything still run after a shared-code change? | `tools/evaluation/round_robin.py --vs-champion`: one match per strategy against the champion (12). The full round-robin (66) only occasionally. A round-robin is not an evaluation | -| What went wrong in these matches (thrashing, stalls, restart geometry)? | `tools/triage.py RUN_DIR --strategy NAME`, then the picture tools. It finds bugs, not why a strategy loses | -| Is this change worth evaluating? | *Planned:* a screen (short paired starts of one strategy against itself). Until it exists, `evaluate.py` | +| What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/triage.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | +| Is this change worth evaluating? | `tools/screen.py STRATEGY --base REF`: short paired starts of one strategy now against itself at REF. *On trial:* run `evaluate.py` whatever it says until its track record is in | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | | Is the simulator realistic? | [Simulator realism](#simulator-realism). Not strategy development | @@ -53,8 +53,10 @@ says why the tools are split this way. | `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; ledger lines from before stalls were recorded count as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | | `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | +| `tools/screen.py` | `screen.py STRATEGY --base REF [--run RUN_DIR] [--seed N] [--max-workers 8]`: a screen, not a verdict. Plays STRATEGY now and as it was at REF (a `.strategy` file in `replays/eval/frozen/`) from the same 60 starts of 20 s of live play drawn at random from a run's replays (default: the latest run with at least 3 of its matches), both against the base under the same reference noise. Prints how many starts fired (the two diverged), the paired differences in goals and how far upfield the ball was, over all and over fired starts, and a call by a fixed rule; appends to `replays/eval/screen_log.jsonl`. Never writes the ledger, keeps no replays, plays one strategy. On trial: see [strategy_tools_plan.md](strategy_tools_plan.md) | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | | `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | +| `tools/evaluation/sim_settings.py` | Not a script: loads the reference opponents and the simulated world and robots (`tools/evaluation/reference/opponents.json`, `world.json`, `robots.json`) for `evaluate.py` and `round_robin.py --sim-noise reference[:seed]`. Kept in `reference/` so a new champion does not rerun every cached match | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | ## Evaluating strategies @@ -99,14 +101,14 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or | Script | Purpose | |---|---| -| `tools/triage.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its round-robin matches, every other round in an evaluation), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/triage/`. `--restarts` is slow (about 45 s a match). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/triage.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its round-robin matches, every other round in an evaluation), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/triage/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | | `tools/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | | `tools/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | | `tools/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Referee handling" | | `tools/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/moments.py` | Regression moments (`utama_core/tests/moments/`): `fouls RUN_DIR` lists our side's fouls in a round-robin with the restart side (`--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json` for either as JSON; each foul names its match's `replay` .npz relative to the repo root), `capture REPLAY --t S [--out PATH]` writes a moment from a replay, `new NAME --command CMD` writes a hand-made template, `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `triage.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/debug_match.py` | One ad hoc match between two strategies for tactic debugging; `--dump-ticks` writes per-tick poses and commanded targets | Library helpers for the same job (`render_window`, `render_clip`, `MatchLog.trace()`) are @@ -155,8 +157,12 @@ the field logs in `replays/field/`. | `examples/shooting_drill.py` | One robot shoots at a goal the other defends (the keeper feeds the ball back, so it loops) on real robots (or `--mode rsim`/`grsim`): field, camera half, IDs and each robot's working hardware in one config block; the Live tab's field check gates the start. Records every camera run as an SSL game log in `replays/field/`; `--calibrate attacker\|defender` plays fixed moves for measuring that robot | | `examples/save_and_counter.py` | A 1v1 game where a keeper that saves takes the ball and counterattacks, on real robots (or `--mode rsim`/`grsim`), a goal each: each robot keeps its goal and attacks the other's, reading every tick from the same world whether it attacks or keeps; a keeper's save turns it into the attacker. Field, rules and hardware type from `shooting_drill.py` | | `examples/pass_receive.py` | Two robots (one per team, so two colours) pass to each other on real robots (or `--mode rsim`/`grsim`): the robot nearer the ball passes once its partner is still and facing it, the other gets open and receives. The Live tab shows each robot's role | +| `examples/score_goal.py` | One robot, no opponent, takes the ball and scores, on a real robot (or `--mode rsim`); also a demo in `pixi run demos` | +| `examples/dribble_and_shoot.py` | `score_goal.py`'s robot dribbles a lap of the field, then scores | | `examples/passing_rally.py` | `pass_receive.py`'s pair passing their way along the field in two lanes, turning round `TURN_M` from each end line, for ever (no shots) | | `tools/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | +| `tools/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([field_logs.md](field_logs.md)) | +| `tools/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([field_logs.md](field_logs.md)) | | `tools/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | diff --git a/tools/moments.py b/tools/moments.py index 6787bcfb..73c96bad 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -32,23 +32,14 @@ a robot came near the ball. Without them a moment passes when the opponent does something else, the ball goes elsewhere, or our robot never gets there. -Hand-made moments: `new` writes a template (both teams in a fixed formation, ours on the right, -the reference noise with seed 1, source null) to edit by hand; `save` and `load` refuse an -invalid one, naming each problem (ids, field lines, check and strategy names). - -List our side's fouls in a round-robin run, as starting points, each with the referee command -active then and whether that restart is ours or theirs (`--skip-own-restart` leaves out ours): - pixi run python tools/moments.py fouls replays/tournament_ [--rule keep_out] [--skip-own-restart] -(`--by strategy,rule` counts them per combination instead; `out_of_bounds`, the ball leaving the -field, is a stoppage and is left out unless `--include-stoppages`.) +A moment comes from a replay (`capture`); `save` and `load` refuse an invalid one, naming each +problem (ids, field lines, check and strategy names). Starting points: our side's fouls in a run, +`pixi run python tools/triage.py replays/tournament_ --fouls` (until 2026-11-11 `moments.py fouls`). Capture one from a replay (its noise and designated position come with it; `--out` writes elsewhere than utama_core/tests/moments/): pixi run python tools/moments.py capture replays/tournament_/
_vs_.npz --t 254.65 \\ --name free_kick_defender_drives_in --check keeps_clear --strategy --opponent \\ --note "..." [--out PATH] -Write a hand-made one, then edit its positions in the JSON: - pixi run python tools/moments.py new --command NORMAL_START [--ball X Y] \\ - [--strategy NAME] [--seconds N] --check --note "..." Play one (`--seed N` replays its noise with another seed, the JSON untouched): pixi run python tools/moments.py play utama_core/tests/moments/.json [--strategy NAME] [--seed N] Play it under several seeds as one table, compare with the code at a git ref (a worktree under @@ -73,7 +64,6 @@ import subprocess import sys import tempfile -from collections import Counter from pathlib import Path from typing import Callable, Optional @@ -87,11 +77,11 @@ OUTFIELD_ROBOT_IDS, TICKS_PER_SECOND, ) +from utama_core.analysis.fouls import restart_side # noqa: E402 from utama_core.entities.referee.referee_command import RefereeCommand # noqa: E402 from utama_core.replay.scenario import ( # noqa: E402 RobotState, Scenario, - _referee_command_at, scenario_from_replay, ) from utama_core.strategy.catalog import plain_name # noqa: E402 @@ -116,7 +106,7 @@ # `play --against`: worktrees live beside the repo (not in it), each with the compiled extensions # below copied in (gitignored, so a new worktree lacks them; without them the planner falls back to # Python and results differ). -AGAINST_DIR = REPO_ROOT.parent / "moments-work-20261017" / "against" +AGAINST_DIR = REPO_ROOT.parent / f"{REPO_ROOT.name}-moments-against" BUILD_ARTIFACTS = ( "utama_core/motion_planning/src/fastpathplanning/_fastpathplanner.cpython-*.so", "utama_core/rsoccer_simulator/src/Simulators/robosim/_robosim.cpython-*.so", @@ -312,50 +302,6 @@ def validate(m: Moment) -> None: raise MomentError(f"{m.name}:\n " + "\n ".join(problems)) -def template( - name: str, - note: str, - command: str, - checks: list[str], - ball: tuple[float, float] = (0.0, 0.0), - strategy: str = "all", - seconds: float = DEFAULT_SECONDS, -) -> Moment: - """A hand-made moment: both teams in a fixed formation (ours yellow on the right, facing left), - the given ball and referee command, the reference noise with seed 1, source null.""" - from utama_core.replay.scenario import RobotState - - ours = [(4.0, 0.0), (2.2, 1.2), (2.2, -1.2), (1.0, 2.0), (1.0, -2.0), (0.6, 0.0)] - - def robots(positions, facing): - return tuple( - RobotState(id=i, x=x, y=y, orientation=facing, vx=0.0, vy=0.0) for i, (x, y) in enumerate(positions) - ) - - from tools.evaluation.sim_settings import reference_noise - - scenario = Scenario( - sim_time=0.0, - ball_x=ball[0], - ball_y=ball[1], - ball_vx=0.0, - ball_vy=0.0, - friendly_robots=robots(ours, math.pi), - enemy_robots=robots([(-x, y) for x, y in ours], 0.0), - referee_command=RefereeCommand[command], - source_replay=Path("hand-made"), - ) - return Moment( - name=name, - note=note, - scenario=scenario, - checks=list(checks), - strategy=_full_name(strategy), - seconds=seconds, - sim_noise=reference_noise(seed=1), - ) - - def with_seed(m: Moment, seed: int) -> Moment: """`m` played with its sim noise's seed replaced (`play --seed`), the JSON untouched.""" if m.sim_noise is None: @@ -376,18 +322,6 @@ class Tick: ball_speed: Optional[float] = None # m/s, for `events`' kicks -def restart_side(command: Optional[RefereeCommand], we_are_yellow: bool = True) -> Optional[str]: - """ "ours" for a restart our team takes, "theirs" for one the other team takes, None for - STOP, live play and timeouts.""" - if command is None or command.name.startswith("TIMEOUT"): - return None - if command.name.endswith("YELLOW" if we_are_yellow else "BLUE"): - return "ours" - if command.name.endswith("BLUE" if we_are_yellow else "YELLOW"): - return "theirs" - return None - - def _restart_against_us(command: Optional[RefereeCommand], we_are_yellow: bool) -> bool: """STOP, or a restart the other team takes: when every robot of ours keeps out.""" return command is RefereeCommand.STOP or restart_side(command, we_are_yellow) == "theirs" @@ -702,92 +636,6 @@ def _designated_position(replay: Path, t: float) -> Optional[tuple[float, float] return tuple(designated) if designated else None -def without_own_restarts(fouls: list[dict]) -> list[dict]: - """`fouls` minus those during a restart our team takes: `keeps_clear` does not apply there.""" - return [f for f in fouls if f.get("restart") != "ours"] - - -# Rules that stop play without being a rules foul: the ball leaving the field. -STOPPAGE_RULES = frozenset({"out_of_bounds"}) -FOUL_COLUMNS = ("strategy", "rule", "tactic", "restart") - - -def without_stoppages(fouls: list[dict]) -> list[dict]: - return [f for f in fouls if f["rule"] not in STOPPAGE_RULES] - - -def _foul_column(f: dict, column: str) -> str: - if column == "strategy": - return short_name(f["config_a"]) - if column == "restart": - return f.get("restart") or "live" - return str(f.get(column) or "-") - - -def count_fouls(fouls: list[dict], columns: list[str]) -> list[tuple[tuple[str, ...], int]]: - """How many of `fouls` fall in each combination of `columns` (names from `FOUL_COLUMNS`), - most common first; ties in name order.""" - counts = Counter(tuple(_foul_column(f, c) for c in columns) for f in fouls) - return sorted(counts.items(), key=lambda item: (-item[1], item[0])) - - -def fouls_json(fouls: list[dict], columns: Optional[list[str]] = None) -> str: - """`fouls` as JSON: the foul dicts as they are, or with `columns` the `count_fouls` rows as - {column: value, ..., "count": n} objects, most common first.""" - if columns is None: - data = fouls - else: - data = [{**dict(zip(columns, key)), "count": n} for key, n in count_fouls(fouls, columns)] - return json.dumps(data, indent=1, sort_keys=True) - - -def print_fouls_by(fouls: list[dict], columns: list[str]) -> None: - """`count_fouls` as a table: a count column, then one column per name, then the total.""" - rows = count_fouls(fouls, columns) - widths = [max([len(c)] + [len(key[i]) for key, _ in rows]) for i, c in enumerate(columns)] - print(f"{'count':>5} " + " ".join(f"{c:<{w}}" for c, w in zip(columns, widths))) - for key, n in rows: - print(f"{n:>5} " + " ".join(f"{v:<{w}}" for v, w in zip(key, widths))) - print(f"{sum(n for _, n in rows):>5} total") - - -def our_fouls(run_dir: Path, rule: Optional[str] = None) -> list[dict]: - """Every foul config_a (our side in the replay) committed in a round-robin run, from its - summary.json: the starting points for new moments. Each carries the referee `command` active - at its time (from the match's `.intentions.jsonl`, None if absent), its `restart` side - ("ours", "theirs", or None for live play and STOP) and its match's `replay` (the .npz, else the - .pkl, relative to the repo root; None if neither is there), for replay_trace and repro.""" - run_dir = Path(run_dir) - summary = json.loads((run_dir / "summary.json").read_text()) - out = [] - for r in summary["results"]: - stem = run_dir / f"{short_name(r['config_a'])}_vs_{short_name(r['config_b'])}" - sidecar = Path(f"{stem}.intentions.jsonl") - replay = next((p for p in (Path(f"{stem}.npz"), Path(f"{stem}.pkl")) if p.exists()), None) - for f in (r.get("stats") or {}).get("fouls") or []: - if f.get("side") == "friendly" and (rule is None or f["rule"] == rule): - command = _referee_command_at(sidecar, f["sim_time"]) - out.append( - { - "config_a": r["config_a"], - "config_b": r["config_b"], - **f, - "command": command.name if command else None, - "restart": restart_side(command), - "replay": _repo_relative(replay) if replay is not None else None, - } - ) - return out - - -def _repo_relative(path: Path) -> str: - """`path` relative to the repo root (as a string), or as given if it is outside the repo.""" - try: - return str(Path(path).resolve().relative_to(REPO_ROOT)) - except ValueError: - return str(path) - - def parse_seeds(spec: str) -> list[int]: """`0-4` or `0,2,3` (or both, `0-1,3`): the seeds in order, each once.""" seeds = [] @@ -918,42 +766,6 @@ def main() -> None: p.add_argument("--designated-position", type=float, nargs=2, default=None) p.add_argument("--out", type=Path, default=None, help=f"where to write it (default {MOMENTS_DIR}/.json)") - p = sub.add_parser("fouls", help="list our side's fouls in a round-robin run") - p.add_argument("run_dir", type=Path) - p.add_argument("--rule", default=None) - p.add_argument( - "--skip-own-restart", - action="store_true", - help="leave out fouls during our own restarts (keeps_clear does not apply there)", - ) - p.add_argument( - "--include-stoppages", - action="store_true", - help="also list out_of_bounds (the ball leaving the field: a stoppage, not a rules foul)", - ) - p.add_argument( - "--by", - default=None, - metavar="COLUMNS", - help=f"print counts per combination of these columns, comma-separated, of {', '.join(FOUL_COLUMNS)} " - "(e.g. strategy,rule), instead of one line per foul", - ) - p.add_argument( - "--json", - action="store_true", - help="write JSON to stdout instead of text: the foul dicts, or with --by a list of {column: value, ..., " - "count} rows", - ) - - p = sub.add_parser("new", help="write a hand-made moment template to edit by hand") - p.add_argument("name", help="lowercase letters, digits and underscores") - p.add_argument("--command", required=True, choices=[c.name for c in RefereeCommand]) - p.add_argument("--ball", type=float, nargs=2, default=(0.0, 0.0), metavar=("X", "Y")) - p.add_argument("--strategy", default="all") - p.add_argument("--seconds", type=float, default=DEFAULT_SECONDS) - p.add_argument("--check", nargs="+", required=True, help=f"checks ({', '.join(CHECKS)}), rule names or '*'") - p.add_argument("--note", required=True, help="what went wrong, and why it must not happen again") - p = sub.add_parser("play", help="play a moment and print what broke its checks") p.add_argument("moment", type=Path) p.add_argument( @@ -972,26 +784,7 @@ def main() -> None: p.add_argument("--json", type=Path, help=argparse.SUPPRESS) # --against reads the other tree's results args = parser.parse_args() - if args.cmd == "new": - if not re.fullmatch(r"[a-z0-9_]+", args.name): - parser.error("the name must be lowercase letters, digits and underscores") - path = MOMENTS_DIR / f"{args.name}.json" - if path.exists(): - parser.error(f"{path} exists") - try: - m = template( - args.name, - args.note, - args.command, - args.check, - ball=tuple(args.ball), - strategy=args.strategy, - seconds=args.seconds, - ) - print(f"Wrote {save(m)}: edit its positions by hand, then `play` it") - except MomentError as e: - parser.error(str(e)) - elif args.cmd == "capture": + if args.cmd == "capture": m = capture( args.replay, args.t, @@ -1006,30 +799,6 @@ def main() -> None: print( f"Wrote {save(m, args.out)} ({m.scenario.referee_command.name if m.scenario.referee_command else 'no command'})" ) - elif args.cmd == "fouls": - fouls = our_fouls(args.run_dir, args.rule) - if args.skip_own_restart: - fouls = without_own_restarts(fouls) - if not args.include_stoppages: - fouls = without_stoppages(fouls) - if args.by: - columns = [c.strip() for c in args.by.split(",")] - unknown = [c for c in columns if c not in FOUL_COLUMNS] - if unknown: - parser.error(f"--by: unknown column(s) {unknown}; choose from {', '.join(FOUL_COLUMNS)}") - if args.json: - print(fouls_json(fouls, columns)) - else: - print_fouls_by(fouls, columns) - elif args.json: - print(fouls_json(fouls)) - else: - for f in fouls: - print( - f"{f['rule']:<28} t={f['sim_time']:>7.2f} robot {f.get('robot_id')} {f.get('tactic') or '':<24} " - f"{(f['command'] or '?'):<22} {f['restart'] or 'live':<7} " - f"{short_name(f['config_a'])} vs {short_name(f['config_b'])}" - ) else: m = load(args.moment) if args.seed is not None and args.seeds: diff --git a/tools/screen.py b/tools/screen.py new file mode 100644 index 00000000..175296dc --- /dev/null +++ b/tools/screen.py @@ -0,0 +1,346 @@ +#!/usr/bin/env python3 +# ruff: noqa: E402 +"""screen.py — did a change to one strategy do anything in play? A SCREEN, not a verdict. + + pixi run python tools/screen.py STRATEGY --base REF [--run RUN_DIR] [--starts 60] [--seconds 20] + +It plays STRATEGY as it is now (the change: the working tree, shared code included) and as it was at +git ref REF (the base, packed as a `.strategy` file in `replays/eval/frozen/`, as `evaluate.py --frozen` +does) from the same short starts: moments of live play drawn at random from the replays of a run in +which STRATEGY played (by default the latest `replays/tournament_*` that has it), so situations come as +often as they do in matches. Both play our side against the same opponent, the base, under the same +seeded reference noise, so a pair of starts differs only by the change. + +- **Fired:** the two starts of a pair diverged (any robot or the ball apart by more than `SAME_M`). A + change that never fires says nothing; the firing rate is the first thing it reports. +- **Differences** (change minus base), over all starts and over the starts where it fired: goals for, + goals against, and how far upfield the ball was on average. +- **Call**, by a rule fixed before any result (`call()`; docs/strategy_tools_plan.md, "The screen"): + `SKIP: did not fire` if fewer than `MIN_FIRED_SHARE` of starts fired; `SKIP: fewer goals in the + starts` if, over the fired starts, the goal difference is lower by more than 2 standard errors; + otherwise `WORTH EVALUATING`. Only `evaluate.py` gives a verdict. + +It never writes the evaluation ledger, keeps no replays, and plays one strategy only: comparing two +different strategies from short starts is the retired scenario bench, whose per-strategy bias made its +ranking fail. Each run appends a line to `replays/eval/screen_log.jsonl` (`--no-record` skips it): the +screen is on trial, and its calls are checked against `evaluate.py`'s verdicts on the same changes +before it may decide anything. + +Starts begin from rest with fresh tactic memory (`tools/repro_from_replay.py`'s limits), so behaviour +that needs a long build-up fires less often here than in matches. +""" + +from __future__ import annotations + +import os + +os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") + +import argparse +import json +import math +import random +import statistics +import subprocess +import sys +import zlib +from concurrent.futures import ProcessPoolExecutor +from dataclasses import asdict, dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Optional, Sequence + +REPO_ROOT = Path(__file__).resolve().parents[1] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from tools.evaluation.match import TICKS_PER_SECOND +from tools.evaluation.sim_settings import reference_noise +from tools.sim_setup import load_side, sim_runner +from utama_core.bundle.strategy_file import BundledStrategy, frozen +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.replay.fingerprint import CodeGraph +from utama_core.replay.scenario import apply_scenario, scenario_from_replay +from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.strategy import catalog + +FROZEN_DIR = Path("replays/eval/frozen") # shared with evaluate.py --frozen: one file per strategy and commit +LOG_PATH = Path("replays/eval/screen_log.jsonl") + +# The design, fixed before any change was screened (docs/strategy_tools_plan.md, "The screen"). +STARTS = 60 +SECONDS = 20.0 +MIN_FIRED_SHARE = 0.10 +GOAL_SE = 2.0 +SAME_M = 1e-6 + +LIVE = (RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START) +EDGE_S = 5.0 # no starts this close to a replay's ends +MAX_DRAWS = 50 # tries per start to land on live play + + +@dataclass(frozen=True) +class Start: + replay: str + t: float + seed: int + + +@dataclass(frozen=True) +class PairResult: + start: Start + fired: bool + diverged_at_s: Optional[float] + change: dict # goals_for, goals_against, upfield_m + base: dict + + +# --------------------------------------------------------------------------- pure parts (unit tested) + + +def diverged_at(a: Sequence[Sequence[float]], b: Sequence[Sequence[float]], tol: float = SAME_M) -> Optional[int]: + """The first tick at which two trajectories (one row of coordinates per tick) are apart by more than + `tol` in any coordinate, or differ in length; None if they never are.""" + for i, (row_a, row_b) in enumerate(zip(a, b)): + if len(row_a) != len(row_b) or any(abs(x - y) > tol for x, y in zip(row_a, row_b)): + return i + return None if len(a) == len(b) else min(len(a), len(b)) + + +def mean_se(values: Sequence[float]) -> tuple[float, float]: + """Mean and its standard error; (0, 0) for none, SE 0 for one.""" + if not values: + return 0.0, 0.0 + if len(values) == 1: + return float(values[0]), 0.0 + return statistics.fmean(values), statistics.stdev(values) / math.sqrt(len(values)) + + +def goal_difference_changes(results: Sequence[PairResult]) -> list[float]: + """Per pair: the change's goal difference minus the base's.""" + return [ + (r.change["goals_for"] - r.change["goals_against"]) - (r.base["goals_for"] - r.base["goals_against"]) + for r in results + ] + + +def call(n_starts: int, fired_gd_changes: Sequence[float]) -> str: + """The screen's call: `fired_gd_changes` holds the goal-difference change of each start that fired. + + Screening out a change that would have won loses it for good; letting a useless one through costs + one evaluation. So it skips only a change that did nothing, or one whose fired starts scored clearly + worse (by more than `GOAL_SE` standard errors).""" + if n_starts == 0 or len(fired_gd_changes) < MIN_FIRED_SHARE * n_starts: + return "SKIP: did not fire" + mean, se = mean_se(fired_gd_changes) + if mean + GOAL_SE * se < 0: + return "SKIP: fewer goals in the starts" + return "WORTH EVALUATING" + + +def draw_times(rng: random.Random, duration_s: float, n: int) -> list[float]: + """`n` times uniformly within a replay of `duration_s`, `EDGE_S` from each end.""" + lo, hi = EDGE_S, max(EDGE_S, duration_s - EDGE_S - SECONDS) + return [rng.uniform(lo, hi) for _ in range(n)] + + +# --------------------------------------------------------------------------- choosing starts + + +def replays_with(run_dir: Path, strategy: str) -> list[Path]: + """The run's replays in which `strategy` played, those where it was config_a (our side) first. In the + others a start puts it in its opponent's positions: still a situation of its matches.""" + summary = json.loads((run_dir / "summary.json").read_text()) + name = catalog.plain_name(strategy) + as_a, as_b = [], [] + for r in summary.get("results", []): + a, b = catalog.plain_name(r["config_a"]), catalog.plain_name(r["config_b"]) + path = run_dir / f"{a}_vs_{b}.npz" + if not path.exists(): + continue + if a == name: + as_a.append(path) + elif b == name: + as_b.append(path) + return as_a + as_b + + +MIN_REPLAYS = 3 # a run with fewer replays of the strategy (a `--pair` run) gives too few situations + + +def latest_run_with(strategy: str, replays: Path = Path("replays")) -> Path: + """The latest run with at least `MIN_REPLAYS` replays of `strategy`, else the latest with any.""" + runs = [d for d in sorted(replays.glob("tournament_*"), reverse=True) if (d / "summary.json").exists()] + counts = {d: len(replays_with(d, strategy)) for d in runs} + for wanted in (MIN_REPLAYS, 1): + for run_dir in runs: + if counts[run_dir] >= wanted: + return run_dir + raise SystemExit(f"no replays/tournament_* has a replay of {strategy}; give one with --run") + + +def replay_seconds(path: Path) -> float: + """How long a replay runs, on the clock `scenario_from_replay` takes.""" + from utama_core.replay.columnar_reader import load_columnar_replay + + ts = load_columnar_replay(path).ts + return float(ts[-1] - ts[0]) if len(ts) else 0.0 + + +def choose_starts(paths: list[Path], n: int, seed: int) -> list[Start]: + """`n` moments of live play, the replays taken in turn, each with its own noise seed.""" + rng = random.Random(seed) + lengths = {path: replay_seconds(path) for path in paths} + starts: list[Start] = [] + for i in range(n): + path = paths[i % len(paths)] + for t in draw_times(rng, lengths[path], MAX_DRAWS): + try: + scenario = scenario_from_replay(path, t) + except (ValueError, IndexError): + continue + if scenario.referee_command in LIVE: + starts.append(Start(path.as_posix(), round(t, 3), zlib.crc32(f"{seed}:{i}".encode()))) + break + return starts + + +# --------------------------------------------------------------------------- playing + + +def _play(side: str, opponent: str, start: Start, seconds: float) -> tuple[list[tuple], dict]: + """One start: our side `side` against `opponent`. Returns the trajectory and the measures.""" + strategy, enemy = load_side(side), load_side(opponent) + runner, _ = sim_runner(strategy, enemy, sim_noise=SimNoise.from_dict(reference_noise(start.seed))) + trajectory: list[tuple] = [] + ball_x: list[float] = [] + try: + apply_scenario(runner, scenario_from_replay(Path(start.replay), start.t), verify=False) + for _ in range(int(seconds * TICKS_PER_SECOND)): + runner.step_once() + frame = runner.my.current_game_frame + row = [] + if frame.ball is not None: + row += [frame.ball.p.x, frame.ball.p.y] + ball_x.append(frame.ball.p.x) + for robots in (frame.friendly_robots, frame.enemy_robots): + for rid in sorted(robots): + row += [robots[rid].p.x, robots[rid].p.y] + trajectory.append(tuple(row)) + referee = runner.my.game.referee + goals_for, goals_against = referee.yellow_team.score, referee.blue_team.score # our side is yellow + finally: + runner.close() + for s in (strategy, enemy): + if isinstance(s, BundledStrategy): + s.close() + # Our side defends the right goal (sim_runner), so upfield is towards -x. + upfield = -statistics.fmean(ball_x) if ball_x else 0.0 + return trajectory, {"goals_for": goals_for, "goals_against": goals_against, "upfield_m": round(upfield, 4)} + + +def play_pair(change: str, base: str, start: Start, seconds: float) -> PairResult: + change_traj, change_m = _play(change, base, start, seconds) + base_traj, base_m = _play(base, base, start, seconds) + tick = diverged_at(change_traj, base_traj) + return PairResult(start, tick is not None, None if tick is None else tick / TICKS_PER_SECOND, change_m, base_m) + + +# --------------------------------------------------------------------------- report + + +def _git(*args: str) -> str: + return subprocess.run(["git", *args], cwd=REPO_ROOT, capture_output=True, text=True).stdout.strip() + + +def report(results: list[PairResult], n_starts: int) -> tuple[list[str], dict]: + fired = [r for r in results if r.fired] + lines = [f"fired in {len(fired)} of {n_starts} starts"] + numbers: dict = {"starts": n_starts, "fired": len(fired)} + for label, group in (("all starts", results), ("fired starts", fired)): + rows = { + "goal difference": goal_difference_changes(group), + "goals for": [r.change["goals_for"] - r.base["goals_for"] for r in group], + "goals against": [r.change["goals_against"] - r.base["goals_against"] for r in group], + "ball upfield (m)": [r.change["upfield_m"] - r.base["upfield_m"] for r in group], + } + lines.append(f"change minus base, {label} ({len(group)}):") + for name, values in rows.items(): + mean, se = mean_se(values) + lines.append(f" {name:<18} {mean:+.3f} ± {se:.3f} (SE)") + numbers.setdefault(label, {})[name] = [round(mean, 4), round(se, 4)] + if fired: + times = sorted(r.diverged_at_s for r in fired) + lines.append(f"first divergence: median {statistics.median(times):.2f} s into a start") + numbers["call"] = call(n_starts, goal_difference_changes(fired)) + return lines, numbers + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("strategy", help="the one strategy the change is to (a catalog name)") + parser.add_argument("--base", required=True, help="git ref of the code before the change, e.g. HEAD~1 or v2.5.0") + parser.add_argument("--run", type=Path, default=None, help="run dir to draw starts from (default: latest with it)") + parser.add_argument("--starts", type=int, default=STARTS) + parser.add_argument("--seconds", type=float, default=SECONDS) + parser.add_argument("--seed", type=int, default=0, help="which starts and noise (default 0)") + parser.add_argument("--max-workers", type=int, default=8, help="parallel starts (default 8)") + parser.add_argument("--no-record", action="store_true", help=f"don't append to {LOG_PATH}") + args = parser.parse_args() + + name = catalog.plain_name(args.strategy) + if name not in catalog.names(): + raise SystemExit(f"unknown strategy {args.strategy!r}; strategies: {', '.join(catalog.names())}") + designed = (args.starts, args.seconds) == (STARTS, SECONDS) + print("SCREEN, not a verdict: did this change do anything in play? Only evaluate.py judges a strategy.") + if not designed: + print( + f" (off-design: {args.starts} starts of {args.seconds:g} s; the call's rule assumes {STARTS} of {SECONDS:g})" + ) + + base_file = frozen(name, args.base, FROZEN_DIR).as_posix() + graph = CodeGraph() + change_fp, base_fp = graph.strategy_fingerprint(name)[:16], graph.strategy_fingerprint(base_file)[:16] + record = { + "time_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"), + "strategy": name, + "base": base_file, + "commit": _git("rev-parse", "HEAD"), + "dirty": bool(_git("status", "--porcelain", "--untracked-files=no")), + "change_fp": change_fp, + "base_fp": base_fp, + "seed": args.seed, + "on_design": designed, + } + print(f" {name} now ({change_fp}) against {base_file} ({base_fp})") + + if change_fp == base_fp: + lines, numbers = ["the strategy's code is the same at both refs: nothing to play"], { + "starts": 0, + "fired": 0, + "call": "SKIP: did not fire", + } + else: + run_dir = args.run or latest_run_with(name) + paths = replays_with(run_dir, name) + starts = choose_starts(paths, args.starts, args.seed) + record["run"] = run_dir.as_posix() + print(f" {len(starts)} starts of {args.seconds:g} s of live play from {len(paths)} replays in {run_dir}") + with ProcessPoolExecutor(max_workers=args.max_workers) as pool: + results = list(pool.map(play_pair, [name] * len(starts), [base_file] * len(starts), starts, + [args.seconds] * len(starts))) # fmt: skip + lines, numbers = report(results, len(starts)) + record["pairs"] = [asdict(r) for r in results] + + print("\n".join(lines)) + print(f"call: {numbers['call']}") + record.update(numbers) + if not args.no_record: + LOG_PATH.parent.mkdir(parents=True, exist_ok=True) + with LOG_PATH.open("a") as f: + f.write(json.dumps(record) + "\n") + print(f"recorded in {LOG_PATH}") + + +if __name__ == "__main__": + main() diff --git a/tools/triage.py b/tools/triage.py index 2556f68f..8783cd4d 100644 --- a/tools/triage.py +++ b/tools/triage.py @@ -24,6 +24,15 @@ their scores, the finding counts by kind, then each pictured finding with its message and picture path. `OUT` defaults to `RUN_DIR/triage/`. Read-only: nothing is played or changed. + +`--fouls` instead lists our side's (config_a's) fouls in a round-robin run, each with the referee command +active then and whether that restart was ours or theirs: the starting points for a regression moment +(`tools/moments.py capture`). `--rule NAME` keeps one rule, `--skip-own-restart` leaves out fouls during our +own restarts, `--by strategy,rule` counts per combination instead (columns: strategy, rule, tactic, +restart), `--json` writes JSON. `out_of_bounds`, the ball leaving the field, is a stoppage and is left out +unless `--include-stoppages` (`utama_core/analysis/fouls.py`; until 2026-11-11 `moments.py fouls`). + + pixi run python tools/triage.py replays/tournament_ --fouls [--rule keep_out] [--by strategy,rule] """ from __future__ import annotations @@ -49,6 +58,7 @@ from tools import match_timeline from tools.evaluation.match import _short_name from tools.plan_trace import replay_game_at +from utama_core.analysis import fouls as fouls_lib from utama_core.analysis.findings import Finding, write_jsonl from utama_core.analysis.matches import STEM, Match, load_match from utama_core.analysis.plan_trace import plan_findings, plan_trace @@ -379,6 +389,32 @@ def triage( return write_index(out, run_dir, reports, max_pictures, restarts) +def fouls_report( + run_dir: Path, + rule: Optional[str] = None, + skip_own_restart: bool = False, + include_stoppages: bool = False, + by: Optional[str] = None, + as_json: bool = False, +) -> list[str]: + """`--fouls`: our side's fouls in `run_dir` as lines to print (see the module docstring).""" + found = fouls_lib.our_fouls(run_dir, rule) + if skip_own_restart: + found = fouls_lib.without_own_restarts(found) + if not include_stoppages: + found = fouls_lib.without_stoppages(found) + columns = [c.strip() for c in by.split(",")] if by else None + if columns: + unknown = [c for c in columns if c not in fouls_lib.FOUL_COLUMNS] + if unknown: + raise ValueError(f"--by: unknown column(s) {unknown}; choose from {', '.join(fouls_lib.FOUL_COLUMNS)}") + if as_json: + return [fouls_lib.fouls_json(found, columns)] + if columns: + return fouls_lib.fouls_by_table(found, columns) + return [fouls_lib.foul_line(f) for f in found] + + def main() -> None: parser = argparse.ArgumentParser( description=__doc__.split("\n\n")[0], formatter_class=argparse.RawDescriptionHelpFormatter @@ -390,7 +426,7 @@ def main() -> None: "--strategy", action="append", metavar="NAME", - help="only matches where this strategy is config_a (repeatable; short or build_*_kernel_strategy names)", + help="only matches where this strategy is config_a (repeatable; plain names, or the build__kernel_strategy names of old runs)", ) parser.add_argument( "--matches", type=int, default=3, help="each strategy's N worst matches by goal difference (default 3)" @@ -403,7 +439,23 @@ def main() -> None: action="store_true", help="also check every restart's referee override (restart_picture findings). SLOW: about 45 s a match", ) + fouls = parser.add_argument_group("--fouls: list our side's fouls instead (see the module docstring)") + fouls.add_argument("--fouls", action="store_true", help="list our side's fouls in the run; nothing else") + fouls.add_argument("--rule", default=None, help="only this rule") + fouls.add_argument("--skip-own-restart", action="store_true", help="leave out fouls during our own restarts") + fouls.add_argument("--include-stoppages", action="store_true", help="also list out_of_bounds") + fouls.add_argument( + "--by", default=None, metavar="COLUMNS", help=f"counts per combination of {', '.join(fouls_lib.FOUL_COLUMNS)}" + ) + fouls.add_argument("--json", action="store_true", help="JSON to stdout instead of text") args = parser.parse_args() + if args.fouls: + try: + print("\n".join(fouls_report(args.run_dir, args.rule, args.skip_own_restart, args.include_stoppages, + args.by, args.json))) # fmt: skip + except ValueError as e: + parser.error(str(e)) + return index = triage( args.run_dir, strategies=set(args.strategy) if args.strategy else None, diff --git a/utama_core/analysis/fouls.py b/utama_core/analysis/fouls.py new file mode 100644 index 00000000..574fd2f0 --- /dev/null +++ b/utama_core/analysis/fouls.py @@ -0,0 +1,126 @@ +"""Our side's fouls in a round-robin run, with the referee command active at each: the starting points for +new regression moments. `tools/triage.py --fouls` prints them; `tools/moments.py` uses `restart_side` in +its checks. (Until 2026-11-11 this was `moments.py fouls`.) + +`out_of_bounds`, the ball leaving the field, is a stoppage rather than a rules foul (`STOPPAGE_RULES`). +""" + +from __future__ import annotations + +import json +from collections import Counter +from pathlib import Path +from typing import Optional + +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.replay.scenario import _referee_command_at +from utama_core.strategy.catalog import plain_name + +REPO_ROOT = Path(__file__).resolve().parents[2] + +# Rules that stop play without being a rules foul: the ball leaving the field. +STOPPAGE_RULES = frozenset({"out_of_bounds"}) +FOUL_COLUMNS = ("strategy", "rule", "tactic", "restart") + + +def restart_side(command: Optional[RefereeCommand], we_are_yellow: bool = True) -> Optional[str]: + """ "ours" for a restart our team takes, "theirs" for one the other team takes, None for + STOP, live play and timeouts.""" + if command is None or command.name.startswith("TIMEOUT"): + return None + if command.name.endswith("YELLOW" if we_are_yellow else "BLUE"): + return "ours" + if command.name.endswith("BLUE" if we_are_yellow else "YELLOW"): + return "theirs" + return None + + +def without_own_restarts(fouls: list[dict]) -> list[dict]: + """`fouls` minus those during a restart our team takes: `keeps_clear` does not apply there.""" + return [f for f in fouls if f.get("restart") != "ours"] + + +def without_stoppages(fouls: list[dict]) -> list[dict]: + return [f for f in fouls if f["rule"] not in STOPPAGE_RULES] + + +def _foul_column(f: dict, column: str) -> str: + if column == "strategy": + return plain_name(f["config_a"]) + if column == "restart": + return f.get("restart") or "live" + return str(f.get(column) or "-") + + +def count_fouls(fouls: list[dict], columns: list[str]) -> list[tuple[tuple[str, ...], int]]: + """How many of `fouls` fall in each combination of `columns` (names from `FOUL_COLUMNS`), + most common first; ties in name order.""" + counts = Counter(tuple(_foul_column(f, c) for c in columns) for f in fouls) + return sorted(counts.items(), key=lambda item: (-item[1], item[0])) + + +def fouls_json(fouls: list[dict], columns: Optional[list[str]] = None) -> str: + """`fouls` as JSON: the foul dicts as they are, or with `columns` the `count_fouls` rows as + {column: value, ..., "count": n} objects, most common first.""" + if columns is None: + data = fouls + else: + data = [{**dict(zip(columns, key)), "count": n} for key, n in count_fouls(fouls, columns)] + return json.dumps(data, indent=1, sort_keys=True) + + +def fouls_by_table(fouls: list[dict], columns: list[str]) -> list[str]: + """`count_fouls` as table lines: a count column, then one column per name, then the total.""" + rows = count_fouls(fouls, columns) + widths = [max([len(c)] + [len(key[i]) for key, _ in rows]) for i, c in enumerate(columns)] + lines = [f"{'count':>5} " + " ".join(f"{c:<{w}}" for c, w in zip(columns, widths))] + for key, n in rows: + lines.append(f"{n:>5} " + " ".join(f"{v:<{w}}" for v, w in zip(key, widths))) + lines.append(f"{sum(n for _, n in rows):>5} total") + return lines + + +def foul_line(f: dict) -> str: + """One foul as a line: rule, time, robot, tactic, referee command, restart side, match.""" + return ( + f"{f['rule']:<28} t={f['sim_time']:>7.2f} robot {f.get('robot_id')} {f.get('tactic') or '':<24} " + f"{(f['command'] or '?'):<22} {f['restart'] or 'live':<7} " + f"{plain_name(f['config_a'])} vs {plain_name(f['config_b'])}" + ) + + +def _repo_relative(path: Path) -> str: + """`path` relative to the repo root (as a string), or as given if it is outside the repo.""" + try: + return str(Path(path).resolve().relative_to(REPO_ROOT)) + except ValueError: + return str(path) + + +def our_fouls(run_dir: Path, rule: Optional[str] = None) -> list[dict]: + """Every foul config_a (our side in the replay) committed in a round-robin run, from its + summary.json. Each carries the referee `command` active at its time (from the match's + `.intentions.jsonl`, None if absent), its `restart` side ("ours", "theirs", or None for live play + and STOP) and its match's `replay` (the .npz, else the .pkl, relative to the repo root; None if + neither is there), for replay_trace and repro.""" + run_dir = Path(run_dir) + summary = json.loads((run_dir / "summary.json").read_text()) + out = [] + for r in summary["results"]: + stem = run_dir / f"{plain_name(r['config_a'])}_vs_{plain_name(r['config_b'])}" + sidecar = Path(f"{stem}.intentions.jsonl") + replay = next((p for p in (Path(f"{stem}.npz"), Path(f"{stem}.pkl")) if p.exists()), None) + for f in (r.get("stats") or {}).get("fouls") or []: + if f.get("side") == "friendly" and (rule is None or f["rule"] == rule): + command = _referee_command_at(sidecar, f["sim_time"]) + out.append( + { + "config_a": r["config_a"], + "config_b": r["config_b"], + **f, + "command": command.name if command else None, + "restart": restart_side(command), + "replay": _repo_relative(replay) if replay is not None else None, + } + ) + return out diff --git a/utama_core/tests/analysis/test_fouls.py b/utama_core/tests/analysis/test_fouls.py new file mode 100644 index 00000000..465e6308 --- /dev/null +++ b/utama_core/tests/analysis/test_fouls.py @@ -0,0 +1,135 @@ +"""`utama_core/analysis/fouls.py`: our side's fouls in a run with the referee command active, as +`tools/triage.py --fouls` lists them (moved from `moments.py fouls` on 2026-11-11).""" + +import json + +import pytest + +from utama_core.analysis import fouls as F +from utama_core.entities.referee.referee_command import RefereeCommand + + +@pytest.mark.parametrize( + "command, we_are_yellow, side", + [ + ("DIRECT_FREE_YELLOW", True, "ours"), + ("BALL_PLACEMENT_YELLOW", True, "ours"), + ("DIRECT_FREE_BLUE", True, "theirs"), + ("DIRECT_FREE_BLUE", False, "ours"), + ("NORMAL_START", True, None), + ("STOP", True, None), + ("TIMEOUT_YELLOW", True, None), + ], +) +def test_restart_side_is_ours_theirs_or_neither(command, we_are_yellow, side): + assert F.restart_side(RefereeCommand[command], we_are_yellow) == side + assert F.restart_side(None, we_are_yellow) is None + + +def _run(tmp_path, fouls, sidecar_rows=None): + results = [{"config_a": "a", "config_b": "b", "stats": {"fouls": fouls}}] + (tmp_path / "summary.json").write_text(json.dumps({"results": results})) + if sidecar_rows is not None: + (tmp_path / "a_vs_b.intentions.jsonl").write_text("\n".join(json.dumps(r) for r in sidecar_rows) + "\n") + return tmp_path + + +def _foul(t, side="friendly", rule="keep_out"): + return {"rule": rule, "sim_time": t, "side": side, "robot_id": 1, "tactic": "X", "inferred": False} + + +def test_our_fouls_names_the_command_active_and_the_restart_side(tmp_path): + rows = [ + {"event": "referee", "sim_time": 0.0, "command": "NORMAL_START"}, + {"event": "referee", "sim_time": 4.0, "command": "DIRECT_FREE_BLUE"}, + {"event": "referee", "sim_time": 10.0, "command": "DIRECT_FREE_YELLOW"}, + ] + run = _run(tmp_path, [_foul(1.0), _foul(5.0), _foul(12.0), _foul(20.0), _foul(6.0, side="enemy")], rows) + found = F.our_fouls(run) + assert [(f["sim_time"], f["command"], f["restart"]) for f in found] == [ + (1.0, "NORMAL_START", None), + (5.0, "DIRECT_FREE_BLUE", "theirs"), + (12.0, "DIRECT_FREE_YELLOW", "ours"), + (20.0, "DIRECT_FREE_YELLOW", "ours"), + ] + assert [f["sim_time"] for f in F.without_own_restarts(found)] == [1.0, 5.0] + + +def test_our_fouls_names_the_match_replay_relative_to_the_repo(tmp_path): + run = _run(tmp_path, [_foul(3.0)]) + (found,) = F.our_fouls(run) + assert found["replay"] is None # no a_vs_b replay in the run dir + (tmp_path / "a_vs_b.npz").write_bytes(b"") + (found,) = F.our_fouls(run) + assert found["replay"] == str(tmp_path / "a_vs_b.npz") # outside the repo: as given + (tmp_path / "a_vs_b.npz").unlink() + (tmp_path / "a_vs_b.pkl").write_bytes(b"") + (found,) = F.our_fouls(run) + assert found["replay"] == str(tmp_path / "a_vs_b.pkl") + + +def test_repo_relative_paths_drop_the_repo_root(): + assert F._repo_relative(F.REPO_ROOT / "replays" / "t" / "a_vs_b.npz") == "replays/t/a_vs_b.npz" + + +def test_our_fouls_without_a_match_log_has_no_command(tmp_path): + (found,) = F.our_fouls(_run(tmp_path, [_foul(3.0)])) + assert found["command"] is None and found["restart"] is None + assert F.without_own_restarts([found]) == [found] + + +def _row(config_a, rule, restart=None, tactic="X"): + return {"config_a": config_a, "config_b": "b", "rule": rule, "tactic": tactic, "restart": restart} + + +def test_count_fouls_groups_by_the_given_columns_most_common_first(): + rows = [_row("a", "keep_out"), _row("b", "crashing"), _row("a", "keep_out")] + rows += [_row("a", "crashing"), _row("b", "crashing"), _row("b", "crashing")] + assert F.count_fouls(rows, ["strategy", "rule"]) == [ + (("b", "crashing"), 3), + (("a", "keep_out"), 2), + (("a", "crashing"), 1), + ] + + +def test_count_fouls_names_a_missing_restart_live_and_a_missing_tactic_dash(): + rows = [_row("a", "keep_out", restart=None, tactic=None), _row("a", "keep_out", restart="theirs")] + assert F.count_fouls(rows, ["restart", "tactic"]) == [(("live", "-"), 1), (("theirs", "X"), 1)] + + +def test_count_fouls_ties_are_in_name_order(): + assert [k for k, _ in F.count_fouls([_row("b", "keep_out"), _row("a", "keep_out")], ["strategy"])] == [ + ("a",), + ("b",), + ] + + +def test_without_stoppages_drops_out_of_bounds_and_keeps_rules_fouls(): + rows = [_row("a", "out_of_bounds"), _row("a", "defense_area_stoppage"), _row("a", "keep_out")] + assert [f["rule"] for f in F.without_stoppages(rows)] == ["defense_area_stoppage", "keep_out"] + + +def test_fouls_by_table_has_header_counts_and_total(): + lines = F.fouls_by_table([_row("a", "keep_out"), _row("a", "keep_out")], ["strategy", "rule"]) + assert [line.split() for line in lines] == [["count", "strategy", "rule"], ["2", "a", "keep_out"], ["2", "total"]] + + +def test_fouls_json_is_the_foul_list_or_the_by_counts_as_rows(): + rows = [_row("a", "keep_out", restart=None), _row("a", "keep_out"), _row("b", "crashing")] + assert json.loads(F.fouls_json(rows)) == rows + assert json.loads(F.fouls_json(rows, ["strategy", "rule"])) == [ + {"strategy": "a", "rule": "keep_out", "count": 2}, + {"strategy": "b", "rule": "crashing", "count": 1}, + ] + + +def test_triage_fouls_filters_then_counts(tmp_path): + from tools.triage import fouls_report + + run = _run(tmp_path, [_foul(1.0), _foul(2.0, rule="out_of_bounds"), _foul(3.0, rule="crashing")]) + assert len(fouls_report(run)) == 2 # out_of_bounds is a stoppage, left out + assert len(fouls_report(run, include_stoppages=True)) == 3 + assert fouls_report(run, rule="crashing")[0].startswith("crashing") + assert [line.split() for line in fouls_report(run, by="rule")][-1] == ["2", "total"] + with pytest.raises(ValueError, match="unknown column"): + fouls_report(run, by="nope") diff --git a/utama_core/tests/moments/test_moment_authoring.py b/utama_core/tests/moments/test_moment_authoring.py index 18869c6e..9422d900 100644 --- a/utama_core/tests/moments/test_moment_authoring.py +++ b/utama_core/tests/moments/test_moment_authoring.py @@ -1,15 +1,20 @@ -"""Pure checks (no rsim) of hand-made moments in `tools/moments.py`: the template and the -validation errors.""" +"""Pure checks (no rsim) of moments in `tools/moments.py`: loading, saving, the validation errors and +`play --seed`. (Hand-made templates, `moments.py new`, were removed on 2026-11-11: moments are captured +from replays.)""" import dataclasses +import re import pytest from tools import moments +PROBE = moments.MOMENTS_DIR / "free_kick_defender_dodges_into_ball.json" + def _template(): - return moments.template("probe", "a note", "NORMAL_START", ["keeps_clear"]) + """A captured moment (seed 2), renamed, checking `keeps_clear` only.""" + return dataclasses.replace(moments.load(PROBE), name="probe", note="a note", checks=["keeps_clear"]) def _with_friendly(m, robots): @@ -24,24 +29,15 @@ def _replace_robot(robots, rid, **changes): return tuple(dataclasses.replace(r, **changes) if r.id == rid else r for r in robots) -def test_template_round_trips_through_load(tmp_path): +def test_a_moment_round_trips_through_save_and_load(tmp_path): m = _template() path = moments.save(m, tmp_path / "probe.json") again = moments.load(path) assert moments.to_dict(again) == moments.to_dict(m) - assert again.sim_noise["seed"] == 1 assert sorted(r.id for r in again.scenario.friendly_robots) == list(range(6)) assert sorted(r.id for r in again.scenario.enemy_robots) == list(range(6)) -def test_template_is_our_side_on_the_right_facing_left(): - m = _template() - ours = {r.id: r for r in m.scenario.friendly_robots} - theirs = {r.id: r for r in m.scenario.enemy_robots} - assert ours[0].x > 0 and theirs[0].x < 0 - assert all(ours[i].x > 0 and theirs[i].x < 0 for i in range(6)) - - def test_existing_moments_still_load(): for path in sorted(moments.MOMENTS_DIR.glob("*.json")): moments.load(path) @@ -64,13 +60,13 @@ def test_each_side_needs_ids_0_to_5_exactly_once(): def test_robots_must_be_on_the_pitch(): m = _with_friendly(_template(), _replace_robot(_template().scenario.friendly_robots, 2, x=5.0)) - with pytest.raises(moments.MomentError, match=r"friendly robot 2 at \(5.00, -1.20\) is off the pitch"): + with pytest.raises(moments.MomentError, match=r"friendly robot 2 at \(5.00, -?\d+\.\d\d\) is off the pitch"): moments.validate(m) def test_the_ball_must_be_on_the_pitch(): m = dataclasses.replace(_template(), scenario=dataclasses.replace(_template().scenario, ball_y=3.5)) - with pytest.raises(moments.MomentError, match=r"ball at \(0.00, 3.50\) is off the pitch"): + with pytest.raises(moments.MomentError, match=r"ball at \(-?\d+\.\d\d, 3.50\) is off the pitch"): moments.validate(m) @@ -108,7 +104,7 @@ def test_every_problem_is_reported_together(): assert "unknown check 'nope'" in str(err.value) and "seconds must be positive" in str(err.value) -# --- `play --seed`, and the foul listing's restart side --------------------------------------- +# --- `play --seed` and `--against` --------------------------------------------------------------- def test_with_seed_replaces_only_the_seed_and_does_not_mutate_the_moment(): @@ -118,7 +114,7 @@ def test_with_seed_replaces_only_the_seed_and_does_not_mutate_the_moment(): assert {k: v for k, v in seeded.sim_noise.items() if k != "seed"} == { k: v for k, v in m.sim_noise.items() if k != "seed" } - assert m.sim_noise["seed"] == 1 + assert m.sim_noise["seed"] == 2 def test_with_seed_needs_noise_to_seed(): @@ -126,149 +122,8 @@ def test_with_seed_needs_noise_to_seed(): moments.with_seed(dataclasses.replace(_template(), sim_noise=None), 3) -@pytest.mark.parametrize( - "command, we_are_yellow, side", - [ - ("DIRECT_FREE_YELLOW", True, "ours"), - ("BALL_PLACEMENT_YELLOW", True, "ours"), - ("DIRECT_FREE_BLUE", True, "theirs"), - ("DIRECT_FREE_BLUE", False, "ours"), - ("NORMAL_START", True, None), - ("STOP", True, None), - ("TIMEOUT_YELLOW", True, None), - ], -) -def test_restart_side_is_ours_theirs_or_neither(command, we_are_yellow, side): - from utama_core.entities.referee.referee_command import RefereeCommand - - assert moments.restart_side(RefereeCommand[command], we_are_yellow) == side - assert moments.restart_side(None, we_are_yellow) is None - - -def test_our_fouls_names_the_command_active_and_the_restart_side(tmp_path): - import json - - def foul(t, side="friendly", rule="keep_out"): - return {"rule": rule, "sim_time": t, "side": side, "robot_id": 1, "tactic": "X", "inferred": False} - - results = [ - { - "config_a": "a", - "config_b": "b", - "stats": {"fouls": [foul(1.0), foul(5.0), foul(12.0), foul(20.0), foul(6.0, side="enemy")]}, - } - ] - (tmp_path / "summary.json").write_text(json.dumps({"results": results})) - rows = [ - {"event": "referee", "sim_time": 0.0, "command": "NORMAL_START"}, - {"event": "referee", "sim_time": 4.0, "command": "DIRECT_FREE_BLUE"}, - {"event": "referee", "sim_time": 10.0, "command": "DIRECT_FREE_YELLOW"}, - ] - (tmp_path / "a_vs_b.intentions.jsonl").write_text("\n".join(json.dumps(r) for r in rows) + "\n") - - fouls = moments.our_fouls(tmp_path) - assert [(f["sim_time"], f["command"], f["restart"]) for f in fouls] == [ - (1.0, "NORMAL_START", None), - (5.0, "DIRECT_FREE_BLUE", "theirs"), - (12.0, "DIRECT_FREE_YELLOW", "ours"), - (20.0, "DIRECT_FREE_YELLOW", "ours"), - ] - kept = moments.without_own_restarts(fouls) - assert [f["sim_time"] for f in kept] == [1.0, 5.0] - - -def test_our_fouls_names_the_match_replay_relative_to_the_repo(tmp_path): - import json - - row = {"rule": "keep_out", "sim_time": 3.0, "side": "friendly", "robot_id": 1, "tactic": "X"} - results = [{"config_a": "a", "config_b": "b", "stats": {"fouls": [row]}}] - (tmp_path / "summary.json").write_text(json.dumps({"results": results})) - (fouls,) = moments.our_fouls(tmp_path) - assert fouls["replay"] is None # no a_vs_b replay in the run dir - - (tmp_path / "a_vs_b.npz").write_bytes(b"") - (fouls,) = moments.our_fouls(tmp_path) - assert fouls["replay"] == str(tmp_path / "a_vs_b.npz") # outside the repo: as given - - (tmp_path / "a_vs_b.npz").unlink() - (tmp_path / "a_vs_b.pkl").write_bytes(b"") - (fouls,) = moments.our_fouls(tmp_path) - assert fouls["replay"] == str(tmp_path / "a_vs_b.pkl") - - -def test_repo_relative_paths_drop_the_repo_root(): - assert moments._repo_relative(moments.REPO_ROOT / "replays" / "t" / "a_vs_b.npz") == "replays/t/a_vs_b.npz" - - -def test_our_fouls_without_a_match_log_has_no_command(tmp_path): - import json - - row = {"rule": "keep_out", "sim_time": 3.0, "side": "friendly", "robot_id": 1, "tactic": "X"} - results = [{"config_a": "a", "config_b": "b", "stats": {"fouls": [row]}}] - (tmp_path / "summary.json").write_text(json.dumps({"results": results})) - (fouls,) = moments.our_fouls(tmp_path) - assert fouls["command"] is None and fouls["restart"] is None - assert moments.without_own_restarts([fouls]) == [fouls] - - -def _foul_row(config_a, rule, restart=None, tactic="X"): - return { - "config_a": config_a, - "config_b": "b", - "rule": rule, - "tactic": tactic, - "restart": restart, - } - - -def test_count_fouls_groups_by_the_given_columns_most_common_first(): - fouls = [ - _foul_row("a", "keep_out"), - _foul_row("b", "crashing"), - _foul_row("a", "keep_out"), - _foul_row("a", "crashing"), - _foul_row("b", "crashing"), - _foul_row("b", "crashing"), - ] - assert moments.count_fouls(fouls, ["strategy", "rule"]) == [ - (("b", "crashing"), 3), - (("a", "keep_out"), 2), - (("a", "crashing"), 1), - ] - - -def test_count_fouls_names_a_missing_restart_live_and_a_missing_tactic_dash(): - fouls = [_foul_row("a", "keep_out", restart=None, tactic=None), _foul_row("a", "keep_out", restart="theirs")] - assert moments.count_fouls(fouls, ["restart", "tactic"]) == [(("live", "-"), 1), (("theirs", "X"), 1)] - - -def test_count_fouls_ties_are_in_name_order(): - fouls = [_foul_row("b", "keep_out"), _foul_row("a", "keep_out")] - assert [key for key, _ in moments.count_fouls(fouls, ["strategy"])] == [("a",), ("b",)] - - -def test_without_stoppages_drops_out_of_bounds_and_keeps_rules_fouls(): - fouls = [_foul_row("a", "out_of_bounds"), _foul_row("a", "defense_area_stoppage"), _foul_row("a", "keep_out")] - assert [f["rule"] for f in moments.without_stoppages(fouls)] == ["defense_area_stoppage", "keep_out"] - - -def test_print_fouls_by_prints_header_counts_and_total(capsys): - moments.print_fouls_by([_foul_row("a", "keep_out"), _foul_row("a", "keep_out")], ["strategy", "rule"]) - lines = capsys.readouterr().out.splitlines() - assert lines[0].split() == ["count", "strategy", "rule"] - assert lines[1].split() == ["2", "a", "keep_out"] - assert lines[2].split() == ["2", "total"] - - -def test_fouls_json_is_the_foul_list_or_the_by_counts_as_rows(): - import json - - fouls = [_foul_row("a", "keep_out", restart=None), _foul_row("a", "keep_out"), _foul_row("b", "crashing")] - as_list = json.loads(moments.fouls_json(fouls)) - assert as_list == fouls - - rows = json.loads(moments.fouls_json(fouls, ["strategy", "rule"])) - assert rows == [ - {"strategy": "a", "rule": "keep_out", "count": 2}, - {"strategy": "b", "rule": "crashing", "count": 1}, - ] +def test_against_worktrees_sit_beside_the_repo_in_an_undated_folder(): + """Until 2026-11-11 `--against` used `moments-work-20261017/against`, a dated folder from one session.""" + assert moments.AGAINST_DIR.parent == moments.REPO_ROOT.parent + assert moments.AGAINST_DIR.name == f"{moments.REPO_ROOT.name}-moments-against" + assert not re.search(r"\d{8}", str(moments.AGAINST_DIR.relative_to(moments.REPO_ROOT.parent))) diff --git a/utama_core/tests/moments/test_requires_and_outcomes.py b/utama_core/tests/moments/test_requires_and_outcomes.py index f0350237..671471a8 100644 --- a/utama_core/tests/moments/test_requires_and_outcomes.py +++ b/utama_core/tests/moments/test_requires_and_outcomes.py @@ -24,7 +24,9 @@ def _tick(t, command, ball, ours): def _probe(**changes): - return dataclasses.replace(moments.template("probe", "a note", "NORMAL_START", ["*"]), **changes) + """A captured moment, renamed, with no requirements and every rule checked unless `changes` say.""" + m = moments.load(moments.MOMENTS_DIR / "free_kick_defender_dodges_into_ball.json") + return dataclasses.replace(m, **{"name": "probe", "note": "a note", "checks": ["*"], "requires": [], **changes}) # --- restart_lasts ------------------------------------------------------------------------------- diff --git a/utama_core/tests/tools/test_screen.py b/utama_core/tests/tools/test_screen.py new file mode 100644 index 00000000..a1d84da5 --- /dev/null +++ b/utama_core/tests/tools/test_screen.py @@ -0,0 +1,98 @@ +"""`tools/screen.py`'s fixed rule and the pure parts behind it; playing a start is not tested here.""" + +import random + +import pytest + +from tools import screen +from tools.screen import PairResult, Start + + +def _pair(change_gd: int, base_gd: int, fired: bool = True) -> PairResult: + def measures(gd): + return {"goals_for": max(gd, 0), "goals_against": max(-gd, 0), "upfield_m": 0.0} + + return PairResult(Start("r.npz", 10.0, 1), fired, 1.0 if fired else None, measures(change_gd), measures(base_gd)) + + +def test_identical_trajectories_never_diverge(): + rows = [(0.0, 1.0), (0.5, 1.5)] + assert screen.diverged_at(rows, list(rows)) is None + + +def test_divergence_is_the_first_tick_apart_by_more_than_the_tolerance(): + a = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)] + b = [(0.0, 0.0), (1.0, 1.0 + screen.SAME_M / 2), (2.0, 2.0 + 2 * screen.SAME_M)] + assert screen.diverged_at(a, b) == 2 + + +def test_a_robot_missing_in_one_trajectory_is_a_divergence(): + assert screen.diverged_at([(0.0, 0.0, 1.0)], [(0.0, 0.0)]) == 0 + assert screen.diverged_at([(0.0,), (1.0,)], [(0.0,)]) == 1 + + +def test_fired_share_boundary(): + """At least `MIN_FIRED_SHARE` of the starts must fire: 6 of 60 is enough, 5 is not.""" + assert screen.call(60, [0.0] * 5) == "SKIP: did not fire" + assert screen.call(60, [0.0] * 6) == "WORTH EVALUATING" + assert screen.call(0, []) == "SKIP: did not fire" + + +def test_it_skips_only_when_goals_are_lower_by_more_than_two_standard_errors(): + clearly_worse = [-1.0] * 10 + [0.0] * 2 + assert screen.call(60, clearly_worse) == "SKIP: fewer goals in the starts" + mean, se = screen.mean_se([-1.0, 1.0] * 5 + [-1.0]) # slightly lower, well within noise + assert mean < 0 < mean + screen.GOAL_SE * se + assert screen.call(60, [-1.0, 1.0] * 5 + [-1.0]) == "WORTH EVALUATING" + + +def test_a_change_with_more_goals_is_never_skipped(): + assert screen.call(60, [1.0] * 30) == "WORTH EVALUATING" + + +def test_goal_difference_change_is_change_minus_base(): + assert screen.goal_difference_changes([_pair(1, 0), _pair(0, 1), _pair(-1, -1)]) == [1, -1, 0] + + +def test_mean_se_edge_cases(): + assert screen.mean_se([]) == (0.0, 0.0) + assert screen.mean_se([2.0]) == (2.0, 0.0) + assert screen.mean_se([1.0, 3.0]) == pytest.approx((2.0, 1.0)) + + +def test_drawn_times_leave_room_for_a_whole_start(): + times = screen.draw_times(random.Random(0), 100.0, 500) + assert min(times) >= screen.EDGE_S + assert max(times) <= 100.0 - screen.EDGE_S - screen.SECONDS + + +def test_report_counts_fired_starts_and_calls_on_them_only(): + results = [_pair(0, 0, fired=False)] * 50 + [_pair(-1, 0)] * 10 + lines, numbers = screen.report(results, 60) + assert lines[0] == "fired in 10 of 60 starts" + assert numbers["fired"] == 10 + assert numbers["call"] == "SKIP: fewer goals in the starts" + + +def _run(root, name, pairs): + import json + + d = root / name + d.mkdir() + (d / "summary.json").write_text(json.dumps({"results": [{"config_a": a, "config_b": b} for a, b in pairs]})) + for a, b in pairs: + (d / f"{a}_vs_{b}.npz").touch() + return d + + +def test_starts_come_from_the_latest_run_with_several_replays_of_the_strategy(tmp_path): + """A one-match `--pair` run is newer but gives too few situations; it is the fallback only.""" + full = _run(tmp_path, "tournament_1", [("s", "x"), ("y", "s"), ("s", "z")]) + _run(tmp_path, "tournament_2", [("x", "s")]) + assert screen.latest_run_with("s", tmp_path) == full + assert screen.latest_run_with("x", tmp_path).name == "tournament_2" + + +def test_replays_where_it_was_our_side_come_first(tmp_path): + d = _run(tmp_path, "tournament_1", [("y", "s"), ("s", "x"), ("a", "b")]) + assert [p.name for p in screen.replays_with(d, "s")] == ["s_vs_x.npz", "y_vs_s.npz"] From d4d090f06333b6c41031f7e4c58e1b588b2d2fa3 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Wed, 11 Nov 2026 09:57:40 +0000 Subject: [PATCH 12/59] tools: screen in about 4 minutes; first track-record entry - Starts are picked from each replay's referee sidecar, read once, instead of rebuilding a scenario for every draw: 83 s -> 3.5 s, the same rule (the last referee command at or before t). - --max-workers defaults to 12 (8 left half of 16 cores idle): 60 starts in about 4 minutes. - strategy_tools_plan.md: measured cost, a track-record table with the first real change (split_shape at 5b623b0e: fired 60 of 60, WORTH EVALUATING, evaluate.py not run yet), and what that run shows, not acted on: every code change fires within 0.1 s, and 120 starts hold only 10 goals. - roadmap.md, tools.md, STRATEGY_DEVELOPMENT.md: the screen and its cost. Co-Authored-By: Claude Opus 5.5 --- docs/STRATEGY_DEVELOPMENT.md | 2 +- docs/roadmap.md | 2 +- docs/strategy_tools_plan.md | 14 ++++++++- docs/tools.md | 2 +- tools/screen.py | 45 +++++++++++++++++++++++---- utama_core/tests/tools/test_screen.py | 17 ++++++++++ 6 files changed, 72 insertions(+), 10 deletions(-) diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index ac5323f9..91db4f31 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -333,7 +333,7 @@ flowchart TD - **Screen** (`tools/screen.py STRATEGY --base REF`, on trial): before an evaluation, did a change to one strategy do anything in play? It plays the strategy now and as it was at REF from the same 60 starts of 20 s of live play, drawn from a run's replays, against the base under the same noise, and reports how - often the two diverged ("fired") and the paired differences. Its call (`WORTH EVALUATING`, `SKIP: did + often the two diverged ("fired") and the paired differences, in about 4 minutes. Its call (`WORTH EVALUATING`, `SKIP: did not fire`, `SKIP: fewer goals in the starts`) follows a rule fixed in advance; it never writes the ledger and never compares two strategies. Until its track record is in ([strategy_tools_plan.md](strategy_tools_plan.md), "The screen"), run `evaluate.py` whatever it says. diff --git a/docs/roadmap.md b/docs/roadmap.md index e1890507..545f0f67 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -32,7 +32,7 @@ entry by its title, not its number. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). - **`metric_correlation.py` reads `.npz`**. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). -- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. +- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. In front of it, on trial since 2026-11-11: `tools/screen.py`, a 4-minute check that a change to one strategy does anything in play; it decides nothing until its calls match `evaluate.py`'s verdicts on 8 real changes (`docs/strategy_tools_plan.md`, "The screen"). - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 6820341d..93b68053 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -65,7 +65,8 @@ play?" It is for deciding whether a change is worth the cost of an evaluation. - **Call:** `SKIP: did not fire` if under 10% of starts fired; `SKIP: fewer goals in the starts` if, over the fired starts, the goal difference (change minus base) is lower by more than 2 standard errors; otherwise `WORTH EVALUATING`. -- **Cost:** about 30 minutes on 8 workers, against several hours for a 6-round `evaluate.py` run. +- **Cost:** about 4 minutes on 12 workers (120 starts of 20 s; measured 2026-11-11), against 10–15 minutes + per `evaluate.py` round and up to 6 rounds. - Every run appends to `replays/eval/screen_log.jsonl` (commit, fingerprints of both sides, every pair, the call), so its calls can be checked against verdicts later. @@ -85,6 +86,17 @@ is judged going forward: - If the record grows too slowly, deliberate small mistakes in the champion (each confirmed worse by `evaluate.py` first), their reversals and changes that cannot alter play can be added as known answers. +**Track record.** One row per real change; the screen's runs are in `replays/eval/screen_log.jsonl`. + +| Date | Change | Screen | `evaluate.py` | +|---|---|---|---| +| 2026-11-11 | `split_shape` at `5b623b0e` (no open-play pass under 1.5 m, one attacker kept upfield) against `e16649d5` | fired 60 of 60; goal difference +0.00 ± 0.05; WORTH EVALUATING | not run yet | + +What the first run shows, recorded and not acted on (the rule is not tuned during the trial): any change +to a strategy's code fires in every start, within 0.1 s, because the sim diverges from the smallest +difference, so "did not fire" can only catch changes the starts never reach. The goal rule has little to +work with: 10 goals in 120 starts of 20 s. + **Why not the retired scenario bench.** The scenario bench (retired 2026-10-17) also started matches from fixed states. It ranked *different* strategies. Its estimate was biased per strategy, so the ranking failed: Spearman -0.09 against round-robin results (see diff --git a/docs/tools.md b/docs/tools.md index b7318c9d..8881288e 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -53,7 +53,7 @@ says why the tools are split this way. | `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; ledger lines from before stalls were recorded count as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | | `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | -| `tools/screen.py` | `screen.py STRATEGY --base REF [--run RUN_DIR] [--seed N] [--max-workers 8]`: a screen, not a verdict. Plays STRATEGY now and as it was at REF (a `.strategy` file in `replays/eval/frozen/`) from the same 60 starts of 20 s of live play drawn at random from a run's replays (default: the latest run with at least 3 of its matches), both against the base under the same reference noise. Prints how many starts fired (the two diverged), the paired differences in goals and how far upfield the ball was, over all and over fired starts, and a call by a fixed rule; appends to `replays/eval/screen_log.jsonl`. Never writes the ledger, keeps no replays, plays one strategy. On trial: see [strategy_tools_plan.md](strategy_tools_plan.md) | +| `tools/screen.py` | `screen.py STRATEGY --base REF [--run RUN_DIR] [--seed N] [--max-workers 12]`: a screen, not a verdict. Plays STRATEGY now and as it was at REF (a `.strategy` file in `replays/eval/frozen/`) from the same 60 starts of 20 s of live play drawn at random from a run's replays (default: the latest run with at least 3 of its matches), both against the base under the same reference noise. Prints how many starts fired (the two diverged), the paired differences in goals and how far upfield the ball was, over all and over fired starts, and a call by a fixed rule; appends to `replays/eval/screen_log.jsonl`. About 4 minutes on 12 workers (`--max-workers`). Never writes the ledger, keeps no replays, plays one strategy. On trial: see [strategy_tools_plan.md](strategy_tools_plan.md) | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | | `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the reference opponents and the simulated world and robots (`tools/evaluation/reference/opponents.json`, `world.json`, `robots.json`) for `evaluate.py` and `round_robin.py --sim-noise reference[:seed]`. Kept in `reference/` so a new champion does not rerun every cached match | diff --git a/tools/screen.py b/tools/screen.py index 175296dc..4e5e8c64 100644 --- a/tools/screen.py +++ b/tools/screen.py @@ -37,6 +37,7 @@ os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") import argparse +import bisect import json import math import random @@ -187,19 +188,49 @@ def replay_seconds(path: Path) -> float: return float(ts[-1] - ts[0]) if len(ts) else 0.0 +def referee_timeline(sidecar: Path) -> list[tuple[float, str]]: + """The `event: referee` rows of a match's `.intentions.jsonl` as (sim_time, command), in time order.""" + rows = [] + for line in sidecar.read_text().splitlines(): + try: + row = json.loads(line) + except json.JSONDecodeError: + continue + if row.get("event") == "referee" and row.get("sim_time") is not None and row.get("command"): + rows.append((float(row["sim_time"]), row["command"])) + return sorted(rows, key=lambda r: r[0]) + + +def command_at(timeline: list[tuple[float, str]], t: float) -> Optional[str]: + """The last command at or before `t` (as `scenario._referee_command_at` reads it), None before the first.""" + i = bisect.bisect_right([ts for ts, _ in timeline], t) + return timeline[i - 1][1] if i else None + + +def _is_live(path: Path, t: float, timelines: dict) -> bool: + """Live play at `t`: from the sidecar, read once per replay (reloading the replay for every draw took + over a minute per screen); from the replay's own frame when there is no sidecar.""" + sidecar = path.with_name(f"{path.stem}.intentions.jsonl") + if sidecar.exists(): + if path not in timelines: + timelines[path] = referee_timeline(sidecar) + return command_at(timelines[path], t) in {c.name for c in LIVE} + try: + return scenario_from_replay(path, t).referee_command in LIVE + except (ValueError, IndexError): + return False + + def choose_starts(paths: list[Path], n: int, seed: int) -> list[Start]: """`n` moments of live play, the replays taken in turn, each with its own noise seed.""" rng = random.Random(seed) lengths = {path: replay_seconds(path) for path in paths} + timelines: dict = {} starts: list[Start] = [] for i in range(n): path = paths[i % len(paths)] for t in draw_times(rng, lengths[path], MAX_DRAWS): - try: - scenario = scenario_from_replay(path, t) - except (ValueError, IndexError): - continue - if scenario.referee_command in LIVE: + if _is_live(path, t, timelines): starts.append(Start(path.as_posix(), round(t, 3), zlib.crc32(f"{seed}:{i}".encode()))) break return starts @@ -284,7 +315,9 @@ def main() -> None: parser.add_argument("--starts", type=int, default=STARTS) parser.add_argument("--seconds", type=float, default=SECONDS) parser.add_argument("--seed", type=int, default=0, help="which starts and noise (default 0)") - parser.add_argument("--max-workers", type=int, default=8, help="parallel starts (default 8)") + parser.add_argument( + "--max-workers", type=int, default=12, help="parallel starts (default 12; each runs about 3 processes)" + ) parser.add_argument("--no-record", action="store_true", help=f"don't append to {LOG_PATH}") args = parser.parse_args() diff --git a/utama_core/tests/tools/test_screen.py b/utama_core/tests/tools/test_screen.py index a1d84da5..d5b8f022 100644 --- a/utama_core/tests/tools/test_screen.py +++ b/utama_core/tests/tools/test_screen.py @@ -96,3 +96,20 @@ def test_starts_come_from_the_latest_run_with_several_replays_of_the_strategy(tm def test_replays_where_it_was_our_side_come_first(tmp_path): d = _run(tmp_path, "tournament_1", [("y", "s"), ("s", "x"), ("a", "b")]) assert [p.name for p in screen.replays_with(d, "s")] == ["s_vs_x.npz", "y_vs_s.npz"] + + +def test_command_at_is_the_last_referee_command_at_or_before_t(tmp_path): + import json + + rows = [ + {"event": "referee", "sim_time": 4.0, "command": "STOP"}, + {"event": "intention", "sim_time": 5.0}, + {"event": "referee", "sim_time": 0.0, "command": "NORMAL_START"}, + ] + sidecar = tmp_path / "a_vs_b.intentions.jsonl" + sidecar.write_text("\n".join(json.dumps(r) for r in rows) + "\nnot json\n") + timeline = screen.referee_timeline(sidecar) + assert timeline == [(0.0, "NORMAL_START"), (4.0, "STOP")] + assert screen.command_at(timeline, -1.0) is None + assert screen.command_at(timeline, 3.99) == "NORMAL_START" + assert screen.command_at(timeline, 4.0) == "STOP" # at the change, the new command, as the scenario reads it From 49568ced9bcdc98dfa2925830f753774d2b81734 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 13:38:08 +0000 Subject: [PATCH 13/59] tools: remove the screen, which could not save evaluations Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 5 - docs/STRATEGY_DEVELOPMENT.md | 7 - docs/roadmap.md | 2 +- docs/strategy_tools_plan.md | 79 +----- docs/tools.md | 2 - tools/screen.py | 379 -------------------------- utama_core/tests/tools/test_screen.py | 115 -------- 7 files changed, 6 insertions(+), 583 deletions(-) delete mode 100644 tools/screen.py delete mode 100644 utama_core/tests/tools/test_screen.py diff --git a/AGENTS.md b/AGENTS.md index 3c7a273a..381ffa72 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -43,11 +43,6 @@ One term per thing; reuse these instead of coining new ones. the bugs found so far: `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure". - **Pitch zones** — defensive / middle / attacking third, left wing / centre / right wing, the box, danger: defined once, with a diagram, in `docs/pitch_zones.md`. Use those names. -- **Screen** — `tools/screen.py STRATEGY --base REF`: did a change to one strategy do anything in - play? Short paired starts of the strategy now against itself at REF, from live-play moments of a - run's replays; reports how often the change fired and a call by a fixed rule. Never a verdict, never - two strategies, never in the ledger. On trial until its calls match `evaluate.py`'s verdicts on real - changes (`docs/strategy_tools_plan.md`); until then evaluate whatever it says. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). - **Position map / shot map** — on-pitch pictures of a strategy over many matches, drawn by `tools/pitch_maps.py` (and `evaluate.py --explain` for a candidate against the champion), always diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 91db4f31..26fb0180 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -330,13 +330,6 @@ flowchart TD against the champion (12 matches, not the 66 of a full round-robin), defaulting to `--sim-noise reference:2` so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2. Read its STALLS section; a strategy's verdict still comes from `evaluate.py`. -- **Screen** (`tools/screen.py STRATEGY --base REF`, on trial): before an evaluation, did a change to one - strategy do anything in play? It plays the strategy now and as it was at REF from the same 60 starts of - 20 s of live play, drawn from a run's replays, against the base under the same noise, and reports how - often the two diverged ("fired") and the paired differences, in about 4 minutes. Its call (`WORTH EVALUATING`, `SKIP: did - not fire`, `SKIP: fewer goals in the starts`) follows a rule fixed in advance; it never writes the - ledger and never compares two strategies. Until its track record is in - ([strategy_tools_plan.md](strategy_tools_plan.md), "The screen"), run `evaluate.py` whatever it says. - **Before promoting** a candidate called better, run `evaluate.py --held-out`: it must not be clearly worse against opponents never used for selection. Then edit the champion in `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse diff --git a/docs/roadmap.md b/docs/roadmap.md index 545f0f67..087ff44a 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -32,7 +32,7 @@ entry by its title, not its number. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). - **`metric_correlation.py` reads `.npz`**. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). -- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. In front of it, on trial since 2026-11-11: `tools/screen.py`, a 4-minute check that a change to one strategy does anything in play; it decides nothing until its calls match `evaluate.py`'s verdicts on 8 real changes (`docs/strategy_tools_plan.md`, "The screen"). +- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 93b68053..7f97b1c9 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -28,7 +28,6 @@ links back here. | Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | | Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | | What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/triage.py` (`--fouls` for our side's fouls), then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | -| Is this change worth evaluating? | `tools/screen.py`: short paired starts of one strategy against itself, at a git ref. Never a verdict. Never two different strategies. Never written to the ledger. Reports how often the change fired. See "The screen" below | Built 2026-11-11, on trial | | Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | | Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | | Is the simulator realistic? | Simulator tools: `realism_scorecard.py`, `physics_ranges.py`, `field_physics.py`, `robot_calibration.py`, `convert_ssl_log.py`. Not part of strategy development | Today | @@ -39,71 +38,9 @@ Notes on the table: stronger than the champion?". Keep the two apart in the docs and in the output. - "Look closely" tools explain a result. They never judge one. -## The screen (built, on trial) - -The screen asks a narrower question than `evaluate.py`: "did this change do anything in -play?" It is for deciding whether a change is worth the cost of an evaluation. - -- It plays short paired starts of **one** strategy against **itself**, at two git refs: the - change and its base. The same starts and the same noise are used on both sides. -- It is never a verdict. Its output says where the change had an effect, not whether it helps. -- It never plays two different strategies, and its matches never go into the ledger. -- It must report how often the change fired (how many of the starts reached the code the change - touched). A screen that never fired says nothing. - -**As built** (`tools/screen.py`, 2026-11-11). The design was fixed before any change was screened: - -- **Starts:** 60 moments of live play (NORMAL_START or FORCE_START), drawn uniformly at random from - the replays of a run in which the strategy played, so situations come as often as in matches. - 20 s each. Robots start from rest with fresh tactic memory. -- **Sides:** the change (the working tree) and the base (a `.strategy` file at REF, as `evaluate.py - --frozen` builds) each play our side against the base, under the reference world and robots with - one seed per start. -- **Fired:** the two starts diverged (a robot or the ball more than 1 µm apart). Checked: the same - code, file against code, never diverged on 3 starts; a strategy whose code is the same at both refs - is not played at all. -- **Call:** `SKIP: did not fire` if under 10% of starts fired; `SKIP: fewer goals in the starts` if, - over the fired starts, the goal difference (change minus base) is lower by more than 2 standard - errors; otherwise `WORTH EVALUATING`. -- **Cost:** about 4 minutes on 12 workers (120 starts of 20 s; measured 2026-11-11), against 10–15 minutes - per `evaluate.py` round and up to 6 rounds. -- Every run appends to `replays/eval/screen_log.jsonl` (commit, fingerprints of both sides, every - pair, the call), so its calls can be checked against verdicts later. - -**Pass mark: a track record on real changes (agreed 2026-11-11).** The screen is a filter in front of -`evaluate.py`, so its two errors cost different amounts. Screening out a change that would have won -loses an improvement for good. Letting a useless change through only costs one evaluation. Past verdicts -are too few to judge it on (three `evaluate.py` runs on a change to one strategy, all "better"), so it -is judged going forward: - -- On every real change to one strategy, run the screen first and keep its call, then run - `evaluate.py` as usual. **`evaluate.py` stays the only gate meanwhile:** the screen decides nothing. -- It earns the right to skip evaluations after **at least 8 real changes with a clear verdict** - (better or worse) where it **never** called "skip" on one `evaluate.py` called better, and would have - skipped **at least half** of those called worse. -- The rule above is not tuned during the trial. If it fails, it is changed once and the record starts - again; if it fails twice, the screen is dropped and `evaluate.py` stays the only gate. -- If the record grows too slowly, deliberate small mistakes in the champion (each confirmed worse by - `evaluate.py` first), their reversals and changes that cannot alter play can be added as known answers. - -**Track record.** One row per real change; the screen's runs are in `replays/eval/screen_log.jsonl`. - -| Date | Change | Screen | `evaluate.py` | -|---|---|---|---| -| 2026-11-11 | `split_shape` at `5b623b0e` (no open-play pass under 1.5 m, one attacker kept upfield) against `e16649d5` | fired 60 of 60; goal difference +0.00 ± 0.05; WORTH EVALUATING | not run yet | - -What the first run shows, recorded and not acted on (the rule is not tuned during the trial): any change -to a strategy's code fires in every start, within 0.1 s, because the sim diverges from the smallest -difference, so "did not fire" can only catch changes the starts never reach. The goal rule has little to -work with: 10 goals in 120 starts of 20 s. - -**Why not the retired scenario bench.** The scenario bench (retired 2026-10-17) also started -matches from fixed states. It ranked *different* strategies. Its estimate was biased per -strategy, so the ranking failed: Spearman -0.09 against round-robin results (see -[roadmap.md](roadmap.md), "Strategy evaluation"; the retirement is in -[sim_realism.md](sim_realism.md), "Evaluation infrastructure"). The screen differs on both -points: it compares one strategy with itself, so per-strategy bias cancels, and it does not -rank anything. It is still a new mechanism, so it decides nothing until its track record is in. +## The screen (dropped) + +The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. ## Moments @@ -140,10 +77,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: fingerprint of every cached match, so every match replays and the ledger is invalidated (`utama_core/replay/fingerprint.py`). If it must change, batch it with other changes to shared code and say so in the commit. -6. **The screen.** Built as `tools/screen.py` (2026-11-11), on trial: its calls are kept beside - `evaluate.py`'s verdicts on real changes until the track record above is in. Only if it passes, - a `compare.py` tool with two subcommands, `verdict` (wraps `evaluate.py`) and `screen`, with no - options shared between them. Renames happen together with the merge they belong to, not before. +6. **The screen.** The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. 7. **Triage takes the foul listing.** Done: `triage.py --fouls`; `moments.py` lost `fouls` and `new`, and `--against` no longer uses a dated folder. @@ -152,10 +86,7 @@ such changes, and run one round-robin at the end. ## Names considered (undecided) -- **`drill`** for the screen: rejected as a name, because `examples/shooting_drill.py` already - uses "drill". The trial tool is `screen.py`; its final name comes with the `compare.py` merge. - **Triage**: `scan_replays.py` or `find_bugs.py`. Undecided. `triage.py` stays until then. -- **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Step 6 uses `compare.py` - as a placeholder. Undecided. +- **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Undecided. Nothing above is decided by a name. Pick the name when the tool is merged, not before. diff --git a/docs/tools.md b/docs/tools.md index 8881288e..138babb8 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -15,7 +15,6 @@ says why the tools are split this way. | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion. The only verdict. Add `--held-out` before promoting | | Does everything still run after a shared-code change? | `tools/evaluation/round_robin.py --vs-champion`: one match per strategy against the champion (12). The full round-robin (66) only occasionally. A round-robin is not an evaluation | | What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/triage.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | -| Is this change worth evaluating? | `tools/screen.py STRATEGY --base REF`: short paired starts of one strategy now against itself at REF. *On trial:* run `evaluate.py` whatever it says until its track record is in | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | | Is the simulator realistic? | [Simulator realism](#simulator-realism). Not strategy development | @@ -53,7 +52,6 @@ says why the tools are split this way. | `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; ledger lines from before stalls were recorded count as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | | `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | -| `tools/screen.py` | `screen.py STRATEGY --base REF [--run RUN_DIR] [--seed N] [--max-workers 12]`: a screen, not a verdict. Plays STRATEGY now and as it was at REF (a `.strategy` file in `replays/eval/frozen/`) from the same 60 starts of 20 s of live play drawn at random from a run's replays (default: the latest run with at least 3 of its matches), both against the base under the same reference noise. Prints how many starts fired (the two diverged), the paired differences in goals and how far upfield the ball was, over all and over fired starts, and a call by a fixed rule; appends to `replays/eval/screen_log.jsonl`. About 4 minutes on 12 workers (`--max-workers`). Never writes the ledger, keeps no replays, plays one strategy. On trial: see [strategy_tools_plan.md](strategy_tools_plan.md) | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | | `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the reference opponents and the simulated world and robots (`tools/evaluation/reference/opponents.json`, `world.json`, `robots.json`) for `evaluate.py` and `round_robin.py --sim-noise reference[:seed]`. Kept in `reference/` so a new champion does not rerun every cached match | diff --git a/tools/screen.py b/tools/screen.py deleted file mode 100644 index 4e5e8c64..00000000 --- a/tools/screen.py +++ /dev/null @@ -1,379 +0,0 @@ -#!/usr/bin/env python3 -# ruff: noqa: E402 -"""screen.py — did a change to one strategy do anything in play? A SCREEN, not a verdict. - - pixi run python tools/screen.py STRATEGY --base REF [--run RUN_DIR] [--starts 60] [--seconds 20] - -It plays STRATEGY as it is now (the change: the working tree, shared code included) and as it was at -git ref REF (the base, packed as a `.strategy` file in `replays/eval/frozen/`, as `evaluate.py --frozen` -does) from the same short starts: moments of live play drawn at random from the replays of a run in -which STRATEGY played (by default the latest `replays/tournament_*` that has it), so situations come as -often as they do in matches. Both play our side against the same opponent, the base, under the same -seeded reference noise, so a pair of starts differs only by the change. - -- **Fired:** the two starts of a pair diverged (any robot or the ball apart by more than `SAME_M`). A - change that never fires says nothing; the firing rate is the first thing it reports. -- **Differences** (change minus base), over all starts and over the starts where it fired: goals for, - goals against, and how far upfield the ball was on average. -- **Call**, by a rule fixed before any result (`call()`; docs/strategy_tools_plan.md, "The screen"): - `SKIP: did not fire` if fewer than `MIN_FIRED_SHARE` of starts fired; `SKIP: fewer goals in the - starts` if, over the fired starts, the goal difference is lower by more than 2 standard errors; - otherwise `WORTH EVALUATING`. Only `evaluate.py` gives a verdict. - -It never writes the evaluation ledger, keeps no replays, and plays one strategy only: comparing two -different strategies from short starts is the retired scenario bench, whose per-strategy bias made its -ranking fail. Each run appends a line to `replays/eval/screen_log.jsonl` (`--no-record` skips it): the -screen is on trial, and its calls are checked against `evaluate.py`'s verdicts on the same changes -before it may decide anything. - -Starts begin from rest with fresh tactic memory (`tools/repro_from_replay.py`'s limits), so behaviour -that needs a long build-up fires less often here than in matches. -""" - -from __future__ import annotations - -import os - -os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") - -import argparse -import bisect -import json -import math -import random -import statistics -import subprocess -import sys -import zlib -from concurrent.futures import ProcessPoolExecutor -from dataclasses import asdict, dataclass -from datetime import datetime, timezone -from pathlib import Path -from typing import Optional, Sequence - -REPO_ROOT = Path(__file__).resolve().parents[1] -if str(REPO_ROOT) not in sys.path: - sys.path.insert(0, str(REPO_ROOT)) - -from tools.evaluation.match import TICKS_PER_SECOND -from tools.evaluation.sim_settings import reference_noise -from tools.sim_setup import load_side, sim_runner -from utama_core.bundle.strategy_file import BundledStrategy, frozen -from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.replay.fingerprint import CodeGraph -from utama_core.replay.scenario import apply_scenario, scenario_from_replay -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise -from utama_core.strategy import catalog - -FROZEN_DIR = Path("replays/eval/frozen") # shared with evaluate.py --frozen: one file per strategy and commit -LOG_PATH = Path("replays/eval/screen_log.jsonl") - -# The design, fixed before any change was screened (docs/strategy_tools_plan.md, "The screen"). -STARTS = 60 -SECONDS = 20.0 -MIN_FIRED_SHARE = 0.10 -GOAL_SE = 2.0 -SAME_M = 1e-6 - -LIVE = (RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START) -EDGE_S = 5.0 # no starts this close to a replay's ends -MAX_DRAWS = 50 # tries per start to land on live play - - -@dataclass(frozen=True) -class Start: - replay: str - t: float - seed: int - - -@dataclass(frozen=True) -class PairResult: - start: Start - fired: bool - diverged_at_s: Optional[float] - change: dict # goals_for, goals_against, upfield_m - base: dict - - -# --------------------------------------------------------------------------- pure parts (unit tested) - - -def diverged_at(a: Sequence[Sequence[float]], b: Sequence[Sequence[float]], tol: float = SAME_M) -> Optional[int]: - """The first tick at which two trajectories (one row of coordinates per tick) are apart by more than - `tol` in any coordinate, or differ in length; None if they never are.""" - for i, (row_a, row_b) in enumerate(zip(a, b)): - if len(row_a) != len(row_b) or any(abs(x - y) > tol for x, y in zip(row_a, row_b)): - return i - return None if len(a) == len(b) else min(len(a), len(b)) - - -def mean_se(values: Sequence[float]) -> tuple[float, float]: - """Mean and its standard error; (0, 0) for none, SE 0 for one.""" - if not values: - return 0.0, 0.0 - if len(values) == 1: - return float(values[0]), 0.0 - return statistics.fmean(values), statistics.stdev(values) / math.sqrt(len(values)) - - -def goal_difference_changes(results: Sequence[PairResult]) -> list[float]: - """Per pair: the change's goal difference minus the base's.""" - return [ - (r.change["goals_for"] - r.change["goals_against"]) - (r.base["goals_for"] - r.base["goals_against"]) - for r in results - ] - - -def call(n_starts: int, fired_gd_changes: Sequence[float]) -> str: - """The screen's call: `fired_gd_changes` holds the goal-difference change of each start that fired. - - Screening out a change that would have won loses it for good; letting a useless one through costs - one evaluation. So it skips only a change that did nothing, or one whose fired starts scored clearly - worse (by more than `GOAL_SE` standard errors).""" - if n_starts == 0 or len(fired_gd_changes) < MIN_FIRED_SHARE * n_starts: - return "SKIP: did not fire" - mean, se = mean_se(fired_gd_changes) - if mean + GOAL_SE * se < 0: - return "SKIP: fewer goals in the starts" - return "WORTH EVALUATING" - - -def draw_times(rng: random.Random, duration_s: float, n: int) -> list[float]: - """`n` times uniformly within a replay of `duration_s`, `EDGE_S` from each end.""" - lo, hi = EDGE_S, max(EDGE_S, duration_s - EDGE_S - SECONDS) - return [rng.uniform(lo, hi) for _ in range(n)] - - -# --------------------------------------------------------------------------- choosing starts - - -def replays_with(run_dir: Path, strategy: str) -> list[Path]: - """The run's replays in which `strategy` played, those where it was config_a (our side) first. In the - others a start puts it in its opponent's positions: still a situation of its matches.""" - summary = json.loads((run_dir / "summary.json").read_text()) - name = catalog.plain_name(strategy) - as_a, as_b = [], [] - for r in summary.get("results", []): - a, b = catalog.plain_name(r["config_a"]), catalog.plain_name(r["config_b"]) - path = run_dir / f"{a}_vs_{b}.npz" - if not path.exists(): - continue - if a == name: - as_a.append(path) - elif b == name: - as_b.append(path) - return as_a + as_b - - -MIN_REPLAYS = 3 # a run with fewer replays of the strategy (a `--pair` run) gives too few situations - - -def latest_run_with(strategy: str, replays: Path = Path("replays")) -> Path: - """The latest run with at least `MIN_REPLAYS` replays of `strategy`, else the latest with any.""" - runs = [d for d in sorted(replays.glob("tournament_*"), reverse=True) if (d / "summary.json").exists()] - counts = {d: len(replays_with(d, strategy)) for d in runs} - for wanted in (MIN_REPLAYS, 1): - for run_dir in runs: - if counts[run_dir] >= wanted: - return run_dir - raise SystemExit(f"no replays/tournament_* has a replay of {strategy}; give one with --run") - - -def replay_seconds(path: Path) -> float: - """How long a replay runs, on the clock `scenario_from_replay` takes.""" - from utama_core.replay.columnar_reader import load_columnar_replay - - ts = load_columnar_replay(path).ts - return float(ts[-1] - ts[0]) if len(ts) else 0.0 - - -def referee_timeline(sidecar: Path) -> list[tuple[float, str]]: - """The `event: referee` rows of a match's `.intentions.jsonl` as (sim_time, command), in time order.""" - rows = [] - for line in sidecar.read_text().splitlines(): - try: - row = json.loads(line) - except json.JSONDecodeError: - continue - if row.get("event") == "referee" and row.get("sim_time") is not None and row.get("command"): - rows.append((float(row["sim_time"]), row["command"])) - return sorted(rows, key=lambda r: r[0]) - - -def command_at(timeline: list[tuple[float, str]], t: float) -> Optional[str]: - """The last command at or before `t` (as `scenario._referee_command_at` reads it), None before the first.""" - i = bisect.bisect_right([ts for ts, _ in timeline], t) - return timeline[i - 1][1] if i else None - - -def _is_live(path: Path, t: float, timelines: dict) -> bool: - """Live play at `t`: from the sidecar, read once per replay (reloading the replay for every draw took - over a minute per screen); from the replay's own frame when there is no sidecar.""" - sidecar = path.with_name(f"{path.stem}.intentions.jsonl") - if sidecar.exists(): - if path not in timelines: - timelines[path] = referee_timeline(sidecar) - return command_at(timelines[path], t) in {c.name for c in LIVE} - try: - return scenario_from_replay(path, t).referee_command in LIVE - except (ValueError, IndexError): - return False - - -def choose_starts(paths: list[Path], n: int, seed: int) -> list[Start]: - """`n` moments of live play, the replays taken in turn, each with its own noise seed.""" - rng = random.Random(seed) - lengths = {path: replay_seconds(path) for path in paths} - timelines: dict = {} - starts: list[Start] = [] - for i in range(n): - path = paths[i % len(paths)] - for t in draw_times(rng, lengths[path], MAX_DRAWS): - if _is_live(path, t, timelines): - starts.append(Start(path.as_posix(), round(t, 3), zlib.crc32(f"{seed}:{i}".encode()))) - break - return starts - - -# --------------------------------------------------------------------------- playing - - -def _play(side: str, opponent: str, start: Start, seconds: float) -> tuple[list[tuple], dict]: - """One start: our side `side` against `opponent`. Returns the trajectory and the measures.""" - strategy, enemy = load_side(side), load_side(opponent) - runner, _ = sim_runner(strategy, enemy, sim_noise=SimNoise.from_dict(reference_noise(start.seed))) - trajectory: list[tuple] = [] - ball_x: list[float] = [] - try: - apply_scenario(runner, scenario_from_replay(Path(start.replay), start.t), verify=False) - for _ in range(int(seconds * TICKS_PER_SECOND)): - runner.step_once() - frame = runner.my.current_game_frame - row = [] - if frame.ball is not None: - row += [frame.ball.p.x, frame.ball.p.y] - ball_x.append(frame.ball.p.x) - for robots in (frame.friendly_robots, frame.enemy_robots): - for rid in sorted(robots): - row += [robots[rid].p.x, robots[rid].p.y] - trajectory.append(tuple(row)) - referee = runner.my.game.referee - goals_for, goals_against = referee.yellow_team.score, referee.blue_team.score # our side is yellow - finally: - runner.close() - for s in (strategy, enemy): - if isinstance(s, BundledStrategy): - s.close() - # Our side defends the right goal (sim_runner), so upfield is towards -x. - upfield = -statistics.fmean(ball_x) if ball_x else 0.0 - return trajectory, {"goals_for": goals_for, "goals_against": goals_against, "upfield_m": round(upfield, 4)} - - -def play_pair(change: str, base: str, start: Start, seconds: float) -> PairResult: - change_traj, change_m = _play(change, base, start, seconds) - base_traj, base_m = _play(base, base, start, seconds) - tick = diverged_at(change_traj, base_traj) - return PairResult(start, tick is not None, None if tick is None else tick / TICKS_PER_SECOND, change_m, base_m) - - -# --------------------------------------------------------------------------- report - - -def _git(*args: str) -> str: - return subprocess.run(["git", *args], cwd=REPO_ROOT, capture_output=True, text=True).stdout.strip() - - -def report(results: list[PairResult], n_starts: int) -> tuple[list[str], dict]: - fired = [r for r in results if r.fired] - lines = [f"fired in {len(fired)} of {n_starts} starts"] - numbers: dict = {"starts": n_starts, "fired": len(fired)} - for label, group in (("all starts", results), ("fired starts", fired)): - rows = { - "goal difference": goal_difference_changes(group), - "goals for": [r.change["goals_for"] - r.base["goals_for"] for r in group], - "goals against": [r.change["goals_against"] - r.base["goals_against"] for r in group], - "ball upfield (m)": [r.change["upfield_m"] - r.base["upfield_m"] for r in group], - } - lines.append(f"change minus base, {label} ({len(group)}):") - for name, values in rows.items(): - mean, se = mean_se(values) - lines.append(f" {name:<18} {mean:+.3f} ± {se:.3f} (SE)") - numbers.setdefault(label, {})[name] = [round(mean, 4), round(se, 4)] - if fired: - times = sorted(r.diverged_at_s for r in fired) - lines.append(f"first divergence: median {statistics.median(times):.2f} s into a start") - numbers["call"] = call(n_starts, goal_difference_changes(fired)) - return lines, numbers - - -def main() -> None: - parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("strategy", help="the one strategy the change is to (a catalog name)") - parser.add_argument("--base", required=True, help="git ref of the code before the change, e.g. HEAD~1 or v2.5.0") - parser.add_argument("--run", type=Path, default=None, help="run dir to draw starts from (default: latest with it)") - parser.add_argument("--starts", type=int, default=STARTS) - parser.add_argument("--seconds", type=float, default=SECONDS) - parser.add_argument("--seed", type=int, default=0, help="which starts and noise (default 0)") - parser.add_argument( - "--max-workers", type=int, default=12, help="parallel starts (default 12; each runs about 3 processes)" - ) - parser.add_argument("--no-record", action="store_true", help=f"don't append to {LOG_PATH}") - args = parser.parse_args() - - name = catalog.plain_name(args.strategy) - if name not in catalog.names(): - raise SystemExit(f"unknown strategy {args.strategy!r}; strategies: {', '.join(catalog.names())}") - designed = (args.starts, args.seconds) == (STARTS, SECONDS) - print("SCREEN, not a verdict: did this change do anything in play? Only evaluate.py judges a strategy.") - if not designed: - print( - f" (off-design: {args.starts} starts of {args.seconds:g} s; the call's rule assumes {STARTS} of {SECONDS:g})" - ) - - base_file = frozen(name, args.base, FROZEN_DIR).as_posix() - graph = CodeGraph() - change_fp, base_fp = graph.strategy_fingerprint(name)[:16], graph.strategy_fingerprint(base_file)[:16] - record = { - "time_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"), - "strategy": name, - "base": base_file, - "commit": _git("rev-parse", "HEAD"), - "dirty": bool(_git("status", "--porcelain", "--untracked-files=no")), - "change_fp": change_fp, - "base_fp": base_fp, - "seed": args.seed, - "on_design": designed, - } - print(f" {name} now ({change_fp}) against {base_file} ({base_fp})") - - if change_fp == base_fp: - lines, numbers = ["the strategy's code is the same at both refs: nothing to play"], { - "starts": 0, - "fired": 0, - "call": "SKIP: did not fire", - } - else: - run_dir = args.run or latest_run_with(name) - paths = replays_with(run_dir, name) - starts = choose_starts(paths, args.starts, args.seed) - record["run"] = run_dir.as_posix() - print(f" {len(starts)} starts of {args.seconds:g} s of live play from {len(paths)} replays in {run_dir}") - with ProcessPoolExecutor(max_workers=args.max_workers) as pool: - results = list(pool.map(play_pair, [name] * len(starts), [base_file] * len(starts), starts, - [args.seconds] * len(starts))) # fmt: skip - lines, numbers = report(results, len(starts)) - record["pairs"] = [asdict(r) for r in results] - - print("\n".join(lines)) - print(f"call: {numbers['call']}") - record.update(numbers) - if not args.no_record: - LOG_PATH.parent.mkdir(parents=True, exist_ok=True) - with LOG_PATH.open("a") as f: - f.write(json.dumps(record) + "\n") - print(f"recorded in {LOG_PATH}") - - -if __name__ == "__main__": - main() diff --git a/utama_core/tests/tools/test_screen.py b/utama_core/tests/tools/test_screen.py deleted file mode 100644 index d5b8f022..00000000 --- a/utama_core/tests/tools/test_screen.py +++ /dev/null @@ -1,115 +0,0 @@ -"""`tools/screen.py`'s fixed rule and the pure parts behind it; playing a start is not tested here.""" - -import random - -import pytest - -from tools import screen -from tools.screen import PairResult, Start - - -def _pair(change_gd: int, base_gd: int, fired: bool = True) -> PairResult: - def measures(gd): - return {"goals_for": max(gd, 0), "goals_against": max(-gd, 0), "upfield_m": 0.0} - - return PairResult(Start("r.npz", 10.0, 1), fired, 1.0 if fired else None, measures(change_gd), measures(base_gd)) - - -def test_identical_trajectories_never_diverge(): - rows = [(0.0, 1.0), (0.5, 1.5)] - assert screen.diverged_at(rows, list(rows)) is None - - -def test_divergence_is_the_first_tick_apart_by_more_than_the_tolerance(): - a = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0)] - b = [(0.0, 0.0), (1.0, 1.0 + screen.SAME_M / 2), (2.0, 2.0 + 2 * screen.SAME_M)] - assert screen.diverged_at(a, b) == 2 - - -def test_a_robot_missing_in_one_trajectory_is_a_divergence(): - assert screen.diverged_at([(0.0, 0.0, 1.0)], [(0.0, 0.0)]) == 0 - assert screen.diverged_at([(0.0,), (1.0,)], [(0.0,)]) == 1 - - -def test_fired_share_boundary(): - """At least `MIN_FIRED_SHARE` of the starts must fire: 6 of 60 is enough, 5 is not.""" - assert screen.call(60, [0.0] * 5) == "SKIP: did not fire" - assert screen.call(60, [0.0] * 6) == "WORTH EVALUATING" - assert screen.call(0, []) == "SKIP: did not fire" - - -def test_it_skips_only_when_goals_are_lower_by_more_than_two_standard_errors(): - clearly_worse = [-1.0] * 10 + [0.0] * 2 - assert screen.call(60, clearly_worse) == "SKIP: fewer goals in the starts" - mean, se = screen.mean_se([-1.0, 1.0] * 5 + [-1.0]) # slightly lower, well within noise - assert mean < 0 < mean + screen.GOAL_SE * se - assert screen.call(60, [-1.0, 1.0] * 5 + [-1.0]) == "WORTH EVALUATING" - - -def test_a_change_with_more_goals_is_never_skipped(): - assert screen.call(60, [1.0] * 30) == "WORTH EVALUATING" - - -def test_goal_difference_change_is_change_minus_base(): - assert screen.goal_difference_changes([_pair(1, 0), _pair(0, 1), _pair(-1, -1)]) == [1, -1, 0] - - -def test_mean_se_edge_cases(): - assert screen.mean_se([]) == (0.0, 0.0) - assert screen.mean_se([2.0]) == (2.0, 0.0) - assert screen.mean_se([1.0, 3.0]) == pytest.approx((2.0, 1.0)) - - -def test_drawn_times_leave_room_for_a_whole_start(): - times = screen.draw_times(random.Random(0), 100.0, 500) - assert min(times) >= screen.EDGE_S - assert max(times) <= 100.0 - screen.EDGE_S - screen.SECONDS - - -def test_report_counts_fired_starts_and_calls_on_them_only(): - results = [_pair(0, 0, fired=False)] * 50 + [_pair(-1, 0)] * 10 - lines, numbers = screen.report(results, 60) - assert lines[0] == "fired in 10 of 60 starts" - assert numbers["fired"] == 10 - assert numbers["call"] == "SKIP: fewer goals in the starts" - - -def _run(root, name, pairs): - import json - - d = root / name - d.mkdir() - (d / "summary.json").write_text(json.dumps({"results": [{"config_a": a, "config_b": b} for a, b in pairs]})) - for a, b in pairs: - (d / f"{a}_vs_{b}.npz").touch() - return d - - -def test_starts_come_from_the_latest_run_with_several_replays_of_the_strategy(tmp_path): - """A one-match `--pair` run is newer but gives too few situations; it is the fallback only.""" - full = _run(tmp_path, "tournament_1", [("s", "x"), ("y", "s"), ("s", "z")]) - _run(tmp_path, "tournament_2", [("x", "s")]) - assert screen.latest_run_with("s", tmp_path) == full - assert screen.latest_run_with("x", tmp_path).name == "tournament_2" - - -def test_replays_where_it_was_our_side_come_first(tmp_path): - d = _run(tmp_path, "tournament_1", [("y", "s"), ("s", "x"), ("a", "b")]) - assert [p.name for p in screen.replays_with(d, "s")] == ["s_vs_x.npz", "y_vs_s.npz"] - - -def test_command_at_is_the_last_referee_command_at_or_before_t(tmp_path): - import json - - rows = [ - {"event": "referee", "sim_time": 4.0, "command": "STOP"}, - {"event": "intention", "sim_time": 5.0}, - {"event": "referee", "sim_time": 0.0, "command": "NORMAL_START"}, - ] - sidecar = tmp_path / "a_vs_b.intentions.jsonl" - sidecar.write_text("\n".join(json.dumps(r) for r in rows) + "\nnot json\n") - timeline = screen.referee_timeline(sidecar) - assert timeline == [(0.0, "NORMAL_START"), (4.0, "STOP")] - assert screen.command_at(timeline, -1.0) is None - assert screen.command_at(timeline, 3.99) == "NORMAL_START" - assert screen.command_at(timeline, 4.0) == "STOP" # at the change, the new command, as the scenario reads it From 89c036bb75a302e0c426b6da060493ba1d53c6d7 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 13:48:11 +0000 Subject: [PATCH 14/59] replay: one match results store, reuse automatic The match cache (round-robin --reuse) and the evaluation ledger become one store, replay/match_results.py, under replays/match_results//.json. A match is looked up by its fixture before it is played and stored after; --reuse, --spot-check and the spot-check are gone. match_key moves into the fixture and the environment. Old stores are no longer read; deleting the store replays everything. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 8 +- docs/STRATEGY_DEVELOPMENT.md | 56 +-- docs/architecture.md | 6 +- docs/img/architecture/make_match_data_flow.py | 19 +- docs/img/architecture/match_data_flow.png | Bin 149111 -> 143524 bytes docs/roadmap.md | 2 +- docs/signals.md | 6 +- docs/sim_realism.md | 10 +- docs/strategies.md | 2 +- docs/strategy_tools_plan.md | 12 +- docs/tools.md | 4 +- tools/evaluation/evaluate.py | 89 ++--- tools/evaluation/explain.py | 2 +- tools/evaluation/round_robin.py | 372 +++++++----------- tools/package_logs.py | 4 +- utama_core/replay/eval_ledger.py | 124 ------ utama_core/replay/fingerprint.py | 43 +- utama_core/replay/match_cache.py | 75 ---- utama_core/replay/match_results.py | 175 ++++++++ utama_core/tests/engine/test_evaluate.py | 80 ---- .../tests/engine/test_tournament_cli_args.py | 94 ++--- .../tests/engine/test_tournament_reuse.py | 117 +++--- .../engine/test_tournament_vs_champion.py | 31 +- utama_core/tests/replay/test_fingerprint.py | 76 ++-- utama_core/tests/replay/test_match_cache.py | 70 ---- utama_core/tests/replay/test_match_results.py | 158 ++++++++ 26 files changed, 753 insertions(+), 882 deletions(-) delete mode 100644 utama_core/replay/eval_ledger.py delete mode 100644 utama_core/replay/match_cache.py create mode 100644 utama_core/replay/match_results.py delete mode 100644 utama_core/tests/replay/test_match_cache.py create mode 100644 utama_core/tests/replay/test_match_results.py diff --git a/AGENTS.md b/AGENTS.md index 381ffa72..d3bccc2c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -28,9 +28,9 @@ exists yet: say so in your change rather than guessing. One term per thing; reuse these instead of coining new ones. - **Round-robin / tournament run** — every strategy config plays every other once - (`tools/evaluation/round_robin.py`); writes `replays/tournament_/summary.json` and adds its matches to the evaluation ledger. + (`tools/evaluation/round_robin.py`); writes `replays/tournament_/summary.json` and adds its matches to the match results store (`replays/match_results/`). The check for stalls and the occasional health check of the whole catalog; a single - strategy is judged with `evaluate.py` (below). With `--reuse` only matches whose code changed rerun. + strategy is judged with `evaluate.py` (below). A match the store already holds is not played again, so only matches whose code changed rerun. - **Standings** — only a round-robin's ranking: wins and draws as `round_robin.py` prints them, or points per match (3 a win, 1 a draw) as `metric_correlation.py` computes them. Not the verdict on a strategy; see Evaluation. @@ -51,14 +51,14 @@ One term per thing; reuse these instead of coining new ones. the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. -- **Evaluation / ratings / reference opponents / ledger** — `tools/evaluation/evaluate.py`: is a +- **Evaluation / ratings / reference opponents / match results** — `tools/evaluation/evaluate.py`: is a candidate stronger than the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: the champion, six opponents, three held-out opponents)? Rounds of matches against those opponents in the simulated world and robots (`tools/evaluation/reference/world.json`, `robots.json`) under seeded sim noise, decided on paired results (candidate and champion against the same opponent under the same noise) and stopping once the answer is clear; ratings (strength ± SD in goals per match, - `analysis/ratings.py`) over every match in the ledger (`replays/eval/ledger.jsonl`). + `analysis/ratings.py`) over every match in the match results store (`replays/match_results/`, `replay/match_results.py`). Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. - **Strategy file / frozen baseline** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 26fb0180..f389f6c7 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -233,25 +233,27 @@ kernel invariants. Give its partitioner pure-function tests in `tests/strategy/t before anything else. 3. **Matches:** `tools/evaluation/evaluate.py ` (see [Evaluating a strategy](#evaluating-a-strategy)): is it better than the champion in `tools/evaluation/reference/opponents.json`, worse, or not clearly either? Several candidates go in - one call. A strict round-robin (`round_robin.py --strict --reuse`) is the check for stalls + one call. A strict round-robin (`round_robin.py --strict`) is the check for stalls and the occasional health check of the whole catalog, no longer the way to judge one change. A change to `tactics/`, `skills/` or `pickers.py` is the other way round: reuse saves little, because most strategies import the changed code and their matches all rerun. Batch such changes and run one round-robin over the batch. -**`--reuse`** takes a match's result from -`replays/match_cache/` when nothing it runs has changed since it was stored, so after a change -to one strategy only its matches play, one per other config. A default round-robin plays the 12 configs -not in `RETIRED` (`tools/evaluation/round_robin.py`; the catalog has 22), so a change to one of them replays -11 of its 66 matches. Naming all 22 configs gives 21 of 231. What counts as -"runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that -imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole -files), and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing `pickers.py` -reruns every config that imports it, which is most of them; changing shared code reruns -everything, correctly. Each run replays 5% of what it would reuse (`--spot-check`) and compares; a -difference evicts the records, says the fingerprint missed a dependency, and fails the run. -Use `--reuse` on every run. +**Reuse is automatic.** A match the match results store holds (`replays/match_results/`, +`replay/match_results.py`) is taken from it, not played; there is no flag. A match's fixture is its +environment (the shared code and machine, the match length, the planner, the sim noise without its +seed, the restart fuzzing), both players' fingerprints, their sides and the noise seed. So after a +change to one strategy only its matches play, one per other config. A default round-robin plays the +12 configs not in `RETIRED` (`tools/evaluation/round_robin.py`; the catalog has 22), so a change to one +of them replays 11 of its 66 matches. Naming all 22 configs gives 21 of 231. What counts as "runs" is +`utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that imports +(`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole files), +and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing +`pickers.py` reruns every config that imports it, which is most of them; changing shared code reruns +everything, correctly. The store does not check itself (the spot-check of earlier versions is gone): +if a fingerprint misses a dependency, delete the store, or one environment's folder inside it, to play +everything again. A round-robin prints "N taken from replays/match_results ... M to play" first; read it. **What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against the champion of the reference opponents. A round-robin's W-D-L is a diagnostic. Everything in [Reading a tournament run](#reading-a-tournament-run) explains a result; none of @@ -279,7 +281,7 @@ flowchart TD subgraph ev["evaluate.py: is this candidate stronger than the champion?"] e1["Reference opponents.json: champion, six opponents,
three held-out opponents; world and robots, sim noise"] e2["Round k, noise seed k
candidate and champion each play every opponent"] - e7["Every match appended to the ledger
replays/eval/ledger.jsonl"] + e7["Every match stored in the match results
replays/match_results/"] e3{"P(candidate stronger), paired
with the champion's results"} e4["better: P >= 0.99
then --held-out before promoting"] e5["worse: P <= 0.2
drop it"] @@ -314,17 +316,17 @@ flowchart TD (paired results correlated ~0.9): one goal better found every time in ~3 rounds, half a goal 55%. Small gains of unrelated strategies are below what matches resolve at this cost. - **Ratings** (`analysis/ratings.py`): a strength per strategy in goals per match with its SD, - fitted on every match in the ledger; printed at the end, and the match noise for the decision. -- **The ledger** (`replays/eval/ledger.jsonl`, `replay/eval_ledger.py`): one line per match from - evaluate.py and round-robins, keyed by the code that played it. A match is never played twice; + fitted on every match in the match results; printed at the end, and the match noise for the decision. +- **Match results** (`replays/match_results/`, `replay/match_results.py`): one record per match from + evaluate.py and round-robins, keyed by its fixture (the code that played it). A match is never played twice; the champion's matches are played once per seed and reused by every candidate, and editing a strategy starts its record afresh. Replays are not kept, except during a `--explain` run (rerun one with `round_robin.py --pair A B --sim-noise reference:`). - **Stalls** are reported after each candidate's and the champion's verdict, for post-analysis only: they never change a verdict or stop a run. "stalls checked in N of M ... (watchdog covers config_a only)" counts the matches where the watchdog could see that side (`run/strategy_runner.py` records - stats for config_a only). A match where the side was config_b, or a ledger line from before stalls - were recorded, counts as unchecked; "unknown" means none was checked. The JSON report has them under + stats for config_a only). A match where the side was config_b, or whose stats were not collected, + counts as unchecked; "unknown" means none was checked. The JSON report has them under `candidates[...].stalls` and `champion_stalls`. - **Health check.** After a shared-code change, `round_robin.py --vs-champion` plays each strategy once against the champion (12 matches, not the 66 of a full round-robin), defaulting to `--sim-noise @@ -339,14 +341,14 @@ flowchart TD the opponents from `.strategy` files of that commit (`replays/eval/frozen/`, built once) and the candidate from the working tree. A bundled match equals the same match run normally, frame for frame. The referee and the simulator are today's for both sides, so a frozen side meets rule changes it was not written for. A file and - the same code are one player in the ledger, and matches between two files are replayed only when the referee, + the same code are one player in the match results, and matches between two files are replayed only when the referee, the simulator or the match runner change: a skills or tactics edit reruns only the candidate's matches. - **Pictures** (`evaluate.py --explain`, `tools/evaluation/explain.py`): for each candidate, where both strategies' robots stand with and without the ball, their shots for and against, their fouls by rule, and a `summary.json` of the numbers behind them, written to `replays/eval/explain/_/`. The run's matches are kept until they are written. They explain a verdict and never make one: the verdict is still goals, and a picture is not a ranking. - Matches reused from the ledger have no replay in the run, so the pictures cover only what was + Matches taken from the match results have no replay in the run, so the pictures cover only what was played; the paired goal difference in `summary.json` is only as complete as that. Example, from a round-robin (`explain.py replays/tournament_ split_shape clear_press_plus --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) @@ -359,8 +361,8 @@ A new or changed strategy, whether a person or an agent writes it, goes on its o reaches `main` by pull request: 1. Branch from `main` as `strategy/`. In a git worktree, symlink `.pixi` and `replays` - from the main checkout first: pixi needs the environment, and `--reuse` needs - `replays/match_cache/`, or every match plays again. + from the main checkout first: pixi needs the environment, and the match results store + (`replays/match_results/`) is what keeps a match from playing again. 2. Change only `utama_core/strategy/`, `utama_core/tactics/` (new modules only), `utama_core/tests/strategy/` (tests for your strategy and any tactic you add) and `docs/strategies.md`. CI fails a `strategy/*` pull request that changes anything else @@ -376,14 +378,14 @@ reaches `main` by pull request: directly. 4. Write, test and evaluate it as above, and record the round-robin in `docs/strategies.md`. `git add` new files before `pixi run lint`: it checks tracked files only. Before waiting on - a `--reuse` round-robin, read the "N reused ... M to play" line it prints: M much larger - than your own matches means the cache is stale (shared code changed since it was filled). + a round-robin, read the "N taken from ... M to play" line it prints: M much larger + than your own matches means the store is stale (shared code changed since it was filled). Let it run anyway (a full round-robin of 600 s matches has taken from about 1 h 50 min, on 15 workers plugged in, to 4.7 h for `tournament_20261005_170958`; matches are now two halves of 300 s of playing time: about 710 s of sim time on average by the final run's stoppages, 785 s in two measured matches, so expect roughly 20-30% longer): the other - strategies' matches run `main`'s code, so they refill the cache for everyone. + strategies' matches run `main`'s code, so they refill the store for everyone. 4. Open a draft pull request into `main` with the round-robin result. An agent never merges: a person reviews and merges. Several branches can be worked on at once, each in its own worktree; they share -`replays/match_cache/`. A round-robin uses one worker per core (`--max-workers N` to cap it), so +`replays/match_results/`. A round-robin uses one worker per core (`--max-workers N` to cap it), so concurrent runs split the machine's cores and each takes longer; a machine with more cores runs more of them at once. How to organise a search (how many in parallel, which ideas) is up to whoever runs it. diff --git a/docs/architecture.md b/docs/architecture.md index 00c44c7d..218d8045 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -67,15 +67,15 @@ flowchart TD Every rsim match writes files under `replays/` (`REPLAY_BASE_PATH`), and the analyses, tools and evaluation read them back. A match's file stem is `A_vs_B` (`round_robin.py`'s `_tag`); the names -below are from a real run directory. `--reuse` reads the match cache, and only matches whose -fingerprint changed are played again. +below are from a real run directory. The match results store (`replays/match_results/`) is read first: +a match it holds is not played again, so only matches whose fingerprint changed are played. ![Match data flow: drivers, StrategyRunner, the per-match files, the stores and the readers](img/architecture/match_data_flow.png) Drawn by `docs/img/architecture/make_match_data_flow.py`; rerun it when a name in it changes. `evaluate.py` removes its own scratch run directory when it finishes, so its matches survive only -in the ledger. +in the match results store. ## Package dependencies diff --git a/docs/img/architecture/make_match_data_flow.py b/docs/img/architecture/make_match_data_flow.py index 5628daf8..4ad49dd9 100644 --- a/docs/img/architecture/make_match_data_flow.py +++ b/docs/img/architecture/make_match_data_flow.py @@ -13,7 +13,6 @@ # Every name a box shows; utama_core/tests/tools/test_diagram_names.py checks they still exist. NAMES = [ "StrategyRunner", - "match_key", "tools/evaluation/round_robin.py", "tools/evaluation/evaluate.py", "tools/convert_ssl_log.py", @@ -23,9 +22,8 @@ "utama_core/replay/columnar_reader.py", "utama_core/engine/match_log.py", "utama_core/engine/match_stats.py", - "utama_core/replay/match_cache.py", + "utama_core/replay/match_results.py", "utama_core/replay/fingerprint.py", - "utama_core/replay/eval_ledger.py", "utama_core/analysis/goal_ledger.py", "utama_core/analysis/ratings.py", "utama_core/analysis/chances.py", @@ -54,7 +52,7 @@ 36, 20, "Drivers", - "tools/evaluation/round_robin.py\ntools/evaluation/evaluate.py\nmatch_key (replay/fingerprint.py)\npicks which matches to play", + "tools/evaluation/round_robin.py\ntools/evaluation/evaluate.py\nfixtures (replay/match_results.py)\npicks which matches to play", kind="decision", ) d.box(22, 104, 38, 12, "Official SSL logs", "*.log.gz\nconvert_ssl_log.py, replay/ssl_log.py", kind="source") @@ -85,11 +83,8 @@ d.arrow((88, 78), (98, 80)) # --- stores --------------------------------------------------------------------------------------- -d.box(22, 44, 34, 12, "Match cache", "replays/match_cache/\nreplay/match_cache.py", kind="state") -d.arrow((14, 70), (14, 50), "store", lx=1.0) -d.arrow((30, 50), (30, 70), "reuse", lx=1.0) -d.box(72, 26, 32, 12, "Evaluation ledger", "replays/eval/ledger.jsonl\nreplay/eval_ledger.py", kind="state") -d.arrow((40, 71), (56, 30), "append", lx=-1.0, ha="right") +d.box(72, 26, 32, 12, "Match results", "replays/match_results/\nreplay/match_results.py", kind="state") +d.arrow((40, 71), (56, 30), "store; stored matches taken, not played", lx=-1.0, ha="right") d.box(118, 60, 36, 12, "summary.json", "+ ball_losses.md, one per run", kind="state") d.arrow((40, 73), (100, 62), "round_robin.py", lx=0.0, ly=2.0) @@ -110,10 +105,12 @@ d.arrow((142, 94), (148, 72)) d.arrow((142, 80), (148, 70)) d.arrow((142, 76), (148, 48)) -d.arrow((88, 26), (148, 26), "every ledger match", lx=0.0, ly=2.0) +d.arrow((88, 26), (148, 26), "every stored match", lx=0.0, ly=2.0) d.note( - 4, 10, "evaluate.py deletes its scratch run directory when it finishes;\nits matches survive only in the ledger." + 4, + 10, + "evaluate.py deletes its scratch run directory when it finishes;\nits matches survive only in the match results.", ) d.key( diff --git a/docs/img/architecture/match_data_flow.png b/docs/img/architecture/match_data_flow.png index c054e8778bbd080c8d68e3ce3ae13c6b9ba998c7..9c7ef55be69712a51f24110d22a96a11684bc33c 100644 GIT binary patch delta 99268 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

UT;BOEH4aZe3m?MF8F_=pT!e65b|4GHPr=Z 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

^JrER) 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 Rddat+lAQX3;`.timeline.json`) and ticks are sent as columns of whole numbers diff --git a/docs/signals.md b/docs/signals.md index 1f68b3c6..0611707b 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -69,7 +69,7 @@ round-robin (`tools/signal_report.py ` regenerates them), with notes on **Offline only** (not in a round-robin's output): `tools/metric_correlation.py ...` replays a run at 10 Hz for the signals marked *offline* below, and -`python -m utama_core.analysis.goal_ledger ` writes the goal ledger +`python -m utama_core.analysis.goal_sources ` writes the goal sources ([Where do goals come from?](#where-do-goals-come-from)). **Sides.** Per-match stats are config_a's view ("friendly"); a strategy's row reads its own @@ -141,7 +141,7 @@ Check these first: a broken strategy's other signals mean nothing. ## Where do goals come from? -The goal ledger (`analysis/goal_ledger.py`, *offline*) gives every goal to the situation that +The goal sources (`analysis/goal_sources.py`, *offline*) gives every goal to the situation that started the play it ended, if that was less than 10 s before: a restart going live (kickoff, free kick, penalty, force start) or a side winning the ball in open play, each named from the strategy's side ("own" / "opponent") with the third in the owner's attack frame. Goals with no @@ -153,7 +153,7 @@ logs too. The rules are in the module's docstring. `--rates PATH` writes how oft situation happens per team per live minute, whoever owns it (the scenario bench, retired 2026-10-17, used these as its weights). -How a goal is credited (`analysis/goal_ledger.py`; `WINDOW_S` = 10 s): +How a goal is credited (`analysis/goal_sources.py`; `WINDOW_S` = 10 s): ```mermaid flowchart TD @@ -185,7 +185,7 @@ conceded per match). | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Situations per match | `goal_ledger.json` `strategies[*].types[*].situations_per_match` | how often each situation happens in a strategy's matches | own free kicks in the attacking third 6.7, the opponent's 6.2; balls won in the attacking third: own 3.4, opponent's 3.6; in the defensive third ~19 each | Many "opponent ball won, attacking third": losing the ball near our own goal (build-up). Many opponent free kicks in the attacking third: fouls and clearances out near our goal | +| Situations per match | `goal_sources.json` `strategies[*].types[*].situations_per_match` | how often each situation happens in a strategy's matches | own free kicks in the attacking third 6.7, the opponent's 6.2; balls won in the attacking third: own 3.4, opponent's 3.6; in the defensive third ~19 each | Many "opponent ball won, attacking third": losing the ball near our own goal (build-up). Many opponent free kicks in the attacking third: fouls and clearances out near our goal | | P(goal) per situation | `p_scored`, `p_conceded` | share of a situation's occurrences followed by a goal before the next situation starts, within 10 s | scored: own penalty 88%, own ball won in the attacking third 47%, own free kick in the attacking third 28%; conceded: opponent penalty 100%, opponent free kick in the attacking third 20%, opponent ball won in the attacking third 20% | High P(conceded) from opponent free kicks: set-piece defence (wall, marking). High from balls the opponent wins high: nobody covers behind the press | | Goals per match by situation | `scored_per_match`, `conceded_per_match` | situations per match × P(goal); the column sums to goals per match | conceded 4.41 = opponent balls won 1.41 + free kicks 1.35 + penalties 0.76 + sustained possession 0.71 + kickoffs 0.18 | The largest row is where a fix pays most | diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index e9569d09..68848374 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -27,7 +27,7 @@ links back here. | Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | | Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | | Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | -| What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/triage.py` (`--fouls` for our side's fouls), then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | +| What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py` (`--fouls` for our side's fouls), then the picture tools. find_bugs finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal sources (`utama_core/analysis/goal_sources.py`) | Today | | Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | | Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | | Is the simulator realistic? | Simulator tools: `realism_scorecard.py`, `physics_ranges.py`, `field_physics.py`, `robot_calibration.py`, `convert_ssl_log.py`. Not part of strategy development | Today | @@ -47,7 +47,7 @@ The screen was built and dropped on 2026-11-12: any code change made the paired Regression moments are fixed-state checks of shared-code bugs (restart and placement geometry), played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: -- **`moments.py fouls` moved into `tools/triage.py --fouls`** (the code in +- **`moments.py fouls` moved into `tools/find_bugs.py --fouls`** (the code in `utama_core/analysis/fouls.py`), so there is one place to find what went wrong in a run. - **`new` (hand-made templates) removed.** Moments come from `capture`, from a replay. - **`--seeds` kept.** `play --seeds 0-4` is how a moment is checked (it must fail on 4 of 5 @@ -77,7 +77,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: this (its set-up is now in `sim_setup.py`), so every stored match replays once. The match results store (`replay/match_results.py`) changed the same fingerprints, so one replay covers both. 6. **The screen.** The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. -7. **Triage takes the foul listing.** Done: `triage.py --fouls`; `moments.py` lost `fouls` and `new`, +7. **Triage takes the foul listing.** Done: `find_bugs.py --fouls`; `moments.py` lost `fouls` and `new`, and `--against` no longer uses a dated folder. Every step that changes shared code follows the rule in `docs/STRATEGY_DEVELOPMENT.md`: batch @@ -85,7 +85,7 @@ such changes, and run one round-robin at the end. ## Names considered (undecided) -- **Triage**: `scan_replays.py` or `find_bugs.py`. Undecided. `triage.py` stays until then. +- **Scan replays**: `scan_replays.py` or `find_bugs.py`. Undecided. `find_bugs.py` stays until then. - **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Undecided. Nothing above is decided by a name. Pick the name when the tool is merged, not before. diff --git a/docs/tools.md b/docs/tools.md index e5d4d3a6..a72629f2 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -14,7 +14,7 @@ says why the tools are split this way. | Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` and the round-robin report them | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion. The only verdict. Add `--held-out` before promoting | | Does everything still run after a shared-code change? | `tools/evaluation/round_robin.py --vs-champion`: one match per strategy against the champion (12). The full round-robin (66) only occasionally. A round-robin is not an evaluation | -| What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/triage.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | +| What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | | Is the simulator realistic? | [Simulator realism](#simulator-realism). Not strategy development | @@ -66,7 +66,7 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY |---|---| | `tools/signal_report.py` | Figures of a round-robin's strategy signals for [signal_report.md](signal_report.md) | | `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for [signal_report.md](signal_report.md#on-the-pitch). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | -| `utama_core/analysis/goal_ledger.py` | `python -m utama_core.analysis.goal_ledger `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | +| `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | | `tools/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | ### Validation studies @@ -99,14 +99,14 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or | Script | Purpose | |---|---| -| `tools/triage.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its round-robin matches, every other round in an evaluation), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/triage/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its round-robin matches, every other round in an evaluation), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | | `tools/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | | `tools/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | | `tools/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Referee handling" | | `tools/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `triage.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `find_bugs.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/debug_match.py` | One ad hoc match between two strategies for tactic debugging; `--dump-ticks` writes per-tick poses and commanded targets | Library helpers for the same job (`render_window`, `render_clip`, `MatchLog.trace()`) are diff --git a/docs/visual_guide.md b/docs/visual_guide.md index b3e64745..30aae3e7 100644 --- a/docs/visual_guide.md +++ b/docs/visual_guide.md @@ -15,9 +15,9 @@ is context), the pitch is in metres with the centre at (0, 0), and the strategy so the studied strategy attacks right. Zone names (defensive third, the box, ...) are the ones in [pitch_zones.md](pitch_zones.md). -## Start here: triage +## Start here: find bugs -`pixi run python tools/triage.py RUN_DIR --strategy NAME` picks the strategy's worst matches (by goal +`pixi run python tools/find_bugs.py RUN_DIR --strategy NAME` picks the strategy's worst matches (by goal difference, among those it played as config_a), collects every problem the tools flag (tactic flip-backs, stalls, and with `--restarts` illegal restart targets), and draws the worst few with the picture for that kind. Read its `index.md` first: each problem's numbers, then the picture path. About 20 s a match diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index 6ff27abb..ba060c4d 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -15,7 +15,7 @@ - `fouls.png`: each strategy's fouls by rule, one fixed colour per rule (`pitch_maps.plot_fouls`); - `summary.json`: the numbers behind the pictures per side, and the paired goal difference per opponent (same opponent, seed and colour, as `evaluate.py` pairs them), where the run has them. -- `triage/`: `tools/triage.py` on the candidate's two worst matches as config_a (`index.md` first). +- `find_bugs/`: `tools/find_bugs.py` on the candidate's two worst matches as config_a (`index.md` first). Everything is in the attacking frame of `pitch_maps.py` (attacking right). Goals come from the replay's final referee state (the score), fouls from the match's `.stats.json`. @@ -40,9 +40,9 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) +from tools import find_bugs # noqa: E402 from tools import pitch_maps as pm # noqa: E402 from tools import signal_report as sr # noqa: E402 -from tools import triage # noqa: E402 from tools.evaluation.match import _short_name # noqa: E402 from utama_core.analysis.matches import Match, find_matches # noqa: E402 @@ -200,7 +200,7 @@ def explain(run_dir, candidate: str, champion: str, out_dir, workers: int = 2) - (out_dir / "summary.json").write_text(json.dumps(summary, indent=2)) # The candidate's two worst matches as config_a (the friendly side the intentions log covers), for an agent to # start from; evaluate.py's failure guard covers this call too. - triage.triage(run_dir, strategies={cand}, matches=2, out=out_dir / "triage", workers=workers) + find_bugs.find_bugs(run_dir, strategies={cand}, matches=2, out=out_dir / "find_bugs", workers=workers) return summary diff --git a/tools/triage.py b/tools/find_bugs.py similarity index 96% rename from tools/triage.py rename to tools/find_bugs.py index 8783cd4d..416f6fb7 100644 --- a/tools/triage.py +++ b/tools/find_bugs.py @@ -1,8 +1,8 @@ #!/usr/bin/env python3 # ruff: noqa: E402 -"""Triage a run dir: which problems happened in which matches, with the numbers, and a picture for the worst. +"""Find the bugs in a run dir: which problems happened in which matches, with the numbers, and a picture for the worst. - pixi run python tools/triage.py REPLAYS_OR_RUN_DIR [--strategy NAME ...] [--matches 3] [--out DIR] + pixi run python tools/find_bugs.py REPLAYS_OR_RUN_DIR [--strategy NAME ...] [--matches 3] [--out DIR] [--max-pictures 8] [--workers 2] [--restarts] Start here when a strategy plays badly. For each strategy the friendly side (config_a, the only side the @@ -23,7 +23,7 @@ restart_stall) `restart_picture` at its restart. `OUT/index.md` is the report to read first: per strategy, its matches with their scores, the finding counts by kind, then each pictured finding with its message and picture path. -`OUT` defaults to `RUN_DIR/triage/`. Read-only: nothing is played or changed. +`OUT` defaults to `RUN_DIR/find_bugs/`. Read-only: nothing is played or changed. `--fouls` instead lists our side's (config_a's) fouls in a round-robin run, each with the referee command active then and whether that restart was ours or theirs: the starting points for a regression moment @@ -32,7 +32,7 @@ restart), `--json` writes JSON. `out_of_bounds`, the ball leaving the field, is a stoppage and is left out unless `--include-stoppages` (`utama_core/analysis/fouls.py`; until 2026-11-11 `moments.py fouls`). - pixi run python tools/triage.py replays/tournament_ --fouls [--rule keep_out] [--by strategy,rule] + pixi run python tools/find_bugs.py replays/tournament_ --fouls [--rule keep_out] [--by strategy,rule] """ from __future__ import annotations @@ -312,7 +312,7 @@ def write_index( restarts: bool, ) -> Path: lines = [ - f"# Triage: {run_dir.name}", + f"# Find bugs: {run_dir.name}", "", f"Friendly side (config_a) of each strategy's worst matches by goal difference. " f"Pictures: the top {max_pictures} findings with a picture source. Restart findings: " @@ -357,7 +357,7 @@ def write_index( return path -def triage( +def find_bugs( run_dir: Union[str, Path], *, strategies: Optional[set[str]] = None, @@ -370,7 +370,7 @@ def triage( """Analyse the selected matches, draw the top pictures and write `out/index.md` and `out/findings.jsonl`. Returns the index path.""" run_dir = Path(run_dir) - out = Path(out) if out is not None else run_dir / "triage" + out = Path(out) if out is not None else run_dir / "find_bugs" pictures = out / "pictures" pictures.mkdir(parents=True, exist_ok=True) selected = select_matches(run_dir, strategies, matches) @@ -431,7 +431,7 @@ def main() -> None: parser.add_argument( "--matches", type=int, default=3, help="each strategy's N worst matches by goal difference (default 3)" ) - parser.add_argument("--out", type=Path, default=None, help="output dir (default RUN_DIR/triage/)") + parser.add_argument("--out", type=Path, default=None, help="output dir (default RUN_DIR/find_bugs/)") parser.add_argument("--max-pictures", type=int, default=8, help="pictures to draw (default 8)") parser.add_argument("--workers", type=int, default=2, help="worker processes, one match each (default 2)") parser.add_argument( @@ -456,7 +456,7 @@ def main() -> None: except ValueError as e: parser.error(str(e)) return - index = triage( + index = find_bugs( args.run_dir, strategies=set(args.strategy) if args.strategy else None, matches=args.matches, diff --git a/tools/moments.py b/tools/moments.py index 73c96bad..a6e2d1ec 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -34,7 +34,7 @@ A moment comes from a replay (`capture`); `save` and `load` refuse an invalid one, naming each problem (ids, field lines, check and strategy names). Starting points: our side's fouls in a run, -`pixi run python tools/triage.py replays/tournament_ --fouls` (until 2026-11-11 `moments.py fouls`). +`pixi run python tools/find_bugs.py replays/tournament_ --fouls` (until 2026-11-11 `moments.py fouls`). Capture one from a replay (its noise and designated position come with it; `--out` writes elsewhere than utama_core/tests/moments/): pixi run python tools/moments.py capture replays/tournament_/_vs_.npz --t 254.65 \\ diff --git a/utama_core/analysis/findings.py b/utama_core/analysis/findings.py index 547d25a7..c5419e7a 100644 --- a/utama_core/analysis/findings.py +++ b/utama_core/analysis/findings.py @@ -1,7 +1,7 @@ """One shared format for the problems the picture tools flag (`--findings PATH` on each tool). A picture is for understanding a flagged problem, never the only evidence for it: each tool also emits -its flags as JSON lines, one `Finding` per line, so an agent (or `tools/triage.py`) can filter on the +its flags as JSON lines, one `Finding` per line, so an agent (or `tools/find_bugs.py`) can filter on the JSON and open the picture only to see what it means. {"tool": "match_timeline", "kind": "tactic_thrash", "replay": "replays/.../a_vs_b.npz", "side": "friendly", diff --git a/utama_core/analysis/fouls.py b/utama_core/analysis/fouls.py index 574fd2f0..96f6d50e 100644 --- a/utama_core/analysis/fouls.py +++ b/utama_core/analysis/fouls.py @@ -1,5 +1,5 @@ """Our side's fouls in a round-robin run, with the referee command active at each: the starting points for -new regression moments. `tools/triage.py --fouls` prints them; `tools/moments.py` uses `restart_side` in +new regression moments. `tools/find_bugs.py --fouls` prints them; `tools/moments.py` uses `restart_side` in its checks. (Until 2026-11-11 this was `moments.py fouls`.) `out_of_bounds`, the ball leaving the field, is a stoppage rather than a rules foul (`STOPPAGE_RULES`). diff --git a/utama_core/analysis/goal_ledger.py b/utama_core/analysis/goal_sources.py similarity index 98% rename from utama_core/analysis/goal_ledger.py rename to utama_core/analysis/goal_sources.py index f22c40ec..ec1f90a9 100644 --- a/utama_core/analysis/goal_ledger.py +++ b/utama_core/analysis/goal_sources.py @@ -1,6 +1,6 @@ """Where goals come from: every goal attributed to the situation that started the play it ended. - pixi run python -m utama_core.analysis.goal_ledger replays/tournament_ --out ledger.json + pixi run python -m utama_core.analysis.goal_sources replays/tournament_ --out ledger.json A strategy's goals per match is exactly a sum over situation types of how often the situation happens per match times how often it ends in a goal (P). That splits a result into what a @@ -400,7 +400,7 @@ def main() -> None: parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) parser.add_argument("paths", nargs="+", type=Path, help="run directories and/or replay .npz files") parser.add_argument("--labels", type=Path, help='JSON {"": ["", ""]}: who played') - parser.add_argument("--out", type=Path, help="JSON output (default: goal_ledger.json beside the first input)") + parser.add_argument("--out", type=Path, help="JSON output (default: goal_sources.json beside the first input)") parser.add_argument("--rates", type=Path, help="also write the corpus's situation rates here (situation_rates)") parser.add_argument("--workers", type=int, default=8) args = parser.parse_args() @@ -410,13 +410,13 @@ def main() -> None: strategies = tables(matches) print(report(strategies)) first = args.paths[0] - out = args.out or (first if first.is_dir() else first.parent) / "goal_ledger.json" + out = args.out or (first if first.is_dir() else first.parent) / "goal_sources.json" out.write_text(json.dumps({"strategies": strategies, "matches": matches}, indent=1)) print(f"wrote {out}: {len(matches)} matches, {sum(len(m['goals']) for m in matches)} goals") if args.rates: rates = situation_rates(matches) rates["inputs"] = [p.name for p in args.paths] - rates["command"] = " ".join(["python -m utama_core.analysis.goal_ledger", *sys.argv[1:]]) + rates["command"] = " ".join(["python -m utama_core.analysis.goal_sources", *sys.argv[1:]]) args.rates.write_text(json.dumps(rates, indent=1) + "\n") print(f"wrote {args.rates}: {rates['live_min_per_match']:.2f} live minutes per match") diff --git a/utama_core/analysis/matches.py b/utama_core/analysis/matches.py index 0da6c6b9..4bbf1ce2 100644 --- a/utama_core/analysis/matches.py +++ b/utama_core/analysis/matches.py @@ -2,7 +2,7 @@ A match file's stem is `_vs_` (round-robin) or `_vs__s` (an evaluate.py run). config_a is the friendly side (yellow) in every run. Shared by `tools/evaluation/explain.py` -and `tools/triage.py`. +and `tools/find_bugs.py`. """ from __future__ import annotations diff --git a/utama_core/dashboard/static/timeline.js b/utama_core/dashboard/static/timeline.js index 22cbd4fe..e751faa0 100644 --- a/utama_core/dashboard/static/timeline.js +++ b/utama_core/dashboard/static/timeline.js @@ -3,7 +3,7 @@ // Live tab up to now. Top to bottom, on one time axis: // - the referee command band (live play, STOP, kickoff, free kick, penalty, placement, HALT); // - possession: whose ball it is, in the team's colour. In a replay, one span per situation -// (a restart going live or a side winning the ball, as goal_ledger counts them); live, +// (a restart going live or a side winning the ball, as goal_sources counts them); live, // the side with a robot on the ball; // - one lane per friendly robot: a span per tactic it was in (the Tactic class from the // intention log), a dark tick where it switched, and a light strip where it had the ball; @@ -372,7 +372,7 @@ const group = refGroup(state.command); extend(d.referee, group, (state.command || "").replace(/_/g, " ").toLowerCase()); - // possession as goal_ledger reads it: the side with a robot on the ball while the other + // possession as goal_sources reads it: the side with a robot on the ball while the other // has none keeps it until the other side touches it; nobody holds it outside live play const last = d.possession[d.possession.length - 1]; const ours = friendly.some((r) => r.has_ball); diff --git a/utama_core/dashboard/views/replay.py b/utama_core/dashboard/views/replay.py index d93deae4..9fcf96b1 100644 --- a/utama_core/dashboard/views/replay.py +++ b/utama_core/dashboard/views/replay.py @@ -31,7 +31,7 @@ replay frame by frame, several seconds; its result is kept beside the replay in `.timeline.json`, redone when the replay or `ANALYSIS_VERSION` changes. -`play` is the match told as its situations (`goal_ledger`: a restart going live +`play` is the match told as its situations (`goal_sources`: a restart going live or a side winning the ball), one row each with how it ended: a goal, a stoppage and its reason, or the other side winning the ball (with how we lost it). @@ -51,7 +51,7 @@ import numpy as np -from utama_core.analysis import goal_ledger +from utama_core.analysis import goal_sources from utama_core.analysis.turnover_breakdown import analyse_match, is_real from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.settings import REPLAY_BASE_PATH @@ -293,10 +293,10 @@ def _play(replay_path: Path, referee_events: list, losses: list[dict], end_t: fl if replay_path.suffix != ".npz": return [] try: - match = goal_ledger.match_ledger(replay_path) + match = goal_sources.match_ledger(replay_path) except Exception: # noqa: BLE001 - optional, like the markers return [] - return play_rows(goal_ledger.situations(match), referee_events, losses, end_t) + return play_rows(goal_sources.situations(match), referee_events, losses, end_t) def play_rows(starts: list[dict], referee_events: list, losses: list[dict], end_t: float) -> list[dict]: diff --git a/utama_core/tests/analysis/test_triage.py b/utama_core/tests/analysis/test_find_bugs.py similarity index 68% rename from utama_core/tests/analysis/test_triage.py rename to utama_core/tests/analysis/test_find_bugs.py index 0c1d2563..8d2fd98d 100644 --- a/utama_core/tests/analysis/test_triage.py +++ b/utama_core/tests/analysis/test_find_bugs.py @@ -1,4 +1,4 @@ -"""tools/triage.py without replays: which matches are chosen (each strategy's worst N as config_a, by goal +"""tools/find_bugs.py without replays: which matches are chosen (each strategy's worst N as config_a, by goal difference), the picture ranking and cap, and the index's text. Match files are empty stubs and their scores come from a fake `final_score`, so nothing is simulated or drawn from a real replay.""" @@ -6,7 +6,7 @@ import pytest -from tools import triage +from tools import find_bugs from utama_core.analysis import matches as match_files from utama_core.analysis.findings import Finding @@ -48,41 +48,41 @@ def run_dir(tmp_path, monkeypatch): def test_worst_n_by_goal_difference_as_config_a(run_dir): - chosen = triage.select_matches(run_dir, None, 2) + chosen = find_bugs.select_matches(run_dir, None, 2) alpha = [m.npz.name for m in chosen if m.a == "alpha"] assert alpha == ["alpha_vs_beta.npz", "alpha_vs_gamma_s1.npz"] # GD -3 then 0; the +1 match is the best and cut def test_strategy_filter_takes_full_or_short_names(run_dir): - chosen = triage.select_matches(run_dir, {A}, 5) + chosen = find_bugs.select_matches(run_dir, {A}, 5) assert {m.a for m in chosen} == {"alpha"} assert len(chosen) == 3 - chosen = triage.select_matches(run_dir, {"beta"}, 5) + chosen = find_bugs.select_matches(run_dir, {"beta"}, 5) assert [m.npz.name for m in chosen] == ["beta_vs_gamma.npz", "beta_vs_alpha.npz"] # GD 0 then +4 def test_every_strategy_gets_its_own_worst_matches(run_dir): - chosen = triage.select_matches(run_dir, None, 1) + chosen = find_bugs.select_matches(run_dir, None, 1) assert sorted((m.a, m.npz.name) for m in chosen) == [ ("alpha", "alpha_vs_beta.npz"), ("beta", "beta_vs_gamma.npz"), ] -def _timeline(t0: float = 0.0) -> triage.TimelinePicture: - return triage.TimelinePicture(Path("m.npz"), t0, t0 + 40.0) +def _timeline(t0: float = 0.0) -> find_bugs.TimelinePicture: + return find_bugs.TimelinePicture(Path("m.npz"), t0, t0 + 40.0) def test_rank_puts_kind_priority_first_then_value(): items = [ - triage.Item(_finding("tactic_thrash", 50.0), request=_timeline(1.0)), - triage.Item(_finding("stall", 3.0), request=_timeline(2.0)), - triage.Item(_finding("tactic_thrash", 9.0), request=_timeline(3.0)), - triage.Item(_finding("keep_out_short", 1.0), request=triage.RestartPicture(Path("r.npz"), 2.0, None)), - triage.Item(_finding("target_in_keep_out", 0.1), request=triage.RestartPicture(Path("r.npz"), 1.0, None)), - triage.Item(_finding("stall", 9.0)), # no picture source: never ranked + find_bugs.Item(_finding("tactic_thrash", 50.0), request=_timeline(1.0)), + find_bugs.Item(_finding("stall", 3.0), request=_timeline(2.0)), + find_bugs.Item(_finding("tactic_thrash", 9.0), request=_timeline(3.0)), + find_bugs.Item(_finding("keep_out_short", 1.0), request=find_bugs.RestartPicture(Path("r.npz"), 2.0, None)), + find_bugs.Item(_finding("target_in_keep_out", 0.1), request=find_bugs.RestartPicture(Path("r.npz"), 1.0, None)), + find_bugs.Item(_finding("stall", 9.0)), # no picture source: never ranked ] - ranked = triage.rank(items) + ranked = find_bugs.rank(items) assert [it.finding.kind for it in ranked] == [ "stall", "target_in_keep_out", @@ -100,13 +100,13 @@ def fake_build(npz, t0, t1, side, out): drawn.append((t0, t1)) Path(out).write_bytes(b"\x89PNG stub") - monkeypatch.setattr(triage.match_timeline, "build", fake_build) - items = [triage.Item(_finding("stall", 3.0), request=_timeline())] - items += [triage.Item(_finding("tactic_thrash", 2.0 + i), request=_timeline()) for i in range(3)] - items += [triage.Item(_finding("tactic_thrash", 1.0), request=_timeline(100.0))] + monkeypatch.setattr(find_bugs.match_timeline, "build", fake_build) + items = [find_bugs.Item(_finding("stall", 3.0), request=_timeline())] + items += [find_bugs.Item(_finding("tactic_thrash", 2.0 + i), request=_timeline()) for i in range(3)] + items += [find_bugs.Item(_finding("tactic_thrash", 1.0), request=_timeline(100.0))] pictures = tmp_path / "pictures" pictures.mkdir() - shown = triage.draw_pictures(items, pictures, max_pictures=2) + shown = find_bugs.draw_pictures(items, pictures, max_pictures=2) assert len(shown) == 2 pictured = [it for it in items if it.image is not None] assert [it.finding.kind for it in pictured] == ["stall", "tactic_thrash"] @@ -118,18 +118,18 @@ def test_index_has_each_pictured_finding_message_and_path(run_dir, tmp_path): out.mkdir() picture = out / "01_stall.png" picture.write_bytes(b"x") - stall = triage.Item( + stall = find_bugs.Item( _finding("stall", 3.0, message="R1 oscillates with the ball frozen for 3.0 s."), request=_timeline(773.0), window=(773.0, 796.0), image=picture, ) - quiet = triage.Item( + quiet = find_bugs.Item( _finding("tactic_thrash", 4.0, message="R2 thrashes, no picture.") ) # not pictured: counted only - m = triage.select_matches(run_dir, {A}, 1)[0] - report = triage.MatchReport(m, [stall, quiet], notes=[]) - index = triage.write_index(out, run_dir, [report], max_pictures=8, restarts=False).read_text() + m = find_bugs.select_matches(run_dir, {A}, 1)[0] + report = find_bugs.MatchReport(m, [stall, quiet], notes=[]) + index = find_bugs.write_index(out, run_dir, [report], max_pictures=8, restarts=False).read_text() assert "R1 oscillates with the ball frozen for 3.0 s." in index assert str(picture.resolve()) in index assert "Picture of 773.0-796.0 s" in index @@ -141,5 +141,5 @@ def test_index_has_each_pictured_finding_message_and_path(run_dir, tmp_path): def test_index_says_so_when_a_strategy_has_no_matches(tmp_path): out = tmp_path / "out" out.mkdir() - index = triage.write_index(out, tmp_path, [], max_pictures=8, restarts=False).read_text() + index = find_bugs.write_index(out, tmp_path, [], max_pictures=8, restarts=False).read_text() assert "No matches with this strategy" in index diff --git a/utama_core/tests/analysis/test_fouls.py b/utama_core/tests/analysis/test_fouls.py index 465e6308..0f8ef7c6 100644 --- a/utama_core/tests/analysis/test_fouls.py +++ b/utama_core/tests/analysis/test_fouls.py @@ -1,5 +1,5 @@ """`utama_core/analysis/fouls.py`: our side's fouls in a run with the referee command active, as -`tools/triage.py --fouls` lists them (moved from `moments.py fouls` on 2026-11-11).""" +`tools/find_bugs.py --fouls` lists them (moved from `moments.py fouls` on 2026-11-11).""" import json @@ -123,8 +123,8 @@ def test_fouls_json_is_the_foul_list_or_the_by_counts_as_rows(): ] -def test_triage_fouls_filters_then_counts(tmp_path): - from tools.triage import fouls_report +def test_find_bugs_fouls_filters_then_counts(tmp_path): + from tools.find_bugs import fouls_report run = _run(tmp_path, [_foul(1.0), _foul(2.0, rule="out_of_bounds"), _foul(3.0, rule="crashing")]) assert len(fouls_report(run)) == 2 # out_of_bounds is a stoppage, left out diff --git a/utama_core/tests/analysis/test_goal_ledger.py b/utama_core/tests/analysis/test_goal_sources.py similarity index 99% rename from utama_core/tests/analysis/test_goal_ledger.py rename to utama_core/tests/analysis/test_goal_sources.py index 3496974f..1dbec609 100644 --- a/utama_core/tests/analysis/test_goal_ledger.py +++ b/utama_core/tests/analysis/test_goal_sources.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from utama_core.analysis.goal_ledger import ( +from utama_core.analysis.goal_sources import ( SUSTAINED, attribute, find_goals, diff --git a/utama_core/tests/engine/test_check_strategy_branch.py b/utama_core/tests/engine/test_check_strategy_branch.py index f56ac841..cd8b8b53 100644 --- a/utama_core/tests/engine/test_check_strategy_branch.py +++ b/utama_core/tests/engine/test_check_strategy_branch.py @@ -41,7 +41,7 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): "path", [ "utama_core/engine/strategy.py", - "utama_core/analysis/goal_ledger.py", + "utama_core/analysis/goal_sources.py", "tools/evaluation/match.py", "tools/check_strategy_branch.py", ".github/workflows/ci.yml", diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index b727a8f2..a9febd46 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -107,7 +107,7 @@ def test_explain_writes_the_four_files(run_dir, tmp_path): data = (out / name).read_bytes() assert data[:8] == b"\x89PNG\r\n\x1a\n" and len(data) < 250_000 assert json.loads((out / "summary.json").read_text())["candidate"] == "cand" - assert (out / "triage" / "index.md").exists() # the candidate's worst matches, as config_a + assert (out / "find_bugs" / "index.md").exists() # the candidate's worst matches, as config_a def test_each_side_counts_its_own_matches_and_goals(run_dir, tmp_path): From 4bc09bcd979b6d9f2c72ab35465b98bf4c0d373e Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 14:14:40 +0000 Subject: [PATCH 17/59] strategy: delete the ten retired strategies Nobody knew whether tiki_taka, counter_press, high_line_zone, three_slot, switch_of_play, low_block, zone_fluid, score_aware_zone_flow, overload_flow and shadow_switch still worked, so they go rather than come back. The RETIRED list goes with them: the catalog is every module in strategy/. holds_ball (three_slot's only) goes from pickers.py. DefenseTactic stays: examples/shooting_drill.py (pixi run demos) uses it. Co-Authored-By: Claude Opus 5.5 --- docs/STRATEGY_DEVELOPMENT.md | 3 +- docs/strategies.md | 22 +- docs/tools.md | 2 +- main.py | 2 +- tools/evaluation/match.py | 3 +- tools/evaluation/round_robin.py | 22 +- tools/moments.py | 7 +- utama_core/strategy/counter_press.py | 94 -------- utama_core/strategy/high_line_zone.py | 128 ---------- utama_core/strategy/low_block.py | 34 --- utama_core/strategy/overload_flow.py | 149 ------------ utama_core/strategy/pickers.py | 7 - utama_core/strategy/score_aware_zone_flow.py | 124 ---------- utama_core/strategy/shadow_switch.py | 116 ---------- utama_core/strategy/switch_of_play.py | 39 ---- utama_core/strategy/three_slot.py | 95 -------- utama_core/strategy/tiki_taka.py | 103 -------- utama_core/strategy/zone_fluid.py | 101 -------- .../tests/engine/test_all_strategy_configs.py | 219 +----------------- .../tests/engine/test_tournament_cli_args.py | 27 +-- .../tests/engine/test_tournament_match_end.py | 4 +- .../tests/engine/test_tournament_reuse.py | 18 +- .../engine/test_tournament_vs_champion.py | 4 +- utama_core/tests/replay/test_fingerprint.py | 2 +- .../strategy/test_overload_flow_streak.py | 31 --- .../strategy_runner/test_change_of_ends.py | 4 +- .../test_goalkeeper_stability.py | 2 +- 27 files changed, 48 insertions(+), 1314 deletions(-) delete mode 100644 utama_core/strategy/counter_press.py delete mode 100644 utama_core/strategy/high_line_zone.py delete mode 100644 utama_core/strategy/low_block.py delete mode 100644 utama_core/strategy/overload_flow.py delete mode 100644 utama_core/strategy/score_aware_zone_flow.py delete mode 100644 utama_core/strategy/shadow_switch.py delete mode 100644 utama_core/strategy/switch_of_play.py delete mode 100644 utama_core/strategy/three_slot.py delete mode 100644 utama_core/strategy/tiki_taka.py delete mode 100644 utama_core/strategy/zone_fluid.py delete mode 100644 utama_core/tests/strategy/test_overload_flow_streak.py diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 26bf2567..0607d8e4 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -245,8 +245,7 @@ changes and run one round-robin over the batch. environment (the shared code and machine, the match length, the planner, the sim noise without its seed, the restart fuzzing), both players' fingerprints, their sides and the noise seed. So after a change to one strategy only its matches play, one per other config. A default round-robin plays the -12 configs not in `RETIRED` (`tools/evaluation/round_robin.py`; the catalog has 22), so a change to one -of them replays 11 of its 66 matches. Naming all 22 configs gives 21 of 231. What counts as "runs" is +12 strategies of the catalog, so a change to one of them replays 11 of its 66 matches. What counts as "runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole files), and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing diff --git a/docs/strategies.md b/docs/strategies.md index 29d25e1c..9844ffad 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -33,23 +33,9 @@ strategies named plays these. | `decoy_and_overload` | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | | `clear_danger` | `counter_flow` postures plus an own-third `ClearBallTactic` danger-clearance valve. | -**Retired** (2026-10-10): the bottom ten of the 2026-10-05 round-robin. Left out of a round-robin -unless named (`RETIRED` in `tools/evaluation/round_robin.py`). Their code stays: -kept strategies and tests build on some of them. A retired strategy comes back by being judged -with `evaluate.py` against the reference opponents. - -| Strategy | Description | -|---|---| -| `tiki_taka` | 3 give-and-go + 2 shadow-and-mark with the ball; 3 press + 2 shadow without. | -| `counter_press` | Full press on loss, low block otherwise, 4-up switch-of-play on winning the ball. | -| `high_line_zone` | Zone screen (`BlockShapeTactic`) + switch attack, built to deny tiki_taka 1v1s. | -| `three_slot` | Three concurrent slots: press + mark + give-and-go. Exercises N>2 scheduling. | -| `switch_of_play` | `SwitchOfPlayTactic` (min 3) + `DefenseTactic`, fixed 50/50. | -| `low_block` | `PassAndShootTactic` (min 2) + `DefenseTactic`, fixed 20/80 defense-heavy split. | -| `zone_fluid` | Man-shape defense; give-and-go through the middle, decoy/overload in the final third. | -| `score_aware_zone_flow` | `zone_fluid` plus a late-half scoreline shift (protect a lead / chase). | -| `overload_flow` | `zone_fluid`; give-and-go grows 3→4 only after the possession edge holds ~1.5s. | -| `shadow_switch` | `SwitchOfPlayTactic` relay attack + `ShadowAndMarkTactic` defense, 3/2. | +**Deleted** (2026-11-12): the ten strategies retired on 2026-10-10 (`tiki_taka`, `counter_press`, +`high_line_zone`, `three_slot`, `switch_of_play`, `low_block`, `zone_fluid`, `score_aware_zone_flow`, +`overload_flow`, `shadow_switch`), because nobody knew whether they still worked. Git history keeps them. `default`: Everyone runs `PassAndShootTactic`; only 2 robots are ever commanded (see bugs). Excluded from round-robin discovery. @@ -101,6 +87,6 @@ bugs" refer to them — read them with `git log -p -- docs/strategies.md`. Still - New strategy → add a row with a one-line description to the round-robin table. - New tournament → replace the matching results table (one table per tournament type) and record the run directory; don't append narrative. Findings belong in commit messages. -- Strategy abandoned after losing → add it to `RETIRED` and move its row to the retired table. +- Strategy abandoned after losing → delete its module and its row. - Only single matches (`--pair`), no round-robin → put them in the pull request, not here: this file holds round-robin and full-match results only. diff --git a/docs/tools.md b/docs/tools.md index a72629f2..c6654df0 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -48,7 +48,7 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every config not in `RETIRED` (12 of the 22 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the match results store. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; A match the store already holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played: automatic, with no flag, so only matches whose code changed play. To play every match again, delete the store. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | +| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every strategy in the catalog (12 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the match results store. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; A match the store already holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played: automatic, with no flag, so only matches whose code changed play. To play every match again, delete the store. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | | `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the match results store `replays/match_results/` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; a match whose stats were not collected counts as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | diff --git a/main.py b/main.py index d53b3e48..762e79d3 100644 --- a/main.py +++ b/main.py @@ -3,7 +3,7 @@ Run: pixi run main # split_shape vs high_press - pixi run main tiki_taka counter_flow # any two names from docs/strategies.md + pixi run main split_shape counter_flow # any two names from docs/strategies.md pixi run main a.strategy high_press # or a .strategy file (tools/build_strategy.py) # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index a54f09ab..d1b4412f 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -47,8 +47,7 @@ # despite the name, it isn't a competitive team — it's the kernel's minimal # single-tactic smoke-test scaffold (see its docstring), used across the test # suite with as few as zero outfield robots, and plays a real match with 3 of 5 -# outfield robots never issued a command. Every other strategy is playable here; -# which ones a round-robin plays by default is round_robin.RETIRED's business. +# outfield robots never issued a command. Every other strategy is playable here. _CONFIG_NAMES = [name for name in catalog.names() if name != "default"] diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index bd5eb411..18038702 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -9,7 +9,7 @@ Run: pixi run python tools/evaluation/round_robin.py [config ...] [flags] -Configs are short names (`tiki_taka`); none means every config not in RETIRED. Flags: +Configs are short names (`split_shape`); none means every strategy in the catalog. Flags: --pair A B one match, A as config_a --vs-champion the day-to-day health check: one match per active strategy against the champion (reference/opponents.json), plus champion vs the first opponent; @@ -35,7 +35,7 @@ strategies `utama_core/strategy/catalog.py` finds (one `strategy/.py` each), runs one `StrategyRunner` match (6v6: 1 goalkeeper + 5 outfield robots per side — enough for every factory's minimum, including the `min_attack=2` -configs and `three_slot`'s three concurrent slots), +configs), steps it until `CustomReferee` calls full time, and records the final score from its scoreboard. @@ -123,22 +123,6 @@ from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.strategy.catalog import plain_name -# Left out of a round-robin unless named: the bottom ten of the 2026-10-05 full round-robin -# (docs/strategies.md). Their code stays, since kept strategies and tests build on some of them. -# Named here, outside the match results' fixtures, so retiring one reruns nothing. -RETIRED = { - "tiki_taka", - "counter_press", - "high_line_zone", - "three_slot", - "switch_of_play", - "low_block", - "zone_fluid", - "score_aware_zone_flow", - "overload_flow", - "shadow_switch", -} - # A full match, as the rulebook has it: two halves of 300 s of playing time, the clock stopped # whenever no team may play the ball (`custom_referee/state_machine.py`), so about 710 s of # sim time (785 s in two measured matches, tournament_20261006_111922). config_a starts on the @@ -406,7 +390,7 @@ def main() -> None: if len(config_names) < 2: raise SystemExit("Need at least 2 configs to play a round-robin.") else: - config_names = [name for name in _CONFIG_NAMES if name not in RETIRED] + config_names = list(_CONFIG_NAMES) if vs_champion: reference = load_opponents() diff --git a/tools/moments.py b/tools/moments.py index a6e2d1ec..27aa847b 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -211,11 +211,10 @@ def save(m: Moment, path: Optional[Path] = None) -> Path: def catalog() -> list[str]: - """The round-robin's strategies: every strategy in the catalog, minus the - retired ones.""" - from tools.evaluation.round_robin import _CONFIG_NAMES, RETIRED + """The round-robin's strategies: every strategy in the catalog.""" + from tools.evaluation.round_robin import _CONFIG_NAMES - return [n for n in _CONFIG_NAMES if n not in RETIRED] + return list(_CONFIG_NAMES) def _referee_behaviour(name: str) -> tuple: diff --git a/utama_core/strategy/counter_press.py b/utama_core/strategy/counter_press.py deleted file mode 100644 index 61e15291..00000000 --- a/utama_core/strategy/counter_press.py +++ /dev/null @@ -1,94 +0,0 @@ -"""The `counter_press` kernel strategy: `counter_press` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.block_shape import BlockShapeTactic -from utama_core.tactics.press_and_contain import PressAndContainTactic -from utama_core.tactics.switch_of_play import SwitchOfPlayTactic - - -def _counter_press_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """Counter-press posture: all-out pressure when we lose it, low block when - there is nothing to press, four-up on the switch when we regain it. - - - Opponent has the ball and pressing is possible: everyone presses - (1 ball-presser + everyone else man-marking) — the ball is smothered - where it was lost. - - Opponent has the ball but nothing is pressable: everyone holds the - `block_shape` zone screen — the compact low block. - - We have the ball: the switch-of-play needs its three roles - (carrier/pivot/runner), so 4 robots attack through the weak side while - 1 keeps the screen shape as insurance on the counter. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - friendly_edge = friendly_closer_to_ball(game) - losing = friendly_edge is not True - - press_ok = "press" in available_tactic_ids - attack_ok = "attack" in available_tactic_ids - block_ok = "block" in available_tactic_ids - - if losing: - if press_ok: - return allocate_ordered(ordered, "press", len(ordered)) - if block_ok: - return allocate_ordered(ordered, "block", len(ordered)) - if attack_ok: - return allocate_ordered(ordered, "attack", len(ordered)) - return {} - if attack_ok: - return allocate_ordered(ordered, "attack", 4, "block" if block_ok else None) - if block_ok: - return allocate_ordered(ordered, "block", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """High-intensity transition team: smother the ball where it was lost, - then switch the play to the weak side at full commitment. - - Three concurrent slots — `SwitchOfPlayTactic` ("attack"), - `PressAndContainTactic` ("press"), and the new `BlockShapeTactic` - ("block") — allocated by `_counter_press_picker`: everyone presses while - the opponent has it (and something is pressable), everyone drops into - the zone screen when they are shielded from the press, and 4 robots - attack through the pivot/runner switch the moment the ball is won. The - three-role switch (carrier/pivot/runner) needs at least 3 robots, hence - the 4+1 split. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": SwitchOfPlayTactic(), - "press": PressAndContainTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_counter_press_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/high_line_zone.py b/utama_core/strategy/high_line_zone.py deleted file mode 100644 index ba42604d..00000000 --- a/utama_core/strategy/high_line_zone.py +++ /dev/null @@ -1,128 +0,0 @@ -"""The `high_line_zone` kernel strategy: `high_line_zone` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - ball_zone, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.block_shape import BlockShapeTactic -from utama_core.tactics.decoy_and_overload import DecoyOverloadTactic -from utama_core.tactics.switch_of_play import SwitchOfPlayTactic - - -def _high_line_zone_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """High-line zone posture: deny tiki_taka's give-and-go trio the 1v1s it - wants with a zone screen instead of man-marking, switch the ball to the - weak side its 2-robot defense can't cover, finish with the overload duet - once we're through. - - - The opponent has the ball: the whole team holds `BlockShapeTactic`'s - shifting zone line — tiki_taka's give-and-go build-up is a 3-robot - short-passing relay that thrives against man-marking cover it can - dribble/pass past one defender at a time; a zone screen that shifts - with the ball and never breaks shape denies it the individual - matchups it's built around, unlike `ShadowAndMarkTactic`'s greedy - per-robot marking (which is what tiki_taka's own defense runs, and - exactly the shape `overload_press` targets instead). - - We have the ball, not yet in the final third: `SwitchOfPlayTactic` - leads — tiki_taka's defense is only ever 2 robots, so a genuine - weak-side imbalance is easy to manufacture; 2 hold the block screen as - insurance against the counter. - - We have the ball in the final third: switch to the overload duet - (`DecoyOverloadTactic`) to finish, same final-third handoff - `_zone_flow_picker` uses — the switch has already done its job of - breaking the defense's shape open by this point. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - block_ok = "block" in available_tactic_ids - switch_ok = "switch" in available_tactic_ids - overload_ok = "overload" in available_tactic_ids - - # Sticky possession edge: a plain `friendly_closer_to_ball` re-read every - # tick flips constantly in a genuinely contested 50/50 (measured: switch - # assigned and released again within single-digit ticks, over and over, - # for the first ~10s of a live match against tiki_taka) — `switch`'s - # carrier/pivot/runner relay needs several seconds to settle and never - # got the chance, discarded before `is_committed()` ever saw it commit. - # `prev_partition` is this picker's only persistent state (a `Partitioner` - # is a plain function, no `mem` of its own — unlike a `Tactic`, which - # gets one), so use "did we hold switch/overload last tick" as the - # attacking side's memory and require a full possession loss (proximity - # edge, not just "not clearly ahead") before dropping it. Mirrors - # `SwitchOfPlayTactic`'s own internal weak-side hysteresis, one level up. - prev_partition = prev_partition or {} - currently_attacking = bool(prev_partition.get("switch")) or bool(prev_partition.get("overload")) - friendly_edge = friendly_closer_to_ball(game) - if currently_attacking: - losing = friendly_edge is False # only give up the ball on a clear loss, not just "unknown" - else: - losing = friendly_edge is not True # regaining needs a clear win, same conservative default as elsewhere - - if losing: - if block_ok: - return allocate_ordered(ordered, "block", len(ordered)) - if switch_ok: - return allocate_ordered(ordered, "switch", len(ordered)) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - return {} - - zone = ball_zone(game) - if zone == "final" and overload_ok: - return allocate_ordered(ordered, "overload", 2, "block" if block_ok else None) - if switch_ok: - return allocate_ordered(ordered, "switch", 3, "block" if block_ok else None) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - if block_ok: - return allocate_ordered(ordered, "block", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Zone-defense team built to deny tiki_taka's give-and-go trio the 1v1s - it's designed around, switching the ball past its thin 2-robot cover. - - Three concurrent slots — `SwitchOfPlayTactic` ("switch"), - `DecoyOverloadTactic` ("overload"), and `BlockShapeTactic` ("block") — - allocated by `_high_line_zone_picker`: the whole team holds the zone - screen when the ball is lost (denying man-marking 1v1s instead of - running them, unlike tiki_taka's own `ShadowAndMarkTactic` defense); - 3 robots read the weak side and switch there once we have it (tiki_taka's - defense is always just 2 robots — an imbalance is easy to create); the - final third hands off to the overload duet to finish. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "switch": SwitchOfPlayTactic(), - "overload": DecoyOverloadTactic(), - "block": BlockShapeTactic(), - }, - partitioner=_high_line_zone_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/low_block.py b/utama_core/strategy/low_block.py deleted file mode 100644 index 279442f9..00000000 --- a/utama_core/strategy/low_block.py +++ /dev/null @@ -1,34 +0,0 @@ -"""The `low_block` kernel strategy: `low_block` and the pickers only it uses.""" - -from __future__ import annotations - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import fixed_ratio_picker -from utama_core.tactics.defense import DefenseTactic -from utama_core.tactics.pass_and_shoot import PassAndShootTactic - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """5-robot (or fewer) `Strategy` factory: a conservative, defense-heavy - counterpart to `high_press` — most of the pool - stays back regardless of possession (floored at `min_attack=2`, since - `PassAndShootTactic` hard-requires at least 2 robots). Wires - `PassAndShootTactic` ("attack") and `DefenseTactic` ("defense"), the - original two ported Tactics, still useful as the minimal-risk baseline - they were designed to be (§1/§2's original pairing) rather than the - newer, more elaborate Tactics used elsewhere in this file. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": PassAndShootTactic(), "defense": DefenseTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.2, min_attack=2), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/overload_flow.py b/utama_core/strategy/overload_flow.py deleted file mode 100644 index c886e7ff..00000000 --- a/utama_core/strategy/overload_flow.py +++ /dev/null @@ -1,149 +0,0 @@ -"""The `overload_flow` kernel strategy: `overload_flow` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Partitioner -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - ball_zone, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.decoy_and_overload import DecoyOverloadTactic -from utama_core.tactics.give_and_go import GiveAndGoTactic -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic - -# --------------------------------------------------------------------------- -# overload_flow (2026-09-02 addition) -# -# Every existing possession-edge picker (including `_zone_flow_picker`, -# which this strategy is otherwise identical to) reacts to a single tick's -# edge read alone. `score_aware_zone_flow` proved a cheap graft onto that -# same base is worth testing (the scoreline); this strategy grafts a -# different, still-unused signal instead: how *long* the possession edge has -# held, not just its current value. Rationale: `_zone_flow_picker`'s -# give-and-go trio already builds patiently through the middle thirds -- -# committing a 4th attacker the instant the edge flips, before that -# possession is actually secure, risks overextending into exactly the kind -# of single-tick noise `CLOSER_TO_BALL_MARGIN` and every sticky-edge picker -# (`counter_flow`, `high_line_zone`, `shadow_switch`) already had to guard -# against elsewhere. Only commit the extra body once the edge has held for a -# real, sustained window. -# --------------------------------------------------------------------------- - -# ~1.5s at the kernel's tick rate (60Hz, matching every other tick-count -# constant in this file, e.g. `PressAndContainTactic`'s hysteresis window) -# -- long enough to filter a -# single contested-ball flicker, short enough that a genuine sustained -# possession spell still gets the extra attacker well before a give-and-go -# hop cycle completes. -_POSSESSION_STREAK_TICKS = 90 - - -def _overload_flow_picker() -> Partitioner: - """A fresh picker with its own possession streak. - - A `Partitioner` has no `mem`, and `prev_partition` can't carry a tick count, - so the streak lives in this closure: one per strategy instance. It was a - module-level `global`, which both teams share when they play the same - strategy in one process, and which carried from one match to the next in a - round-robin worker unless the factory reset it. - """ - streak = 0 - - def pick( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], - ) -> dict[str, frozenset[RobotId]]: - nonlocal streak - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - losing = friendly_closer_to_ball(game) is not True - streak = 0 if losing else min(streak + 1, _POSSESSION_STREAK_TICKS) - return _allocate(game, ordered, available_tactic_ids, losing, streak) - - return pick - - -def _allocate( - game: Game, - ordered: list[RobotId], - available_tactic_ids: frozenset[str], - losing: bool, - streak: int, -) -> dict[str, frozenset[RobotId]]: - """`_zone_flow_picker`'s allocation, with the own/mid-third give-and-go - attacker count growing from 3 to 4 only once the possession edge has - held for `_POSSESSION_STREAK_TICKS` consecutive ticks, instead of - reacting to the edge's current value alone. - - Not late in a possession spell, losing, or in the final third: - identical to `_zone_flow_picker`. Final-third handoff to the overload - duet is unchanged (that tactic is a 2-role duet regardless of streak - length -- the streak only ever affects the own/mid-third give-and-go - count). - """ - defense_ok = "defense" in available_tactic_ids - givego_ok = "givego" in available_tactic_ids - overload_ok = "overload" in available_tactic_ids - - if losing: - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - if givego_ok: - return allocate_ordered(ordered, "givego", len(ordered)) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - return {} - - zone = ball_zone(game) - if zone == "final" and overload_ok: - return allocate_ordered(ordered, "overload", 2, "defense" if defense_ok else None) - if givego_ok: - attackers = 4 if streak >= _POSSESSION_STREAK_TICKS else 3 - return allocate_ordered(ordered, "givego", attackers, "defense" if defense_ok else None) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """`zone_fluid` with a possession-*duration*-aware give-and-go attacker - count: 3 attackers as usual, growing to 4 only once the possession edge - has held for a sustained window (`_POSSESSION_STREAK_TICKS`), instead of - reacting to a single tick's edge read the way every other picker in the - catalog does. See the "overload_flow" comment block above - `_overload_flow_picker` for the full rationale. - - Same three tactics/slots as `zone_fluid` (`GiveAndGoTactic`/ - `DecoyOverloadTactic`/`ShadowAndMarkTactic`) -- only the picker's - attacker-count decision differs, so any observed difference from plain - `zone_fluid` is attributable to the streak requirement alone. - - Returns a `build(motion_controller)` callable suitable - for `AbstractStrategy`'s constructor argument of the same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_overload_flow_picker(), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/pickers.py b/utama_core/strategy/pickers.py index 1cb14555..1cbf6bfd 100644 --- a/utama_core/strategy/pickers.py +++ b/utama_core/strategy/pickers.py @@ -292,13 +292,6 @@ def dist(robot) -> float: return rid if dist(robot) <= _KICK_REACH_M < enemy_nearest else None -def holds_ball(game: Game, robot_id: RobotId) -> bool: - """True if `robot_id` is on the ball (dribbler contact) or is the kicker waiting at a - still ball: the robot `carrier_first` puts first.""" - robot = game.friendly_robots.get(robot_id) - return robot is not None and (robot.has_ball or robot_id == _kicker_at_still_ball(game)) - - def clearer_first(game: Game, ordered: list[RobotId]) -> list[RobotId]: """`ordered` (from `carrier_first`) with the robot that should clear first. diff --git a/utama_core/strategy/score_aware_zone_flow.py b/utama_core/strategy/score_aware_zone_flow.py deleted file mode 100644 index 28683eda..00000000 --- a/utama_core/strategy/score_aware_zone_flow.py +++ /dev/null @@ -1,124 +0,0 @@ -"""The `score_aware_zone_flow` kernel strategy: `score_aware_zone_flow` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - ball_zone, - carrier_first, - friendly_closer_to_ball, - friendly_score_diff, - is_late_in_half, -) -from utama_core.tactics.decoy_and_overload import DecoyOverloadTactic -from utama_core.tactics.give_and_go import GiveAndGoTactic -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic - -# --------------------------------------------------------------------------- -# Score-aware zone-flow (2026-08-23 addition) -# -# Every existing picker reads possession/ball-zone but none reads the -# scoreline itself, even though `game.referee.{yellow,blue}_team.score` is -# already populated in any refereed match (`round_robin.py` reads the same fields to report a -# match's result). -# This variant is `_zone_flow_picker`'s allocation with one added axis: late -# in a half, shift the *size* of the attack/defense split based on whether -# we're ahead or behind, instead of holding the same 3/2-ish split regardless -# of score. Ahead late: fewer bodies committed forward, more men behind the -# ball to protect the lead. Behind late: the reverse, chase the game. Tied, -# early in the half, or score unreadable (`game.referee is None`): identical -# to `_zone_flow_picker`, so this strategy only diverges from `zone_fluid` -# when the new signal actually has something to say. -# --------------------------------------------------------------------------- - - -def _score_aware_zone_flow_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """`_zone_flow_picker`'s allocation, with the attack/defense split size - shifted late in a half by whether we're ahead or behind. - - Not late, tied, or score unreadable: identical to `_zone_flow_picker` - (3 attackers/2 defenders when we have the ball, everyone shadows when we - don't). Late and ahead: only 2 forward, 3 back, to protect the lead. Late - and behind: 4 forward, 1 back, to chase an equaliser. The final-third - overload duet always stays 2 robots regardless (that tactic is a - two-role duet by design, see `_zone_flow_picker`) — only the - own/mid-third give-and-go split size reacts to the scoreline. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - friendly_edge = friendly_closer_to_ball(game) - losing_possession = friendly_edge is not True - - defense_ok = "defense" in available_tactic_ids - givego_ok = "givego" in available_tactic_ids - overload_ok = "overload" in available_tactic_ids - - if losing_possession: - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - if givego_ok: - return allocate_ordered(ordered, "givego", len(ordered)) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - return {} - - zone = ball_zone(game) - if zone == "final" and overload_ok: - return allocate_ordered(ordered, "overload", 2, "defense" if defense_ok else None) - - if givego_ok: - attackers = 3 - if is_late_in_half(game): - score_diff = friendly_score_diff(game) - if score_diff is not None and score_diff > 0: - attackers = 2 - elif score_diff is not None and score_diff < 0: - attackers = 4 - return allocate_ordered(ordered, "givego", attackers, "defense" if defense_ok else None) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Zone-flow team (see `zone_fluid`) with one added - decision input nothing else in the catalog uses: the scoreline. Late in a - half, the give-and-go attack/defense split shrinks when we're ahead - (protect the lead) and grows when we're behind (chase the game), instead - of holding the same split regardless of score. Same three tactics/slots - as `zone_fluid` (`GiveAndGoTactic`/`DecoyOverloadTactic`/ - `ShadowAndMarkTactic`) — only the picker differs, so any difference in - results is attributable to the new score-aware allocation, not a - different tactic set. - - Returns a `build(motion_controller)` callable suitable - for `AbstractStrategy`'s constructor argument of the same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_score_aware_zone_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/shadow_switch.py b/utama_core/strategy/shadow_switch.py deleted file mode 100644 index 739552c7..00000000 --- a/utama_core/strategy/shadow_switch.py +++ /dev/null @@ -1,116 +0,0 @@ -"""The `shadow_switch` kernel strategy: `shadow_switch` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic -from utama_core.tactics.switch_of_play import SwitchOfPlayTactic - -# --------------------------------------------------------------------------- -# shadow_switch (2026-09-02 addition) -# -# `high_line_zone` paired `SwitchOfPlayTactic` with `BlockShapeTactic`'s zone -# screen and stayed parked (2-7-4 in its best backfill) -- the screen denies -# individual matchups, but the switch's carrier/pivot/runner relay still -# needs several seconds to settle, which a genuinely contested match rarely -# grants. `tiki_taka`'s `ShadowAndMarkTactic` defense is independently -# proven viable (it's the top-tested strategy's own defense, 1W-8D-4L in -# isolation but never the bottleneck -- every loss traced to the *attack* -# side, not the shadow cover). This pairing -- switch's attack, shadow's -# defense -- has never been tried: `high_line_zone` used switch with the -# zone screen, `tiki_taka`/`tiki_taka_plus` used shadow with give-and-go. -# Hypothesis: man-marking cover (proven to hold up on its own) may free the -# switch attack to develop without the zone screen's own unproven defensive -# contribution as a confound in either direction. -# --------------------------------------------------------------------------- - - -def _shadow_switch_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """Switch-attack, shadow-defense posture. - - - The opponent has the ball: the whole team shadows/marks - (`ShadowAndMarkTactic`), same defensive shape `tiki_taka` already - validates. - - We have the ball: `SwitchOfPlayTactic` leads with 3 (the relay's - carrier/pivot/runner roles), 2 hold shadow cover behind it -- same - 3/2 split shape as `high_line_zone`'s switch branch, defense slot - swapped. - - Sticky possession edge, same fix `_high_line_zone_picker`/ - `_counter_flow_picker` needed: the switch relay needs several seconds to - settle, which a tick-by-tick possession-edge re-read does not reliably - give it in a contested match. `prev_partition` ("did we hold switch last - tick") is the memory; require a clear possession loss to drop it. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - prev_partition = prev_partition or {} - currently_attacking = bool(prev_partition.get("switch")) - friendly_edge = friendly_closer_to_ball(game) - if currently_attacking: - losing = friendly_edge is False - else: - losing = friendly_edge is not True - - switch_ok = "switch" in available_tactic_ids - defense_ok = "defense" in available_tactic_ids - - if losing: - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - if switch_ok: - return allocate_ordered(ordered, "switch", len(ordered)) - return {} - - if switch_ok: - return allocate_ordered(ordered, "switch", 3, "defense" if defense_ok else None) - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Switch-of-play attack with man-marking cover -- a tactic pairing never - tried elsewhere in the catalog (`high_line_zone` paired the switch with - a zone screen; `tiki_taka`/`tiki_taka_plus` paired shadow-and-mark with - give-and-go). See the "shadow_switch" comment block above - `_shadow_switch_picker` for the full rationale. - - Two concurrent slots -- `SwitchOfPlayTactic` ("switch") and - `ShadowAndMarkTactic` ("defense") -- allocated by `_shadow_switch_picker` - on a 3/2 split with sticky possession-edge hysteresis, matching the - settling time the switch relay needs. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "switch": SwitchOfPlayTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_shadow_switch_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/switch_of_play.py b/utama_core/strategy/switch_of_play.py deleted file mode 100644 index d00d1ce5..00000000 --- a/utama_core/strategy/switch_of_play.py +++ /dev/null @@ -1,39 +0,0 @@ -"""The `switch_of_play` kernel strategy: `switch_of_play` and the pickers only it uses.""" - -from __future__ import annotations - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import fixed_ratio_picker -from utama_core.tactics.defense import DefenseTactic -from utama_core.tactics.switch_of_play import SwitchOfPlayTactic - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """5-robot (or fewer) `Strategy` factory exercising `SwitchOfPlayTactic`. - - Wires `SwitchOfPlayTactic` ("attack") and `DefenseTactic` ("defense"), - split by `fixed_ratio_picker` with `min_attack=3` — the tactic's full - carrier/pivot/runner relay needs 3 robots to actually exercise the - "switch" leg (the pivot outlet) rather than silently degrading to its - 2-robot direct-pass fallback every tick, the same floor rationale - `low_block` gives `PassAndShootTactic` and - `decoy_and_overload` gives `DecoyOverloadTactic`. - Attack fraction left at a plain 0.5 split (possession-agnostic), same as - `decoy_and_overload` — nothing about reading the - weak side and relaying the ball across it is more or less urgent when the - opponent has the ball. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={"attack": SwitchOfPlayTactic(), "defense": DefenseTactic()}, - partitioner=fixed_ratio_picker("attack", "defense", attack_fraction=0.5, min_attack=3), - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/three_slot.py b/utama_core/strategy/three_slot.py deleted file mode 100644 index e5f03a09..00000000 --- a/utama_core/strategy/three_slot.py +++ /dev/null @@ -1,95 +0,0 @@ -"""The `three_slot` kernel strategy: `three_slot` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import carrier_first, holds_ball -from utama_core.tactics.give_and_go import GiveAndGoTactic -from utama_core.tactics.press_and_contain import PressAndContainTactic -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic - - -def _three_way_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """Splits the free pool three ways — first exercise of `Strategy` running - more than two concurrent slots (nothing in `Strategy`/`_validate_partition` - is hardcoded to two, but no config before this one had actually tried - three). One presser, one shadow-and-mark defensive pair when there are - enough robots to spare, everyone else attacks via give-and-go. Falls back - to redistributing a slot's share to "attack" whenever that slot's Tactic - is currently inapplicable or pinned elsewhere, same defensive pattern as - `_press_and_pass_split_picker`. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - press_ok = "press" in available_tactic_ids - mark_ok = "mark" in available_tactic_ids - attack_ok = "attack" in available_tactic_ids - - remaining = list(ordered) - partition: dict[str, frozenset[RobotId]] = {} - - # The robot on the ball (a free-kick taker included) attacks. Handed to "press" or "mark" - # it clears the ball blind, straight upfield (`kick_upfield`), and the kick ran the length - # of the pitch and out over the far goal line: 24 a match, most of three_slot's out-of-bounds - # fouls (three_slot_vs_zone_fluid t=87.8: the taker of our free kick in "mark"). - holder = [remaining.pop(0)] if attack_ok and holds_ball(game, remaining[0]) else [] - - if press_ok and remaining: - partition["press"] = frozenset([remaining.pop(0)]) - if mark_ok and len(remaining) >= 2: - partition["mark"] = frozenset(remaining[:2]) - remaining = remaining[2:] - if attack_ok: - if holder or remaining: - partition["attack"] = frozenset(holder + remaining) - elif remaining: - # "attack" unavailable too — nothing left to hand the rest to; leave - # them off the partition only if every other slot already claimed - # everyone, otherwise this would violate the exhaustive-cover - # invariant, so fall back to whichever defensive slot is still open. - if mark_ok: - partition["mark"] = frozenset(set(partition.get("mark", frozenset())) | set(remaining)) - elif press_ok: - partition["press"] = frozenset(set(partition.get("press", frozenset())) | set(remaining)) - - return partition - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """5-robot (or fewer) `Strategy` factory running three concurrent Tactic - slots at once: `PressAndContainTactic` ("press"), `ShadowAndMarkTactic` - ("mark"), and `GiveAndGoTactic` ("attack"). Distinct in kind from every - other factory in this file, which all run exactly two slots — this is - the first config to actually exercise `Strategy` with N>2, which the - kernel has always structurally supported (`_validate_partition` iterates - `partition.items()` generically) but nothing had tested until now. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "press": PressAndContainTactic(), - "mark": ShadowAndMarkTactic(), - "attack": GiveAndGoTactic(), - }, - partitioner=_three_way_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/tiki_taka.py b/utama_core/strategy/tiki_taka.py deleted file mode 100644 index 99ce4eba..00000000 --- a/utama_core/strategy/tiki_taka.py +++ /dev/null @@ -1,103 +0,0 @@ -"""The `tiki_taka` kernel strategy: `tiki_taka` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.give_and_go import GiveAndGoTactic -from utama_core.tactics.press_and_contain import PressAndContainTactic -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic - - -def _tiki_taka_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """Tiki-taka posture: possession attack with give-and-go, press on loss, - shadow-and-mark cover in both postures. - - - We have the ball (friendly closer to it, or unknown): 3 attackers - (give-and-go trio), 2 defenders (one shadowing pair on the shot line). - - The opponent has the ball: 3 pressers (1 ball-presser + 2 man-markers) - and 2 shadowers — the press denies the immediate play while the shadow - pair keeps the shot line honest behind it. - - A slot that is unavailable (inapplicable — PressAndContain only, or - commitment-pinned so it never appears in `available_tactic_ids`) has - its share folded into the other non-pinned attacker/defender slot, so - every free robot always lands somewhere. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - friendly_edge = friendly_closer_to_ball(game) - losing = friendly_edge is not True # enemy closer, or unknown -> conservative - - press_ok = "press" in available_tactic_ids - attack_ok = "attack" in available_tactic_ids - defense_ok = "defense" in available_tactic_ids - - if losing and press_ok: - # Press with the ball-side group, shadow with the rest; if there is - # nothing to shadow behind (no defense slot), press with everyone. - if defense_ok: - return allocate_ordered(ordered, "press", 3, "defense") - return allocate_ordered(ordered, "press", len(ordered)) - if losing: - # No press available: everyone shadows/marks. - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - if attack_ok: - return allocate_ordered(ordered, "attack", len(ordered)) - return {} - - # We have the ball: attack with the forward group, keep a covering pair. - if attack_ok: - return allocate_ordered(ordered, "attack", 3, "defense" if defense_ok else None) - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Real possession-play team: give-and-go build-up, press on loss, - shadow-and-mark cover behind every attack. - - Three concurrent slots — `GiveAndGoTactic` ("attack"), - `PressAndContainTactic` ("press", only when an enemy is within pressing - range of the ball — its `applicable()`), and - `ShadowAndMarkTactic` ("defense") — allocated by `_tiki_taka_picker` on - the possession edge: 3+2 attack/cover when the ball is ours, 3+2 - press/cover when it is lost. The give-and-go loop is the build-up engine: - short hops under pressure instead of `PassAndShootTactic`'s scripted - setup-then-shoot, which the match-stuck investigation showed cannot - complete under contest. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "attack": GiveAndGoTactic(), - "press": PressAndContainTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_tiki_taka_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/strategy/zone_fluid.py b/utama_core/strategy/zone_fluid.py deleted file mode 100644 index 6585755c..00000000 --- a/utama_core/strategy/zone_fluid.py +++ /dev/null @@ -1,101 +0,0 @@ -"""The `zone_fluid` kernel strategy: `zone_fluid` and the pickers only it uses.""" - -from __future__ import annotations - -from typing import Optional - -from utama_core.engine.context import TickContext -from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.engine.tactic import RobotId -from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.strategy.pickers import ( - allocate_ordered, - ball_zone, - carrier_first, - friendly_closer_to_ball, -) -from utama_core.tactics.decoy_and_overload import DecoyOverloadTactic -from utama_core.tactics.give_and_go import GiveAndGoTactic -from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic - - -def _zone_flow_picker( - game: Game, - free_robots: frozenset[RobotId], - prev_partition: Optional[dict[str, frozenset[RobotId]]], - available_tactic_ids: frozenset[str], -) -> dict[str, frozenset[RobotId]]: - """Zone-flow posture: the attacking *pattern* changes with ball zone, the - defense stays man-shaped throughout. - - - Opponent has the ball: everyone shadows/marks (the whole team in - shape). - - We have the ball in our own or middle third: a give-and-go trio works - the ball forward while 2 shadow/mark. - - We have the ball in the final third: the decoy-and-overload pair - lures the last line out of position (2 robots — that tactic is a - two-role duet by design) while the other 3 hold the defensive shape. - """ - ordered = carrier_first(game, free_robots) - if not ordered: - return {} - - friendly_edge = friendly_closer_to_ball(game) - losing = friendly_edge is not True - - defense_ok = "defense" in available_tactic_ids - givego_ok = "givego" in available_tactic_ids - overload_ok = "overload" in available_tactic_ids - - if losing: - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - if givego_ok: - return allocate_ordered(ordered, "givego", len(ordered)) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - return {} - - zone = ball_zone(game) - if zone == "final" and overload_ok: - return allocate_ordered(ordered, "overload", 2, "defense" if defense_ok else None) - if givego_ok: - return allocate_ordered(ordered, "givego", 3, "defense" if defense_ok else None) - if overload_ok: - return allocate_ordered(ordered, "overload", len(ordered)) - if defense_ok: - return allocate_ordered(ordered, "defense", len(ordered)) - return {} - - -def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Zone-adaptive team: the attacking pattern itself changes with ball - position, the first strategy in the catalog with two concurrent ATTACK- - tagged slots that the picker chooses between — exactly the use the closed - `TacticTag` vocabulary exists for. - - Three concurrent slots — `GiveAndGoTactic` ("givego"), - `DecoyOverloadTactic` ("overload"), and `ShadowAndMarkTactic` - ("defense") — allocated by `_zone_flow_picker`: the whole team takes - man-shape when the ball is lost; the give-and-go trio builds up through - the middle thirds; and in the final third the two-robot decoy/overload - duet replaces the trio, luring the last line out of position instead of - passing into it. - - Returns a `build(motion_controller)` - callable suitable for `AbstractStrategy`'s constructor argument of the - same name. - """ - - ctx = TickContext(motion_controller=motion_controller) - return KernelSchedulerStrategy( - tactics={ - "givego": GiveAndGoTactic(), - "overload": DecoyOverloadTactic(), - "defense": ShadowAndMarkTactic(), - }, - partitioner=_zone_flow_picker, - outfield_robot_ids=outfield_robot_ids, - ctx=ctx, - ) diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index 04375990..1bf9f584 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -3,7 +3,6 @@ Replaces the earlier one-file-per-config pattern (`test_split_shape_kernel_strategy.py`, `test_press_and_pass_kernel_strategy.py`, `test_high_press_kernel_strategy.py`, -`test_low_block_kernel_strategy.py`, `test_three_slot_kernel_strategy.py`, `test_give_and_go_solo_kernel_strategy.py`), each of which re-asserted the same handful of generic properties ("builds a Strategy", "runs N ticks without error", "partition covers every outfield robot", "goalkeeper stays pinned") @@ -15,8 +14,7 @@ convenient example config — not "does this config's partition behave correctly") or `test_kernel_strategy_debug_status.py` (tests `debug_status()` mechanics specifically). Picker-level unit tests that don't need rsim at all -(e.g. `fixed_ratio_picker`'s exact split ratios, `_three_way_picker`'s slot -allocation) also stay separate, below, since they're cheap, precise, and +(e.g. `fixed_ratio_picker`'s exact split ratios) also stay separate, below, since they're cheap, precise, and don't belong in a `StrategyRunner`-driven table. """ @@ -34,11 +32,7 @@ from utama_core.strategy.clear_danger import _clear_danger_picker from utama_core.strategy.clear_press_plus import _clear_press_plus_picker from utama_core.strategy.counter_flow import _counter_flow_picker -from utama_core.strategy.counter_press import _counter_press_picker from utama_core.strategy.pickers import fixed_ratio_picker -from utama_core.strategy.three_slot import _three_way_picker -from utama_core.strategy.tiki_taka import _tiki_taka_picker -from utama_core.strategy.zone_fluid import _zone_flow_picker _OUTFIELD_IDS = (1, 2, 3, 4, 5) @@ -108,11 +102,11 @@ def test_fixed_ratio_picker_high_press_split(): assert len(partition["defense"]) == 1 -def test_fixed_ratio_picker_low_block_split_respects_min_attack_floor(): +def test_fixed_ratio_picker_defense_heavy_split_respects_min_attack_floor(): """attack_fraction=0.2 on 5 robots rounds to 1, but PassAndShootTactic hard-requires >=2 (it unconditionally reads robot_ids[1]) — min_attack=2 - floors the split rather than letting `low_block` - crash the tactic it wires (the exact regression this test guards).""" + floors the split rather than letting a defense-heavy + split crash the tactic it wires (the exact regression this test guards).""" picker = fixed_ratio_picker("attack", "defense", attack_fraction=0.2, min_attack=2) partition = picker( game=_NOBODY_ON_BALL, @@ -124,66 +118,6 @@ def test_fixed_ratio_picker_low_block_split_respects_min_attack_floor(): assert len(partition["defense"]) == 3 -def test_three_way_picker_splits_all_three_slots_when_all_applicable(): - partition = _three_way_picker( - game=_NOBODY_ON_BALL, - free_robots=frozenset({1, 2, 3, 4, 5}), - prev_partition=None, - available_tactic_ids=frozenset({"press", "mark", "attack"}), - ) - assert len(partition["press"]) == 1 - assert len(partition["mark"]) == 2 - assert len(partition["attack"]) == 2 - assert frozenset().union(*partition.values()) == frozenset({1, 2, 3, 4, 5}) - - -def _holder_game(holder_id): - """A still ball in one robot's dribbler; nobody else near it.""" - return SimpleNamespace( - ball=SimpleNamespace(p=SimpleNamespace(x=0.0, y=0.0), v=SimpleNamespace(x=0.0, y=0.0)), - friendly_robots={ - rid: SimpleNamespace(has_ball=rid == holder_id, p=SimpleNamespace(x=-1.0 - rid, y=0.0)) - for rid in range(1, 6) - }, - enemy_robots={}, - ) - - -def test_three_way_picker_gives_the_ball_holder_to_attack_not_press_or_mark(): - # three_slot_vs_zone_fluid (2026-10-05) t=87.8: the taker of our free kick sat in "mark" and - # `kick_upfield` sent the ball the length of the pitch and out; 24 such kicks a match went to - # the presser or a shadow. The holder attacks, whichever slots are open. - for open_slots in ({"press", "mark", "attack"}, {"mark", "attack"}, {"press", "attack"}): - partition = _three_way_picker( - game=_holder_game(holder_id=5), - free_robots=frozenset({1, 2, 3, 4, 5}), - prev_partition=None, - available_tactic_ids=frozenset(open_slots), - ) - assert 5 in partition["attack"], open_slots - assert frozenset().union(*partition.values()) == frozenset({1, 2, 3, 4, 5}) - - -def test_three_way_picker_keeps_the_holder_in_press_when_attack_is_unavailable(): - partition = _three_way_picker( - game=_holder_game(holder_id=5), - free_robots=frozenset({1, 2, 3, 4, 5}), - prev_partition=None, - available_tactic_ids=frozenset({"press", "mark"}), - ) - assert partition["press"] == frozenset({5}) - - -def test_three_way_picker_falls_back_to_attack_when_press_and_mark_inapplicable(): - partition = _three_way_picker( - game=_NOBODY_ON_BALL, - free_robots=frozenset({1, 2, 3}), - prev_partition=None, - available_tactic_ids=frozenset({"attack"}), - ) - assert partition == {"attack": frozenset({1, 2, 3})} - - def test_give_and_go_solo_always_assigns_everyone_to_attack(make_runner): runner = make_runner("give_and_go_solo") runner.step_once() @@ -227,152 +161,7 @@ def _stub_game(friendly_dist, enemy_dist, ball_x: float, my_team_is_right: bool _FIVE = frozenset({1, 2, 3, 4, 5}) -_ALL = frozenset({"attack", "defense", "press", "givego", "overload", "block"}) - - -def test_tiki_taka_attacks_with_three_when_ball_is_ours(): - partition = _tiki_taka_picker( - _stub_game(friendly_dist=0.2, enemy_dist=1.5, ball_x=0.0), - _FIVE, - None, - _ALL, - ) - assert len(partition["attack"]) == 3 - assert len(partition["defense"]) == 2 - assert frozenset().union(*partition.values()) == _FIVE - - -def test_tiki_taka_presses_with_three_when_ball_is_lost(): - partition = _tiki_taka_picker( - _stub_game(friendly_dist=1.5, enemy_dist=0.2, ball_x=0.0), - _FIVE, - None, - _ALL, - ) - assert len(partition["press"]) == 3 - assert len(partition["defense"]) == 2 - - -def test_tiki_taka_unknown_edge_falls_back_to_conservative_press(): - # Unknown possession edge (both None) must not send everyone forward. - partition = _tiki_taka_picker( - _stub_game(friendly_dist=None, enemy_dist=None, ball_x=0.0), - _FIVE, - None, - _ALL, - ) - assert len(partition["press"]) == 3 - assert len(partition["defense"]) == 2 - - -def test_tiki_taka_press_inapplicable_covers_with_defense(): - partition = _tiki_taka_picker( - _stub_game(friendly_dist=1.5, enemy_dist=0.2, ball_x=0.0), - _FIVE, - None, - frozenset({"attack", "defense"}), # press out of pressing range - ) - assert partition == {"defense": _FIVE} - - -def test_tiki_taka_attack_pinned_folds_share_into_defense(): - # Give-and-go committed mid-hop: its robots are pinned (not in the free - # pool) and "attack" never appears in available_tactic_ids — everyone - # free must still land in a legal slot. - partition = _tiki_taka_picker( - _stub_game(friendly_dist=0.2, enemy_dist=1.5, ball_x=-3.0), - _FIVE, - None, - frozenset({"defense", "press"}), - ) - assert partition == {"defense": _FIVE} - - -def test_counter_press_everyone_presses_when_lost(): - partition = _counter_press_picker( - _stub_game(friendly_dist=2.0, enemy_dist=0.3, ball_x=0.0), - _FIVE, - None, - _ALL, - ) - assert partition == {"press": _FIVE} - - -def test_counter_press_drops_into_low_block_when_nothing_to_press(): - partition = _counter_press_picker( - _stub_game(friendly_dist=2.0, enemy_dist=0.3, ball_x=0.0), - _FIVE, - None, - frozenset({"attack", "block"}), # opponent shielded from the press - ) - assert partition == {"block": _FIVE} - - -def test_counter_press_attacks_with_four_and_one_screen_when_won(): - partition = _counter_press_picker( - _stub_game(friendly_dist=0.3, enemy_dist=2.0, ball_x=-3.0), - _FIVE, - None, - _ALL, - ) - assert len(partition["attack"]) == 4 - assert len(partition["block"]) == 1 - - -def test_counter_press_won_ball_without_block_sends_all_five_forward(): - partition = _counter_press_picker( - _stub_game(friendly_dist=0.3, enemy_dist=2.0, ball_x=-3.0), - _FIVE, - None, - frozenset({"attack", "press"}), - ) - assert partition == {"attack": _FIVE} - - -def test_zone_flow_everyone_takes_shape_when_ball_lost(): - partition = _zone_flow_picker( - _stub_game(friendly_dist=2.0, enemy_dist=0.3, ball_x=0.0), - _FIVE, - None, - _ALL, - ) - assert partition == {"defense": _FIVE} - - -def test_zone_flow_givego_trio_builds_up_in_middle_third(): - partition = _zone_flow_picker( - _stub_game(friendly_dist=0.3, enemy_dist=2.0, ball_x=0.0), # mid third - _FIVE, - None, - _ALL, - ) - assert len(partition["givego"]) == 3 - assert len(partition["defense"]) == 2 - - -def test_zone_flow_overload_pair_swaps_in_for_final_third(): - partition = _zone_flow_picker( - _stub_game(friendly_dist=0.3, enemy_dist=2.0, ball_x=-3.0), # final third - _FIVE, - None, - _ALL, - ) - assert partition["overload"] == frozenset({1, 2}) - assert len(partition["defense"]) == 3 - - -def test_zone_flow_overload_pinned_builds_with_givego_instead(): - partition = _zone_flow_picker( - _stub_game(friendly_dist=0.3, enemy_dist=2.0, ball_x=-3.0), # final third - _FIVE, - None, - frozenset({"givego", "defense"}), # decoy/overload duet elsewhere - ) - assert len(partition["givego"]) == 3 - assert len(partition["defense"]) == 2 - -# --- clear-danger picker unit tests (danger valve + counter_flow postures) --- _CLEAR_ALL = frozenset({"attack", "press", "block", "clear"}) diff --git a/utama_core/tests/engine/test_tournament_cli_args.py b/utama_core/tests/engine/test_tournament_cli_args.py index 722663c1..b5518c9e 100644 --- a/utama_core/tests/engine/test_tournament_cli_args.py +++ b/utama_core/tests/engine/test_tournament_cli_args.py @@ -62,8 +62,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): "--fuzz-interval", "5", "10", - "low_block", - "tiki_taka", + "split_shape", + "tiki_taka_plus", ], ) @@ -94,8 +94,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): [ "tournament.py", "--sequential", - "low_block", - "tiki_taka", + "split_shape", + "tiki_taka_plus", ], ) @@ -126,11 +126,13 @@ def _fake_run_match(config_a_name, config_b_name, **_kwargs): return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "tiki_taka", "low_block"]) + monkeypatch.setattr( + "sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "tiki_taka_plus", "split_shape"] + ) tournament.main() - assert calls == [("tiki_taka", "low_block")] + assert calls == [("tiki_taka_plus", "split_shape")] def test_help_prints_usage_and_plays_nothing(monkeypatch, capsys): @@ -146,7 +148,7 @@ def _no_match(*_args, **_kwargs): assert "--pair A B" in out and "replays/match_results/" in out -def test_no_configs_plays_every_config_but_the_retired_and_a_named_retired_one_still_plays(tmp_path, monkeypatch): +def test_no_configs_plays_every_pair_in_the_catalog_and_named_configs_play_only_their_pair(tmp_path, monkeypatch): calls = [] def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): @@ -156,11 +158,10 @@ def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): names = ["a", "b", "c"] monkeypatch.setattr(tournament, "run_match", _fake_run_match) monkeypatch.setattr(tournament, "_CONFIG_NAMES", names) - monkeypatch.setattr(tournament, "RETIRED", {"c"}) monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save"]) tournament.main() - assert calls == [("a", "b")] + assert sorted(calls) == [("a", "b"), ("a", "c"), ("b", "c")] calls.clear() monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "c"]) @@ -185,8 +186,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): "--sequential", "--sim-noise", '{"seed": 3, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.2}', - "low_block", - "tiki_taka", + "split_shape", + "tiki_taka_plus", ], ) @@ -202,13 +203,13 @@ def test_match_seconds_is_part_of_the_environment_so_each_length_has_its_own_res # environment in the store, and the length is recorded in the summary. monkeypatch.setattr(tournament, "run_match", _stub_result) monkeypatch.setattr( - "sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "low_block", "tiki_taka"] + "sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "split_shape", "tiki_taka_plus"] ) tournament.main() (summary_path,) = tmp_path.glob("tournament_*/summary.json") assert json.loads(summary_path.read_text())["max_match_seconds"] == 300.0 - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "low_block", "tiki_taka"]) + monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "split_shape", "tiki_taka_plus"]) tournament.main() envs = sorted((tmp_path / "match_results").iterdir()) diff --git a/utama_core/tests/engine/test_tournament_match_end.py b/utama_core/tests/engine/test_tournament_match_end.py index 18759f4c..ed9d204f 100644 --- a/utama_core/tests/engine/test_tournament_match_end.py +++ b/utama_core/tests/engine/test_tournament_match_end.py @@ -37,7 +37,7 @@ def close(self): def test_a_match_ends_at_full_time_not_at_the_sim_time_cap(monkeypatch): monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) - result = match.run_match("tiki_taka", "low_block", duration_seconds=1200.0) + result = match.run_match("tiki_taka_plus", "split_shape", duration_seconds=1200.0) assert _FakeRunner.last.ticks == _FakeRunner.full_time_ticks assert (result.score_a, result.score_b) == (2, 1) @@ -47,6 +47,6 @@ def test_the_cap_still_ends_a_match_that_never_reaches_full_time(monkeypatch): monkeypatch.setattr(_FakeRunner, "full_time_ticks", 10**9) monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) - match.run_match("tiki_taka", "low_block", duration_seconds=1.0) + match.run_match("tiki_taka_plus", "split_shape", duration_seconds=1.0) assert _FakeRunner.last.ticks == match.TICKS_PER_SECOND diff --git a/utama_core/tests/engine/test_tournament_reuse.py b/utama_core/tests/engine/test_tournament_reuse.py index 967de553..8e3b48e0 100644 --- a/utama_core/tests/engine/test_tournament_reuse.py +++ b/utama_core/tests/engine/test_tournament_reuse.py @@ -14,7 +14,7 @@ from tools.evaluation import round_robin as tournament from utama_core.replay import match_results -_CONFIGS = ["tiki_taka", "low_block", "high_press"] +_CONFIGS = ["tiki_taka_plus", "press_and_pass", "high_press"] class _Graph: @@ -27,7 +27,7 @@ def base_fingerprint(self, entries): return "base" def strategy_fingerprint(self, name): - return f"fp-{name}-{self.rig.version[name]}" + return f"{self.rig.version[name]}-{name}" # version first: the tool keeps 16 characters @pytest.fixture @@ -85,13 +85,13 @@ def test_a_second_run_takes_every_stored_match_and_reports_the_same_results(rig) def test_after_one_config_changes_only_its_matches_play(rig): rig.run() - rig.version["low_block"] += 1 + rig.version["press_and_pass"] += 1 rig.run() assert sorted(rig.played) == [ - ("high_press", "low_block"), - ("low_block", "tiki_taka"), + ("high_press", "press_and_pass"), + ("press_and_pass", "tiki_taka_plus"), ] @@ -109,17 +109,17 @@ def test_a_stored_match_keeps_the_restarts_and_losses_its_replay_gave(rig, monke def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): - # Editing tiki_taka during the first match leaves that match's code as it was, so it is stored. - # The two tiki_taka matches finish under changed code, so neither is stored. + # Editing tiki_taka_plus during the first match leaves that match's code as it was, so it is stored. + # The two tiki_taka_plus matches finish under changed code, so neither is stored. def edit(): - rig.version["tiki_taka"] = 9 + rig.version["tiki_taka_plus"] = 9 rig.on_play = edit rig.run() stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] - assert [(r["a"], r["b"]) for r in stored] == [("high_press", "low_block")] + assert [(r["a"], r["b"]) for r in stored] == [("high_press", "press_and_pass")] def test_a_no_save_run_plays_and_stores_nothing(rig, monkeypatch): diff --git a/utama_core/tests/engine/test_tournament_vs_champion.py b/utama_core/tests/engine/test_tournament_vs_champion.py index 05c5eab3..271e1001 100644 --- a/utama_core/tests/engine/test_tournament_vs_champion.py +++ b/utama_core/tests/engine/test_tournament_vs_champion.py @@ -66,8 +66,7 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): monkeypatch.setattr(tournament, "run_match", _fake_run_match) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "b", "c", "champ"]) - monkeypatch.setattr(tournament, "RETIRED", {"c"}) + monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "b", "champ"]) monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a", "b"]}) monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--vs-champion"]) @@ -93,7 +92,6 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): monkeypatch.setattr(tournament, "run_match", _fake_run_match) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "champ"]) - monkeypatch.setattr(tournament, "RETIRED", set()) monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a"]}) monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "champ"]) diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 790f5324..6835a1f3 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -323,7 +323,7 @@ def test_editing_one_real_strategy_does_not_change_another_configs_fingerprint(g modules = {c: f"utama_core.strategy.{c}" for c in _players()} for config, module in modules.items(): assert graph.strategy_modules(config) & set(modules.values()) == {module}, config - assert graph.strategy_fingerprint("tiki_taka") != graph.strategy_fingerprint("counter_press") + assert graph.strategy_fingerprint("tiki_taka_plus") != graph.strategy_fingerprint("counter_flow") def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): diff --git a/utama_core/tests/strategy/test_overload_flow_streak.py b/utama_core/tests/strategy/test_overload_flow_streak.py deleted file mode 100644 index e2a053de..00000000 --- a/utama_core/tests/strategy/test_overload_flow_streak.py +++ /dev/null @@ -1,31 +0,0 @@ -"""`overload_flow` adds a 4th give-and-go attacker once its team has held the -possession edge for `_POSSESSION_STREAK_TICKS` ticks. The streak was one -module-level counter, so two `overload_flow` teams in one process (a mirror match, -an A/B against itself) counted each other's possession. -""" - -from unittest.mock import MagicMock - -from utama_core.strategy import overload_flow -from utama_core.strategy.catalog import builder -from utama_core.strategy.overload_flow import _POSSESSION_STREAK_TICKS - -_ROBOTS = frozenset({1, 2, 3, 4, 5}) -_TACTICS = frozenset({"givego", "overload", "defense"}) - - -def _picker(): - return builder("overload_flow", (1, 2, 3, 4, 5))(MagicMock())._partitioner - - -def test_each_strategy_counts_its_own_possession_streak(monkeypatch): - monkeypatch.setattr(overload_flow, "carrier_first", lambda game, free: sorted(free)) - monkeypatch.setattr(overload_flow, "friendly_closer_to_ball", lambda game: True) - monkeypatch.setattr(overload_flow, "ball_zone", lambda game: "middle") - a, b = _picker(), _picker() - - for _ in range(_POSSESSION_STREAK_TICKS - 1): - assert len(a(None, _ROBOTS, None, _TACTICS)["givego"]) == 3 - assert len(a(None, _ROBOTS, None, _TACTICS)["givego"]) == 4 - # b has had the ball for one tick, whatever a's streak. - assert len(b(None, _ROBOTS, None, _TACTICS)["givego"]) == 3 diff --git a/utama_core/tests/strategy_runner/test_change_of_ends.py b/utama_core/tests/strategy_runner/test_change_of_ends.py index b4e4fa99..de8f8e56 100644 --- a/utama_core/tests/strategy_runner/test_change_of_ends.py +++ b/utama_core/tests/strategy_runner/test_change_of_ends.py @@ -30,8 +30,8 @@ def test_the_teams_play_the_second_half_from_the_other_end(headless): profile = load_profile("simulation") profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, half_duration_seconds=HALF_S)) runner = StrategyRunner( - strategy=AbstractStrategy(build=builder("tiki_taka", tuple(range(1, N_OUTFIELD + 1)))), - opp_strategy=AbstractStrategy(build=builder("tiki_taka", tuple(range(1, N_OUTFIELD + 1)))), + strategy=AbstractStrategy(build=builder("tiki_taka_plus", tuple(range(1, N_OUTFIELD + 1)))), + opp_strategy=AbstractStrategy(build=builder("tiki_taka_plus", tuple(range(1, N_OUTFIELD + 1)))), my_team_is_yellow=True, my_team_is_right=True, mode="rsim", diff --git a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py index 00e1f8c6..4e3c4e54 100644 --- a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py +++ b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py @@ -34,7 +34,7 @@ # Same pairing that surfaced the bug live. _NAME_A = "counter_flow" -_NAME_B = "tiki_taka" +_NAME_B = "tiki_taka_plus" def test_goalkeeper_converges_on_static_target_without_oscillating(headless): From a9aee7bc9b0dd8a6a3907bb00e3479e147848ebf Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 14:23:15 +0000 Subject: [PATCH 18/59] strategy: name the twelve strategies A name says who a strategy is, not what it does, so it stays true when the strategy changes; the first line of each module says the style. pendulum (was split_shape), breakwater (clear_press_plus), avalanche (overload_press), wolfpack (high_press), mirage (decoy_and_overload), riptide (counter_flow), chameleon (score_aware_counter_flow), tripwire (press_trigger_flow), firebreak (clear_danger), terrier (press_and_pass), weaver (tiki_taka_plus), ricochet (give_and_go_solo). catalog.RENAMED maps the old names on, so old replays and summaries still load; replay files keep their names, and lines in docs and comments that name an old replay or match keep the old names. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 16 +- docs/custom_referee_gui.md | 2 +- docs/img/strategy/make_tactic_kernel.py | 4 +- docs/signals.md | 28 +-- docs/strategies.md | 50 ++--- docs/tools.md | 4 +- docs/visual_guide.md | 36 ++-- examples/demo_referee_gui_rsim.py | 10 +- examples/demo_split_shape_match.py | 4 +- main.py | 10 +- tools/build_strategy.py | 6 +- tools/debug_match.py | 4 +- tools/evaluation/reference/opponents.json | 20 +- tools/evaluation/round_robin.py | 6 +- tools/match_timeline.py | 6 +- tools/metric_correlation.py | 2 +- tools/moments.py | 4 +- tools/repro_from_replay.py | 10 +- tools/sim_setup.py | 4 +- utama_core/engine/match_stats.py | 2 +- utama_core/shared/pass_and_score_geometry.py | 4 +- utama_core/skills/src/goalkeep.py | 2 +- .../{overload_press.py => avalanche.py} | 8 +- .../{clear_press_plus.py => breakwater.py} | 22 +-- utama_core/strategy/catalog.py | 29 ++- ...ore_aware_counter_flow.py => chameleon.py} | 22 +-- .../{clear_danger.py => firebreak.py} | 22 +-- .../{decoy_and_overload.py => mirage.py} | 2 +- .../strategy/{split_shape.py => pendulum.py} | 2 +- utama_core/strategy/pickers.py | 2 +- .../{give_and_go_solo.py => ricochet.py} | 2 +- .../strategy/{counter_flow.py => riptide.py} | 12 +- .../{press_and_pass.py => terrier.py} | 10 +- .../{press_trigger_flow.py => tripwire.py} | 30 +-- .../strategy/{tiki_taka_plus.py => weaver.py} | 28 +-- .../strategy/{high_press.py => wolfpack.py} | 4 +- utama_core/tactics/block_shape.py | 2 +- utama_core/tactics/defense.py | 2 +- utama_core/tactics/give_and_go.py | 2 +- utama_core/tactics/lead_and_support.py | 2 +- utama_core/tactics/press_and_contain.py | 2 +- utama_core/tactics/switch_of_play.py | 2 +- utama_core/tests/bundle/test_strategy_file.py | 14 +- .../custom_referee/test_stage_advance.py | 2 +- .../tests/dashboard/test_tournament_view.py | 2 +- .../tests/engine/test_all_strategy_configs.py | 80 ++++---- .../tests/engine/test_give_and_go_tactic.py | 2 +- .../test_kernel_strategy_debug_status.py | 38 ++-- .../test_kickoff_goalkeeper_exemption.py | 24 +-- .../tests/engine/test_referee_override.py | 180 +++++++++--------- .../test_referee_overrides_customization.py | 4 +- .../tests/engine/test_tournament_cli_args.py | 24 +-- .../tests/engine/test_tournament_match_end.py | 4 +- .../tests/engine/test_tournament_reuse.py | 16 +- .../tests/engine/test_tournament_summary.py | 10 +- .../free_kick_defender_dodges_into_ball.json | 2 +- .../free_kick_robot_drives_in_at_start.json | 2 +- ...acement_corner_robot_drives_onto_ball.json | 2 +- .../placement_in_corner_traps_defender.json | 2 +- .../placement_robot_drives_in_mid_pitch.json | 2 +- utama_core/tests/moments/test_play_options.py | 4 +- .../defense_area_avoidance_test.py | 2 +- utama_core/tests/replay/test_fingerprint.py | 2 +- utama_core/tests/replay/test_match_results.py | 6 +- .../shared/test_pass_and_score_geometry.py | 2 +- .../tests/strategy/test_carrier_allocation.py | 4 +- .../tests/strategy/test_split_shape_split.py | 10 +- .../strategy_runner/test_change_of_ends.py | 6 +- .../test_goalkeeper_stability.py | 4 +- utama_core/tests/test_main_entry.py | 4 +- utama_core/tests/tools/test_sim_setup.py | 10 +- 72 files changed, 464 insertions(+), 443 deletions(-) rename utama_core/strategy/{overload_press.py => avalanche.py} (95%) rename utama_core/strategy/{clear_press_plus.py => breakwater.py} (87%) rename utama_core/strategy/{score_aware_counter_flow.py => chameleon.py} (85%) rename utama_core/strategy/{clear_danger.py => firebreak.py} (85%) rename utama_core/strategy/{decoy_and_overload.py => mirage.py} (92%) rename utama_core/strategy/{split_shape.py => pendulum.py} (96%) rename utama_core/strategy/{give_and_go_solo.py => ricochet.py} (92%) rename utama_core/strategy/{counter_flow.py => riptide.py} (94%) rename utama_core/strategy/{press_and_pass.py => terrier.py} (91%) rename utama_core/strategy/{press_trigger_flow.py => tripwire.py} (80%) rename utama_core/strategy/{tiki_taka_plus.py => weaver.py} (89%) rename utama_core/strategy/{high_press.py => wolfpack.py} (88%) diff --git a/AGENTS.md b/AGENTS.md index 1e3b9e85..044eab78 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -87,7 +87,7 @@ One term per thing; reuse these instead of coining new ones. specifically to avoid colliding with "kernel strategy" — the model's own established vocabulary — so "where do I find the kernel strategies" unambiguously means `strategy/` below, not here. - `utama_core/strategy/` — the actual strategies people write, run, and compare - (`tiki_taka`, `counter_flow`, etc.), one module per strategy (`strategy/.py`, with one + (`tiki_taka`, `riptide`, etc.), one module per strategy (`strategy/.py`, with one `build(outfield_robot_ids, motion_controller)` and the pickers only it uses) plus `pickers.py` for helpers shared by several. The module's name is the strategy's name and `catalog.py` finds them, so a new strategy is a new file. This is where day-to-day strategy-dev edits land. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 0607d8e4..5d6095e4 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -54,7 +54,7 @@ sequenceDiagram participant AS as AbstractStrategy
engine/abstract_strategy.py participant S as Strategy
engine/strategy.py participant RO as RefereeOverride
engine/referee_override.py - participant P as Partitioner
e.g. strategy/split_shape.py + participant P as Partitioner
e.g. strategy/pendulum.py participant T as Tactic
tactics/*.py participant SK as Skills
skills/src/ participant RC as robot controller @@ -174,7 +174,7 @@ A strategy is a combination of existing tactics plus a partitioner that decides each gets. Most new strategies need no new tactic. When one does, add it as a new module in `tactics/` (on a strategy branch, never by changing an existing tactic: see below). -How a strategy composes tactics, using `split_shape`: two tactic slots and +How a strategy composes tactics, using `pendulum`: two tactic slots and one hand-written partitioner that switches on which side has the ball. ```mermaid @@ -185,7 +185,7 @@ flowchart TD free["free pool = outfield robots not pinned"] avail{"both slots available?
(not pinned, applicable)"} only["the one available slot
takes every free robot"] - subgraph picker["_possession_split_picker
strategy/split_shape.py"] + subgraph picker["_possession_split_picker
strategy/pendulum.py"] order["carrier_first(game, free)
strategy/pickers.py: ball carrier first"] edge{"friendly closer to the ball
than the enemy?"} hi["attack = (n+1)//2 + 1"] @@ -219,7 +219,7 @@ pieces in `strategy/pickers.py` rather than re-deriving them: near-tie or unreadable state, where a sticky picker keeps its previous split. - `carrier_first(game, free)` / `clearer_first(game, ordered)` — robot order for a slot that must take the ball: the carrier (or the kicker at a still ball) first, else the nearest. -- `fixed_ratio_picker` (in `pickers.py`), `_possession_split_picker` (in `split_shape.py`) — the +- `fixed_ratio_picker` (in `pickers.py`), `_possession_split_picker` (in `pendulum.py`) — the two common split shapes. `tests/engine/test_all_strategy_configs.py` picks it up the same way and runs it through the @@ -349,7 +349,7 @@ flowchart TD explain a verdict and never make one: the verdict is still goals, and a picture is not a ranking. Matches taken from the match results have no replay in the run, so the pictures cover only what was played; the paired goal difference in `summary.json` is only as complete as that. Example, from a - round-robin (`explain.py replays/tournament_ split_shape clear_press_plus --out ...`): + round-robin (`explain.py replays/tournament_ pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) - **Cost.** ~45 min of laptop per 66 matches on 8 workers. A clearly worse candidate costs ~14 matches (~10 min), a close one up to 42. @@ -413,11 +413,11 @@ whoever runs it. The dashboard draws the same lanes under the Replay tab's controls (click to seek; hover for what each mark is) and live in the Live tab. Beside a replay, its Play list reads the match as situations: who had the ball from which restart or regain, for how long, and how it ended. - Thrashing in `split_shape` against `tiki_taka_plus`: robots 2-4 flip between the attack and defence - slots about every 1.5 s, in pairs of rows at the same tick. It is not split_shape's alone: most + Thrashing in `pendulum` against `weaver`: robots 2-4 flip between the attack and defence + slots about every 1.5 s, in pairs of rows at the same tick. It is not pendulum's alone: most strategies that split attack and defence on possession take a tactic for under 1 s and revert about 5 times a minute (the `tactic_thrash` finding, with the numbers per strategy in `match_timeline.py`): - ![split_shape lanes thrashing between attack and defence slots](img/match_timeline/split_shape_100-160.png) + ![pendulum lanes thrashing between attack and defence slots](img/match_timeline/pendulum_100-160.png) - **`render_clip()`** (`analysis/render_clip.py`) — MP4 of a window for humans, ball-following or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. diff --git a/docs/custom_referee_gui.md b/docs/custom_referee_gui.md index 52ae6b85..30f4a084 100644 --- a/docs/custom_referee_gui.md +++ b/docs/custom_referee_gui.md @@ -9,7 +9,7 @@ referee_view.attach(server, referee, profile) # utama_core.dashboard.views.ref ``` `examples/demo_referee_gui_rsim.py` does this with RSim, the `human` profile and -`tiki_taka_plus` (constants `PROFILE`, `N_ROBOTS`, `MY_TEAM_IS_YELLOW`, `MY_TEAM_IS_RIGHT` at +`weaver` (constants `PROFILE`, `N_ROBOTS`, `MY_TEAM_IS_YELLOW`, `MY_TEAM_IS_RIGHT` at the top of the file): ```bash diff --git a/docs/img/strategy/make_tactic_kernel.py b/docs/img/strategy/make_tactic_kernel.py index d64c1472..90cbf6d1 100644 --- a/docs/img/strategy/make_tactic_kernel.py +++ b/docs/img/strategy/make_tactic_kernel.py @@ -32,7 +32,7 @@ "utama_core/engine/tactic.py", "utama_core/engine/context.py", "utama_core/engine/match_log.py", - "utama_core/strategy/split_shape.py", + "utama_core/strategy/pendulum.py", "utama_core/tactics", "utama_core/skills/src", ] @@ -104,7 +104,7 @@ 46, 12, "Partitioner", - "strategy/split_shape.py and similar: splits\nthe free robots over the applicable tactics", + "strategy/pendulum.py and similar: splits\nthe free robots over the applicable tactics", kind="decision", ) d.main((M, 67.5), (M, 60)) diff --git a/docs/signals.md b/docs/signals.md index 0611707b..575f0777 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -37,7 +37,7 @@ match results store (`replays/match_results/`). - **Shots on target.** Within one run, strengths from shots predicted held-out matches about as well as goals; across runs, goal strengths from run 1 predicted run 2's goal strengths better - (rank correlation 0.57) than shot strengths did (0.37), leaving out split_shape, whose margin + (rank correlation 0.57) than shot strengths did (0.37), leaving out pendulum, whose margin swung from +1.5 to +4.9 between seeds and dominates any correlation that includes it. - **xG** (real-data model, `analysis/realism/xg.py`): sim keepers save twice as often as real ones, so it misjudges sim strategies by how they shoot. @@ -89,7 +89,7 @@ Check these first: a broken strategy's other signals mean nothing. | Stalls | STALLS; `stats.stall_events` | `RESTART_STALL`: a restart held > 15 s, with a one-line diagnosis. `COMMITTED_FROZEN`: ball moved < 5 cm for > 10 s in live play while a slot was committed, with who holds the ball | 10 of 231 matches | A bug to fix before anything else. Rerun with `round_robin.py --pair A B`, look with `tools/replay_trace.py` and `render_window()` | | Possession backstop | `results[*].possession_backstop` | possession pinned 100/0 with the ball barely moving: a freeze the watchdog missed | 0 | Same as a stall | | Restarts not taken | RESTARTS; `restarts.by_kind[*].outcomes` | a kickoff, free kick or penalty `voided`, `timeout`, `stopped_before_kick` instead of `taken` | free kicks: 3414 taken of 3467 | The taker can't reach or kick the ball: restart positioning, a planner clamp, a keep-out circle | -| Fouls by rule | FOULS; `fouls` | every foul by rule, then strategy/tactic of the offending robot | per strategy 6.3 (`score_aware_counter_flow`) · 7.9 · 23.3 (`three_slot`); run: out_of_bounds 2938, excessive_dribbling 448, defense_area 310, crashing 307 | One tactic dominating a rule is its bug: dribbling too far, entering the box, driving into robots | +| Fouls by rule | FOULS; `fouls` | every foul by rule, then strategy/tactic of the offending robot | per strategy 6.3 (`chameleon`) · 7.9 · 23.3 (`three_slot`); run: out_of_bounds 2938, excessive_dribbling 448, defense_area 310, crashing 307 | One tactic dominating a rule is its bug: dribbling too far, entering the box, driving into robots | | `no_progress` restarts | `results[*].stats.rule_event_counts` | the referee stopped play: nobody moved the ball for 10 s | 296 in the run | Two robots wedged on the ball, or a carrier holding without a pass | | Near stalls *(offline)* | `near_stall_events` | a side's nearest robot stuck within 0.5 m of the ball for 2 s without gaining it: an early warning before the watchdog | not checked on current code | Wedges, a robot that can't take the ball | | Kicker thrash *(offline)* | `kicker_identity_thrash` | during a restart, how often a side's nearest-to-ball robot changes | not checked on current code | Restart takers swapping on position noise (a sticky pick missing) | @@ -100,10 +100,10 @@ Check these first: a broken strategy's other signals mean nothing. | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Shots | STRATEGIES `shots`; `chances.shots` | hard balls from the attacking third heading into the goal mouth (on target by construction) | 1.4 (`three_slot`) · 6.1 · 11.2 (`split_shape`) | Few shots with many entries: attacks stall in the final third | -| Attacking-third entries | STRATEGIES `entries` | times the ball crossed into the attacking third | 6.6 (`shadow_switch`) · 11.9 · 17.2 (`split_shape`) | Few: the build-up never reaches the final third | -| Regain to shot | CHANCES `regain>shot`, `secs`; `chances.regain_to_shot`, `regain_to_shot_s` | share of open-play regains (kept ≥ 1 s, not just after a restart) followed by a shot within 10 s, and how fast | 1% (`shadow_switch`) · 9% · 28% (`split_shape`); 2.0 s · 4.4 · 9.3 | Low: winning the ball leads nowhere. Slow: too many passes before the shot | -| Free kick to shot | CHANCES `fk>shot`; `chances.free_kick_to_shot`, `attacking_free_kick_to_shot` | share of the side's free kicks (corner and goal kicks included) followed by a shot within 10 s | 0% (`three_slot`) · 12% · 38% (`split_shape`) | Low in the attacking third: set pieces are wasted | +| Shots | STRATEGIES `shots`; `chances.shots` | hard balls from the attacking third heading into the goal mouth (on target by construction) | 1.4 (`three_slot`) · 6.1 · 11.2 (`pendulum`) | Few shots with many entries: attacks stall in the final third | +| Attacking-third entries | STRATEGIES `entries` | times the ball crossed into the attacking third | 6.6 (`shadow_switch`) · 11.9 · 17.2 (`pendulum`) | Few: the build-up never reaches the final third | +| Regain to shot | CHANCES `regain>shot`, `secs`; `chances.regain_to_shot`, `regain_to_shot_s` | share of open-play regains (kept ≥ 1 s, not just after a restart) followed by a shot within 10 s, and how fast | 1% (`shadow_switch`) · 9% · 28% (`pendulum`); 2.0 s · 4.4 · 9.3 | Low: winning the ball leads nowhere. Slow: too many passes before the shot | +| Free kick to shot | CHANCES `fk>shot`; `chances.free_kick_to_shot`, `attacking_free_kick_to_shot` | share of the side's free kicks (corner and goal kicks included) followed by a shot within 10 s | 0% (`three_slot`) · 12% · 38% (`pendulum`) | Low in the attacking third: set pieces are wasted | | Shot distance | CHANCES `dist`; `chances.shot_distance_m` | metres from the goal centre where the shooting side last held the ball | 2.2 · 2.5 · 3.0 m | Far: shooting because nothing better was found | | Open goal mouth | CHANCES `open`; `chances.shot_open_goal` | share of the goal mouth no opponent blocked at the shot. Tops out near 75%, the keeper always covers some | 43% · 50% · 68% | Low: shooting into bodies; the attack never opens a lane | | Conversion | CHANCES `conv`; `chances.conversion` | goals per shot. High for everyone, since a shot is already on target | 21% · 35% · 60% | Read with distance and open goal, not alone | @@ -114,10 +114,10 @@ Check these first: a broken strategy's other signals mean nothing. | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Completed passes | STRATEGIES `passes` | passes from one teammate's control to another's | 15 (`split_shape`) · 38 · 61 (`overload_press`) | Many passes with few shots: circulation without progress | -| Pass progress | CHANCES `progress`, `fwd`; `pass_progress_m`, `forward_pass_share` | mean metres gained toward goal per completed pass, and the share gaining ≥ 1 m | 0.3 (`overload_press`) · 0.65 · 1.7 m (`split_shape`); 10% · 23% · 56% | Near 0: sideways passing. Fine if the strategy wins by regaining instead | +| Completed passes | STRATEGIES `passes` | passes from one teammate's control to another's | 15 (`pendulum`) · 38 · 61 (`avalanche`) | Many passes with few shots: circulation without progress | +| Pass progress | CHANCES `progress`, `fwd`; `pass_progress_m`, `forward_pass_share` | mean metres gained toward goal per completed pass, and the share gaining ≥ 1 m | 0.3 (`avalanche`) · 0.65 · 1.7 m (`pendulum`); 10% · 23% · 56% | Near 0: sideways passing. Fine if the strategy wins by regaining instead | | Pass outcomes, catch rate *(config_a)* | `passes:` line; `ball_losses.receptions` | every pass followed to `received` / `missed_reception` (reached a teammate, no contact) / `intercepted` / `off_target`; catch rate of reachable passes, by receiver facing and by tactic | run: 79% caught; 96% when the receiver faces the ball within 10° | Low catch rate: reception or passing into a turned receiver. ±4–8 points between runs is noise | -| Real ball losses *(config_a)* | LOSS KINDS; `real_losses_as_a`, `real_loss_kinds_as_a` | losses not won back within 1 s, by kind: `tackled`, `ball_out_after_kick`, `shot_saved_or_blocked`, `pass_intercepted`, `loose_ball_lost`, `foul`, `ball_out_other` | total 25 (`tiki_taka_plus`) · 34.5 · 42.7 (`three_slot`); tackled 2 · 12.3 · 23.8 | The dominant kind names the fix: tackled (carrying into pressure), kicked out (aim), intercepted (pass choice) | +| Real ball losses *(config_a)* | LOSS KINDS; `real_losses_as_a`, `real_loss_kinds_as_a` | losses not won back within 1 s, by kind: `tackled`, `ball_out_after_kick`, `shot_saved_or_blocked`, `pass_intercepted`, `loose_ball_lost`, `foul`, `ball_out_other` | total 25 (`weaver`) · 34.5 · 42.7 (`three_slot`); tackled 2 · 12.3 · 23.8 | The dominant kind names the fix: tackled (carrying into pressure), kicked out (aim), intercepted (pass choice) | | Losses by tactic *(config_a)* | BALL LOSSES; `ball_losses.by_tactic`, `ball_losses.md` | which tactic held the ball when it was lost | — | One tactic with most losses is where to look | | Possession under pressure | `results[*].stats.possession_under_pressure_s` | seconds the side's ball holder had an opponent within 0.5 m | — | High: carrying into opponents | @@ -125,11 +125,11 @@ Check these first: a broken strategy's other signals mean nothing. | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Goals against | STRATEGIES `GA` | | 23 (`split_shape`) · 40 · 122 (`shadow_switch`) per 21 matches | | -| Danger conceded | CHANCES `danger`; `chances.danger_s_per_match`, `danger_spells_per_match` | seconds the enemy had possession (its passes and shots in flight included) with the ball in the side's defensive third in live play, and how many separate spells | 50 (`overload_press`) · 78 · 167 s (`high_line_zone`) | High: the defense doesn't win the ball back near its goal or lets the enemy settle there. One stalled match can add hundreds of seconds | -| Shots faced, open goal faced | `chances.shots_faced`, `faced_open_goal` | the enemy's shots and how open they were | open 37% · 49% · 66% (`give_and_go_solo`) | Open shots faced: nobody blocks the lane; usually everyone is upfield | -| Save rate | CHANCES `save`; `chances.save_rate` | 1 - goals from shots / shots faced. Every strategy fields the same keeper, so this measures the shots the defense allows | 49% (`high_press`) · 64% · 74% (`split_shape`) | Low: see open goal faced | -| Regains | `chances.regains` | open-play regains kept ≥ 1 s | 16 (`shadow_switch`) · 25 · 29 (`high_press`) | Few: the press or the marking doesn't win the ball | +| Goals against | STRATEGIES `GA` | | 23 (`pendulum`) · 40 · 122 (`shadow_switch`) per 21 matches | | +| Danger conceded | CHANCES `danger`; `chances.danger_s_per_match`, `danger_spells_per_match` | seconds the enemy had possession (its passes and shots in flight included) with the ball in the side's defensive third in live play, and how many separate spells | 50 (`avalanche`) · 78 · 167 s (`high_line_zone`) | High: the defense doesn't win the ball back near its goal or lets the enemy settle there. One stalled match can add hundreds of seconds | +| Shots faced, open goal faced | `chances.shots_faced`, `faced_open_goal` | the enemy's shots and how open they were | open 37% · 49% · 66% (`ricochet`) | Open shots faced: nobody blocks the lane; usually everyone is upfield | +| Save rate | CHANCES `save`; `chances.save_rate` | 1 - goals from shots / shots faced. Every strategy fields the same keeper, so this measures the shots the defense allows | 49% (`wolfpack`) · 64% · 74% (`pendulum`) | Low: see open goal faced | +| Regains | `chances.regains` | open-play regains kept ≥ 1 s | 16 (`shadow_switch`) · 25 · 29 (`wolfpack`) | Few: the press or the marking doesn't win the ball | ## Restarts diff --git a/docs/strategies.md b/docs/strategies.md index 9844ffad..91dcd0d5 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -20,18 +20,18 @@ strategies named plays these. | Strategy | Description | |---|---| -| `split_shape` | `LeadAndSupportTactic` + `ShadowAndMarkTactic`, split by possession edge. | -| `counter_flow` | Give-and-go attack, press on the ball, `BlockShapeTactic` screen; 3/2 with possession hysteresis. | -| `score_aware_counter_flow` | `counter_flow` plus a late-half scoreline shift (protect a lead / chase). | -| `press_and_pass` | `GiveAndGoTactic` + `PressAndContainTactic`, possession-edge split. | -| `clear_press_plus` | `clear_danger` plus `tiki_taka_plus`'s final-third overload. | -| `high_press` | Same pair as `press_and_pass`, fixed 80/20 attack-heavy split ignoring possession. | -| `tiki_taka_plus` | `tiki_taka`, handing off to `DecoyOverloadTactic`'s duet in the final third. | -| `give_and_go_solo` | Whole pool runs `GiveAndGoTactic`, no defense slot. | -| `overload_press` | 4-robot overload/switch attack + 1 block, built to outnumber tiki_taka's shadow line. | -| `press_trigger_flow` | `counter_flow`, but an all-in press when the ball is lost in our own third. | -| `decoy_and_overload` | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | -| `clear_danger` | `counter_flow` postures plus an own-third `ClearBallTactic` danger-clearance valve. | +| `pendulum` | `LeadAndSupportTactic` + `ShadowAndMarkTactic`, split by possession edge. | +| `riptide` | Give-and-go attack, press on the ball, `BlockShapeTactic` screen; 3/2 with possession hysteresis. | +| `chameleon` | `riptide` plus a late-half scoreline shift (protect a lead / chase). | +| `terrier` | `GiveAndGoTactic` + `PressAndContainTactic`, possession-edge split. | +| `breakwater` | `firebreak` plus `weaver`'s final-third overload. | +| `wolfpack` | Same pair as `terrier`, fixed 80/20 attack-heavy split ignoring possession. | +| `weaver` | `tiki_taka`, handing off to `DecoyOverloadTactic`'s duet in the final third. | +| `ricochet` | Whole pool runs `GiveAndGoTactic`, no defense slot. | +| `avalanche` | 4-robot overload/switch attack + 1 block, built to outnumber tiki_taka's shadow line. | +| `tripwire` | `riptide`, but an all-in press when the ball is lost in our own third. | +| `mirage` | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | +| `firebreak` | `riptide` postures plus an own-third `ClearBallTactic` danger-clearance valve. | **Deleted** (2026-11-12): the ten strategies retired on 2026-10-10 (`tiki_taka`, `counter_press`, `high_line_zone`, `three_slot`, `switch_of_play`, `low_block`, `zone_fluid`, `score_aware_zone_flow`, @@ -55,23 +55,23 @@ reached NORMAL_START. Against the 2026-10-10 run: rsim is our fork with the v3 sim noise (latency, motion limits, ball friction, kick direction), and restarts, ball placement and the carry limit were fixed, so goals fell from 7.1 a match to 4.0 and the results are not comparable with earlier runs. -`split_shape` is still first, unbeaten; `counter_flow`, second before, is eleventh. +`pendulum` is still first, unbeaten; `riptide`, second before, is eleventh. What each strategy does well and badly in this run, in figures: [`signal_report.md`](signal_report.md). | Strategy | W-D-L | GF-GA | Points per match | |---|---|---|---| -| `split_shape` | 10-1-0 | 66-14 | 2.82 | -| `clear_press_plus` | 5-5-1 | 14-9 | 1.82 | -| `overload_press` | 6-2-3 | 22-18 | 1.82 | -| `clear_danger` | 5-2-4 | 20-24 | 1.55 | -| `tiki_taka_plus` | 5-1-5 | 23-21 | 1.45 | -| `high_press` | 4-3-4 | 24-27 | 1.36 | -| `press_trigger_flow` | 4-1-6 | 13-19 | 1.18 | -| `give_and_go_solo` | 3-3-5 | 20-30 | 1.09 | -| `press_and_pass` | 3-3-5 | 14-28 | 1.09 | -| `decoy_and_overload` | 3-2-6 | 16-27 | 1.00 | -| `counter_flow` | 2-4-5 | 17-21 | 0.91 | -| `score_aware_counter_flow` | 2-1-8 | 16-27 | 0.64 | +| `pendulum` | 10-1-0 | 66-14 | 2.82 | +| `breakwater` | 5-5-1 | 14-9 | 1.82 | +| `avalanche` | 6-2-3 | 22-18 | 1.82 | +| `firebreak` | 5-2-4 | 20-24 | 1.55 | +| `weaver` | 5-1-5 | 23-21 | 1.45 | +| `wolfpack` | 4-3-4 | 24-27 | 1.36 | +| `tripwire` | 4-1-6 | 13-19 | 1.18 | +| `ricochet` | 3-3-5 | 20-30 | 1.09 | +| `terrier` | 3-3-5 | 14-28 | 1.09 | +| `mirage` | 3-2-6 | 16-27 | 1.00 | +| `riptide` | 2-4-5 | 17-21 | 0.91 | +| `chameleon` | 2-1-8 | 16-27 | 0.64 | ## Known open bugs diff --git a/docs/tools.md b/docs/tools.md index c6654df0..b5734c09 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -143,7 +143,7 @@ the field logs in `replays/field/`. | Script | Purpose | |---|---| -| `main.py` | Watch one match in rsim with the referee and dashboard: `pixi run main [yellow] [blue]`, default `split_shape` vs `high_press`. | +| `main.py` | Watch one match in rsim with the referee and dashboard: `pixi run main [yellow] [blue]`, default `pendulum` vs `wolfpack`. | | `examples/demo_custom_referee.py` | Every `CustomReferee` rule in a scripted scenario, in a pygame window; no simulator needed | | `examples/demo_referee_gui_rsim.py` | `CustomReferee` with the dashboard's referee tab, over rsim | | `examples/demo_referee_feedback_gui.py` | The referee UI's controller-feedback panel with fake feedback, no hardware | @@ -165,4 +165,4 @@ the field logs in `replays/field/`. | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | | `examples/demo_dribbler_test.py` | One robot dribbling round a rectangle on the Exhibition Road field | -| `examples/demo_split_shape_match.py` | Visible grSim 6v6 of `split_shape` against itself | +| `examples/demo_pendulum_match.py` | Visible grSim 6v6 of `pendulum` against itself | diff --git a/docs/visual_guide.md b/docs/visual_guide.md index 30aae3e7..bba55900 100644 --- a/docs/visual_guide.md +++ b/docs/visual_guide.md @@ -23,10 +23,10 @@ stalls, and with `--restarts` illegal restart targets), and draws the worst few kind. Read its `index.md` first: each problem's numbers, then the picture path. About 20 s a match (a minute with `--restarts`); `evaluate.py --explain` runs it on the candidate's two worst matches. -A stall it found in `split_shape` against `tiki_taka_plus`: from 783 to 786 s, four of our robots +A stall it found in `pendulum` against `weaver`: from 783 to 786 s, four of our robots oscillate with the ball frozen. The picture is the match timeline around it, recorded data only: -![a stall in the match timeline](img/match_timeline/stall_split_shape_773-796.png) +![a stall in the match timeline](img/match_timeline/stall_pendulum_773-796.png) Robots 2-4 switch between `ShadowAndMarkTactic` and `LeadAndSupportTactic` together, three times within half a second at 780.5 s and again at 782.4, 783.2 and 785.2 s, while robots 0, 1, 2 and 5 stay within @@ -51,27 +51,27 @@ What it shows: Which tactic draws them, from the intentions log (live play, robots on the line): - the line in our half is mostly `BlockShapeTactic`'s screen, held at a fixed depth by design (`_SCREEN_OFFSET` in front of our box, shifting only sideways with the ball): 73-83% of the - samples there in `clear_danger`, `counter_flow`, `press_trigger_flow`, `score_aware_counter_flow` - and `clear_press_plus`. Those robots stand still 57-63% of the time, with the ball a median - 2-3 m ahead of them. `split_shape` and `decoy_and_overload` draw the same kind of line with + samples there in `firebreak`, `riptide`, `tripwire`, `chameleon` + and `breakwater`. Those robots stand still 57-63% of the time, with the ball a median + 2-3 m ahead of them. `pendulum` and `mirage` draw the same kind of line with `ShadowAndMarkTactic` a little deeper (x ≈ −3.0 m). - - the lines from `GiveAndGoTactic` (x ≈ −2.4 and +3.0 m in `give_and_go_solo` and `high_press`) + - the lines from `GiveAndGoTactic` (x ≈ −2.4 and +3.0 m in `ricochet` and `wolfpack`) are not explained yet: the ball is at the same depth (median 0 m ahead), mostly near a touchline (median |y| 2.4-2.6 m). - A fixed line is not by itself why a strategy loses: `clear_danger` holds the screen and ranks + A fixed line is not by itself why a strategy loses: `firebreak` holds the screen and ranks fourth. Whether a ball-following depth beats it is a question for `evaluate.py`, not this picture. -- `split_shape`, the top scorer, keeps most of its outfield robots in **its own defensive third even - with the ball**, and attacks with one or two. `overload_press` is the opposite: a block just past +- `pendulum`, the top scorer, keeps most of its outfield robots in **its own defensive third even + with the ball**, and attacks with one or two. `avalanche` is the opposite: a block just past halfway, in and out of possession. -- `decoy_and_overload` sits deep in a cluster in front of its own box. +- `mirage` sits deep in a cluster in front of its own box. ### Where it shoots from, and concedes: the shot map ![shots for and against](img/signals/shots.png) Blue are the strategy's own shots at the spot they were struck from (filled: a goal), faded orange the -shots it conceded. `split_shape` takes 241 shots in its 11 matches, from all over the attacking half, +shots it conceded. `pendulum` takes 241 shots in its 11 matches, from all over the attacking half, two and a half times the next strategy; the others take 69-98. ### Where it fouls @@ -90,8 +90,8 @@ The rest of the strategy report, as numbers: [signal_report.md](signal_report.md The same maps for just two strategies, a candidate and the champion, side by side on one colour scale; `evaluate.py --explain` draws them (with shots, fouls and a `summary.json`) before an evaluation removes -its replays. This example is drawn from the round-robin: `split_shape` holds 37% of its possession in the -attacking half against `clear_press_plus`'s 65%, yet takes 21.9 shots a match against 6.3, and commits +its replays. This example is drawn from the round-robin: `pendulum` holds 37% of its possession in the +attacking half against `breakwater`'s 65%, yet takes 21.9 shots a match against 6.3, and commits twice the fouls (10.0 against 4.7 a match, mostly ball held in the defense area and crashing). Draw: `tools/evaluation/evaluate.py CANDIDATE --explain`, or `tools/evaluation/explain.py RUN_DIR @@ -99,9 +99,9 @@ CANDIDATE CHAMPION --out DIR` on any run dir. ## 3. One match over time -![split_shape timeline](img/match_timeline/split_shape_100-160.png) +![pendulum timeline](img/match_timeline/pendulum_100-160.png) -Sixty seconds of `split_shape` against `tiki_taka_plus`. From the top: events (fouls, shots), the +Sixty seconds of `pendulum` against `weaver`. From the top: events (fouls, shots), the referee command, one lane per robot coloured by the tactic it was in (a tick at each switch, a black strip while it had the ball), and each robot's distance to the ball. Hatched lanes are stoppages, where the referee override moves robots instead of their tactics. @@ -109,8 +109,8 @@ referee override moves robots instead of their tactics. What it shows: robots 2-4 switch between `ShadowAndMarkTactic` and `LeadAndSupportTactic` together, several times within a few seconds (112-117 s, 139-146 s), while robots 1 and 5 hold one tactic. Over a whole round-robin, a tactic held under 1 s and then reverted (a flip-back) happens about 5 times a -minute in most strategies that split attack and defence on possession, 13 in `press_and_pass`, and -almost never in `give_and_go_solo`, `high_press` or `decoy_and_overload`. Not fixed yet. +minute in most strategies that split attack and defence on possession, 13 in `terrier`, and +almost never in `ricochet`, `wolfpack` or `mirage`. Not fixed yet. Draw: `pixi run python tools/match_timeline.py REPLAY.npz T0 T1`. @@ -162,7 +162,7 @@ benchmark: [motion_planning_comparison.md](motion_planning_comparison.md). The planner's decision for one robot on one recorded tick: every robot with its clearance ring, the ball's keep-out circle (dashed), the robot's target and the carrot (the point the planner steers to this -tick). Here `tiki_taka_plus`'s robot 4 (the replay's enemy side) sits on the keep-out circle at a kickoff, 0.799 m from the ball; its target +tick). Here `weaver`'s robot 4 (the replay's enemy side) sits on the keep-out circle at a kickoff, 0.799 m from the ball; its target (−1.0, −0.3) is across the circle. The planner's answer is a carrot 5 cm away: push the robot out to 0.85 m first. diff --git a/examples/demo_referee_gui_rsim.py b/examples/demo_referee_gui_rsim.py index b9976d37..43e9a6c6 100644 --- a/examples/demo_referee_gui_rsim.py +++ b/examples/demo_referee_gui_rsim.py @@ -11,7 +11,7 @@ - Passes the referee to StrategyRunner via referee=. StrategyRunner calls referee.step() on every tick and handles ball teleports on STOP automatically — no patching required. - - builder("tiki_taka_plus", ...) builds the give-and-go + + - builder("weaver", ...) builds the give-and-go + final-third decoy-overload kernel strategy (see docs/strategies.md) so you can watch real tactic assignments in the dashboard's Live tab instead of an aimless wandering tactic, and watch @@ -20,7 +20,7 @@ Operator workflow: 1. Open http://localhost:8080 in a browser. - 2. Robots start playing under tiki_taka_plus; the Live tab's Tactics panel + 2. Robots start playing under weaver; the Live tab's Tactics panel shows each robot's current slot ("attack"/"overload"/"press"/"defense"). 3. Click any command button (Halt, Stop, Kickoff Yellow…) — robots reposition. 4. Click Normal Start to resume free play. @@ -47,7 +47,7 @@ PROFILE = "human" # "human" or "simulation" DASHBOARD_PORT = 8080 -N_ROBOTS = 6 # robots per side (5 outfield + 1 goalkeeper) — tiki_taka_plus's tournament size +N_ROBOTS = 6 # robots per side (5 outfield + 1 goalkeeper) — weaver's tournament size MY_TEAM_IS_YELLOW = True MY_TEAM_IS_RIGHT = True @@ -69,7 +69,7 @@ def main() -> None: outfield_robot_ids = tuple(range(1, N_ROBOTS)) runner = StrategyRunner( - strategy=AbstractStrategy(build=builder("tiki_taka_plus", outfield_robot_ids)), + strategy=AbstractStrategy(build=builder("weaver", outfield_robot_ids)), my_team_is_yellow=MY_TEAM_IS_YELLOW, my_team_is_right=MY_TEAM_IS_RIGHT, mode="rsim", @@ -78,7 +78,7 @@ def main() -> None: exp_enemy=N_ROBOTS, referee=referee, # StrategyRunner drives referee.step() each tick show_live_status=True, - opp_strategy=AbstractStrategy(build=builder("tiki_taka_plus", outfield_robot_ids)), + opp_strategy=AbstractStrategy(build=builder("weaver", outfield_robot_ids)), ) runner.run() diff --git a/examples/demo_split_shape_match.py b/examples/demo_split_shape_match.py index c4a53d20..888d71a3 100644 --- a/examples/demo_split_shape_match.py +++ b/examples/demo_split_shape_match.py @@ -35,8 +35,8 @@ def main(): - my_strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) - opp_strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + my_strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) + opp_strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) profile = load_profile("simulation") referee = CustomReferee(profile, n_robots_yellow=6, n_robots_blue=6) diff --git a/main.py b/main.py index 762e79d3..6c00139f 100644 --- a/main.py +++ b/main.py @@ -2,9 +2,9 @@ round-robin matches are. Run: - pixi run main # split_shape vs high_press - pixi run main split_shape counter_flow # any two names from docs/strategies.md - pixi run main a.strategy high_press # or a .strategy file (tools/build_strategy.py) + pixi run main # pendulum vs wolfpack + pixi run main pendulum riptide # any two names from docs/strategies.md + pixi run main a.strategy wolfpack # or a .strategy file (tools/build_strategy.py) # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop Yellow (the first strategy) starts on the right and kicks off. For many matches with @@ -30,8 +30,8 @@ def _strategy(name: str) -> AbstractStrategy: def main() -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("yellow", nargs="?", default="split_shape") - parser.add_argument("blue", nargs="?", default="high_press") + parser.add_argument("yellow", nargs="?", default="pendulum") + parser.add_argument("blue", nargs="?", default="wolfpack") args = parser.parse_args() yellow, blue = _strategy(args.yellow), _strategy(args.blue) # fail on a bad name before the dashboard starts diff --git a/tools/build_strategy.py b/tools/build_strategy.py index aaec9bf6..dadfb347 100644 --- a/tools/build_strategy.py +++ b/tools/build_strategy.py @@ -1,7 +1,7 @@ """Pack one strategy and the code it runs on into a `.strategy` file. - pixi run python tools/build_strategy.py split_shape split_shape.strategy - pixi run python tools/build_strategy.py split_shape frozen.strategy --ref v2.5.0 + pixi run python tools/build_strategy.py pendulum pendulum.strategy + pixi run python tools/build_strategy.py pendulum frozen.strategy --ref v2.5.0 Without `--ref` it takes the working tree as it stands, uncommitted changes included. """ @@ -19,7 +19,7 @@ def main() -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("strategy", help="strategy name, e.g. split_shape") + parser.add_argument("strategy", help="strategy name, e.g. pendulum") parser.add_argument("output", type=Path) parser.add_argument("--ref", help="git commit to pack (default: the working tree)") args = parser.parse_args() diff --git a/tools/debug_match.py b/tools/debug_match.py index 9dc6c193..dea2da7d 100644 --- a/tools/debug_match.py +++ b/tools/debug_match.py @@ -1,8 +1,8 @@ """debug_match.py — one-off ad hoc match runner for tactic debugging. Run: - pixi run python tools/debug_match.py --strategy counter_flow \\ - --opponent high_press --duration 90 --headless + pixi run python tools/debug_match.py --strategy riptide \\ + --opponent wolfpack --duration 90 --headless Replaces the pattern of hand-writing a fresh `StrategyRunner(...)` block per bug (`trace_relay_stall.py`, `trace_finish_detail.py`, `check_keeper.py`, diff --git a/tools/evaluation/reference/opponents.json b/tools/evaluation/reference/opponents.json index 09045804..e892f2e6 100644 --- a/tools/evaluation/reference/opponents.json +++ b/tools/evaluation/reference/opponents.json @@ -1,17 +1,17 @@ { "note": "Chosen 2026-10-17 from the 12 strategies of tournament_20261016_201213 for spread of styles, not standings. Change it only on purpose: ratings are comparable within one set of opponents.", - "champion": "split_shape", + "champion": "pendulum", "opponents": [ - "clear_danger", - "decoy_and_overload", - "counter_flow", - "high_press", - "tiki_taka_plus", - "press_and_pass" + "firebreak", + "mirage", + "riptide", + "wolfpack", + "weaver", + "terrier" ], "held_out": [ - "overload_press", - "score_aware_counter_flow", - "give_and_go_solo" + "avalanche", + "chameleon", + "ricochet" ] } diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index 18038702..94616418 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -9,7 +9,7 @@ Run: pixi run python tools/evaluation/round_robin.py [config ...] [flags] -Configs are short names (`split_shape`); none means every strategy in the catalog. Flags: +Configs are short names (`pendulum`); none means every strategy in the catalog. Flags: --pair A B one match, A as config_a --vs-champion the day-to-day health check: one match per active strategy against the champion (reference/opponents.json), plus champion vs the first opponent; @@ -121,7 +121,7 @@ from utama_core.replay import match_results from utama_core.replay.fingerprint import CodeGraph from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise -from utama_core.strategy.catalog import plain_name +from utama_core.strategy.catalog import current_name, plain_name # A full match, as the rulebook has it: two halves of 300 s of playing time, the clock stopped # whenever no team may play the ball (`custom_referee/state_machine.py`), so about 710 s of @@ -692,7 +692,7 @@ def _tag(pair: tuple[str, str]) -> str: def _resolve_config_names(requested_names: list[str]) -> list[str]: """The strategies named, in catalog order, then any `.strategy` files as given.""" files = [name for name in requested_names if name.endswith(SUFFIX)] - requested = {plain_name(name) for name in requested_names if name not in files} + requested = {current_name(name) for name in requested_names if name not in files} config_names = [name for name in _CONFIG_NAMES if name in requested] unmatched = requested - set(config_names) if unmatched: diff --git a/tools/match_timeline.py b/tools/match_timeline.py index 332d6300..5db26e84 100644 --- a/tools/match_timeline.py +++ b/tools/match_timeline.py @@ -55,9 +55,9 @@ # the robot reverted before B could do anything. A robot with at least FLIP_BACKS_PER_MIN of them per minute # of live play gets a `tactic_thrash` finding. Raw switch rate is not the signal: most strategies switch # 10-25 times per live minute by design (attack/defence on possession). Measured on tournament_20261017_151052 -# (66 matches, friendly robots, median flip-backs under 1 s per live min): give_and_go_solo 0.0, decoy_and_overload -# 0.1, high_press 0.3, overload_press 0.5; counter_flow, clear_danger, clear_press_plus, split_shape, -# press_trigger_flow, score_aware_counter_flow 4.6-5.6; press_and_pass 13.4. 2 per min (one every 30 s of live +# (66 matches, friendly robots, median flip-backs under 1 s per live min): ricochet 0.0, mirage +# 0.1, wolfpack 0.3, avalanche 0.5; riptide, firebreak, breakwater, pendulum, +# tripwire, chameleon 4.6-5.6; terrier 13.4. 2 per min (one every 30 s of live # play) sits between the steady and the flipping strategies. FLIP_S = 1.0 FLIP_BACKS_PER_MIN = 2.0 diff --git a/tools/metric_correlation.py b/tools/metric_correlation.py index a73901dd..44eee8c2 100644 --- a/tools/metric_correlation.py +++ b/tools/metric_correlation.py @@ -1183,7 +1183,7 @@ def main() -> None: # uniform: 46% of matches in that check had zero out_of_bounds events, # but a few pathological matches hit 40-58 in a single 65s window, and # the per-strategy rate spanned an 8-10x range (switch_of_play/ - # counter_press/high_line_zone/clear_press_plus far above tiki_taka/ + # counter_press/high_line_zone/breakwater far above tiki_taka/ # three_slot/decoy_and_overload) -- worth its own metric to track # whether that skew is a specific strategy's aim/geometry issue (e.g. a # cross-field switch-of-play pass overshooting the sideline) rather than diff --git a/tools/moments.py b/tools/moments.py index 27aa847b..e30a875a 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -7,7 +7,7 @@ {"name": ..., "note": what went wrong and why it must not happen again, "source": {"replay": ..., "t": ...} or null for a hand-made one, - "strategy": "all" or one strategy, "opponent": the other side (default split_shape), + "strategy": "all" or one strategy, "opponent": the other side (default pendulum), "seconds": how long to play (default 3), "checks": names from `CHECKS` below, or referee rule names our side must not break (`custom_referee/rules/`, "*" for any), @@ -87,7 +87,7 @@ from utama_core.strategy.catalog import plain_name # noqa: E402 MOMENTS_DIR = REPO_ROOT / "utama_core" / "tests" / "moments" -DEFAULT_OPPONENT = "split_shape" +DEFAULT_OPPONENT = "pendulum" DEFAULT_SECONDS = 3.0 # Rulebook distances (`custom_referee/rules/keep_out_rule.py`, `robot_stop_speed_rule.py`). diff --git a/tools/repro_from_replay.py b/tools/repro_from_replay.py index b2d03e0c..2f2d3957 100644 --- a/tools/repro_from_replay.py +++ b/tools/repro_from_replay.py @@ -46,7 +46,7 @@ --trace-out /tmp/repro_trace.jsonl `--strategy` / `--opponent` take the name of a strategy in -`utama_core/strategy/` (e.g. `clear_press_plus`, `counter_flow`), the same names as the +`utama_core/strategy/` (e.g. `breakwater`, `riptide`), the same names as the replay's `summary.json` config names. The trace shows the tactics those strategies use, not the strategy names (e.g. `decoy_and_overload.*` keys come from a strategy's DecoyOverloadTactic). @@ -115,7 +115,7 @@ def _resolve_config_name(explicit: Optional[str], from_scenario: Optional[str], ) if name.endswith(SUFFIX): return name - name = catalog.plain_name(name) + name = catalog.current_name(name) if name not in catalog.names(): raise SystemExit( f"Unknown strategy config {name!r} (from {'CLI override' if explicit else 'replay metadata'})." @@ -248,13 +248,13 @@ def main() -> None: parser.add_argument( "--strategy", default=None, - help="override the friendly (config_a) strategy: the short name (e.g. clear_press_plus) or the factory " - "name (e.g. clear_press_plus); default: the replay's summary.json", + help="override the friendly (config_a) strategy: the short name (e.g. breakwater) or the factory " + "name (e.g. breakwater); default: the replay's summary.json", ) parser.add_argument( "--opponent", default=None, - help="override the enemy (config_b) strategy, same two name forms (e.g. counter_flow); default: the " + help="override the enemy (config_b) strategy, same two name forms (e.g. riptide); default: the " "replay's summary.json", ) parser.add_argument( diff --git a/tools/sim_setup.py b/tools/sim_setup.py index a8226cab..3f425b4a 100644 --- a/tools/sim_setup.py +++ b/tools/sim_setup.py @@ -50,9 +50,9 @@ def factory_for(name: str) -> Callable: """`f(outfield_robot_ids)` -> `AbstractStrategy`'s `build`, for a catalog strategy or `PATH.py:FUNCTION` (imported as it is).""" if not is_file_spec(name): - if catalog.plain_name(name) not in catalog.names(): + if catalog.current_name(name) not in catalog.names(): raise UnknownStrategy(f"unknown strategy {name!r}; strategies: {', '.join(catalog.names())}") - return partial(catalog.builder, catalog.plain_name(name)) + return partial(catalog.builder, catalog.current_name(name)) path, _, func = name.rpartition(":") if not Path(path).is_file(): raise UnknownStrategy(f"{name}: no such file {path}") diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index 2e264a2d..bc69a8fe 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -430,7 +430,7 @@ def to_json(self, path: Union[str, Path]) -> None: # tools/metric_correlation.py's `_PASS_RELEASE_MPS`, which itself matches # this file's own `_SHOT_LOCK_RELEASE_MPS`). _PASS_RELEASE_MPS = 1.0 -_MIN_PASS_M = 0.5 # 90% of overload_press's "148 passes" per match were shorter (2026-11-09) +_MIN_PASS_M = 0.5 # 90% of avalanche's "148 passes" per match were shorter (2026-11-09) # Hysteresis band around the attacking-third boundary (half_length + # _SHOT_ATTACKING_THIRD_M) so oscillation on that line doesn't double-count # entries. Matches tools/metric_correlation.py's `_ENTRY_HYSTERESIS_M`. diff --git a/utama_core/shared/pass_and_score_geometry.py b/utama_core/shared/pass_and_score_geometry.py index 6ef0a309..30cce8ec 100644 --- a/utama_core/shared/pass_and_score_geometry.py +++ b/utama_core/shared/pass_and_score_geometry.py @@ -244,7 +244,7 @@ def carry_exhausted(game: Game, origin: Optional[Vector2D], stops_after: bool = reaction time (`_CARRY_REACTION_S`) included -- without it a ~1.4m/s lure braked another ~0.4m and fouled at 1.01m anyway. Leave False for a carrier that kicks while moving (GiveAndGo): counting it there ended - carries ~0.5m early and cost give_and_go_solo half its goals in an A/B + carries ~0.5m early and cost ricochet half its goals in an A/B (tournament_20260924_092119 bisect).""" if origin is None or game.ball is None: return False @@ -954,7 +954,7 @@ def no_shot_reposition_target( the blocker is about to move on its own. Against a stationary keeper covering the whole goal from close range (the common case once a carrier reaches the goal mouth) nothing about that position ever changes, so the - freeze is permanent: this was the actual mechanism behind a `clear_danger` + freeze is permanent: this was the actual mechanism behind a `firebreak` vs `low_block` match pinning 0-0 for 48 straight seconds (see `docs/strategies.md`'s "Known open bugs" and `docs/investigation_default_vs_lowblock_stalemate.md` for the sibling diff --git a/utama_core/skills/src/goalkeep.py b/utama_core/skills/src/goalkeep.py index b13e33c9..a4251140 100644 --- a/utama_core/skills/src/goalkeep.py +++ b/utama_core/skills/src/goalkeep.py @@ -16,7 +16,7 @@ did: it always drove to a goal-line intercept regardless of where the ball actually was, so a ball that rolled dead in the box (not heading at goal, `predict_ball_pos_at_x` returns `None` for a near-stationary ball) just sat -there for the rest of the match. Found live: a `clear_danger` vs `low_block` +there for the rest of the match. Found live: a `firebreak` vs `low_block` match pinned for the last 28 s of a 60 s game this way (see `docs/strategies.md`'s "Known open bugs"). """ diff --git a/utama_core/strategy/overload_press.py b/utama_core/strategy/avalanche.py similarity index 95% rename from utama_core/strategy/overload_press.py rename to utama_core/strategy/avalanche.py index c6b1e446..5b16db69 100644 --- a/utama_core/strategy/overload_press.py +++ b/utama_core/strategy/avalanche.py @@ -1,4 +1,4 @@ -"""The `overload_press` kernel strategy: `overload_press` and the pickers only it uses.""" +"""`avalanche` (until 2026-11-12 `overload_press`): floods one area with four robots, one blocks. The pickers only it uses are here.""" from __future__ import annotations @@ -42,7 +42,7 @@ # --------------------------------------------------------------------------- -def _overload_press_picker( +def _avalanche_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], @@ -102,7 +102,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll Four concurrent slots — `DecoyOverloadTactic` ("overload"), `SwitchOfPlayTactic` ("switch"), `LeadAndSupportTactic` ("counter"), and - `BlockShapeTactic` ("block") — allocated by `_overload_press_picker`: + `BlockShapeTactic` ("block") — allocated by `_avalanche_picker`: 4 robots overload/switch the attack (more bodies than tiki_taka's 2-robot defense slot ever marks) with 1 held on the block screen while we have the ball; on loss, the whole team goes direct via the counter rather than @@ -121,7 +121,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "counter": LeadAndSupportTactic(), "block": BlockShapeTactic(), }, - partitioner=_overload_press_picker, + partitioner=_avalanche_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/clear_press_plus.py b/utama_core/strategy/breakwater.py similarity index 87% rename from utama_core/strategy/clear_press_plus.py rename to utama_core/strategy/breakwater.py index 9d9c4d5e..83d79e98 100644 --- a/utama_core/strategy/clear_press_plus.py +++ b/utama_core/strategy/breakwater.py @@ -1,4 +1,4 @@ -"""The `clear_press_plus` kernel strategy: `clear_press_plus` and the pickers only it uses.""" +"""`breakwater` (until 2026-11-12 `clear_press_plus`): breaks attacks, clears danger from its own third, then overloads the final third. The pickers only it uses are here.""" from __future__ import annotations @@ -23,12 +23,12 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic # --------------------------------------------------------------------------- -# clear_press_plus (2026-09-02 addition) +# breakwater (2026-09-02 addition) # # Stacks the catalog's two most validated single-wrinkle additions onto one -# base instead of picking between them: `clear_danger`'s safety valve (a +# base instead of picking between them: `firebreak`'s safety valve (a # deep-and-contested own-third clearance, the one situational gap no other -# strategy fills) plus `tiki_taka_plus`'s final-third overload handoff (the +# strategy fills) plus `weaver`'s final-third overload handoff (the # only other single-wrinkle addition with a confirmed independent win -- # 10W-6D in its most recent tournament, clearing the field outright). The # two wrinkles fire in disjoint game states by construction (the valve needs @@ -38,19 +38,19 @@ # --------------------------------------------------------------------------- -def _clear_press_plus_picker( +def _breakwater_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], available_tactic_ids: frozenset[str], ) -> dict[str, frozenset[RobotId]]: - """`_clear_danger_picker`'s allocation, with `_tiki_taka_plus_picker`'s + """`_firebreak_picker`'s allocation, with `_weaver_picker`'s final-third handoff grafted onto its attacking branch: when we hold the ball and it is not deep-and-contested in our own third, the final third hands off from the give-and-go trio to the 2-robot overload duet instead of running give-and-go the length of the pitch. The clearance valve and the losing-possession press/block branches are unchanged from - `_clear_danger_picker`. + `_firebreak_picker`. """ ordered = carrier_first(game, free_robots) if not ordered: @@ -98,15 +98,15 @@ def _clear_press_plus_picker( def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """`clear_danger` plus `tiki_taka_plus`'s final-third overload handoff. + """`firebreak` plus `weaver`'s final-third overload handoff. Five concurrent slots -- `GiveAndGoTactic` ("attack"), `DecoyOverloadTactic` ("overload"), `ClearBallTactic` ("clear"), `PressAndContainTactic` ("press"), and `BlockShapeTactic` ("block") -- - allocated by `_clear_press_plus_picker`: identical to `clear_danger` + allocated by `_breakwater_picker`: identical to `firebreak` except the attacking branch hands off from give-and-go to the overload duet once the ball reaches the final third, the same swap - `tiki_taka_plus` validated on `tiki_taka`'s base. + `weaver` validated on `tiki_taka`'s base. Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the @@ -122,7 +122,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "block": BlockShapeTactic(), }, - partitioner=_clear_press_plus_picker, + partitioner=_breakwater_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/catalog.py b/utama_core/strategy/catalog.py index b05ad837..bfdb8afd 100644 --- a/utama_core/strategy/catalog.py +++ b/utama_core/strategy/catalog.py @@ -18,9 +18,34 @@ def names() -> list[str]: return sorted(p.stem for p in _PACKAGE.glob("*.py") if "\ndef build(" in p.read_text()) +# The names strategies had until 2026-11-12, so old replays and summaries still load. Only `builder` +# and `current_name` read this: replay files keep the names they were saved under, so `plain_name` +# (which tools use to find those files) does not. +RENAMED = { + "split_shape": "pendulum", + "clear_press_plus": "breakwater", + "overload_press": "avalanche", + "high_press": "wolfpack", + "decoy_and_overload": "mirage", + "counter_flow": "riptide", + "score_aware_counter_flow": "chameleon", + "press_trigger_flow": "tripwire", + "clear_danger": "firebreak", + "press_and_pass": "terrier", + "tiki_taka_plus": "weaver", + "give_and_go_solo": "ricochet", +} + + +def current_name(name: str) -> str: + """`name` as the catalog calls it today: old `build_*_kernel_strategy` and pre-2026-11-12 names map on.""" + plain = plain_name(name) + return RENAMED.get(plain, plain) + + def builder(name: str, outfield_robot_ids: tuple[int, ...]) -> Callable: - """`AbstractStrategy`'s first argument for strategy `name`.""" - return partial(import_module(f"utama_core.strategy.{plain_name(name)}").build, outfield_robot_ids) + """`AbstractStrategy`'s first argument for strategy `name` (an old name works too).""" + return partial(import_module(f"utama_core.strategy.{current_name(name)}").build, outfield_robot_ids) def plain_name(name: str) -> str: diff --git a/utama_core/strategy/score_aware_counter_flow.py b/utama_core/strategy/chameleon.py similarity index 85% rename from utama_core/strategy/score_aware_counter_flow.py rename to utama_core/strategy/chameleon.py index 37130089..7a187f57 100644 --- a/utama_core/strategy/score_aware_counter_flow.py +++ b/utama_core/strategy/chameleon.py @@ -1,4 +1,4 @@ -"""The `score_aware_counter_flow` kernel strategy: `score_aware_counter_flow` and the pickers only it uses.""" +"""`chameleon` (until 2026-11-12 `score_aware_counter_flow`): `riptide` that changes its play with the score. The pickers only it uses are here.""" from __future__ import annotations @@ -21,35 +21,35 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic # --------------------------------------------------------------------------- -# score_aware_counter_flow (2026-09-02 addition) +# chameleon (2026-09-02 addition) # # `score_aware_zone_flow` validated the scoreline-aware attack/defense split # shift as a free improvement grafted onto `zone_fluid`'s picker with zero # other changes -- but `zone_fluid` is one of the catalog's weaker bases # (2W-6D-5L in the 2026-08-21 backfill). This strategy applies the identical # mechanism (shrink the attacking commitment when ahead late, grow it when -# behind late) to `counter_flow`'s picker instead -- the catalog's only +# behind late) to `riptide`'s picker instead -- the catalog's only # undefeated strategy, 0L across every backfill/tournament to date. Every # other axis is left untouched: same 3 tactics (`GiveAndGoTactic`/ # `PressAndContainTactic`/`BlockShapeTactic`), same sticky possession-edge # hysteresis, same 3/2 split everywhere except the late-game scoreline -# branch -- so any observed difference from plain `counter_flow` is +# branch -- so any observed difference from plain `riptide` is # attributable to the new scoreline input alone, not a different base. # --------------------------------------------------------------------------- -def _score_aware_counter_flow_picker( +def _chameleon_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], available_tactic_ids: frozenset[str], ) -> dict[str, frozenset[RobotId]]: - """`_counter_flow_picker`'s allocation, with the attacking commitment size + """`_riptide_picker`'s allocation, with the attacking commitment size shifted late in a half by whether we're ahead or behind -- see `_score_aware_zone_flow_picker` for the identical mechanism applied to a different base. - Not late, tied, or score unreadable: identical to `_counter_flow_picker` + Not late, tied, or score unreadable: identical to `_riptide_picker` (3 attack/2 block when we hold the edge, 3 press/2 block when we don't). Late and ahead: only 2 attack, 3 block -- protect the lead behind a heavier screen. Late and behind: 4 attack, 1 block -- chase an @@ -98,12 +98,12 @@ def _score_aware_counter_flow_picker( def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """`counter_flow` (the catalog's only undefeated strategy) with the same + """`riptide` (the catalog's only undefeated strategy) with the same scoreline-aware attack-commitment shift `score_aware_zone_flow` validated - on a weaker base. Same three tactics/slots as `counter_flow` + on a weaker base. Same three tactics/slots as `riptide` (`GiveAndGoTactic`/`PressAndContainTactic`/`BlockShapeTactic`) and the same sticky possession-edge hysteresis -- only the picker's late-game - attack-count decision differs. See `_score_aware_counter_flow_picker`. + attack-count decision differs. See `_chameleon_picker`. Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the same name. @@ -116,7 +116,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "block": BlockShapeTactic(), }, - partitioner=_score_aware_counter_flow_picker, + partitioner=_chameleon_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/clear_danger.py b/utama_core/strategy/firebreak.py similarity index 85% rename from utama_core/strategy/clear_danger.py rename to utama_core/strategy/firebreak.py index 6ae0253b..fd70f901 100644 --- a/utama_core/strategy/clear_danger.py +++ b/utama_core/strategy/firebreak.py @@ -1,4 +1,4 @@ -"""The `clear_danger` kernel strategy: `clear_danger` and the pickers only it uses.""" +"""`firebreak` (until 2026-11-12 `clear_danger`): `riptide` that clears the ball out of its own third when it is in danger. The pickers only it uses are here.""" from __future__ import annotations @@ -21,13 +21,13 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic -def _clear_danger_picker( +def _firebreak_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], available_tactic_ids: frozenset[str], ) -> dict[str, frozenset[RobotId]]: - """Safety-valve posture: counter_flow's proven attack/press/block postures, + """Safety-valve posture: riptide's proven attack/press/block postures, plus a danger valve — when the ball is deep in our own third AND contested (`ClearBallTactic.applicable()`, the real §15 gate this config exists to exercise), one robot clears it long while everyone else holds the screen. @@ -36,19 +36,19 @@ def _clear_danger_picker( other postures: building out of a contested own-third pocket is exactly what `GiveAndGoTactic` should not be doing (its hops are short by design), and pressing leaves nobody removing the ball. - - Lost, no danger: counter_flow's defensive posture — press 3 + block 2 + - Lost, no danger: riptide's defensive posture — press 3 + block 2 when something is pressable, all-block otherwise. - - Won: counter_flow's attacking posture — attack 3 + block 2. + - Won: riptide's attacking posture — attack 3 + block 2. The press slot is NOT optional here (an earlier draft dropped it in favour of block-everyone-unless-danger): traced live, that team never contests any ball anywhere — possession collapsed to ~1% as the opponent's carrier parked unpressured at midfield, and the ball never even reached our third, so the valve itself never fired. Ball control, not territory, is the bottleneck - (the same lesson as `go_to_ball`'s shield fix); counter_flow's press stays, + (the same lesson as `go_to_ball`'s shield fix); riptide's press stays, the valve rides on top of it. - Sticky possession edge, same fix `_counter_flow_picker`/`_high_line_zone_picker` + Sticky possession edge, same fix `_riptide_picker`/`_high_line_zone_picker` needed: re-reading `friendly_closer_to_ball` every tick flips constantly in a genuinely contested match and resets `GiveAndGoTactic`'s hop cycle before a single hop completes. `prev_partition` ("did we hold attack last tick") is @@ -98,12 +98,12 @@ def _clear_danger_picker( def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """Safety-valve team: counter_flow's postures plus a danger-clearance valve. + """Safety-valve team: riptide's postures plus a danger-clearance valve. Four concurrent slots — `GiveAndGoTactic` ("attack"), `ClearBallTactic` ("clear"), `PressAndContainTactic` ("press"), and - `BlockShapeTactic` ("block") — allocated by `_clear_danger_picker`. - Identical to `counter_flow` whenever the ball is not deep-and-contested in + `BlockShapeTactic` ("block") — allocated by `_firebreak_picker`. + Identical to `riptide` whenever the ball is not deep-and-contested in our own third; when it is, the valve takes one robot and removes the ball instead of only screening it. Fills the one hole the catalog has: no existing tactic ever deliberately kicks the ball out of danger (the only @@ -123,7 +123,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "block": BlockShapeTactic(), }, - partitioner=_clear_danger_picker, + partitioner=_firebreak_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/decoy_and_overload.py b/utama_core/strategy/mirage.py similarity index 92% rename from utama_core/strategy/decoy_and_overload.py rename to utama_core/strategy/mirage.py index a4797f8d..0580a1aa 100644 --- a/utama_core/strategy/decoy_and_overload.py +++ b/utama_core/strategy/mirage.py @@ -1,4 +1,4 @@ -"""The `decoy_and_overload` kernel strategy: `decoy_and_overload` and the pickers only it uses.""" +"""`mirage` (until 2026-11-12 `decoy_and_overload`): decoy runs pull defenders away from the real attack. The pickers only it uses are here.""" from __future__ import annotations diff --git a/utama_core/strategy/split_shape.py b/utama_core/strategy/pendulum.py similarity index 96% rename from utama_core/strategy/split_shape.py rename to utama_core/strategy/pendulum.py index 1ce25215..b4ca43f7 100644 --- a/utama_core/strategy/split_shape.py +++ b/utama_core/strategy/pendulum.py @@ -1,4 +1,4 @@ -"""The `split_shape` kernel strategy: `split_shape` and the pickers only it uses.""" +"""`pendulum` (until 2026-11-12 `split_shape`): swings between attack and defence with possession. The pickers only it uses are here.""" from __future__ import annotations diff --git a/utama_core/strategy/pickers.py b/utama_core/strategy/pickers.py index 1cbf6bfd..d99e3e95 100644 --- a/utama_core/strategy/pickers.py +++ b/utama_core/strategy/pickers.py @@ -65,7 +65,7 @@ def _partitioner( # --------------------------------------------------------------------------- # Arena strategies — plan-driven multi-tactic teams (2026-08-20 addition) # -# The barebone factories (default/split_shape/low_block/...) exist to exercise +# The barebone factories (default/pendulum/low_block/...) exist to exercise # the kernel machinery; these three are meant as *playable* teams: every # posture reads live game state (ball ownership, ball zone), every posture # has both an attack and a defense answer, and the allocation reacts to the diff --git a/utama_core/strategy/give_and_go_solo.py b/utama_core/strategy/ricochet.py similarity index 92% rename from utama_core/strategy/give_and_go_solo.py rename to utama_core/strategy/ricochet.py index 283a2ee3..a2fb361a 100644 --- a/utama_core/strategy/give_and_go_solo.py +++ b/utama_core/strategy/ricochet.py @@ -1,4 +1,4 @@ -"""The `give_and_go_solo` kernel strategy: `give_and_go_solo` and the pickers only it uses.""" +"""`ricochet` (until 2026-11-12 `give_and_go_solo`): all one-twos, no defence. The pickers only it uses are here.""" from __future__ import annotations diff --git a/utama_core/strategy/counter_flow.py b/utama_core/strategy/riptide.py similarity index 94% rename from utama_core/strategy/counter_flow.py rename to utama_core/strategy/riptide.py index 66f5b6cd..bbe54f7a 100644 --- a/utama_core/strategy/counter_flow.py +++ b/utama_core/strategy/riptide.py @@ -1,4 +1,4 @@ -"""The `counter_flow` kernel strategy: `counter_flow` and the pickers only it uses.""" +"""`riptide` (until 2026-11-12 `counter_flow`): soaks up pressure, then counters fast. The pickers only it uses are here.""" from __future__ import annotations @@ -19,7 +19,7 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic -def _counter_flow_picker( +def _riptide_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], @@ -30,7 +30,7 @@ def _counter_flow_picker( window with our own press instead of ceding it, and fall back to a space-denying screen (not man-shadow) when neither side has an edge. - Both `overload_press` and `high_line_zone` tried to out-number + Both `avalanche` and `high_line_zone` tried to out-number tiki_taka's 2-robot shadow defense and lost before that numbers edge ever got to matter — tiki_taka's 3-robot press (1 presser + 2 markers, `PressAndContainTactic` only becomes applicable within 1.5 m of the @@ -108,9 +108,9 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll Three concurrent slots — `GiveAndGoTactic` ("attack"), `PressAndContainTactic` ("press"), and `BlockShapeTactic` ("block") — - allocated by `_counter_flow_picker` on a 3/2 split matching tiki_taka's + allocated by `_riptide_picker` on a 3/2 split matching tiki_taka's own commitment in both postures, rather than the numbers-overload bet - `overload_press`/`high_line_zone` made and lost. The theory: neither + `avalanche`/`high_line_zone` made and lost. The theory: neither prior anti-tiki_taka attempt ever got far enough to test its numbers edge because tiki_taka's press won the transition window outright: this strategy contests that window symmetrically (our own 3-press) instead @@ -129,7 +129,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "block": BlockShapeTactic(), }, - partitioner=_counter_flow_picker, + partitioner=_riptide_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/press_and_pass.py b/utama_core/strategy/terrier.py similarity index 91% rename from utama_core/strategy/press_and_pass.py rename to utama_core/strategy/terrier.py index e8520bed..aba6188c 100644 --- a/utama_core/strategy/press_and_pass.py +++ b/utama_core/strategy/terrier.py @@ -1,4 +1,4 @@ -"""The `press_and_pass` kernel strategy: `press_and_pass` and the pickers only it uses.""" +"""`terrier` (until 2026-11-12 `press_and_pass`): presses, then plays quick one-twos. The pickers only it uses are here.""" from __future__ import annotations @@ -14,7 +14,7 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic -def _press_and_pass_split_picker( +def _terrier_split_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], @@ -59,8 +59,8 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll Wires `GiveAndGoTactic` ("attack") and `PressAndContainTactic` ("defense") as two concurrently active slots, split by - `_press_and_pass_split_picker`. Sibling to - `split_shape`, same shape, different tactic pair — + `_terrier_split_picker`. Sibling to + `pendulum`, same shape, different tactic pair — lets the give-and-go/press-and-contain tactics be driven end to end via `StrategyRunner` instead of only unit-level `tick()` calls. @@ -72,7 +72,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll ctx = TickContext(motion_controller=motion_controller) return KernelSchedulerStrategy( tactics={"attack": GiveAndGoTactic(), "defense": PressAndContainTactic()}, - partitioner=_press_and_pass_split_picker, + partitioner=_terrier_split_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/press_trigger_flow.py b/utama_core/strategy/tripwire.py similarity index 80% rename from utama_core/strategy/press_trigger_flow.py rename to utama_core/strategy/tripwire.py index a3fbce72..c5c2608a 100644 --- a/utama_core/strategy/press_trigger_flow.py +++ b/utama_core/strategy/tripwire.py @@ -1,4 +1,4 @@ -"""The `press_trigger_flow` kernel strategy: `press_trigger_flow` and the pickers only it uses.""" +"""`tripwire` (until 2026-11-12 `press_trigger_flow`): `riptide` that goes all in on the ball once it is lost in its own third. The pickers only it uses are here.""" from __future__ import annotations @@ -20,35 +20,35 @@ from utama_core.tactics.press_and_contain import PressAndContainTactic # --------------------------------------------------------------------------- -# press_trigger_flow (2026-09-02 addition) +# tripwire (2026-09-02 addition) # -# `counter_flow` presses with a fixed 3 robots any time pressing is +# `riptide` presses with a fixed 3 robots any time pressing is # applicable at all, regardless of where on the pitch that press happens -- # the same commitment whether the ball was lost at the halfway line or deep # in our own third. `ball_zone` is already read by every zone-handoff -# picker (`zone_fluid`, `tiki_taka_plus`, `high_line_zone`, ...) to change +# picker (`zone_fluid`, `weaver`, `high_line_zone`, ...) to change # the *attacking* pattern by zone, but no picker in the catalog uses it to # change the *press* commitment by zone -- this strategy is that missing -# combination: counter_flow's proven engine, with the press going all-in +# combination: riptide's proven engine, with the press going all-in # (every free robot, not just 3) specifically when the loss happens in our # own third, since a loose ball that close to our own goal is the one -# situation where `clear_danger`'s own author-noted lesson ("ball control, +# situation where `firebreak`'s own author-noted lesson ("ball control, # not territory, is the bottleneck") is most costly to get wrong. Everywhere # else (mid/final third losses, and every attacking-side branch), this is -# byte-for-byte identical to `_counter_flow_picker`. +# byte-for-byte identical to `_riptide_picker`. # --------------------------------------------------------------------------- -def _press_trigger_flow_picker( +def _tripwire_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], available_tactic_ids: frozenset[str], ) -> dict[str, frozenset[RobotId]]: - """`_counter_flow_picker`'s allocation, with an all-in press (every free + """`_riptide_picker`'s allocation, with an all-in press (every free robot, not the usual 3+2 split) when the ball is lost specifically in our own third. Mid/final-third losses and every attacking-side branch - are unchanged from `_counter_flow_picker` -- see that picker's + are unchanged from `_riptide_picker` -- see that picker's docstring for the shared attack/press/block rationale this one inherits unmodified outside the own-third-press branch. """ @@ -88,16 +88,16 @@ def _press_trigger_flow_picker( def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: - """`counter_flow` with a zone-triggered all-in press: the usual 3-press/ + """`riptide` with a zone-triggered all-in press: the usual 3-press/ 2-block split everywhere, except an all-in press (every free robot) when the ball is lost in our own third specifically. See the - "press_trigger_flow" comment block above `_press_trigger_flow_picker` + "tripwire" comment block above `_tripwire_picker` for the full rationale. - Same three tactics/slots as `counter_flow` (`GiveAndGoTactic`/ + Same three tactics/slots as `riptide` (`GiveAndGoTactic`/ `PressAndContainTactic`/`BlockShapeTactic`) -- only the picker's own-third press commitment differs, so any observed difference from - plain `counter_flow` is attributable to the zone-triggered press alone. + plain `riptide` is attributable to the zone-triggered press alone. Returns a `build(motion_controller)` callable suitable for `AbstractStrategy`'s constructor argument of the @@ -111,7 +111,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "block": BlockShapeTactic(), }, - partitioner=_press_trigger_flow_picker, + partitioner=_tripwire_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/tiki_taka_plus.py b/utama_core/strategy/weaver.py similarity index 89% rename from utama_core/strategy/tiki_taka_plus.py rename to utama_core/strategy/weaver.py index f1c71a47..141fe4aa 100644 --- a/utama_core/strategy/tiki_taka_plus.py +++ b/utama_core/strategy/weaver.py @@ -1,4 +1,4 @@ -"""The `tiki_taka_plus` kernel strategy: `tiki_taka_plus` and the pickers only it uses.""" +"""`weaver` (until 2026-11-12 `tiki_taka_plus`): short passing, then a two-robot move in the final third. The pickers only it uses are here.""" from __future__ import annotations @@ -21,19 +21,19 @@ from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic # --------------------------------------------------------------------------- -# tiki_taka_plus (2026-08-23 addition) +# weaver (2026-08-23 addition) # -# Every "beat tiki_taka" attempt in the catalog (`overload_press`, -# `high_line_zone`, `counter_flow`) targeted the same weakness: tiki_taka's +# Every "beat tiki_taka" attempt in the catalog (`avalanche`, +# `high_line_zone`, `riptide`) targeted the same weakness: tiki_taka's # defensive cover is a flat 2 robots in *every* posture, with no # specialization anywhere on the pitch. The two attempts that tried to # outnumber that thin line lost before the numbers edge ever mattered -- # tiki_taka's own 3-robot press smothered them in the transition window -# first. `counter_flow` won instead by matching tiki_taka's engine +# first. `riptide` won instead by matching tiki_taka's engine # (`GiveAndGoTactic`, same press numbers) and adding a wrinkle tiki_taka # itself lacks (a space-denying block screen instead of man-marking). # -# `tiki_taka_plus` applies that same lesson *to* tiki_taka rather than +# `weaver` applies that same lesson *to* tiki_taka rather than # *against* it: keep tiki_taka's proven build-up/press engine untouched, and # add the one wrinkle it doesn't have -- a distinct final-third finishing # move. `_zone_flow_picker` already validated handing the attacking slot @@ -52,13 +52,13 @@ # presses with 3 robots (not just the 2 original cover robots) any time the # ball is lost. tiki_taka's cover pair already gets folded into the press # the moment possession is lost -- there is no separate "poaching" gap to -# close at the picker level. So `tiki_taka_plus` only implements the +# close at the picker level. So `weaver` only implements the # final-third handoff; it reuses `_tiki_taka_picker`'s possession-edge and # press logic unchanged. # --------------------------------------------------------------------------- -def _tiki_taka_plus_picker( +def _weaver_picker( game: Game, free_robots: frozenset[RobotId], prev_partition: Optional[dict[str, frozenset[RobotId]]], @@ -122,22 +122,22 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll build-up and press-on-loss engine, but the attacking slot hands off to `DecoyOverloadTactic`'s two-role duet once the ball reaches the final third, instead of running the give-and-go trio the whole length of the - pitch. See the "tiki_taka_plus" comment block above - `_tiki_taka_plus_picker` for the full design rationale, including why a + pitch. See the "weaver" comment block above + `_weaver_picker` for the full design rationale, including why a second considered change (press applicability for the cover pair) turned out to already be present in tiki_taka's existing structure. Four concurrent slots -- `GiveAndGoTactic` ("attack"), `DecoyOverloadTactic` ("overload"), `PressAndContainTactic` ("press"), and `ShadowAndMarkTactic` ("defense") -- allocated by - `_tiki_taka_plus_picker`: 3+2 attack/cover in the own/mid thirds, 2+3 + `_weaver_picker`: 3+2 attack/cover in the own/mid thirds, 2+3 overload/cover in the final third, 3+2 press/cover when the ball is lost. Promoted into `full_match_tournament.py`'s `competitive` tier 2026-08-23 on its first decoupled side x kickoff round-robin result (6W-7D over 16 - matches, tying `counter_flow` for most wins and clearly outperforming its - own base `tiki_taka`, 3W-10D) -- see `docs/strategies.md`'s "tiki_taka_plus + matches, tying `riptide` for most wins and clearly outperforming its + own base `tiki_taka`, 3W-10D) -- see `docs/strategies.md`'s "weaver added" section for the full writeup, including the caveat that one 40-match run isn't yet enough to rule out variance at this sample size. @@ -154,7 +154,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionControll "press": PressAndContainTactic(), "defense": ShadowAndMarkTactic(), }, - partitioner=_tiki_taka_plus_picker, + partitioner=_weaver_picker, outfield_robot_ids=outfield_robot_ids, ctx=ctx, ) diff --git a/utama_core/strategy/high_press.py b/utama_core/strategy/wolfpack.py similarity index 88% rename from utama_core/strategy/high_press.py rename to utama_core/strategy/wolfpack.py index 51648ed0..2ef2929b 100644 --- a/utama_core/strategy/high_press.py +++ b/utama_core/strategy/wolfpack.py @@ -1,4 +1,4 @@ -"""The `high_press` kernel strategy: `high_press` and the pickers only it uses.""" +"""`wolfpack` (until 2026-11-12 `high_press`): hunts the ball high up as a group, a fixed 80/20 attack-heavy split. The pickers only it uses are here.""" from __future__ import annotations @@ -13,7 +13,7 @@ def build(outfield_robot_ids: tuple[int, ...], motion_controller: MotionController) -> KernelSchedulerStrategy: """5-robot (or fewer) `Strategy` factory: an aggressive, *non-reactive* posture — most of the pool commits forward regardless of who has the - ball, unlike `press_and_pass`'s possession-edge + ball, unlike `terrier`'s possession-edge split. Wires the same `GiveAndGoTactic`/`PressAndContainTactic` pair as that config, but the two are not interchangeable: the point here is to demonstrate that the same Tactic set can be driven by a mechanically diff --git a/utama_core/tactics/block_shape.py b/utama_core/tactics/block_shape.py index 8260a0f4..9846c293 100644 --- a/utama_core/tactics/block_shape.py +++ b/utama_core/tactics/block_shape.py @@ -23,7 +23,7 @@ sense as a "slow the carrier down" standoff, which is meaningless once there is no carrier at all; without this a loose ball near (but wide of) our own box just sits there with the first defender parked on an axis nobody is threatening. - Found live: a `clear_danger` vs `low_block`-shaped match pinned 28 seconds this + Found live: a `firebreak` vs `low_block`-shaped match pinned 28 seconds this way (see `tactics/defense.py`'s matching fix for the sibling case in `DefenseTactic`). - **screen** (everyone else): holds the line at `_SCREEN_OFFSET` in front of our diff --git a/utama_core/tactics/defense.py b/utama_core/tactics/defense.py index 5a85413b..e651808b 100644 --- a/utama_core/tactics/defense.py +++ b/utama_core/tactics/defense.py @@ -13,7 +13,7 @@ Exception: a loose ball with no enemy contesting it (see `ball_is_loose`) never gets shadowed at all — shadowing only ever reacts to the ball's current position, so an abandoned ball just sits there forever with a -defender parked a shot-shadow's distance away. Found live: a `clear_danger` +defender parked a shot-shadow's distance away. Found live: a `firebreak` vs `low_block` match pinned 28 straight seconds this way, ball dead in a corner near `low_block`'s own goal line, three defenders standing 1.1-1.5m away all still shadowing a shot no one was taking. The nearest diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index a06d2b8e..fa7a3f76 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -208,7 +208,7 @@ def _relocate_target(game: Game, robot_id: int, avoid: list[Vector2D]) -> Vector team always attacks toward `+x` — for `my_team_is_right=False` (attacking `-x`), every candidate this produced sat *behind* the ball, toward this team's own goal, not ahead of it. Found live investigating a real "these - strategies never shoot" bug (`high_press`/`overload_flow`/ + strategies never shoot" bug (`wolfpack`/`overload_flow`/ `score_aware_zone_flow`, 2026-09-05, `docs/roadmap.md`): traced replay showed `give_and_go.shot_lane.open=True` 132 times in one match, yet the carrier's x-position never advanced past -1.10 toward a goal at -4.5 — diff --git a/utama_core/tactics/lead_and_support.py b/utama_core/tactics/lead_and_support.py index b99845e2..3adf4dad 100644 --- a/utama_core/tactics/lead_and_support.py +++ b/utama_core/tactics/lead_and_support.py @@ -73,7 +73,7 @@ def _candidate_support_points(game: Game, count: int) -> list[Vector2D]: # boundary itself, right through the enemy defense area — an outfield # robot standing there is an attacker-infringement foul # (`DefenseAreaRule`). Found via 20 `defense_area` fouls in one live - # match (`overload_press`'s "counter" slot uses this tactic on every + # match (`avalanche`'s "counter" slot uses this tactic on every # tick it doesn't have the ball). Clamp the deep edge with the same # box-avoidance helper `decoy_and_overload.py`'s `_overload_target` uses. clamped_edge = clamp_outside_enemy_defense_area(game, Vector2D(x_hi, 0.0)).x diff --git a/utama_core/tactics/press_and_contain.py b/utama_core/tactics/press_and_contain.py index 22901fd1..ab5c7550 100644 --- a/utama_core/tactics/press_and_contain.py +++ b/utama_core/tactics/press_and_contain.py @@ -55,7 +55,7 @@ # then away, then back, several times a second, until the unstable contact # knocked the ball out of bounds — mirrors the same "sticky edge" fix # `friendly_closer_to_ball`-consuming pickers already needed, see -# `counter_flow.py`'s `_counter_flow_picker`/`high_line_zone.py`'s `_high_line_zone_picker`). +# `riptide.py`'s `_riptide_picker`/`high_line_zone.py`'s `_high_line_zone_picker`). # Require the *opposite* classification to hold for this many consecutive # ticks before actually switching mode. _LOOSE_BALL_HYSTERESIS_TICKS = 15 # 0.25s at 60Hz — enough to reject single-tick flicker, short enough to react promptly once a contest genuinely resolves diff --git a/utama_core/tactics/switch_of_play.py b/utama_core/tactics/switch_of_play.py index 393e0d76..e00243b2 100644 --- a/utama_core/tactics/switch_of_play.py +++ b/utama_core/tactics/switch_of_play.py @@ -494,7 +494,7 @@ def tick( # open, otherwise carry it toward one (`_score_goal`), so "assess" # never advancing past itself is fine. It used to hold the ball # where it stood, which held it forever: at its own corner free - # kicks overload_press's lone switch robot stopped 0.13 m from the + # kicks avalanche's lone switch robot stopped 0.13 m from the # ball (inside the visual has_ball box, short of contact) for 10 s # until no_progress, with the overload slot committed and waiting # (tournament_20261005_170958: vs split_shape t=479, vs three_slot diff --git a/utama_core/tests/bundle/test_strategy_file.py b/utama_core/tests/bundle/test_strategy_file.py index 872a13f6..76c4cded 100644 --- a/utama_core/tests/bundle/test_strategy_file.py +++ b/utama_core/tests/bundle/test_strategy_file.py @@ -22,7 +22,7 @@ from utama_core.replay.fingerprint import CodeGraph from utama_core.strategy import catalog -STRATEGY = "split_shape" +STRATEGY = "pendulum" def _robot(rid: int, friendly: bool, x: float, y: float) -> Robot: @@ -115,7 +115,7 @@ def test_a_bundle_holds_its_code_and_no_tests(tmp_path): with zipfile.ZipFile(path) as archive: names = set(archive.namelist()) manifest = json.loads(archive.read("manifest.json")) - assert {"utama_core/bundle/host.py", "utama_core/strategy/split_shape.py"} <= names + assert {"utama_core/bundle/host.py", "utama_core/strategy/pendulum.py"} <= names assert not any(name.startswith("utama_core/tests/") for name in names) assert manifest["strategy"] == STRATEGY and manifest["format"] == strategy_file.FORMAT_VERSION @@ -127,7 +127,7 @@ def test_a_strategy_that_does_not_exist_is_refused(tmp_path): def test_a_frozen_file_is_named_after_its_commit_and_never_rebuilt(tmp_path): first = strategy_file.frozen(STRATEGY, "HEAD", tmp_path) - assert first.name == f"split_shape@{strategy_file._commit_of('HEAD')[:8]}.strategy" + assert first.name == f"pendulum@{strategy_file._commit_of('HEAD')[:8]}.strategy" first.write_bytes(b"kept") assert strategy_file.frozen(STRATEGY, "HEAD", tmp_path).read_bytes() == b"kept" @@ -168,7 +168,7 @@ def test_what_a_file_adds_around_the_code_is_not_part_of_the_player(tmp_path, mo @pytest.mark.parametrize( "member", [ - "utama_core/strategy/split_shape.py", + "utama_core/strategy/pendulum.py", "utama_core/skills/src/go_to_ball.py", "utama_core/motion_planning/src/common/control_schemes.py", ], @@ -182,8 +182,8 @@ def test_a_file_of_different_code_is_a_different_player(tmp_path, monkeypatch, m def test_a_frozen_player_and_the_same_strategy_today_get_different_match_tags(): - assert match._short_name("replays/eval/frozen/split_shape@09493fd2.strategy") == "split_shape@09493fd2" - assert match._short_name(STRATEGY) == "split_shape" + assert match._short_name("replays/eval/frozen/pendulum@09493fd2.strategy") == "pendulum@09493fd2" + assert match._short_name(STRATEGY) == "pendulum" class _Commands: @@ -312,7 +312,7 @@ def test_the_runner_reads_the_same_from_a_bundled_strategy_as_from_the_same_stra def test_a_strategy_file_is_named_like_any_strategy(): - names = round_robin._resolve_config_names(["split_shape", "replays/x@abc.strategy"]) + names = round_robin._resolve_config_names(["pendulum", "replays/x@abc.strategy"]) assert names == [STRATEGY, "replays/x@abc.strategy"] diff --git a/utama_core/tests/custom_referee/test_stage_advance.py b/utama_core/tests/custom_referee/test_stage_advance.py index b1448bd4..6ececfd8 100644 --- a/utama_core/tests/custom_referee/test_stage_advance.py +++ b/utama_core/tests/custom_referee/test_stage_advance.py @@ -180,7 +180,7 @@ def test_an_operator_profile_ends_no_half_itself(): def test_late_in_half_means_the_last_minute_of_playing_time_not_of_sim_time(): - """strategy.pickers.is_late_in_half (score_aware_counter_flow, score_aware_zone_flow): with the + """strategy.pickers.is_late_in_half (chameleon, score_aware_zone_flow): with the clock counting sim time and stopping at 0, a 600 s round-robin match was "late" from 240 s of sim time to the end.""" from types import SimpleNamespace diff --git a/utama_core/tests/dashboard/test_tournament_view.py b/utama_core/tests/dashboard/test_tournament_view.py index 35a0b34f..74074471 100644 --- a/utama_core/tests/dashboard/test_tournament_view.py +++ b/utama_core/tests/dashboard/test_tournament_view.py @@ -21,7 +21,7 @@ def test_each_match_carries_the_path_of_its_replay_when_the_file_exists(tmp_path tmp_path, [ {"config_a": "low_block", "config_b": "three_slot"}, - {"config_a": "tiki_taka", "config_b": "counter_flow"}, + {"config_a": "tiki_taka", "config_b": "riptide"}, ], ) (run / "low_block_vs_three_slot.npz").write_bytes(b"") diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index 1bf9f584..f61d60a5 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -1,9 +1,9 @@ """Comprehensive, table-driven tests over every strategy in `utama_core/strategy/`. -Replaces the earlier one-file-per-config pattern (`test_split_shape_kernel_strategy.py`, -`test_press_and_pass_kernel_strategy.py`, `test_high_press_kernel_strategy.py`, -`test_give_and_go_solo_kernel_strategy.py`), each of which re-asserted the same +Replaces the earlier one-file-per-config pattern (`test_pendulum_kernel_strategy.py`, +`test_terrier_kernel_strategy.py`, `test_wolfpack_kernel_strategy.py`, +`test_ricochet_kernel_strategy.py`), each of which re-asserted the same handful of generic properties ("builds a Strategy", "runs N ticks without error", "partition covers every outfield robot", "goalkeeper stays pinned") around a near-identical `StrategyRunner`/rsim fixture. A single parametrized @@ -28,11 +28,11 @@ from utama_core.engine.strategy import Strategy from utama_core.entities.data.object import TeamType from utama_core.strategy import catalog +from utama_core.strategy.breakwater import _breakwater_picker from utama_core.strategy.catalog import builder -from utama_core.strategy.clear_danger import _clear_danger_picker -from utama_core.strategy.clear_press_plus import _clear_press_plus_picker -from utama_core.strategy.counter_flow import _counter_flow_picker +from utama_core.strategy.firebreak import _firebreak_picker from utama_core.strategy.pickers import fixed_ratio_picker +from utama_core.strategy.riptide import _riptide_picker _OUTFIELD_IDS = (1, 2, 3, 4, 5) @@ -70,7 +70,7 @@ def _make(name): def test_partitions_every_outfield_robot_and_never_the_keeper_for_30_ticks(name, make_runner): """30 ticks, not 5-10: enough for PressAndContainTactic's applicable() to plausibly flip in configs that use it, exercising the exact hazard - `_press_and_pass_split_picker`/`_three_way_picker` exist to avoid (a + `_terrier_split_picker`/`_three_way_picker` exist to avoid (a Partitioner proposing robots for a currently-inapplicable tactic).""" runner = make_runner(name) strategy = runner.my.strategy @@ -90,7 +90,7 @@ def test_partitions_every_outfield_robot_and_never_the_keeper_for_30_ticks(name, _NOBODY_ON_BALL = SimpleNamespace(friendly_robots={}) -def test_fixed_ratio_picker_high_press_split(): +def test_fixed_ratio_picker_wolfpack_split(): picker = fixed_ratio_picker("attack", "defense", attack_fraction=0.8) partition = picker( game=_NOBODY_ON_BALL, @@ -118,8 +118,8 @@ def test_fixed_ratio_picker_defense_heavy_split_respects_min_attack_floor(): assert len(partition["defense"]) == 3 -def test_give_and_go_solo_always_assigns_everyone_to_attack(make_runner): - runner = make_runner("give_and_go_solo") +def test_ricochet_always_assigns_everyone_to_attack(make_runner): + runner = make_runner("ricochet") runner.step_once() partition = runner.my.strategy._kernel_strategy.active_partition assert partition == {"attack": frozenset(_OUTFIELD_IDS)} @@ -166,10 +166,10 @@ def _stub_game(friendly_dist, enemy_dist, ball_x: float, my_team_is_right: bool _CLEAR_ALL = frozenset({"attack", "press", "block", "clear"}) -def test_clear_danger_valve_takes_one_robot_when_applicable(): +def test_firebreak_valve_takes_one_robot_when_applicable(): """Danger read fires (kernel reports 'clear' applicable): 1 clearer + block screen with the rest, regardless of the possession edge.""" - partition = _clear_danger_picker( + partition = _firebreak_picker( _stub_game(friendly_dist=2.0, enemy_dist=0.3, ball_x=3.0), # losing, deep _FIVE, None, @@ -180,8 +180,8 @@ def test_clear_danger_valve_takes_one_robot_when_applicable(): assert frozenset().union(*partition.values()) == _FIVE -def test_clear_danger_valve_folds_everyone_in_when_block_unavailable(): - partition = _clear_danger_picker( +def test_firebreak_valve_folds_everyone_in_when_block_unavailable(): + partition = _firebreak_picker( _stub_game(friendly_dist=2.0, enemy_dist=0.3, ball_x=3.0), _FIVE, None, @@ -190,8 +190,8 @@ def test_clear_danger_valve_folds_everyone_in_when_block_unavailable(): assert partition == {"clear": _FIVE} -def test_clear_danger_uses_counter_flow_press_posture_when_lost_no_danger(): - partition = _clear_danger_picker( +def test_firebreak_uses_riptide_press_posture_when_lost_no_danger(): + partition = _firebreak_picker( _stub_game(friendly_dist=1.5, enemy_dist=0.2, ball_x=0.0), _FIVE, None, @@ -201,8 +201,8 @@ def test_clear_danger_uses_counter_flow_press_posture_when_lost_no_danger(): assert len(partition["block"]) == 2 -def test_clear_danger_attacks_with_three_when_won_no_danger(): - partition = _clear_danger_picker( +def test_firebreak_attacks_with_three_when_won_no_danger(): + partition = _firebreak_picker( _stub_game(friendly_dist=0.3, enemy_dist=1.5, ball_x=0.0), _FIVE, None, @@ -212,12 +212,12 @@ def test_clear_danger_attacks_with_three_when_won_no_danger(): assert len(partition["block"]) == 2 -def test_clear_danger_attack_stays_on_unknown_possession_edge(): - """Sticky possession edge (same fix counter_flow/high_line_zone needed): +def test_firebreak_attack_stays_on_unknown_possession_edge(): + """Sticky possession edge (same fix riptide/high_line_zone needed): while we held attack last tick, an unreadable edge must not reset the give-and-go trio — only a clear loss (enemy strictly closer) does.""" prev = {"attack": frozenset({1, 2, 3}), "block": frozenset({4, 5})} - partition = _clear_danger_picker( + partition = _firebreak_picker( _stub_game(friendly_dist=None, enemy_dist=None, ball_x=0.0), _FIVE, prev, @@ -226,11 +226,11 @@ def test_clear_danger_attack_stays_on_unknown_possession_edge(): assert len(partition["attack"]) == 3 -def test_clear_danger_valve_overrides_standing_attack(): +def test_firebreak_valve_overrides_standing_attack(): """Danger fires while we were attacking last tick: the valve still takes its robot — danger is depth+pressure, not just possession.""" prev = {"attack": frozenset({1, 2, 3}), "block": frozenset({4, 5})} - partition = _clear_danger_picker( + partition = _firebreak_picker( _stub_game(friendly_dist=0.5, enemy_dist=1.5, ball_x=3.0), # we're closer BUT deep+contested _FIVE, prev, @@ -249,10 +249,10 @@ def test_clear_danger_valve_overrides_standing_attack(): # picker now decides from the possession edge alone. -def test_clear_danger_ignores_a_prior_clear_robot_missing_from_the_free_pool(): +def test_firebreak_ignores_a_prior_clear_robot_missing_from_the_free_pool(): free = frozenset({2, 3, 4, 5}) # robot 1 held "clear" last tick, is not free now prev = {"clear": frozenset({1})} - partition = _clear_danger_picker( + partition = _firebreak_picker( _stub_game(friendly_dist=0.2, enemy_dist=1.5, ball_x=0.0), # we're closer: attack free, prev, @@ -262,10 +262,10 @@ def test_clear_danger_ignores_a_prior_clear_robot_missing_from_the_free_pool(): assert len(partition["block"]) == 1 -def test_clear_press_plus_ignores_a_prior_clear_robot_missing_from_the_free_pool(): +def test_breakwater_ignores_a_prior_clear_robot_missing_from_the_free_pool(): free = frozenset({2, 3, 4, 5}) prev = {"clear": frozenset({1})} - partition = _clear_press_plus_picker( + partition = _breakwater_picker( _stub_game(friendly_dist=0.2, enemy_dist=1.5, ball_x=0.0), free, prev, @@ -290,13 +290,13 @@ def _clear_game(positions: dict[int, tuple[float, float]], carrier: int | None = _SPREAD = {1: (-2.0, 1.0), 2: (0.0, -1.0), 3: (1.0, 1.0), 4: (2.7, 0.2), 5: (-1.0, 0.0)} -def test_clear_danger_valve_goes_to_the_robot_nearest_the_ball(): - partition = _clear_danger_picker(_clear_game(_SPREAD), _FIVE, None, _CLEAR_ALL) +def test_firebreak_valve_goes_to_the_robot_nearest_the_ball(): + partition = _firebreak_picker(_clear_game(_SPREAD), _FIVE, None, _CLEAR_ALL) assert partition["clear"] == frozenset({4}) -def test_clear_press_plus_valve_goes_to_the_robot_nearest_the_ball(): - partition = _clear_press_plus_picker(_clear_game(_SPREAD), _FIVE, None, _CLEAR_ALL | {"overload"}) +def test_breakwater_valve_goes_to_the_robot_nearest_the_ball(): + partition = _breakwater_picker(_clear_game(_SPREAD), _FIVE, None, _CLEAR_ALL | {"overload"}) assert partition["clear"] == frozenset({4}) @@ -304,13 +304,13 @@ def test_clear_valve_keeps_the_carrier_even_when_another_robot_is_nearer(): # Robot 2 holds the ball (so it is first from `carrier_first`); robot 4 happens to # be nearer the ball's reported position. The carrier keeps the clearance. game = _clear_game(_SPREAD, carrier=2) - assert _clear_danger_picker(game, _FIVE, None, _CLEAR_ALL)["clear"] == frozenset({2}) - assert _clear_press_plus_picker(game, _FIVE, None, _CLEAR_ALL | {"overload"})["clear"] == frozenset({2}) + assert _firebreak_picker(game, _FIVE, None, _CLEAR_ALL)["clear"] == frozenset({2}) + assert _breakwater_picker(game, _FIVE, None, _CLEAR_ALL | {"overload"})["clear"] == frozenset({2}) def test_clear_valve_breaks_a_distance_tie_by_lowest_id(): tied = {1: (2.0, 1.0), 2: (2.0, -1.0), 3: (-2.0, 0.0), 4: (-2.0, 1.0), 5: (-2.0, -1.0)} - partition = _clear_danger_picker(_clear_game(tied), _FIVE, None, _CLEAR_ALL) + partition = _firebreak_picker(_clear_game(tied), _FIVE, None, _CLEAR_ALL) assert partition["clear"] == frozenset({1}) @@ -319,28 +319,28 @@ def test_clear_valve_breaks_a_distance_tie_by_lowest_id(): _COUNTER_FLOW_ALL = frozenset({"attack", "press", "block"}) -def test_counter_flow_keeps_attack_through_a_near_tie_for_the_ball(): +def test_riptide_keeps_attack_through_a_near_tie_for_the_ball(): """Friendly 3 cm behind the nearest enemy is inside `CLOSER_TO_BALL_MARGIN`: undecided, so a side that held attack last tick keeps it (the documented hysteresis). `friendly_closer_to_ball` used to return False here, which dropped attack on noise-level gaps.""" prev = {"attack": frozenset({1, 2, 3}), "block": frozenset({4, 5})} - partition = _counter_flow_picker( + partition = _riptide_picker( _stub_game(friendly_dist=0.33, enemy_dist=0.30, ball_x=0.0), _FIVE, prev, _COUNTER_FLOW_ALL ) assert len(partition["attack"]) == 3 -def test_counter_flow_without_prior_attack_stays_conservative_on_a_near_tie(): - partition = _counter_flow_picker( +def test_riptide_without_prior_attack_stays_conservative_on_a_near_tie(): + partition = _riptide_picker( _stub_game(friendly_dist=0.33, enemy_dist=0.30, ball_x=0.0), _FIVE, {}, _COUNTER_FLOW_ALL ) assert "attack" not in partition -def test_counter_flow_drops_attack_on_a_clear_loss(): +def test_riptide_drops_attack_on_a_clear_loss(): prev = {"attack": frozenset({1, 2, 3}), "block": frozenset({4, 5})} - partition = _counter_flow_picker( + partition = _riptide_picker( _stub_game(friendly_dist=0.5, enemy_dist=0.30, ball_x=0.0), _FIVE, prev, _COUNTER_FLOW_ALL ) assert "attack" not in partition diff --git a/utama_core/tests/engine/test_give_and_go_tactic.py b/utama_core/tests/engine/test_give_and_go_tactic.py index ad3d3fa8..67926b44 100644 --- a/utama_core/tests/engine/test_give_and_go_tactic.py +++ b/utama_core/tests/engine/test_give_and_go_tactic.py @@ -359,7 +359,7 @@ def test_first_touch_stuck_eventually_force_shoots_instead_of_repositioning_fore # --------------------------------------------------------------------------- # # Found live investigating a real "these strategies never shoot" bug -# (high_press/overload_flow/score_aware_zone_flow, 2026-09-05, +# (wolfpack/overload_flow/score_aware_zone_flow, 2026-09-05, # docs/roadmap.md): `_relocate_target` generated candidates at # `ball_x + dx` with hardcoded positive `dx` -- correct for a team attacking # +x, but for `my_team_is_right=True` (this codebase's convention: the enemy diff --git a/utama_core/tests/engine/test_kernel_strategy_debug_status.py b/utama_core/tests/engine/test_kernel_strategy_debug_status.py index 7aa47943..cfc06c37 100644 --- a/utama_core/tests/engine/test_kernel_strategy_debug_status.py +++ b/utama_core/tests/engine/test_kernel_strategy_debug_status.py @@ -15,10 +15,10 @@ @pytest.fixture -def split_shape_runner(): +def pendulum_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -32,9 +32,9 @@ def split_shape_runner(): runner.close() -def test_debug_status_covers_goalkeeper_and_all_outfield_robots(split_shape_runner): - split_shape_runner.step_once() - strategy = split_shape_runner.my.strategy +def test_debug_status_covers_goalkeeper_and_all_outfield_robots(pendulum_runner): + pendulum_runner.step_once() + strategy = pendulum_runner.my.strategy status = strategy.debug_status() assert status[0][:2] == ["goalkeeper", ""] @@ -43,9 +43,9 @@ def test_debug_status_covers_goalkeeper_and_all_outfield_robots(split_shape_runn assert len(status[robot_id]) == 3 # [label, tag, steps] -def test_debug_status_labels_match_active_partition(split_shape_runner): - split_shape_runner.step_once() - strategy = split_shape_runner.my.strategy +def test_debug_status_labels_match_active_partition(pendulum_runner): + pendulum_runner.step_once() + strategy = pendulum_runner.my.strategy status = strategy.debug_status() partition = strategy._kernel_strategy.active_partition @@ -54,10 +54,10 @@ def test_debug_status_labels_match_active_partition(split_shape_runner): assert status[robot_id][0].startswith(tactic_id) -def test_slot_status_reports_committed_flag(split_shape_runner): - split_shape_runner.step_once() - strategy = split_shape_runner.my.strategy - game = split_shape_runner.my.game +def test_slot_status_reports_committed_flag(pendulum_runner): + pendulum_runner.step_once() + strategy = pendulum_runner.my.strategy + game = pendulum_runner.my.game status = strategy._kernel_strategy.slot_status(game) for tactic_id, info in status.items(): @@ -65,12 +65,12 @@ def test_slot_status_reports_committed_flag(split_shape_runner): assert info["robots"] -def test_debug_status_tag_is_the_assigned_tactics_own_tag(split_shape_runner): +def test_debug_status_tag_is_the_assigned_tactics_own_tag(pendulum_runner): # The dashboard colours each robot by this second element, so it must be the tag the # tactic currently holding the robot declares, not a per-robot or per-strategy guess. - split_shape_runner.step_once() - strategy = split_shape_runner.my.strategy - game = split_shape_runner.my.game + pendulum_runner.step_once() + strategy = pendulum_runner.my.strategy + game = pendulum_runner.my.game status = strategy.debug_status() for tactic_id, info in strategy._kernel_strategy.slot_status(game).items(): @@ -84,7 +84,7 @@ def test_debug_status_leaves_out_a_goalkeeper_whose_robot_is_not_on_the_field(): phantom "goalkeeper" row for a robot ID that is not there.""" from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build=builder("split_shape", (0, 1)), goalkeeper_id=15) + strategy = AbstractStrategy(build=builder("pendulum", (0, 1)), goalkeeper_id=15) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, my_team_is_right=True, mode="rsim", exp_friendly=2, exp_enemy=0 ) @@ -98,14 +98,14 @@ def test_debug_status_leaves_out_a_goalkeeper_whose_robot_is_not_on_the_field(): def _refereed_runner(command, notifier=None): - """`split_shape` under our own referee, seeded with `command`; `notifier` stands in for a dashboard.""" + """`pendulum` under our own referee, seeded with `command`; `notifier` stands in for a dashboard.""" from utama_core.custom_referee import CustomReferee from utama_core.run.strategy_runner import StrategyRunner referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=6, n_robots_blue=3) if notifier is not None: referee.attach_dashboard_notifier(notifier) - strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) return StrategyRunner( strategy=strategy, my_team_is_yellow=True, diff --git a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py index e671cd28..41a3a1f2 100644 --- a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py +++ b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py @@ -59,10 +59,10 @@ def _set_referee_command( @pytest.fixture -def split_shape_runner(): +def pendulum_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -87,7 +87,7 @@ def nonzero_keeper_runner(): from utama_core.run.strategy_runner import StrategyRunner strategy = AbstractStrategy( - build=builder("split_shape", (0, 1, 2, 4, 5)), + build=builder("pendulum", (0, 1, 2, 4, 5)), goalkeeper_id=3, ) runner = StrategyRunner( @@ -181,23 +181,23 @@ def test_their_kickoff_nonzero_keeper_is_never_in_defensive_wall(nonzero_keeper_ assert dist_to_ball >= BALL_KEEP_OUT_DISTANCE - 0.05, f"non-keeper robot {rid} inside centre keep-out zone" -def test_our_kickoff_default_keeper_id_zero_still_exempt(split_shape_runner): +def test_our_kickoff_default_keeper_id_zero_still_exempt(pendulum_runner): """Regression check for the common case: with the default `goalkeeper_id=0` (matching `TeamInfo`'s default `goalkeeper=0`), robot 0 must still be excluded from both kicker-selection and the support formation — this isn't relying on "any non-zero ID," it must hold for the original id-0 case too. As with the non-zero-keeper tests above, "exempt" means "goes to GoalkeeperTactic's own-goal tracking," not "frozen.\" """ - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() - split_shape_runner.sim_controller.teleport_robot(True, 0, -3.0, 2.0, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 0, -3.0, 2.0, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_KICKOFF_YELLOW, yellow_goalkeeper=0) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_KICKOFF_YELLOW, yellow_goalkeeper=0) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() keeper = game.friendly_robots[0] dist_keeper_to_ball = math.hypot(keeper.p.x - game.ball.p.x, keeper.p.y - game.ball.p.y) @@ -309,7 +309,7 @@ class _Blackboard: assert step.blackboard.cmd_map == {} -def test_their_kickoff_from_the_wrong_half_goes_round_the_centre_circle(split_shape_runner): +def test_their_kickoff_from_the_wrong_half_goes_round_the_centre_circle(pendulum_runner): """After a goal the conceding team is still in the scorer's half (STOP only clears robots near the ball). At PREPARE_KICKOFF they drove straight at their own-half spots through the centre circle and lingered inside the keep-out radius, so @@ -321,7 +321,7 @@ def test_their_kickoff_from_the_wrong_half_goes_round_the_centre_circle(split_sh from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.custom_referee.rules.keep_out_rule import KeepOutRule - runner = split_shape_runner + runner = pendulum_runner game = runner.my.game runner.step_once() # my_team_is_right=True: our half is +x. Line the outfield robots up in the diff --git a/utama_core/tests/engine/test_referee_override.py b/utama_core/tests/engine/test_referee_override.py index 6fa31bcf..c88e8b66 100644 --- a/utama_core/tests/engine/test_referee_override.py +++ b/utama_core/tests/engine/test_referee_override.py @@ -39,10 +39,10 @@ @pytest.fixture -def split_shape_runner(): +def pendulum_runner(): from utama_core.run.strategy_runner import StrategyRunner - strategy = AbstractStrategy(build=builder("split_shape", (1, 2, 3, 4, 5))) + strategy = AbstractStrategy(build=builder("pendulum", (1, 2, 3, 4, 5))) runner = StrategyRunner( strategy=strategy, my_team_is_yellow=True, @@ -92,22 +92,22 @@ def _set_referee_command(runner, command: RefereeCommand, designated_position=No _CLEAR_OF_BALL = 0.2 -def test_their_ball_placement_clears_our_robots_from_keep_out_zone(split_shape_runner): +def test_their_ball_placement_clears_our_robots_from_keep_out_zone(pendulum_runner): """During the opponent's ball placement, a robot starting inside the keep-out zone around the ball moves outside it — a plain tactic tick has no notion of this rule and would just leave it there or drive it closer.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() ball_x, ball_y = game.ball.p.x, game.ball.p.y - split_shape_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) - split_shape_runner.step_once() # let the teleport land in game state + pendulum_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) + pendulum_runner.step_once() # let the teleport land in game state designated = (1.5, 0.0) - _set_referee_command(split_shape_runner, RefereeCommand.BALL_PLACEMENT_BLUE, designated_position=designated) + _set_referee_command(pendulum_runner, RefereeCommand.BALL_PLACEMENT_BLUE, designated_position=designated) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot_id, robot in game.friendly_robots.items(): @@ -117,21 +117,21 @@ def test_their_ball_placement_clears_our_robots_from_keep_out_zone(split_shape_r assert dist_to_spot >= BALL_KEEP_OUT_DISTANCE - 0.05, f"robot {robot_id} too close to designated spot" -def test_their_kickoff_clears_our_robots_outside_center_circle(split_shape_runner): +def test_their_kickoff_clears_our_robots_outside_center_circle(pendulum_runner): """A robot starting at the centre spot for the opponent's kickoff moves outside the keep-out radius.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() # Inside the keep-out radius but clear of the ball: a robot teleported onto # the ball knocks it off the spot, and where it stops then decides the test. - split_shape_runner.sim_controller.teleport_robot(True, 1, _CLEAR_OF_BALL, 0.0, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, _CLEAR_OF_BALL, 0.0, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_KICKOFF_BLUE) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_KICKOFF_BLUE) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p assert math.hypot(ball.x, ball.y) < 0.05, "ball left the centre spot" @@ -140,25 +140,25 @@ def test_their_kickoff_clears_our_robots_outside_center_circle(split_shape_runne assert dist_to_ball >= BALL_KEEP_OUT_DISTANCE - 0.05, f"robot {robot_id} inside centre keep-out zone" -def test_override_ends_and_tactics_resume_on_normal_start(split_shape_runner): +def test_override_ends_and_tactics_resume_on_normal_start(pendulum_runner): """Once NORMAL_START arrives after a restart, tactics tick again (mem was reset by the barrier transition on the way in) instead of the override continuing to hold every robot in place forever. Our own kick-off: after the opponent's, the hold lasts until their kicker moves the ball (5.4).""" - strategy = split_shape_runner.my.strategy + strategy = pendulum_runner.my.strategy - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_KICKOFF_YELLOW) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_KICKOFF_YELLOW) for _ in range(50): - split_shape_runner.step_once() + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.NORMAL_START) - split_shape_runner.step_once() + _set_referee_command(pendulum_runner, RefereeCommand.NORMAL_START) + pendulum_runner.step_once() partition = strategy._kernel_strategy.active_partition assert partition, "tactics never resumed after the restart ended" -def test_back_to_back_restarts_dispatch_a_fresh_step_each_time(split_shape_runner): +def test_back_to_back_restarts_dispatch_a_fresh_step_each_time(pendulum_runner): """A second restart arriving without an intervening NORMAL_START (e.g. a kickoff foul immediately becoming a ball placement) must dispatch to the *new* command's Step, not keep re-running the first command's Step just @@ -174,23 +174,23 @@ def test_back_to_back_restarts_dispatch_a_fresh_step_each_time(split_shape_runne for "did the override switch commands," even though the switch itself is correct and instant. """ - game = split_shape_runner.my.game - strategy = split_shape_runner.my.strategy._kernel_strategy - split_shape_runner.step_once() + game = pendulum_runner.my.game + strategy = pendulum_runner.my.strategy._kernel_strategy + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_KICKOFF_BLUE) - split_shape_runner.step_once() + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_KICKOFF_BLUE) + pendulum_runner.step_once() kickoff_commands = strategy.tick(game) # No NORMAL_START in between — straight into a second, different restart. - _set_referee_command(split_shape_runner, RefereeCommand.BALL_PLACEMENT_BLUE, designated_position=(1.0, 1.0)) - split_shape_runner.step_once() + _set_referee_command(pendulum_runner, RefereeCommand.BALL_PLACEMENT_BLUE, designated_position=(1.0, 1.0)) + pendulum_runner.step_once() placement_commands = strategy.tick(game) assert kickoff_commands != placement_commands, "override did not re-dispatch for the second restart command" -def test_stop_clears_an_encroaching_robot_from_the_keep_out_zone(split_shape_runner): +def test_stop_clears_an_encroaching_robot_from_the_keep_out_zone(pendulum_runner): """STOP is an override command now, not a pure freeze (see `referee_override.py`'s module docstring): a robot already inside the ball keep-out radius at the moment STOP is entered must actively move @@ -198,17 +198,17 @@ def test_stop_clears_an_encroaching_robot_from_the_keep_out_zone(split_shape_run `CustomReferee`'s own STOP-to-queued-restart auto-advance requires every robot to clear `BALL_KEEP_OUT_DISTANCE` first, which a frozen encroaching robot can never satisfy.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() ball_x, ball_y = game.ball.p.x, game.ball.p.y - split_shape_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.STOP) + _set_referee_command(pendulum_runner, RefereeCommand.STOP) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot_id, robot in game.friendly_robots.items(): @@ -216,23 +216,23 @@ def test_stop_clears_an_encroaching_robot_from_the_keep_out_zone(split_shape_run assert dist_to_ball >= BALL_KEEP_OUT_DISTANCE - 0.05, f"robot {robot_id} too close to ball during STOP" -def test_timeout_clears_an_encroaching_robot_from_the_keep_out_zone(split_shape_runner): +def test_timeout_clears_an_encroaching_robot_from_the_keep_out_zone(pendulum_runner): """TIMEOUT_YELLOW/BLUE is also an override command, routed to `StopStep` exactly like STOP (see `referee_override.py`'s module docstring). It was once wired into neither `is_paused` nor `is_override_command`, so a timeout left tactics ticking and issuing ordinary motion commands straight through it.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() ball_x, ball_y = game.ball.p.x, game.ball.p.y - split_shape_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, ball_x + _CLEAR_OF_BALL, ball_y, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.TIMEOUT_YELLOW) + _set_referee_command(pendulum_runner, RefereeCommand.TIMEOUT_YELLOW) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot_id, robot in game.friendly_robots.items(): @@ -240,20 +240,20 @@ def test_timeout_clears_an_encroaching_robot_from_the_keep_out_zone(split_shape_ assert dist_to_ball >= BALL_KEEP_OUT_DISTANCE - 0.05, f"robot {robot_id} too close to ball during TIMEOUT" -def test_goalkeeper_stops_during_halt(split_shape_runner): +def test_goalkeeper_stops_during_halt(pendulum_runner): """The goalkeeper must stop issuing motion commands during HALT, same as the outfield pool (`Strategy.tick()`'s `is_paused` check) — it must not keep chasing the ball just because it's ticked outside `Strategy`.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.HALT) + _set_referee_command(pendulum_runner, RefereeCommand.HALT) for _ in range(30): # let residual velocity from before HALT decay first - split_shape_runner.step_once() + pendulum_runner.step_once() gk_pos_before = (game.friendly_robots[0].p.x, game.friendly_robots[0].p.y) for _ in range(20): - split_shape_runner.step_once() + pendulum_runner.step_once() gk_pos_after = (game.friendly_robots[0].p.x, game.friendly_robots[0].p.y) dist_moved = math.hypot(gk_pos_after[0] - gk_pos_before[0], gk_pos_after[1] - gk_pos_before[1]) @@ -267,28 +267,28 @@ def test_goalkeeper_stops_during_halt(split_shape_runner): # --------------------------------------------------------------------------- -def test_their_penalty_clears_our_robots_from_the_penalty_area(split_shape_runner): +def test_their_penalty_clears_our_robots_from_the_penalty_area(pendulum_runner): """During the opponent's penalty, PreparePenaltyTheirsStep's own two-part formation is actually reached: our goalkeeper moves to our goal line centre, and a non-keeper robot moves onto the behind-the-line formation in our own half — not just "moved somewhere far away" (there is no ball-keep-out-distance rule here at all; it's a fixed formation).""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() # Robot 0 (goalkeeper) and robot 1 both start on the wrong side of the # field entirely, so a passing test demonstrates the override actually # repositioned them rather than them already sitting somewhere plausible # — but close enough to their targets to cover the distance within the # 200-tick (~3.3s) budget this file's other tests use. - split_shape_runner.sim_controller.teleport_robot(True, 0, 2.0, 0.0, 0.0) - split_shape_runner.sim_controller.teleport_robot(True, 1, 0.5, 2.0, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 0, 2.0, 0.0, 0.0) + pendulum_runner.sim_controller.teleport_robot(True, 1, 0.5, 2.0, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_PENALTY_BLUE) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_PENALTY_BLUE) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() field = game.field # PreparePenaltyTheirsStep: our_goal_x = +half_length when my_team_is_right @@ -306,28 +306,28 @@ def test_their_penalty_clears_our_robots_from_the_penalty_area(split_shape_runne assert dist_to_line < 0.5, f"robot 1 did not reach the behind-the-line formation: dist_x={dist_to_line:.3f}m" -def test_their_penalty_defenders_never_enter_the_keep_out_circle(split_shape_runner): +def test_their_penalty_defenders_never_enter_the_keep_out_circle(pendulum_runner): """RR#6 low_block_vs_three_slot (2026-09-28, t=38.6): with the ball on the opponent's mark, four of our robots stood goal-side of it and had to reach the line 1 m behind. Robot 5 cut to 0.38 m from the ball and KeepOutRule (0.5 m) voided the penalty. Start positions are the recorded ones.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() mark = (2.25, 0.0) - split_shape_runner.sim_controller.teleport_ball(*mark) + pendulum_runner.sim_controller.teleport_ball(*mark) recorded = {0: (4.39, 0.04), 2: (3.39, 0.81), 3: (3.04, 1.01), 4: (3.64, 1.71), 5: (2.81, 0.96)} for robot_id, (x, y) in recorded.items(): - split_shape_runner.sim_controller.teleport_robot(True, robot_id, x, y, math.pi) - split_shape_runner.sim_controller.teleport_robot(False, 1, 3.24, 1.63, 0.0) - split_shape_runner.sim_controller.teleport_robot(False, 2, 3.09, -1.49, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, robot_id, x, y, math.pi) + pendulum_runner.sim_controller.teleport_robot(False, 1, 3.24, 1.63, 0.0) + pendulum_runner.sim_controller.teleport_robot(False, 2, 3.09, -1.49, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_PENALTY_BLUE) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_PENALTY_BLUE) closest = {} for _ in range(300): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot_id, robot in game.friendly_robots.items(): d = math.hypot(robot.p.x - ball.x, robot.p.y - ball.y) @@ -336,25 +336,25 @@ def test_their_penalty_defenders_never_enter_the_keep_out_circle(split_shape_run assert min(closest.values()) >= 0.5, f"closest approach to the ball per robot: {closest}" -def test_our_penalty_moves_kicker_to_the_penalty_mark(split_shape_runner): +def test_our_penalty_moves_kicker_to_the_penalty_mark(pendulum_runner): """During our own penalty, the (non-goalkeeper) kicker drives to the opponent's penalty mark — PreparePenaltyOursStep's actual target, not just "moved somewhere".""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() # Robot 1 starts far from the opponent's penalty mark. - split_shape_runner.sim_controller.teleport_robot(True, 1, -1.0, 2.0, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, -1.0, 2.0, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.PREPARE_PENALTY_YELLOW) + _set_referee_command(pendulum_runner, RefereeCommand.PREPARE_PENALTY_YELLOW) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() field = game.field # PreparePenaltyOursStep: opp_goal_x = +half_length if NOT my_team_is_right - # else -half_length. split_shape_runner has my_team_is_right=True, so the + # else -half_length. pendulum_runner has my_team_is_right=True, so the # opponent's goal (and penalty mark) is on the NEGATIVE-x side. penalty_x = -0.5 * field.full_field_half_length non_goalkeeper_ids = [rid for rid in game.friendly_robots if rid != 0] @@ -364,21 +364,21 @@ def test_our_penalty_moves_kicker_to_the_penalty_mark(split_shape_runner): assert dist_to_mark < 0.3, f"kicker (robot {kicker_id}) did not reach the penalty mark: dist={dist_to_mark:.3f}m" -def test_their_direct_free_clears_our_robots_from_ball_keep_out_zone(split_shape_runner): +def test_their_direct_free_clears_our_robots_from_ball_keep_out_zone(pendulum_runner): """During the opponent's direct free kick, a robot starting on the ball clears the keep-out radius — same observable contract as ball placement's "theirs" test above, different command family.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() ball_x, ball_y = game.ball.p.x, game.ball.p.y - split_shape_runner.sim_controller.teleport_robot(True, 1, ball_x, ball_y, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, ball_x, ball_y, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.DIRECT_FREE_BLUE) + _set_referee_command(pendulum_runner, RefereeCommand.DIRECT_FREE_BLUE) for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot_id, robot in game.friendly_robots.items(): @@ -386,23 +386,23 @@ def test_their_direct_free_clears_our_robots_from_ball_keep_out_zone(split_shape assert dist_to_ball >= BALL_KEEP_OUT_DISTANCE - 0.05, f"robot {robot_id} too close to ball" -def test_our_direct_free_moves_kicker_to_the_ball(split_shape_runner): +def test_our_direct_free_moves_kicker_to_the_ball(pendulum_runner): """During our own direct free kick, the closest robot to the ball drives to an approach position near it (DirectFreeOursStep) — the same contract `_ApproachBallManager` verifies on the BT-replacement ball-placement path, for a different command family.""" - game = split_shape_runner.my.game - split_shape_runner.step_once() + game = pendulum_runner.my.game + pendulum_runner.step_once() ball_x, ball_y = game.ball.p.x, game.ball.p.y - split_shape_runner.sim_controller.teleport_robot(True, 1, ball_x + 1.5, ball_y, 0.0) - split_shape_runner.step_once() + pendulum_runner.sim_controller.teleport_robot(True, 1, ball_x + 1.5, ball_y, 0.0) + pendulum_runner.step_once() - _set_referee_command(split_shape_runner, RefereeCommand.DIRECT_FREE_YELLOW) + _set_referee_command(pendulum_runner, RefereeCommand.DIRECT_FREE_YELLOW) dist_to_ball = math.inf for _ in range(200): - split_shape_runner.step_once() + pendulum_runner.step_once() ball = game.ball.p for robot in game.friendly_robots.values(): dist_to_ball = min(dist_to_ball, math.hypot(robot.p.x - ball.x, robot.p.y - ball.y)) diff --git a/utama_core/tests/engine/test_referee_overrides_customization.py b/utama_core/tests/engine/test_referee_overrides_customization.py index 4eb795e7..1f1184c9 100644 --- a/utama_core/tests/engine/test_referee_overrides_customization.py +++ b/utama_core/tests/engine/test_referee_overrides_customization.py @@ -23,7 +23,7 @@ `self._goalkeeper_id not in cmd_map` gate (`test_goalkeeper_ticks_normally_when_override_omits_it`) -Uses the same `split_shape_runner`/`_set_referee_command` pattern as +Uses the same `pendulum_runner`/`_set_referee_command` pattern as `test_referee_override.py` for the end-to-end cases (a real rsim `Game` via `AbstractStrategy`/`StrategyRunner`, since the override integration point — `AbstractStrategy.load_motion_controller` assigning `Strategy.referee_overrides` @@ -194,7 +194,7 @@ def kickoff_override(game, motion_controller): return {1: _SENTINEL_COMMAND} strategy = AbstractStrategy( - build=builder("split_shape", (1, 2, 3, 4, 5)), + build=builder("pendulum", (1, 2, 3, 4, 5)), referee_overrides={RefereeCommand.PREPARE_KICKOFF_YELLOW: kickoff_override}, ) runner = StrategyRunner( diff --git a/utama_core/tests/engine/test_tournament_cli_args.py b/utama_core/tests/engine/test_tournament_cli_args.py index b5518c9e..bbf6b47c 100644 --- a/utama_core/tests/engine/test_tournament_cli_args.py +++ b/utama_core/tests/engine/test_tournament_cli_args.py @@ -62,8 +62,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): "--fuzz-interval", "5", "10", - "split_shape", - "tiki_taka_plus", + "pendulum", + "weaver", ], ) @@ -94,8 +94,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): [ "tournament.py", "--sequential", - "split_shape", - "tiki_taka_plus", + "pendulum", + "weaver", ], ) @@ -126,13 +126,11 @@ def _fake_run_match(config_a_name, config_b_name, **_kwargs): return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr( - "sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "tiki_taka_plus", "split_shape"] - ) + monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "weaver", "pendulum"]) tournament.main() - assert calls == [("tiki_taka_plus", "split_shape")] + assert calls == [("weaver", "pendulum")] def test_help_prints_usage_and_plays_nothing(monkeypatch, capsys): @@ -186,8 +184,8 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): "--sequential", "--sim-noise", '{"seed": 3, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.2}', - "split_shape", - "tiki_taka_plus", + "pendulum", + "weaver", ], ) @@ -202,14 +200,12 @@ def test_match_seconds_is_part_of_the_environment_so_each_length_has_its_own_res # A shortened run's matches must not be taken for full-length ones: each match length is its own # environment in the store, and the length is recorded in the summary. monkeypatch.setattr(tournament, "run_match", _stub_result) - monkeypatch.setattr( - "sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "split_shape", "tiki_taka_plus"] - ) + monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "pendulum", "weaver"]) tournament.main() (summary_path,) = tmp_path.glob("tournament_*/summary.json") assert json.loads(summary_path.read_text())["max_match_seconds"] == 300.0 - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "split_shape", "tiki_taka_plus"]) + monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "pendulum", "weaver"]) tournament.main() envs = sorted((tmp_path / "match_results").iterdir()) diff --git a/utama_core/tests/engine/test_tournament_match_end.py b/utama_core/tests/engine/test_tournament_match_end.py index ed9d204f..04d4937b 100644 --- a/utama_core/tests/engine/test_tournament_match_end.py +++ b/utama_core/tests/engine/test_tournament_match_end.py @@ -37,7 +37,7 @@ def close(self): def test_a_match_ends_at_full_time_not_at_the_sim_time_cap(monkeypatch): monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) - result = match.run_match("tiki_taka_plus", "split_shape", duration_seconds=1200.0) + result = match.run_match("weaver", "pendulum", duration_seconds=1200.0) assert _FakeRunner.last.ticks == _FakeRunner.full_time_ticks assert (result.score_a, result.score_b) == (2, 1) @@ -47,6 +47,6 @@ def test_the_cap_still_ends_a_match_that_never_reaches_full_time(monkeypatch): monkeypatch.setattr(_FakeRunner, "full_time_ticks", 10**9) monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) - match.run_match("tiki_taka_plus", "split_shape", duration_seconds=1.0) + match.run_match("weaver", "pendulum", duration_seconds=1.0) assert _FakeRunner.last.ticks == match.TICKS_PER_SECOND diff --git a/utama_core/tests/engine/test_tournament_reuse.py b/utama_core/tests/engine/test_tournament_reuse.py index 8e3b48e0..becbf1da 100644 --- a/utama_core/tests/engine/test_tournament_reuse.py +++ b/utama_core/tests/engine/test_tournament_reuse.py @@ -14,7 +14,7 @@ from tools.evaluation import round_robin as tournament from utama_core.replay import match_results -_CONFIGS = ["tiki_taka_plus", "press_and_pass", "high_press"] +_CONFIGS = ["weaver", "terrier", "wolfpack"] class _Graph: @@ -85,13 +85,13 @@ def test_a_second_run_takes_every_stored_match_and_reports_the_same_results(rig) def test_after_one_config_changes_only_its_matches_play(rig): rig.run() - rig.version["press_and_pass"] += 1 + rig.version["weaver"] += 1 rig.run() assert sorted(rig.played) == [ - ("high_press", "press_and_pass"), - ("press_and_pass", "tiki_taka_plus"), + ("terrier", "weaver"), + ("weaver", "wolfpack"), ] @@ -109,17 +109,17 @@ def test_a_stored_match_keeps_the_restarts_and_losses_its_replay_gave(rig, monke def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): - # Editing tiki_taka_plus during the first match leaves that match's code as it was, so it is stored. - # The two tiki_taka_plus matches finish under changed code, so neither is stored. + # Editing wolfpack during the first match leaves that match's code as it was, so it is stored. + # The two wolfpack matches finish under changed code, so neither is stored. def edit(): - rig.version["tiki_taka_plus"] = 9 + rig.version["wolfpack"] = 9 rig.on_play = edit rig.run() stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] - assert [(r["a"], r["b"]) for r in stored] == [("high_press", "press_and_pass")] + assert [(r["a"], r["b"]) for r in stored] == [("terrier", "weaver")] def test_a_no_save_run_plays_and_stores_nothing(rig, monkeypatch): diff --git a/utama_core/tests/engine/test_tournament_summary.py b/utama_core/tests/engine/test_tournament_summary.py index 001826cb..a8d1f822 100644 --- a/utama_core/tests/engine/test_tournament_summary.py +++ b/utama_core/tests/engine/test_tournament_summary.py @@ -126,21 +126,21 @@ def _stalled(a: str, b: str, sim_time: float, duration_s: float = 11.3) -> dict: def test_one_deterministic_freeze_against_two_opponents_is_one_incident(): """RR 2026-09-28: overload_flow froze at t=20.5 for 11.3 s against both - press_trigger_flow and score_aware_counter_flow -- the same freeze, since rsim is + tripwire and chameleon -- the same freeze, since rsim is deterministic and neither opponent had diverged yet. The same times with no shared strategy, or a tick apart, are different incidents.""" results = [ - _stalled("overload_flow", "press_trigger_flow", 20.5), - _stalled("overload_flow", "score_aware_counter_flow", 20.5 + 1e-9), + _stalled("overload_flow", "tripwire", 20.5), + _stalled("overload_flow", "chameleon", 20.5 + 1e-9), _stalled("tiki_taka", "zone_fluid", 20.5), _stalled("overload_flow", "low_block", 20.5 + 1 / 60), - _result("overload_flow", "high_press", 0, 0), + _result("overload_flow", "wolfpack", 0, 0), ] incidents = stall_incidents(results) assert [i["matches"] for i in incidents] == [ - ["overload_flow_vs_press_trigger_flow", "overload_flow_vs_score_aware_counter_flow"], + ["overload_flow_vs_tripwire", "overload_flow_vs_chameleon"], ["tiki_taka_vs_zone_fluid"], ["overload_flow_vs_low_block"], ] diff --git a/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json b/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json index 05a91a30..78e16ff6 100644 --- a/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json +++ b/utama_core/tests/moments/free_kick_defender_dodges_into_ball.json @@ -6,7 +6,7 @@ "t": 254.65 }, "strategy": "all", - "opponent": "split_shape", + "opponent": "pendulum", "seconds": 2.0, "checks": [ "keeps_clear" diff --git a/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json b/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json index 5621dc02..1abf929e 100644 --- a/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json +++ b/utama_core/tests/moments/free_kick_robot_drives_in_at_start.json @@ -6,7 +6,7 @@ "t": 155.3 }, "strategy": "all", - "opponent": "overload_press", + "opponent": "avalanche", "seconds": 3.0, "checks": [ "keep_out", diff --git a/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json b/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json index 468b80b8..697cf050 100644 --- a/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json +++ b/utama_core/tests/moments/placement_corner_robot_drives_onto_ball.json @@ -6,7 +6,7 @@ "t": 333.5 }, "strategy": "all", - "opponent": "press_trigger_flow", + "opponent": "tripwire", "seconds": 3.0, "checks": [ "keeps_clear", diff --git a/utama_core/tests/moments/placement_in_corner_traps_defender.json b/utama_core/tests/moments/placement_in_corner_traps_defender.json index c94a5a8c..c4b791c0 100644 --- a/utama_core/tests/moments/placement_in_corner_traps_defender.json +++ b/utama_core/tests/moments/placement_in_corner_traps_defender.json @@ -6,7 +6,7 @@ "t": 163.0 }, "strategy": "all", - "opponent": "give_and_go_solo", + "opponent": "ricochet", "seconds": 3.0, "checks": [ "keeps_clear", diff --git a/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json b/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json index 034d32a9..c0afc8f4 100644 --- a/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json +++ b/utama_core/tests/moments/placement_robot_drives_in_mid_pitch.json @@ -6,7 +6,7 @@ "t": 122.5 }, "strategy": "all", - "opponent": "score_aware_counter_flow", + "opponent": "chameleon", "seconds": 3.0, "checks": [ "keeps_clear" diff --git a/utama_core/tests/moments/test_play_options.py b/utama_core/tests/moments/test_play_options.py index 01f21aad..b3813d16 100644 --- a/utama_core/tests/moments/test_play_options.py +++ b/utama_core/tests/moments/test_play_options.py @@ -85,9 +85,9 @@ def test_events_of_nothing_is_nothing(): def test_factory_for_resolves_a_catalog_name_to_its_builder(): - from utama_core.strategy.split_shape import build + from utama_core.strategy.pendulum import build - assert moments.factory_for("split_shape")((1, 2)).func is build + assert moments.factory_for("pendulum")((1, 2)).func is build def test_factory_for_imports_a_build_from_a_scratch_file(tmp_path): diff --git a/utama_core/tests/motion_planning/defense_area_avoidance_test.py b/utama_core/tests/motion_planning/defense_area_avoidance_test.py index 1359213d..ed6b2323 100644 --- a/utama_core/tests/motion_planning/defense_area_avoidance_test.py +++ b/utama_core/tests/motion_planning/defense_area_avoidance_test.py @@ -1,7 +1,7 @@ """FastPathPlanner must route around the opponent's defense area. Found via a live grsim run of the split-shape kernel strategy -(`demo_split_shape_match.py`): an outfield attacker chasing the ball drove +(`demo_pendulum_match.py`): an outfield attacker chasing the ball drove straight into the opponent's defense area — an SSL rule violation flagged by the referee GUI. `FastPathPlanner._get_obstacles` treated only robots and the field boundary as obstacles; nothing represented the opponent's defense area diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 6835a1f3..95556f99 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -323,7 +323,7 @@ def test_editing_one_real_strategy_does_not_change_another_configs_fingerprint(g modules = {c: f"utama_core.strategy.{c}" for c in _players()} for config, module in modules.items(): assert graph.strategy_modules(config) & set(modules.values()) == {module}, config - assert graph.strategy_fingerprint("tiki_taka_plus") != graph.strategy_fingerprint("counter_flow") + assert graph.strategy_fingerprint("weaver") != graph.strategy_fingerprint("riptide") def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): diff --git a/utama_core/tests/replay/test_match_results.py b/utama_core/tests/replay/test_match_results.py index 38ae375a..7b8c73ea 100644 --- a/utama_core/tests/replay/test_match_results.py +++ b/utama_core/tests/replay/test_match_results.py @@ -101,11 +101,11 @@ def test_load_reads_only_the_environment_asked_for(tmp_path): def test_load_names_a_player_by_its_fingerprint(tmp_path): """A frozen file and the same code in the repo are one player, whichever played the match.""" store = MatchResults(tmp_path) - store.put(_rec(a="split_shape", a_fp="1", b="other", b_fp="2")) + store.put(_rec(a="pendulum", a_fp="1", b="other", b_fp="2")) - loaded = store.load("e", fps={"frozen/split_shape@abc.strategy": "1"}) + loaded = store.load("e", fps={"frozen/pendulum@abc.strategy": "1"}) (rec,) = loaded.values() - assert (rec["a"], rec["b"]) == ("frozen/split_shape@abc.strategy", "other") + assert (rec["a"], rec["b"]) == ("frozen/pendulum@abc.strategy", "other") def test_a_torn_file_is_skipped_and_the_rest_still_load(tmp_path): diff --git a/utama_core/tests/shared/test_pass_and_score_geometry.py b/utama_core/tests/shared/test_pass_and_score_geometry.py index 8d4f2ea4..0b86a968 100644 --- a/utama_core/tests/shared/test_pass_and_score_geometry.py +++ b/utama_core/tests/shared/test_pass_and_score_geometry.py @@ -744,7 +744,7 @@ def test_carry_exhausted_counts_the_distance_needed_to_stop(): assert carry_exhausted(moving, origin, stops_after=True) assert not carry_exhausted(at_rest, origin, stops_after=True) # A carrier that kicks while moving (GiveAndGo) never brakes with the ball, so - # its carry isn't cut short by speed: counting it cost give_and_go_solo half + # its carry isn't cut short by speed: counting it cost ricochet half # its goals in an A/B. assert not carry_exhausted(moving, origin) diff --git a/utama_core/tests/strategy/test_carrier_allocation.py b/utama_core/tests/strategy/test_carrier_allocation.py index 8f35af8e..d862ef67 100644 --- a/utama_core/tests/strategy/test_carrier_allocation.py +++ b/utama_core/tests/strategy/test_carrier_allocation.py @@ -1,7 +1,7 @@ from types import SimpleNamespace from utama_core.entities.data.object import TeamType -from utama_core.strategy.clear_press_plus import _clear_press_plus_picker +from utama_core.strategy.breakwater import _breakwater_picker def _final_third_game(carrier_id): @@ -21,7 +21,7 @@ def test_the_robot_holding_the_ball_goes_to_the_ball_side_slot(): # clear_press_plus_vs_zone_fluid (2026-09-28): the final-third handoff gave # "overload" the two lowest ids and put carrier 4 in "block", which held the # ball still while the overload decoy waited on it — frozen for 38 s. - partition = _clear_press_plus_picker( + partition = _breakwater_picker( _final_third_game(carrier_id=4), frozenset({1, 2, 3, 4, 5}), {"attack": frozenset({3, 4, 5})}, diff --git a/utama_core/tests/strategy/test_split_shape_split.py b/utama_core/tests/strategy/test_split_shape_split.py index f102085b..a2d03662 100644 --- a/utama_core/tests/strategy/test_split_shape_split.py +++ b/utama_core/tests/strategy/test_split_shape_split.py @@ -1,20 +1,20 @@ -"""`split_shape` keeps a second robot in attack while defending, from four outfield robots up, so a +"""`pendulum` keeps a second robot in attack while defending, from four outfield robots up, so a won ball has someone upfield to go to.""" import pytest -from utama_core.strategy import split_shape +from utama_core.strategy import pendulum _TACTICS = frozenset({"attack", "defense"}) @pytest.mark.parametrize("robots, attackers", [(5, 2), (4, 2), (3, 0)]) def test_defending_keeps_a_second_attacker_from_four_robots(monkeypatch, robots, attackers): - monkeypatch.setattr(split_shape, "carrier_first", lambda game, free: sorted(free)) - monkeypatch.setattr(split_shape, "friendly_closer_to_ball", lambda game: False) + monkeypatch.setattr(pendulum, "carrier_first", lambda game, free: sorted(free)) + monkeypatch.setattr(pendulum, "friendly_closer_to_ball", lambda game: False) free = frozenset(range(1, robots + 1)) - partition = split_shape._possession_split_picker(None, free, None, _TACTICS) + partition = pendulum._possession_split_picker(None, free, None, _TACTICS) assert len(partition.get("attack", ())) == attackers assert partition.get("attack", frozenset()) | partition["defense"] == free diff --git a/utama_core/tests/strategy_runner/test_change_of_ends.py b/utama_core/tests/strategy_runner/test_change_of_ends.py index de8f8e56..b64dc62e 100644 --- a/utama_core/tests/strategy_runner/test_change_of_ends.py +++ b/utama_core/tests/strategy_runner/test_change_of_ends.py @@ -30,8 +30,8 @@ def test_the_teams_play_the_second_half_from_the_other_end(headless): profile = load_profile("simulation") profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, half_duration_seconds=HALF_S)) runner = StrategyRunner( - strategy=AbstractStrategy(build=builder("tiki_taka_plus", tuple(range(1, N_OUTFIELD + 1)))), - opp_strategy=AbstractStrategy(build=builder("tiki_taka_plus", tuple(range(1, N_OUTFIELD + 1)))), + strategy=AbstractStrategy(build=builder("weaver", tuple(range(1, N_OUTFIELD + 1)))), + opp_strategy=AbstractStrategy(build=builder("weaver", tuple(range(1, N_OUTFIELD + 1)))), my_team_is_yellow=True, my_team_is_right=True, mode="rsim", @@ -92,7 +92,7 @@ def _robot(x: float, y: float) -> Robot: def test_a_robot_turned_from_past_the_goal_line_stands_on_the_far_line(): - # A robot in the run-off at x=-4.594 (a real one, clear_danger vs decoy_and_overload) + # A robot in the run-off at x=-4.594 (a real one, firebreak vs decoy_and_overload) # turned to x=+4.594, and the sim refused the teleport: the match crashed at half-time. bounds = FieldBounds(top_left=(-4.5, 3.0), bottom_right=(4.5, -3.0)) turned = _turned(_robot(-4.594, 2.399), bounds) diff --git a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py index 4e3c4e54..933ff5a5 100644 --- a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py +++ b/utama_core/tests/strategy_runner/test_goalkeeper_stability.py @@ -33,8 +33,8 @@ OUTFIELD_ROBOT_IDS = tuple(range(1, N_OUTFIELD + 1)) # Same pairing that surfaced the bug live. -_NAME_A = "counter_flow" -_NAME_B = "tiki_taka_plus" +_NAME_A = "riptide" +_NAME_B = "weaver" def test_goalkeeper_converges_on_static_target_without_oscillating(headless): diff --git a/utama_core/tests/test_main_entry.py b/utama_core/tests/test_main_entry.py index 4e155413..d631b165 100644 --- a/utama_core/tests/test_main_entry.py +++ b/utama_core/tests/test_main_entry.py @@ -8,7 +8,7 @@ def test_known_strategy_name_builds_an_abstract_strategy(): - assert isinstance(main._strategy("split_shape"), AbstractStrategy) + assert isinstance(main._strategy("pendulum"), AbstractStrategy) def test_unknown_strategy_name_exits_listing_catalog_names(): @@ -16,5 +16,5 @@ def test_unknown_strategy_name_exits_listing_catalog_names(): main._strategy("no_such_strategy") message = str(excinfo.value) assert "no_such_strategy" in message - assert "split_shape" in message + assert "pendulum" in message assert all(name in message for name in catalog.names()) diff --git a/utama_core/tests/tools/test_sim_setup.py b/utama_core/tests/tools/test_sim_setup.py index e5bbd02c..97b731bf 100644 --- a/utama_core/tests/tools/test_sim_setup.py +++ b/utama_core/tests/tools/test_sim_setup.py @@ -12,7 +12,7 @@ [ ("scratch/try.py:build_x", True), ("/abs/path/try.py:build", True), - ("split_shape", False), + ("pendulum", False), ("try.py:", False), # no factory named ("try.txt:build", False), ("a.strategy", False), @@ -23,11 +23,11 @@ def test_is_file_spec_needs_a_py_path_and_a_factory(name, expected): def test_a_catalog_name_loads_an_abstract_strategy(): - assert isinstance(sim_setup.load_side("split_shape"), AbstractStrategy) + assert isinstance(sim_setup.load_side("pendulum"), AbstractStrategy) def test_an_unknown_name_lists_the_catalog(): - with pytest.raises(sim_setup.UnknownStrategy, match="unknown strategy 'nope'; strategies: .*split_shape"): + with pytest.raises(sim_setup.UnknownStrategy, match="unknown strategy 'nope'; strategies: .*pendulum"): sim_setup.load_side("nope") @@ -51,8 +51,8 @@ def test_a_scratch_file_without_the_factory_is_named(tmp_path): def test_sim_runner_plays_us_yellow_on_the_right_with_six_a_side(): runner, referee = sim_setup.sim_runner( - sim_setup.load_side("split_shape"), - sim_setup.load_side("high_press"), + sim_setup.load_side("pendulum"), + sim_setup.load_side("wolfpack"), initial_command=RefereeCommand.STOP, ) try: From 410b5c5dd032874ca1ec3dae2200547c8210955f Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 14:27:01 +0000 Subject: [PATCH 19/59] tests: old strategy names load today's strategy Co-Authored-By: Claude Opus 5.5 --- utama_core/tests/strategy/test_catalog.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 utama_core/tests/strategy/test_catalog.py diff --git a/utama_core/tests/strategy/test_catalog.py b/utama_core/tests/strategy/test_catalog.py new file mode 100644 index 00000000..6de2821f --- /dev/null +++ b/utama_core/tests/strategy/test_catalog.py @@ -0,0 +1,20 @@ +"""`catalog.current_name`: old strategy names (pre-2026-11-12, and the older `build_*_kernel_strategy`) +load today's strategy, while `plain_name` keeps the saved name that replay files are found by.""" + +from utama_core.strategy import catalog + + +def test_every_old_name_maps_to_a_strategy_in_the_catalog(): + names = set(catalog.names()) + assert set(catalog.RENAMED.values()) <= names + assert not set(catalog.RENAMED) & names # an old name is never also a current one + + +def test_old_names_in_both_old_forms_resolve_to_the_new_name(): + assert catalog.current_name("split_shape") == "pendulum" + assert catalog.current_name("build_split_shape_kernel_strategy") == "pendulum" + assert catalog.current_name("pendulum") == "pendulum" + + +def test_plain_name_keeps_the_saved_name_replay_files_are_named_by(): + assert catalog.plain_name("build_split_shape_kernel_strategy") == "split_shape" From 897ae886ba0886ce463d685adbf4e7cf6ad55f72 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 15:21:51 +0000 Subject: [PATCH 20/59] tools: one match tool, evaluate.py, with a round robin as round 1 evaluate.py now plays every match. With no candidate it plays one round: a round robin of the core strategies (reference/players.json), two reserve strategies rotated in by the round's seed (--all: every strategy) and the reference, the champion at the last release played from a .strategy file (--at REF, --compare-with NAME). With candidates, later rounds play only the undecided candidates' matches until the paired verdict is clear. It reports stalls with how many matches checked them and every signal the round robin printed, never standings. Each round writes replays/eval_/round_/ in the old round-robin layout, so find_bugs, pitch_maps and goal_sources read it; report.json holds the verdicts. round_robin.py, its --pair/--vs-champion/--both-sides/--no-save, the held-out opponents and opponents.json (now players.json) are gone. --strict, --fuzz-restarts and --control-scheme moved over. The dashboard, list_runs and package_logs find the new run directories as well as the old. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 42 +- README.md | 7 +- docs/STRATEGY_DEVELOPMENT.md | 212 ++-- docs/architecture.md | 2 +- docs/custom_referee.md | 6 +- docs/img/architecture/make_match_data_flow.py | 7 +- docs/img/architecture/match_data_flow.png | Bin 143939 -> 143692 bytes docs/signals.md | 20 +- docs/strategies.md | 61 +- docs/strategy_tools_plan.md | 36 +- docs/tools.md | 23 +- main.py | 2 +- tools/debug_match.py | 2 +- tools/evaluation/evaluate.py | 906 ++++++++++++----- tools/evaluation/match.py | 6 +- tools/evaluation/reference/opponents.json | 17 - tools/evaluation/reference/players.json | 5 + tools/evaluation/round_robin.py | 911 ------------------ tools/evaluation/sim_settings.py | 17 +- tools/metric_correlation.py | 4 +- tools/moments.py | 2 +- tools/package_logs.py | 8 +- tools/repro_from_replay.py | 4 +- utama_core/analysis/chances.py | 2 +- utama_core/analysis/list_runs.py | 13 +- utama_core/analysis/restart_outcomes.py | 2 +- utama_core/analysis/strategy_table.py | 2 +- utama_core/analysis/turnover_breakdown.py | 2 +- utama_core/dashboard/views/tournament.py | 9 +- utama_core/engine/match_stats.py | 4 +- utama_core/replay/match_results.py | 6 +- utama_core/tests/bundle/test_strategy_file.py | 4 +- .../tests/dashboard/test_tournament_view.py | 2 +- utama_core/tests/engine/test_evaluate.py | 53 +- utama_core/tests/engine/test_evaluate_run.py | 148 +++ ...nt_summary.py => test_evaluate_signals.py} | 11 +- utama_core/tests/engine/test_explain.py | 2 +- .../tests/engine/test_tournament_cli_args.py | 213 ---- .../tests/engine/test_tournament_reuse.py | 141 --- .../engine/test_tournament_vs_champion.py | 119 --- 40 files changed, 1097 insertions(+), 1936 deletions(-) delete mode 100644 tools/evaluation/reference/opponents.json create mode 100644 tools/evaluation/reference/players.json delete mode 100644 tools/evaluation/round_robin.py create mode 100644 utama_core/tests/engine/test_evaluate_run.py rename utama_core/tests/engine/{test_tournament_summary.py => test_evaluate_signals.py} (93%) delete mode 100644 utama_core/tests/engine/test_tournament_cli_args.py delete mode 100644 utama_core/tests/engine/test_tournament_reuse.py delete mode 100644 utama_core/tests/engine/test_tournament_vs_champion.py diff --git a/AGENTS.md b/AGENTS.md index 044eab78..966b8fc6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -27,13 +27,13 @@ exists yet: say so in your change rather than guessing. One term per thing; reuse these instead of coining new ones. -- **Round-robin / tournament run** — every strategy config plays every other once - (`tools/evaluation/round_robin.py`); writes `replays/tournament_/summary.json` and adds its matches to the match results store (`replays/match_results/`). - The check for stalls and the occasional health check of the whole catalog; a single - strategy is judged with `evaluate.py` (below). A match the store already holds is not played again, so only matches whose code changed rerun. -- **Standings** — only a round-robin's ranking: wins and draws as `round_robin.py` prints them, - or points per match (3 a win, 1 a draw) as `metric_correlation.py` computes them. Not the - verdict on a strategy; see Evaluation. +- **Round robin / health check** — round 1 of `evaluate.py` (below): every player meets every other + once; with no candidate it is the whole run. Reports stalls (with how many matches checked them) and + every signal, in `replays/eval_/round_1/summary.json`. Older runs of the deleted `round_robin.py` + are `replays/tournament_/`. W-D-L there is a signal, never a verdict: there are no standings. +- **Core / reserve strategies** — the core (`tools/evaluation/reference/players.json`) plays every + round; every other strategy in the catalog is reserve, two rotated in per round by its seed (`--all` + plays them all), for a diverse field without playing twelve every time. - **Motion planning benchmark** — `tools/motion_planning_benchmark.py`: the planner alone on fixed scenarios. Unrelated to any strategy. - **Moment / regression moment** — a field state (captured from a replay) that reproduced a @@ -51,21 +51,21 @@ One term per thing; reuse these instead of coining new ones. the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. -- **Evaluation / ratings / reference opponents / match results** — `tools/evaluation/evaluate.py`: is a - candidate stronger than the champion of a fixed set of reference opponents - (`tools/evaluation/reference/opponents.json`: the champion, six opponents, three held-out - opponents)? Rounds of matches against those opponents in the simulated world and robots - (`tools/evaluation/reference/world.json`, `robots.json`) under seeded sim noise, decided on - paired results (candidate and champion against the same opponent under the same noise) and - stopping once the answer is clear; ratings (strength ± SD in goals per match, - `analysis/ratings.py`) over every match in the match results store (`replays/match_results/`, `replay/match_results.py`). +- **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate + stronger than the reference, the champion at the last release (`--at REF`, or `--compare-with + NAME`)? Round k plays under sim-noise seed k in the simulated world and robots + (`tools/evaluation/reference/world.json`, `robots.json`): round 1 a round robin, later rounds only the + undecided candidates' matches, decided on paired results (candidate and reference against the same + opponent under the same noise, `analysis/ratings.py`) and stopping once the answer is clear. Every + match goes to the match results store (`replays/match_results/`, `replay/match_results.py`); a match + the store holds is never played again. Promoting is a one-line change to `players.json` in a PR. Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. -- **Strategy file / frozen baseline** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a +- **Strategy file** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a zip of one strategy and the whole `utama_core` package at one commit; it plays in its own process, game frames in and - robot commands out, in simulation or on real robots (`BundledStrategy(path, robot_ids)`). `evaluate.py CANDIDATE --frozen REF` plays the champion and the opponents from - such files of commit REF (the frozen baseline, kept in `replays/eval/frozen/`), so a change to shared code moves only - the candidate. The referee and the simulator stay today's for both sides. A file is a player like any strategy name wherever one is named (`evaluate.py`, `round_robin.py`, `opponents.json`), with the same replays, stats and logs. Its fingerprint is computed like the code's, so a file and the code it was built from are one player in the ledger. + robot commands out, in simulation or on real robots (`BundledStrategy(path, robot_ids)`). `evaluate.py` plays the reference from + such a file of the last release (kept in `replays/eval/frozen/`), so a change to shared code never moves + the reference. The referee and the simulator stay today's for both sides. A file is a player like any strategy name wherever one is named (`evaluate.py`, `players.json`), with the same replays, stats and logs. Its fingerprint is computed like the code's, so a file and the code it was built from are one player in the match results. - **World / robot capability** — simulator settings fall into two kinds: the world (ball friction, vision noise and dropouts, latency) comes from measurements; robot capability (kick, dribbler, motors) is assumed good at league level, and real robots' shortfalls are compensated @@ -77,7 +77,7 @@ One term per thing; reuse these instead of coining new ones. P(goal). Situation types: own / opponent ball won or free kick in each third, own / opponent kickoff or penalty, force start. See `docs/signals.md`. - **Situation rates** — how often each situation type happens per team per live minute, from - real Division B matches or our round-robin (`goal_sources --rates PATH`). + real Division B matches or our matches (`goal_sources --rates PATH`). ## Repo map @@ -175,7 +175,7 @@ need most: answers, with where it lives in `summary.json`, a reference range and what an off value means. Read it when designing or debugging a strategy, and before adding a metric; they are diagnostics, not objectives. -- `docs/strategies.md` — strategy catalog: status, description, and real round-robin +- `docs/strategies.md` — strategy catalog: core or reserve, description, and real match results per strategy. - `utama_core/tests/engine/` and `utama_core/tests/strategy_runner/` — the real tactic-kernel test surface; everywhere else is largely infrastructure (motion planning, diff --git a/README.md b/README.md index a5a8ff99..23add710 100644 --- a/README.md +++ b/README.md @@ -14,9 +14,12 @@ strategy layer that decides what every robot does. 2. `pixi install` in the repository root, then `pixi run precommit-install` so every commit is linted. 3. `pixi run test` runs the test suite (add `--headless` when calling pytest directly). -4. Play one headless match between two strategies and save its replay: +4. Play one headless match between two strategies: - pixi run python tools/evaluation/round_robin.py --pair tiki_taka low_block + pixi run python tools/debug_match.py --strategy pendulum --opponent riptide + + `pixi run python tools/evaluation/evaluate.py` plays a full round robin and keeps its replays + under `replays/eval_/`. 5. `pixi run python dashboard_server.py` and open http://localhost:8080 to watch replays and browse tournament results. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 5d6095e4..f4d5221d 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -212,8 +212,8 @@ flowchart TD **Writing one.** Add `strategy/.py` with `build(outfield_robot_ids, motion_controller)`, returning a `Strategy(tactics={...}, partitioner=...)`, and the pickers only it uses. The file is -all it takes: `strategy/catalog.py` finds it, so it joins round-robins and `evaluate.py` as -``. Reuse the shared partitioner +all it takes: `strategy/catalog.py` finds it, so it joins `evaluate.py` as `` +(a reserve player until it is added to the core). Reuse the shared partitioner pieces in `strategy/pickers.py` rather than re-deriving them: - `friendly_closer_to_ball(game)` — the possession edge. True/False is a clear edge; None is a near-tie or unreadable state, where a sticky picker keeps its previous split. @@ -224,135 +224,109 @@ pieces in `strategy/pickers.py` rather than re-deriving them: `tests/engine/test_all_strategy_configs.py` picks it up the same way and runs it through the kernel invariants. Give its partitioner pure-function tests in `tests/strategy/test_.py` (a -`Game` built by hand, no rsim), and add a row to `docs/strategies.md`'s round-robin table. +`Game` built by hand, no rsim), and add a row to `docs/strategies.md`'s table. **Evaluating one,** cheapest first; stop as soon as a step fails: 1. **Tests:** its own, `test_all_strategy_configs.py`, then the full suite `--headless`. -2. **One saved match** against a few opponents: `round_robin.py --pair `. - Saved, so stalls are recorded (`--no-save` cannot see them). A stall is a bug to fix - before anything else. -3. **Matches:** `tools/evaluation/evaluate.py ` (see [Evaluating a strategy](#evaluating-a-strategy)): - is it better than the champion in `tools/evaluation/reference/opponents.json`, worse, or not clearly either? Several candidates go in - one call. A strict round-robin (`round_robin.py --strict`) is the check for stalls - and the occasional health check of the whole catalog, no longer the way to judge one change. +2. **Matches:** `tools/evaluation/evaluate.py ` (see [Evaluating a strategy](#evaluating-a-strategy)): + is it better than the champion at the last release, worse, or not clearly either? Several + candidates go in one call. Its round 1 is a round robin, so the same run reports stalls and + signals; a stall is a bug to fix before anything else. A change to `tactics/`, `skills/` or `pickers.py` is the other way round: reuse saves little, because most strategies import the changed code and their matches all rerun. Batch such -changes and run one round-robin over the batch. +changes and run one evaluation over the batch. **Reuse is automatic.** A match the match results store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played; there is no flag. A match's fixture is its environment (the shared code and machine, the match length, the planner, the sim noise without its seed, the restart fuzzing), both players' fingerprints, their sides and the noise seed. So after a -change to one strategy only its matches play, one per other config. A default round-robin plays the -12 strategies of the catalog, so a change to one of them replays 11 of its 66 matches. What counts as "runs" is +change to one strategy only its matches play. What counts as "runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole files), and the shared code and environment (referee, runner, simulator build, packages, CPU). Editing -`pickers.py` reruns every config that imports it, which is most of them; changing shared code reruns -everything, correctly. The store does not check itself (the spot-check of earlier versions is gone): -if a fingerprint misses a dependency, delete the store, or one environment's folder inside it, to play -everything again. A round-robin prints "N taken from replays/match_results ... M to play" first; read it. +`pickers.py` reruns every strategy that imports it, which is most of them; changing shared code reruns +everything, correctly. The store does not check itself: if a fingerprint misses a dependency, delete +the store, or one environment's folder inside it, to play everything again. Each round prints +"N matches, X from the match results store, M to play" first; read it. -**What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against the champion of the reference opponents. A round-robin's W-D-L is a diagnostic. +**What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against +the champion at the last release. W-D-L and every other signal are diagnostics. Everything in [Reading a tournament run](#reading-a-tournament-run) explains a result; none of -it is a target. Don't tune a threshold until results move: a change needs a reason in game -terms. Two round-robins of near-identical code agree -at Spearman +0.97, but that is not a ceiling: rsim is deterministic, so they agree largely -because the code is near-identical. +it is a target. Don't tune a threshold until results move: a change needs a reason in game terms. ### Evaluating a strategy -`tools/evaluation/evaluate.py CANDIDATE [CANDIDATE ...]` answers one question per candidate: is -it stronger than the champion of a fixed set of reference opponents, in goals, under the realistic sim noise? - -The flowchart contrasts it with the round-robin, which answers a different question. +`tools/evaluation/evaluate.py [CANDIDATE ...]` is the one tool for matches. With no candidate it +plays one round, a round robin: the health check of the catalog (stalls, fouls, every signal). With +candidates it also answers, per candidate: is it stronger than the champion at the last release, in +goals, under the realistic sim noise? ```mermaid flowchart TD - subgraph rr["round_robin.py: is the whole catalog healthy?"] - r1["Every strategy plays
every other once (one full match per pair)"] - r2["Stall and error check
--strict fails on a stall"] - r3["Standings in summary.json
not a verdict on any one strategy"] - r1 --> r2 --> r3 - end - - subgraph ev["evaluate.py: is this candidate stronger than the champion?"] - e1["Reference opponents.json: champion, six opponents,
three held-out opponents; world and robots, sim noise"] - e2["Round k, noise seed k
candidate and champion each play every opponent"] - e7["Every match stored in the match results
replays/match_results/"] - e3{"P(candidate stronger), paired
with the champion's results"} - e4["better: P >= 0.99
then --held-out before promoting"] - e5["worse: P <= 0.2
drop it"] - e6["undecided after 6 rounds
drop it"] - e1 --> e2 --> e3 - e2 -.-> e7 - e3 -- "P >= 0.99" --> e4 - e3 -- "P <= 0.2" --> e5 - e3 -- "neither, rounds left" --> e2 - e3 -- "neither, no rounds left" --> e6 - end + p["Players: core (reference/players.json) + 2 reserve rotated by seed
+ the reference: the champion at the last release, a .strategy file"] + r1["Round 1, noise seed 1: every pair once, candidates included
signals and stalls of every player"] + rk["Round k, seed k: only undecided candidates'
matches, and the reference's against the same opponents"] + st["Every match stored in the match results
replays/match_results/"] + d{"P(candidate stronger), paired
with the reference's results"} + b["better: P >= 0.99
promote by hand in players.json"] + w["worse: P <= 0.2
drop it"] + u["undecided after 6 rounds
drop it"] + p --> r1 --> d + r1 -.-> st + rk -.-> st + d -- "P >= 0.99" --> b + d -- "P <= 0.2" --> w + d -- "neither, rounds left" --> rk --> d + d -- "neither, no rounds left" --> u ``` -- **The reference opponents** (`tools/evaluation/reference/opponents.json`): a champion, six - opponents chosen for spread of styles and three held-out opponents. The simulated world and - robots are `world.json` and `robots.json` in the same folder (`sim_settings.py` loads them). - It changes only on purpose, so a result means the same thing next month; it does not follow - the latest standings. -- **Rounds.** In round k every candidate plays each opponent and the champion once, and the - champion plays each opponent, all with noise seed k and the side under test in the same colour - (the noise is drawn per colour and robot, so one seed can favour a colour by half a goal). A - candidate and the champion are compared on the same opponents under the same noise. +- **Players** (`tools/evaluation/reference/players.json`): the champion and the core strategies, + which play every round. Every other strategy in the catalog is reserve: two play each round, rotated + by the round's seed, so the field stays diverse without twelve strategies every round (`--all` + plays them all). The simulated world and robots are `world.json` and `robots.json` in the same + folder (`sim_settings.py` loads them). +- **The reference** is the champion as it was at the latest release tag (`--at REF` for another + commit), played from a `.strategy` file built once into `replays/eval/frozen/`. A change to shared + code (skills, tactics, motion, engine) therefore moves the candidates and the working-tree + strategies, never the reference. A bundled match equals the same match run normally, frame for frame; the + referee and simulator are today's for both sides. An older commit may know the champion by its old + name (`catalog.RENAMED`); that is found. `--compare-with NAME` compares against NAME instead: a new + version against the one it changes. +- **Rounds.** Round k plays with noise seed k. Round 1 plays every pair of players once. Later rounds + play only the undecided candidates: each against the reference and the round's opponents, and the + reference against the same opponents. The candidate (then the reference) is config_a in odd rounds + and config_b in even ones, so both meet each opponent in the same colour under the same noise (the + noise is drawn per colour and robot, so one seed can favour a colour by half a goal). - **The decision** (`ratings.paired_difference`): the candidate's goal difference against each - opponent minus the champion's, same opponent, seed and colour, from rounds 1..k, plus their + opponent minus the reference's, same opponent, seed and colour, from rounds 1..k, plus their head-to-head matches. Paired results face the same noise, so much of it cancels: all of it - for identical code (a byte copy of the champion gets 24 diffs of exactly 0 and stays - undecided), little for unrelated strategies. P(candidate stronger) >= 0.99 is **better**, + for identical code, little for unrelated strategies. P(candidate stronger) >= 0.99 is **better**, <= 0.2 **worse**, and after 6 rounds it is **undecided**: not clearly better, so drop it. Simulated (match noise SD 1.9 goals): two equal strategies are called better at most 3% of the - time. An unrelated strategy one goal per match worse is dropped after ~2 rounds (~14 - matches), one goal better found 61% of the time, half a goal 20%. A small edit of the champion - (paired results correlated ~0.9): one goal better found every time in ~3 rounds, half a goal - 55%. Small gains of unrelated strategies are below what matches resolve at this cost. -- **Ratings** (`analysis/ratings.py`): a strength per strategy in goals per match with its SD, - fitted on every match in the match results; printed at the end, and the match noise for the decision. -- **Match results** (`replays/match_results/`, `replay/match_results.py`): one record per match from - evaluate.py and round-robins, keyed by its fixture (the code that played it). A match is never played twice; - the champion's matches are played once per seed and reused by every candidate, and editing a - strategy starts its record afresh. Replays are not kept, except during a `--explain` run (rerun one with `round_robin.py --pair - A B --sim-noise reference:`). -- **Stalls** are reported after each candidate's and the champion's verdict, for post-analysis only: - they never change a verdict or stop a run. "stalls checked in N of M ... (watchdog covers config_a - only)" counts the matches where the watchdog could see that side (`run/strategy_runner.py` records - stats for config_a only). A match where the side was config_b, or whose stats were not collected, - counts as unchecked; "unknown" means none was checked. The JSON report has them under - `candidates[...].stalls` and `champion_stalls`. -- **Health check.** After a shared-code change, `round_robin.py --vs-champion` plays each strategy once - against the champion (12 matches, not the 66 of a full round-robin), defaulting to `--sim-noise - reference:2` so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2. Read - its STALLS section; a strategy's verdict still comes from `evaluate.py`. -- **Before promoting** a candidate called better, run `evaluate.py --held-out`: it must not - be clearly worse against opponents never used for selection. Then edit the champion in - `reference/opponents.json` by hand. Check its per-opponent table: a candidate far better against one opponent and worse - against the rest is a matchup, not a better strategy. -- **A change to shared code** (skills, tactics, motion, engine) moves every strategy, so a normal run compares - worse with worse as easily as better with better. `evaluate.py --frozen v2.5.0` plays the champion and - the opponents from `.strategy` files of that commit (`replays/eval/frozen/`, built once) and the candidate from - the working tree. A bundled match equals the same match run normally, frame for frame. The referee and the - simulator are today's for both sides, so a frozen side meets rule changes it was not written for. A file and - the same code are one player in the match results, and matches between two files are replayed only when the referee, - the simulator or the match runner change: a skills or tactics edit reruns only the candidate's matches. + time. An unrelated strategy one goal per match worse is dropped after ~2 rounds, one goal better + found 61% of the time, half a goal 20%. A small edit (paired results correlated ~0.9): one goal + better found every time in ~3 rounds, half a goal 55%. Check the per-opponent table: a candidate + far better against one opponent and worse against the rest is a matchup, not a better strategy. +- **Stalls** are reported, never judged on. The watchdog watches config_a only + (`run/strategy_runner.py` records stats for config_a), so the report says in how many matches each + strategy was checked; "unknown" means none was. `--strict` exits non-zero on any stall, for CI. +- **Output.** `replays/eval_/report.json` (verdicts, per-opponent tables, round 1's signals) and + per round `round_/`: each played match's replay, intention log and stats as `
_vs_.*`, + `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` + read. Matches taken from the store have no replay in the run. +- **Promoting** is a decision, not a side effect: change the champion line in `reference/players.json` + in a pull request; the next release makes it the reference. - **Pictures** (`evaluate.py --explain`, `tools/evaluation/explain.py`): for each candidate, where both strategies' robots stand with and without the ball, their shots for and against, their fouls by rule, and a `summary.json` of the numbers behind them, written to - `replays/eval/explain/_/`. The run's matches are kept until they are written. They - explain a verdict and never make one: the verdict is still goals, and a picture is not a ranking. - Matches taken from the match results have no replay in the run, so the pictures cover only what was - played; the paired goal difference in `summary.json` is only as complete as that. Example, from a - round-robin (`explain.py replays/tournament_ pendulum breakwater --out ...`): + `replays/eval/explain/_/`. They explain a verdict and never make one; matches taken + from the store have no replay, so the pictures cover only what was played. Example + (`explain.py replays/eval_/round_1 pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) -- **Cost.** ~45 min of laptop per 66 matches on 8 workers. A clearly worse candidate costs ~14 - matches (~10 min), a close one up to 42. +- **Cost.** Round 1 with nothing stored is 28 matches (8 players) of up to 1200 s, roughly 30-40 min on + 12 workers; a later round is about 2 x 7 matches per candidate. A clearly worse candidate is decided + after 1-2 rounds. ### Strategy branches @@ -375,16 +349,15 @@ reaches `main` by pull request: no changing attributes of what it imports. CI checks all of this statically, from `main`'s copy of the checker; the reviewer still reads the diff. Tests import pickers from your module directly. -4. Write, test and evaluate it as above, and record the round-robin in `docs/strategies.md`. +4. Write, test and evaluate it as above, and record the verdict in `docs/strategies.md`. `git add` new files before `pixi run lint`: it checks tracked files only. Before waiting on - a round-robin, read the "N taken from ... M to play" line it prints: M much larger + an evaluation, read the "X from the match results store, M to play" line it prints: M much larger than your own matches means the store is stale (shared code changed since it was filled). - Let it run anyway (a full round-robin of 600 s matches has taken from about 1 h 50 min, on 15 workers plugged in, to 4.7 h for `tournament_20261005_170958`; matches are now two halves of 300 s of playing time: about 710 s of sim time on average by the final run's stoppages, 785 s in two measured matches, so expect roughly 20-30% longer): the other - strategies' matches run `main`'s code, so they refill the store for everyone. -4. Open a draft pull request into `main` with the round-robin result. An agent never merges: a person reviews and merges. + Let it run anyway: the other strategies' matches run `main`'s code, so they refill the store for everyone. +5. Open a draft pull request into `main` with the evaluation result. An agent never merges: a person reviews and merges. Several branches can be worked on at once, each in its own worktree; they share -`replays/match_results/`. A round-robin uses one worker per core (`--max-workers N` to cap it), so +`replays/match_results/`. `evaluate.py` uses 12 workers (`--max-workers N` to change it), so concurrent runs split the machine's cores and each takes longer; a machine with more cores runs more of them at once. How to organise a search (how many in parallel, which ideas) is up to whoever runs it. @@ -421,12 +394,11 @@ whoever runs it. - **`render_clip()`** (`analysis/render_clip.py`) — MP4 of a window for humans, ball-following or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. -- **`docs/strategies.md`** — every factory, whether a round-robin plays it or it is retired, - and the latest results. -- **`tools/evaluation/round_robin.py`** — round-robin runner (`--max-workers N`, `--both-sides`, - `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED`, `--fuzz-interval LO HI`, - `--sim-noise JSON`, `--no-save`, `--pair A B` for one fixture with A as config_a — reruns a stalled match from a - round-robin; see the determinism caveat below). +- **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. +- **`tools/evaluation/evaluate.py`** — every match run (`--all`, `--max-workers N`, `--strict`, + `--fuzz-restarts SEED`, `--fuzz-interval LO HI`, `--control-scheme NAME`); see + [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: + `tools/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and writes `ball_losses.md`; see [Reading a tournament run](#reading-a-tournament-run). `python -m utama_core.analysis.turnover_breakdown ` re-runs it on an older run. @@ -464,8 +436,8 @@ this way (table below), two were the referee or the check, not the robot. Start with `tools/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind and the pictured findings. Filter `findings.jsonl` on the kind you care about, open that finding's picture to see what it means, and confirm with the numbers in its message (or `replay_trace.py --events`) before concluding anything. `find_bugs.py` reads only the friendly side of -each match (the intentions log is written for it): a strategy's matches where it is config_a. In a round-robin each pair plays once, -so a strategy gets only the pairs where it comes first in the config order. +each match (the intentions log is written for it): a strategy's matches where it is config_a. In a round each pair plays once, +so a strategy is config_a in only some of its matches (`summary.json`'s `stalls_checked` counts them). The same steps as a flowchart; the moment branch is the optional step 5. @@ -561,28 +533,28 @@ ball, and the carry curves off line), a real-robot item. writes into the sim (e.g. `teleport_robot`) must negate y *and* heading — `543741e` fixed a teleported robot facing the mirrored heading, which had silently corrupted teleported scenarios. -**Determinism:** an rsim match is reproducible: `--pair A B` replays a round-robin match exactly (13 of +**Determinism:** an rsim match is reproducible: playing the same fixture again gives the same match exactly (13 of 13 sampled from `tournament_20260928_221404` at `1de1e18d`, every replay array and sidecar). One cause of "differs run to run" was state that outlived a match: `has_ball`'s and shielding's hysteresis were module dicts keyed by robot id, shared by both teams and carried from match to -match in a round-robin worker process (`c27bfad7`). Module-level state in a tactic or +match in an evaluation worker process (`c27bfad7`). Module-level state in a tactic or skill must be keyed by team and cleared at match start (`StrategyRunner.__init__`). If a -round-robin match and its `--pair` rerun still differ, suspect more of the same; compare the two +match and its rerun (delete its record from the store and evaluate again) still differ, suspect more of the same; compare the two replays' `ball_p` to find the first differing tick. **Fast and exact numerics:** the motion planner, refiners and Kalman filter use faster float code by default (about 19% less wall time per match under full load). `UTAMA_EXACT_MATH=1` restores the -original numpy paths, byte-identical to before (`8c191eea`); the round-robin pools and rsim +original numpy paths, byte-identical to before (`8c191eea`); the evaluation's worker pool and rsim all inherit it. The two modes agree to 1e-9 per call but matches diverge after the first differing tick, so a baseline recorded in one mode is only comparable with a candidate run in the same mode. ## Reading a tournament run -Every saved `round_robin.py` run prints its sections and writes the same data to -`replays//summary.json`. [`docs/signals.md`](signals.md) lists every signal it records +Every `evaluate.py` run prints round 1's sections and writes each round's data to +`replays/eval_/round_/summary.json` (older round-robins: `replays/tournament_/`). [`docs/signals.md`](signals.md) lists every signal it records (and the offline ones), grouped by the question each answers: is something broken, does it create chances, keep and move the ball, defend, take restarts. Each comes with where to find -it, a reference range from the latest round-robin and what an off value usually means. Look +it, a reference range from the latest run and what an off value usually means. Look there before adding a metric: it probably exists. These are diagnostics, not objectives. Fewer losses is not better on its own: a strategy that diff --git a/docs/architecture.md b/docs/architecture.md index 218d8045..e1d9006e 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -66,7 +66,7 @@ flowchart TD ## Match data flow Every rsim match writes files under `replays/` (`REPLAY_BASE_PATH`), and the analyses, tools and -evaluation read them back. A match's file stem is `A_vs_B` (`round_robin.py`'s `_tag`); the names +evaluation read them back. A match's file stem is `A_vs_B` (`evaluate.py`'s `tag`); the names below are from a real run directory. The match results store (`replays/match_results/`) is read first: a match it holds is not played again, so only matches whose fingerprint changed are played. diff --git a/docs/custom_referee.md b/docs/custom_referee.md index 196e1d2f..b377a17b 100644 --- a/docs/custom_referee.md +++ b/docs/custom_referee.md @@ -100,7 +100,7 @@ config_a defending the right goal. Replays written before this have one side thr When the second half's time is up, the stage becomes `POST_GAME` with a plain `STOP` (no `designated_position`, so the sim runner doesn't restart play), and violations are -ignored from then on. `round_robin.py` ends a match there. +ignored from then on. `evaluate.py` ends a match there. `force_start_after_goal` is a legacy path (STOP → FORCE_START after `stop_duration_seconds`). Scripts resume play with `referee.set_command(RefereeCommand.NORMAL_START, timestamp=...)`. @@ -135,11 +135,11 @@ again afterwards. `custom_referee/restart_fuzzer.py`: an opt-in subclass that injects legal restarts at seeded-random sim times during live play (never on top of a queued restart), via the same public `set_command` path an operator uses, so a stall it exposes is a real one. rsim is -deterministic, so this is how a round-robin explores new restart geometries. Kinds: ball +deterministic, so this is how an evaluation explores new restart geometries. Kinds: ball placement → `DIRECT_FREE_*` (position ≥0.25m infield, ≥0.2m from both defense areas), `PREPARE_KICKOFF_*`, and `STOP` → `FORCE_START`. `referee.injections` records each one; with a `MatchLog` attached, they are traced as `restart_fuzzer_injection`. Used by -`round_robin.py --fuzz-restarts SEED`. +`evaluate.py --fuzz-restarts SEED`. ```python referee = RestartFuzzingReferee.from_profile_name("simulation", seed=1, interval_s=(8.0, 20.0), diff --git a/docs/img/architecture/make_match_data_flow.py b/docs/img/architecture/make_match_data_flow.py index 26ac28b5..afc0e578 100644 --- a/docs/img/architecture/make_match_data_flow.py +++ b/docs/img/architecture/make_match_data_flow.py @@ -13,7 +13,6 @@ # Every name a box shows; utama_core/tests/tools/test_diagram_names.py checks they still exist. NAMES = [ "StrategyRunner", - "tools/evaluation/round_robin.py", "tools/evaluation/evaluate.py", "tools/convert_ssl_log.py", "utama_core/run/strategy_runner.py", @@ -52,7 +51,7 @@ 36, 20, "Drivers", - "tools/evaluation/round_robin.py\ntools/evaluation/evaluate.py\nfixtures (replay/match_results.py)\npicks which matches to play", + "tools/evaluation/evaluate.py\nfixtures (replay/match_results.py)\npicks which matches to play", kind="decision", ) d.box(22, 104, 38, 12, "Official SSL logs", "*.log.gz\nconvert_ssl_log.py, replay/ssl_log.py", kind="source") @@ -86,7 +85,7 @@ d.box(72, 26, 32, 12, "Match results", "replays/match_results/\nreplay/match_results.py", kind="state") d.arrow((40, 71), (56, 30), "store; stored matches taken, not played", lx=-1.0, ha="right") d.box(118, 60, 36, 12, "summary.json", "+ ball_losses.md, one per run", kind="state") -d.arrow((40, 73), (100, 62), "round_robin.py", lx=0.0, ly=2.0) +d.arrow((40, 73), (100, 62), "evaluate.py", lx=0.0, ly=2.0) # --- readers -------------------------------------------------------------------------------------- d.box(165, 92, 34, 12, "goal_sources.py", "goal_sources.json", kind="output") @@ -110,7 +109,7 @@ d.note( 4, 10, - "evaluate.py deletes its scratch run directory when it finishes;\nits matches survive only in the match results.", + "evaluate.py keeps each round's replays in replays/eval_/round_/;\nresults also go to the match results store.", ) d.key( diff --git a/docs/img/architecture/match_data_flow.png b/docs/img/architecture/match_data_flow.png index a1a13f1fe3f0ffb72d0bcfe954c01f3d73285b68..bd3dbe6cc2b44de3c906b2dbaf46ad6d104eb5b5 100644 GIT binary patch delta 98948 zcmX`Sbx<4c`~3|R2~gbKTBKMh4#nLaiUf+gyM%3VDb_-9cXzkq?he7BI23ny^8S41 z_sr~HnMty{w_N8w=XLe$fJV1KRgzV}SGD|gDiP$>_p*TjL1-SHp5^rpg)6I_<*y#M zEhjC-6|1Y^tHgO(T(XG|K!;^p&&Rht-vVdvKTkl2Elwe4zUzX{XSdH8u7hI|?yk>M zDn>JB>o0>j1YXB;d&T;h83_$hC&KBEkmi3oD47rg3ZJ*t*qaW_L~Pmhkvfw=!YGRX zsdJbQ)}hgEhdLX>)RxFzDcCEf?T%}GR($cX)6#G=^+IItX;@i+54*8!>Ce&f;?lI| z<=)RyU)$v>KW@lPzwhqD+fXy7FTMh<$M5X*s(+vQT!}e&?iG|j35W+izNPrG`2~3W zD`SYS`eS!!!RVdqNJO^Q97YT|!0$~i^xQuZpAaYK8I#f7{dW_BQqu0=-ai`ax}>_) z;!bw5TpyWEtMd7rPghTG-aRph^xMCU{mZx~K5E8z1ASlBb+H~@Rm9YJmcmvl|LLp- z>FCVv0NM_eMh63lnbW4sPt!B|``OP=0*Eqv=UX{in-ka{_Sp0$GO73`ft%As@u5Vm z998%4oa(Kj=+V0gp2GR5NI5eLo#TZYH=8Uj&rf3vPfyult8NQ{Do#b$c{Hm`kMi{V z&2{RbhRiH4mKA!6e)~g2#R@UPPhLY$-gW-FxB{+Qj3=wj!4H_^7PHTXCg&oZrNNDH z+m5CT)KKrUjt8!j#kOb)z>k^eRbl4T@6Seus9$N6tBqA^y}M$7gP3z)1VMd2N?;91tm%5gcX4<)Wdt@d+O8IUhJCM z#%3;(Ua8%;1}2>!l_tEx}>DU zRf}B2D`=G!j;)Qsp|i7F!09bQ6BP~qw+;!Enj}z26qS+)(wo4E11UG1aGC{RC{3?~|%x zIOA+hXKW1glfT`WbycAa&h-zMpIo}_pLp|3`9uIFnv6B?d$|j&x3uh3fDP4Ju+%`x zw}~nv{T*Sg;Lg7WLnaGL1CH&IRDRFsf_FCZUWt?}0^c!#P4L`AVg5U^y63nz9~!yu z4vu2nD_mbjhtLAH#!hvJWUxwl!5?>TeD8cQdBdCv#QnD2F;6O~JGAB!m-z}q8g%ss z-f8A3rSh;)_YMqbI5@EB>g%u97xTxW+)(Dc>3l+dQU|# z>afEu`67X&FDQ6z3T>k~*3nlz=5_n{ymP^7o>wsSU|w33*CYu}Gn&h-fO#3R2eziPYDP3;WI63n1_@M(m zBqm+)(*G%CTqYwY(wXBhRtpq`?er(_z*EiGU)Wx+F~GxdT~e^oK{YY}8$#)~6`cBE z7(gH*E1{%X?o92`Yjo68kdQun8RtO6Kbm|IhLc|#DjA%Z&=9%70*RlLpe-&glR-MQ zuKW7umG@rIx#l_Q*z28@G3;v_qUDOhii=T^5D}{+&X1RBXY&<^Na)3|9Z+c*=izk^ zNX*Pl$Gj^J$*!9nuaQXT#H{#4&1#x(fQxWwFxba^4~ZZu1`0|T8)0qDww@n#Dl~B| zZ=EnD#T;BY?Eq7}Jnf|!?N?IymsYiRK$@EpPz}<3JZ6$rRB>?A4ZyP#eFH@$%>mG3 za(M+dX2qPz>Ad$*&Gxjnwy!sxg+1!zdwLKhktm*Rri>}zO zv!wA#CM~|H%F_J&V=Kvg^B^A`OLE&5*e-Z%@t{ieJ&ezC94kIKSq`=r=337b{I?6H zZY*X$vygtEmeeG2Vj`tw48Ykgn9LLbMsh~iJI6Mi40pXj(Qth{s&@$JlyvNCmFs}A zU}M?dqy~O~+6DVOViQiFI3QS)1=`ACFEWaZ5(aWf{S-X7ND)3v>quSxO#m9y}jG%5-3B*2uuWLlER>voeYN@dvv-pqmlSs`EelLh(j1#6az}b5&DwV_eMqVP} z>gw9uqCr=dFnCVaOBdP{i}(A_E1u`C^sM?n9lw1j?huacRHgX~MG|noLVVxbKlQVd zaNoday#qVs$7>ujcAu7BbF=z_u#hfwFmVgy*#ZsYY%s?>bbRwzGU!_qFhHqyvFC>d zvL3icREUUlKlL4*1;V*r6TQ=Pu#G1Y2u!E?b_6XZeFt6!Vsu80B=HyzZK zB=o&6#Lxy~451sSEpjkMYfH21K4;o@G9C8ay?@OV93BxqK>B*eYrvLiZqe&T+|K6i zm^d9;BBR03a9KlE5x#lX?VsJ=$U28z+-utu`}V85cJgT(+dWYQUYXcxQ37Lp_#s(^ z?B~|TU%zV6`30I|b8FEtC^>%LoGtesLGJo5-Oi2+hsJt-^%>xIba~%BEFd8hbQX{M zyK`81=^AxB0$1Ra=PPEn>t(Hn>(&~BUvENVDm+9=T$M3|Q2uXo+eh}E`OQM}!itS3 z)}$4dWfgm8E{ztj_!NW0Wd)VJa5%D@g>V;e;39VM{V~R^ zc4cR8X?iV|8H9GXr7;Gl+Cj@I4XT2Of>>W0!GIQtE*0a&*5Rr2P~y-1$u*FnsCjtY z^$9w}=OD0=Z-B0Z+D-)0OSDz@n$MwRJFr4#l|B zIB=N2^+3=Ln?yX5<_+H!A2(C7>j&xMMF}C4oBZk-dbQqhp| zQGgT=2M4FlA-&{dw`q)!v8{gTx6)!;~e46i(id|4>8s_m*S0qo7!SO;vx>`gH9Mx+Bmz(BTPdWzD z07!Ujf5qAFUsyadir;|cXhYI&dpb?xNx`nJW40Mu3}0?Cx-o_CsYKYBy$5$_NMdj=vS2o^H6lUNKS zGoN4HJYUY7;k&*d7%leX??H!yf4{V=f~A%wA=y7KR1{t}7beIB#hUq>clM7ZGdk90 zfxE9Z3&N7^Y%en7f3yJf->NqW%*TY1-xE|`Z!z-=3!IJWlARv8>a)V!>mz?=HAMog z-_TAKKsqyLoxkQ;^u}MQmVj?aeU#6Slln%GUT>1x+M1!6fymNNrk^KKB>Hg%3dT9T zx9<#!7>hpmp$r(oV7I@lW6l4TXRfHeOc~6X$`v zHnNDY??Y2p0BuAIq9>?ui!9;GfJ(a7se2fB)#tYGglwS-E`X}*VE+{WGsx^|KatXZHuTzlL&|5zWxrCD;;Mka>xspN_Q`99 z@AOyoZD}d%)$VSiNWqJQ^khSn?UxP2j5U8QvmL&}`O?fa=i)N%Iiy7Lkz= z#Z5&;29Ica(U}E8sSQ&?6T*59&!svFbIo0F-K$PGme%%KY_sn;g#sN-;wI3V%VJm1 zj=E5141l98)mFzQ_yMI77iU#Hb$NcBirBzfyw}Rg_Tm1@n%KSJer8VAz{bEptbwrY znTn^S#eUg!j(u?wx*tY{$_~vuZ~6bWm?=D2`#8S39B%B$mG+kkzluNa-lxA#14Oh| z+D?uwmCxT=PNSUy)5#hqBkm)u?|Q3Qc6RsvP66}vWY*ge+=poaR4;b~BGRWlSMi$5 zjS!+x`t8TfMDy30KlEI0Gu9r6(q&s^SJ@limAYEb7OGJBYw{uia==%XkGg>f!Xtz)`IvDs8FFDu;wRNs0R3|{b9zXy-i#$@Df{mVaO-bE zmM?(p8|1fHzGv-)+7FDNfUIyn{Oc;~p%2R1o$h@C9_?bHr2O^>@B8~_hC5$!q0Ia& zH(rg`h3B5irg3jIuUl@gZX!eorPwD36%w7Y9G?QfDihj{WbS{-Su-2IW%!(NzW}QN=JCJd zyJMUXCY4DI~T~VYvOTJ=}95>)TCNl*f-Nia@rH(lqHk`=fE&X@#Jzzjv(#wMW3Y zWUsM+@A13UOQ-m6?~I4n zxL^I@NsFRG!YzNsKU!`2BDsW)=L~2=AWCQ7Wv(=`vVX)NF@@ME?Jj z;Gyvaq;@}2XD!>=Q&}T4x0?fK*xwUjD$~&+?;etEc|J#3+zn|65OmKH%=Afeq--cRP#N*hRJm>c z$LD@L72Hs{CQDL$u(O}zGC;B787tlzQtOJLmyz7DMTn`Ef+biVh zg^Y^xnf}Rh`Sy6pS|i`+QI=8b+mP})=kpKsS&NJPMJ1+1KO)sQSnRsPiL2d-Sf5X* ze2&YBn93}5mOFgjyk{_^*TI^z+uH;`da)cXr^BX`vuM+KBJk3?*?&Ie>~>Sj`;aYgHcE*JuPjg z_P_C=RumWZh-Pvq?OH49k8gTcQuM%IFyRDy>>+`oCv8Mi1 z_wWbZLBl!S&Rorn|G>#TUb>F!q1!F8cZZU# z5X1E2kq|N%Fh0*3*ziBBviPx(5w*g2>c>@&j-J1vOra}D&JDqBB!T?>j4`v_f{&QJ zi36<`V%OsE@5eU`3YqvL_GYM0%5&~ZwsjR`Mvv`-I>|3fs1n`4`uzXi(_rG=j0m&& z9a$DOv;r(B;CJ^io!>R&;pRkt0gQ{79Y+^n!VQQSehA}9k^5n9XV1?-Q6jH>-C|+l z3pcP>7kXy#-FD=n-ptrq>{%M?Jv)#fasC8b*CLxKDM`MBRS}0=)m^6UJtN8?5!AC4famCc`f*lFYF)x z)yp--MHIt6M9JWd@B}FlfxNzu9>L^%k^f>XC?bFw`ax2a>uUi@PHaG6E#0ockT$w8 zHUBv-x)iosi4Qo@b*wdtiX9GNp_^)N3aF*(=*pSA$FsDW3{rba`BjR3yVs?YVZo4T zK_;Ia^9M5=5?tRyTdwlExzSCBhwiw9B2OcCUN{1IBo%iqK|a}Ei;1CnT1 z&;qDI|6P+_AXK$v7S#iiTcV#vI@m$Wd49zP*$5uWm&K75y|~_Y3A$+4c1rSv0~F;hwj=1S48_G2giRhE1no{VrwQl-B;IOIyA8p z>qM_H_$Mw~wNs=0b%;%Up^*Qwre|B7^^gCaFDncqEhgo7r7cjIN?18@3)gDb2wnG& zByqcVqQ8*!m8T9q_hX)6<;^X51SXrb7MUgu*YQtZQ+UwVU z@1yASfH(N=`8W4=Dw>CYu^v%P+2kfq^cFf~+@})WCZXdVJ&ejFT zO+SCOQ-?MoKH%al(c$E1tJlgKPu1Rr)iz;q%hfg^t8Vbj@HKy%4sV12BpUWDt=1Q~ zZXX#aPX=(~xFpsm^`0f@nuH_lqQ=$z2IEIF1Pxt>`PD#H*`eHOFlegI^n^ZeWro{7 zHU)yvdQPyZa=R&(T7s4$}IT+iGd z0HRZrPUkUaBX2CHsamJ4zZ7vpcxwMH9IiCj z=dJ^pGB9JNP=*R3IUWIffDk_XBPN|n!~Ek>78|mX;c$jQ;yHZ$rXg9SLJC`+IF+xd zKJV%O-$efk?Pj6=q<+DO767QW%3}8UpmqCD`CKQvNbw?)z@8e>3i9y zzf1))B>#6E(#OymM6`OI70eW>{0a>XO+yyLwn1`cL<3;IE6y#-{lJ{8>$AY``NU;j zkiUM_L|RJmpPT9ILUZwM?D;0Q{vtSlza&zjpO!Tp&s=galB?yIod zB4vs)RBhAKliyRx$fon9Eh@^2B^}{_)%dUqqsnxI)w?Nc#ci!6;w@sB%~0I&3+8PX zVo?=7i2JyF=u3~OIC2057>-kl^d*b|YOydug!jZR;J#11Yq3|fz{K_;$Mg|%y1rCr z#Qu#8b%WfGsLDwP=sly0&8|3)N5d1C#Fs5XB$K4r`q2HKftbH=pG=?AqZ60*eBnOl zo>w}oDxUA5tt)BOzllJLyt}R)P*zjc_6YXRIT_4lI8cX5T|4KTC^)0GrPBj^m`?>e zyF2qkO{AYrAEI@1GKZ;F#9oAYs!bKSjA8^JzklMfC)#3d|LLrDc|#BK8JZZ$@9qw; ziJCshMH!r(jc4l{nB47+$h_89vbIJA4=EN3T8b##etyA?%Jj!Fw=|#Z?DPlc-b6%3 zz-)7ia>v~8;$o7eWx-i5-)z8nYiCEYqN1FUY60im{Z$taHt5s)u8eH=Cse~@p62fajo{DMDwNm7r2d(EWuec613uM$EbNz+b4H~y zP2CXv#KE2apm@=zPzMvzXa~@^!#7?kPxo^%SO07$eg-F)gFR)i-GCbVU7t^lb$Q)S z2rk!lN*>Xeb;eU@DQ;&cX7;u{M?0`H!hgyeCI|-Wq|n#;yN4qp(9i~}6FB=aqH>~z z1ZJw3wr5W=1f4?=mQmEK`(3fCjzV2S3OTlC1vS%=p1!Bjh#c)3Fx|C^d^TpUvt%F z=+&(joKClk17)n|qR#&1h%3J3&V|Xr*$Pue0z&-B>GhZF!ZqIny_6y}e&cETnQ1Nj z<@aUE{q-dar2>XvNR6kP>T5x>~gC$&PrTTr>E5)4lWz5p>?f8BaP(` z_wFNqU2%Ghw+qw_9eC^w+k zC%mS07q|fv^GA6(`MkNvSJ)8vc?brqoTiLL-voC86R)Ys`mu#EA{dlH$z}F-%&YxV zOMM&LVuP3CN~H&D14h#;BEd=Madnm>0>i_K3=E0dTwm|JY)%e(D$|9$<7qwY3vSYV zC#S-|Ph_~W9e5bT92u7vs2CIZNoi@~mg8wOMu5@!|5d$VB*P)OkW=#eIqe&?GR8W?p)w6(*Ri6}M5Pc%j z%iCLEVKJLDBtMZga*m1*Ep|YZ4nwvVUp`mze4Xk!%)<)!3ZkcHJs8)?DEahR7Y{&Z zMsK++4!!F~9skqW@eq!zLO#Y@4#(EDLfQ5UY@d8Uas>@_RJ|l*UF4|Xdu_qoAH&=q zhqP#fo~B>l46P2-LXRT-Uw+XxoD{&Dh8)%tZ@2Ul+U|GouOrMr!md*<76d!9HnwWPJj!%Xz#@b4TZayYy|cm-Myo zDbuWwm{?bx{fY-6zDyLU7OaRPX5&m3A@wnnB%3)HR}kWLVMDWsK?Ymly%ad77E^eQAcWTwP-|1x(==Zn|bJe*UPZ%>mPOX1!l6IYVq?ClOKZ@uG) zE_Yq0w86o_!v|m{z)Y15$f}=G2U1D2vkMz`6%ney2iWFX`oIx1ul353v!jqW1k>z- zOdOPS1 z)kloYiIS*t3Z$T*sc^c-Vugtpt zU_M)sYicS#C1mAvy*XLDr&TTHMdBXN@l=W6r;pHPHAx$AMY4_Odx}tRXD$BH1rO|| z{djoD+9B>W3aT@Hnktx193j%${^pu}5-r)mb_Jj9GVV~JNg)5a8KT&pCVnu)#BwUu zq%7Aq%KJ3$!Q+>~<>(Yg^>(jkv^&7jgdm%2oH%S9WUl#bW@vU)6Y>^~I5VkMEe%W2 z+sH(4$F;N!VqZlm{`WZmfssbwwo}_#_!xBd5-c*leP-& zT#GSgieN0%;*#_cQ9Vdz`*t+;Oc*@y^@sD^t&i4#zHa7+V zY?`~%Jcv80c2mpl1IpQlldh#xgyd(HY|57-!hgZqLkh0Emn};y$UkjVlb}`fE@2g}D z|B$rQj5+FWZoXFIhreu^T%um>`F$^aG3+&-cH;SP|7P>XYOM_^^v9-!7c6Qlme{Fl zCI{k>bVeQQjoRZV1VE2(h?#@-SI>I`53g_Sm%2>wx`((ZfXp68vdXpB?DR)3C`}6u z!~8dno@N#7H_o}X?R_Dqeuu_^4_TmgY|Ty8AYx<=%;)6>8zFSNrlHkl54^GI{kOB!n5agwuWdd>1y`BWHA=fLco6n}mgv z!4Xk8^{WQ}4}C2kS(v_By8Ri|US2Z!=UiiV{Aj8jWpIA2A|UIFfx)OUy{4SzS|VSA zspSVpqf~`zB7Q_%)0kTp#0BVUjrIICRt=w*-5I?9`YmZmix^z#%S+69Wkgok?OREW zHYzDqd{VR|&7o#>?a4O?e(tbSI@dJ?ha|Y^%{m!y(i(CZF!6+S<}ba9e6{&3T2(Tv z6kwk-p0-^_e%AqaM97w#7gR$_vwTu#bJD-A3x2q!#agd9LwPdXY^Aam_$L%T#Of!5 za6&7;Z)BC|q^u7YS0^z3yiBYE(R6QX`E$#Z7IUYh6(&fO?{Ty3iO~5vyhA|`9Fw0| z@3jD|_^xabA?w<|IW@3@KIzq2>5faGWDh~7O9IGLhzg@AsU17vJcw;BCRB{3cZ2xq zQYSmp#8974 zg7>j1Rr;A?1oLx^>|kqT-bzEoM7DmH3K<~Gz3KG%WqV=C8pF-rm2)81Q9rB(B)IU7 zK`^q+?t>vaS`51XcDjaO6cQ_LZ9`RgXI*l>?N%&@KGkt~Dkb^MB?apF-h(BC!jmJ41bSSlC9vexUhugu7UMDTUW;P#MlicZa zBZ|Ggdp`6LmsZk!Ih6R*%eZwKIu1+vBYUT1fsh;TdefOfYqAe!SFkgu$3*wsVux>` zi~XN$tyrD*!{`9jL~1S)q-Zpk%OdJdQK5TN(A{XBfjs>>nekY1@j>0gdfzM?OT69j z@nZ4G@w_~E5Dkw`=7t>DScl^at7iy+^QYS=>oFtrcio5xB@Wr5Lu*+k5wK=qeLDBd zsQO-nT*&LsYtebb0^7AT8oxvKJ2U@QH-!g1FklwZcXORcfFEvij6@z%L6FZA(Km8liKnDgsAI6g6TKnna1vRV&Ry5O;;KLXcz^_PhkX4xH#@GwiH zKf8UUSYyJUpm*R~Y_yxxga;{a`Qa9e@#@25gFCa;O3Uuf0#DL0McQzNK$ z=w3iuY=P(D2FPBevcIw?gH|(_>))`upH9W-)!$?_6}hscjr-gslSU;>enjkp;Z4qz zedpWe-HOmMe0e`FPO_*a8d0!JW+6HtEO zriObFh`HKreGQAQSebMw5Gqi`Ik$36_?NMU;U`40-HvCwHihn#C zwyJ@Jtp%!L~F(0OiLm-n#4t&m>6=C6`&c~uj zNZ6_XffE$P^O!~g^R+Vb3A7TQg)^xn3>KTr2>R06|J+Mpoh%QWDUD%U!5J@JNsGbUa7R(q8c#MVd7iJw zPX25MTkl<*Ja*3f!uFhOj+T)pwtaCcEI}c_orAVIs;F0r@FOMR(Z+1wEt$A^!au>L zmw!uQ@<@s<8=NJp!o4-V8NTrhUscE2>th&@JWmJL=V0^mJ8{T!uFBoG$F-B?loG0| zw6Nrkn_^froj!`7hvDn<*o0Y$+E=*sU`#gUS^6e${sE3dUlZvCOwg3J3%%%c91#H6 z$=II45i?0&w@?W(xKU5YrEQ5=a+TY)f{hTxK2i=P;_aIl;48Hk+NtYj+dHA8ydLp# z`E_%B;wq#at`-Rut;LO}v6%fanr;^JEhU&1PVMes3bP zaBB5aS#Bx4KC#|d1zre5RUAHwiG0=%WIg4g?;$;FFzTuM5`do z|N2(ELd_0oPGXZw;_i4-&eZLcVw`~Qxo&EWp_g||)o~J*K8+_9W+f|N^IDAQbM2i^ zBGXh~b|m%ic7hzGWMyG4+}@?ew^9t_)i(oCX2v+pc-#Y*&>>EOlJwsrM{{L3*)FZ-4@2g#!^6c>E*3h?HzhAcUVJ;Y4n2gHu^?DP%UaVU0M#d3d6cc zWUvUBKeXhRY+K2Vd$!Pgno60b`{`zU-+hm_WEize9Icx^o`Kz-g(Vr7m;lj~!wMRP zHbFD0*vg2X){4G4=4aS8bP>)+W13szNa*vZ9 zZ?SA*gU4*ANE%T)U*PaMX6`jLDd}fIy;8HS#}(BPwLx*+1_Oo<94;pl7=#wFfa4zD<1cYikQ+NU^y`I4yVpaWc^!elDLR~q`{+{Q)ET8~mQ7=x!Fsp=SESeyapMh#! z-Q7PEfnm|zy~A&|-6c0Mwu<1R{guSvd;<0qamo++wuDW^HmSom*{hj#J0k*pdXQ%c zpsr66u3E#jyRF0{C`h)hYMkyE6XatjEcr~gx0Vs5Z$0x_3~1YDUA|H#t!sGB9c)L>ven)#qBNF$nXjR$56`t{#drpM3zZr>)f#Sl z8d!1F-vdG0&u6!tKLJ(hJ=VZ&{Bfnn3~)0DO=soi))n_{CW&j22euFkUaE7vN!}uFpDx?TiNn{5(DOJh+CqU%2%Q)Byee+I(sztvY zD~Q$P2^P^6&#*@NRqMc;$gctzRYoD6r+enfwsSU>X=;Y?-tf*&hLe8BCq zHb_^HhtU2Y~;}VpDM6uRevI-513if0L-mTxxDw6 z7ThC@+?O06#xIWRs-yR^DL$TkPA+1qAXL->_oI1dN~s*VPak1xHVWp`E-$aB`<8!} z!$ykJK+93^kS1L9c%@*W4^W$7nEJhIyRYs?D>xpT>UcFO=La(%G)J{E;wG>XLUE8I z$Z+_kX=Bng1>0jA<%Zq>Mc-77prbTP!ib7t(%9A;LEo&r2k@|*ulHdb5X}EzkTVy@ z2vUOHkuTR9QOqMvDYj0tEq~)fwWRJXuc8DqRhfEwj@5;pZjmX2~7M$wL~M;;iYs4yf|- z6$wYujospKG)@r96^R;0C!uH@97_T`&f5w}duj_Cod#*y+71&AYWj=M>#?+T+VI&! z*d1IkSb*`u^2t%lImKsxv-$@(ogElX!u&bLH3wqob`75(#Jx_HkZr3kWhHqk2HyBA zR;4AWZ%+-%Rj&`QpdkS__iRx1=E#|!Y^UuXvKwT!p#5VMRkS0TH%vzmg`X?)#UlG6 z)=T)m6toD{3GFx5P5JuCJW-iFX+w{C6ZaS3%a_>BPAYH{w$$EudSNuhd!s7YUY4zf z9s!GA%5zd&An@MQn{F$$&SdEEDX1-%E|+|OnYoD#1hE-un{6NS@zVOJ(j%8gJC=&$ za8_5i@K*TNDtKWP^4S~b|I$~)?3X}jI5s{V-T$EMfGKRTYSbKNvs(+%eSkM2jG9Vk z0ls~tJ>=inrbfS-1Oh)wJ+m3JD6##10IiE#4xFm_j+tS08nceoVW6i=Sm*!Y64W3J zeN}^Im$|6VFzN%;FNWAhFKbTI%8iuWZ|aaK9)*NYX%*Io@)oK2eYIvt1-5hcfvSN) zK)^x0Iz~H3wZrD8!)c(Bp-|pRvFyc@JVO<-+dw3@cGUU?lW zs9sJsjFwS)7zToT#eWx?gVUS7=t^X@0W9JmYhgtTkx4zvVC3t|X+7G52Anv#dWDbZ zI9bz8XeY?rI!JNfzkh!mjdw^0<~@$6YBKIYmOowMLc6ABH%jb)r4Sr+-022F`Wl66 ztHs`~tCvptzbo^P%b1^9+H2{EI%?{5njQWl4q=4C?hSs;r%%?8B^X>b5AQw!+?@G& zK?-h%8)|GW!Q>U$;GSZVpSp+1jNwAQ-z$FqR);kWv=L7e1zXtxY!QuTlkKj}2#Wdd z^YN?gdGo=_e`z(rkGDC$6Lw~M`GRi`l~Jdvn5G?U|LGpg50uEIM8c#W&l%NTJOU(#V7f8e=#xPa_|!` z1{rSx%sa821+q{7U0%|0a&pSc%4QuO+tt+9C(O`*x|L`GwvUGMYx< z;xqV1L_RE(RD0aWk%@l3v+?uweF0O@z zV$Ag}j$`5*_rENQ@`}QiJ&zO*n2Nd1BB}PP8x7yt>Zg8q+&kD)V%6i?>sH&3N&gi% z^~l2Y)(--)9*9og%}`KLDFnBAoFnAut%{i)0$>>-J5o{6m3D7d_cPukyOU$*=a{(q=Ct7ni^xUzwi?9{i^{ib{n^wM2*c zRyvuF+Upz~9Pd>o3O4;qC*Hk#H}6h#h(Y1&mfeM?IsR5t`1SNeWl?Vb?*U+Fy!s8( z921A{Gy)BM$#}u?j{3rO;WvwY*%v>FRP5>K6G2(Jg6O?#4R(fK>A8VEM(K|?S#9L2 zG@UR2r_S*b(`P4YZ*F}hH}pJ8ZD!u|5CF)pSt zQr(QHs)+yF#`PSdmsvsO_7DJb!~Rdbt&a6k#P!vzZ{^S6{P!X#4DSu*oCvhJwVm`D ztd@R01t1LaR$)|XkU1QeLy_=7z+a9NghDLO*z3qsW!#jM=-XC&$ z<>{FnF6J``&VOqJ;2^K(WSZ&*ior9wu$%aK)z` zGuK(J__W+sCpKZg$!r1MXB^D-s-hSTC%#q-q%gpA@d?_7KCL%yCLVDUj&Q z+xlq&HiOv230@f|i>9V#^+bPAdkNpH4y^pFlwgn}?;V^;0Pp+WyTP)P4&(Z|Y75@T zU$%X1pFlMF=X>IWp$12DXZ?5gA5qMJ7E@XjGk!@Q?OcsEW+e}l}8q>~pHc`9tWX|{U56=HvQ_??i^ zg&?l1%|peG7&y#ETk11mo$J^JNY3c^`Uou(ceM znN5L<3#}VT=6z4=O?4Kr_tiTfrtzrgq2mS%GcQo^cACoQMbtiEB~B$v#QWiX|5#(X zPts)X`eZNB+-7AT1T9QqgPdt*4$e+WvWkd^DA?a;421H)0DtT+Pn43! z%cGG99W&EEf6WG%*iO`(F_Q_R_%T%rvaxc9kB*McZ4ruwxoBz58%q1gCp?F@V-L}$ zmbVYDzJ)^DXJg9kPX?jW@~re9CIGP?Gx(>`RLcq^#Y~z82C@gmL$JT~z{pp+*hPFP zCGq)jMybGj^dY8LAizZL;=M<{@2Zn)$qh;GEqw9;6Z9jiekAd??JN=pLihS=NI4ZvFZ@z0P{b25_;-$Bp|7 z;RwYw*&5!hooQ1`xg0NK0nwN-3vx!zj~c0GuZ|Gm9o$ar{Zpdrm8^ovW`TxRY)4BN z7Cz$tnkcbV*A$FVo3|-xcQ)Mjnoffc$tlcuDD7>fd`;|Nr%u_={PsG?~@=kl6~7bxidmoZBz7 zjMZ5eAG#~pGItaQ5f_x1+BkSI*dg`AphP| zu`ly^ZgD-|3^n>?*j!}HNUwV(>n7FCpqdmTh+{NXuKj5qLF@vsso!;6j=xTA$B0O4 zYn!h#M^T(iFwzq#x+!8B=WHxsby|EM9a{-pMntKB3s3zV3_El4zvYE>v{0nzb~F{bx$vvRh-WSN;;nCYL=@o;FXS8qem zYI!vUYbyT#xcbVlDz~;<>4t@Lmm(d~Ev*ug(v75a=R<=ap@?)#mq<6#(nz;7(%o?; z``zC;-+TUX!NpqZS#!=i#u)dQR-&6zk8@)55mlQ79(LGQY%zRZ)D$IG-b@$ga)Twaq z_T>YkUW2E4nMw5zP^z&i$WJeo)=_m9M2e0%H&#tDvNEpw_{V%_Bd4VF+2d}&1H~uf zvoGjXlE2^0pR0GZc6W!eu&^*NGJbge{JE8l7?_>GGPRm~WdDf+5HsUZKuTIRQtF~} zAz%|@N<}+ugELp)tB9M69}^E*gYafCN1<9^V-a(8xf&#wf>3me!ZR?xR<4dUSG!>7PI`zTW#7gU^uTDXJCZ z6j^HqukPQD)ehNTwbF3kDXQO5oE)~yiA`|^Nw9^a#rIxSuP;8u9~MpMnkz-GLED}V zZuZ$W0SCgcjuwl@XXq~(dyrVx3wXrY=5`cipr-jN)q(q?yoN3v`3s+Fz7UN=ThQU^ zn)>>l#p^#@q*D-0f*9XL+Cbkg8l1)O%NY(MxXC}8B(d&#b16nDk8H(}oa8XjcOMTL zi_!bbC?x0mV&TzT6t_E2E*rivBP6WcG@qwwNC*PwdhR!D<?de%( z`%rR=0jMB47NuXmbij!HYPzqvzFEMENy5DPY_!p%Y#S2A;KSMIlb8Rtxk>Cwxy*hy z$p#;stQ#bFeSLknm@OMUa<0~@Fvx|q;Y`5e zNm~ZFXNk7g(dlGCHcIUQ8vo<+qPN$9!)uo3!rCi7-}0U~#ch7z+FwZtv=^ijs;!w5 zEZonRi1dX#e)Ksko<)wig>B973Ngn5b!$&&RaSOWE};8=2J6Obe3vVOyCFw!%6MI! z8i=Q*sih&XfZ}SG^Ld$eOC+B~mVGWE)$1&qkX75!;cFk-;TFt7c(TqMVpDVCT!)_* z(4l>0iv+ul;UWyq|A;kL0p$12t39}-XLEVch0sAFAZip~;v^cY$UicYcCmUnCZlB`?hIXnJ7X)Vx-E8hAm^W#3PC5(#pC zBC@#A8@&i2;>)!syRr%rMCg9YX2pr6IXnFoL%eA4VQ0Sc$$`PyBH}+wueTv%X6j*v z@b1<4x}W_uR>K72fKKm()lM5fdjv~jN6v5b9eyAuEeT>|W)lyJQ#)_mgvair3{beeY39Fee=AttQ!Z4c7mcF_umQ`CSAYMK+|(4He?Uh~ zzP)TO%6c6d(w3II_ zEbw)-^WIF3k5}m?cq%J92#Ak>i3qcyGzAJF*O*a93_qcZY9VtcBWzS<-s&@Q{s*%os%9fcmn|beWvff0iKZGlIy`kNPOt&~-*KsPJV)KyZ7_#_BbHB#A*eNk z!;t?G0Svv-W&U|-CFUm_NImV@fM<*oSJv|%agnU=-hCTA@uH$L2{g>63$YoJnm;>9`DcnFsjB79AHK>rq`n@4W$}VmXM1J;21&(oD~` zSDNw?I{rP*eO!Ls_d#FWXqWN3567aRIQh-rTXu_?_VbufyUt`!94dCgD7KVv(@9K6 zPjScp;X?_)2E5U) zx~Xbhi%+EZYoUumFMa1~J7X0ZU7Y(_fh5v35sh*8pE<+}4MG?nQ2hsADy#|H24qAq zs;Vh!`&+b5E$v*jBeoyRcEx7PC8`>(R(`P3;GIakovC0Eq?IQXki$5_sGSOz=NauAXUs(Y+_~mTv>lj)s2xm7Se%OL1yKtME{L{RPuP&XGKf;yk}By*Hwl zPpYic>AN6|s^~Y#FFcpy&g*`#r+C4px!Y4iqm#P`q6y>`6tr|JzN_gi(k`Y&Lqgaz z)lT-`mX~R-w!4SMC%GlN-1hX}Fe-SpPN@b|r1q60m2u87-b13Sx{PoY9{lA5den`H!FNtv zKDKy|J0xgqjpNA1K8`uNwmt;2t>ia`WP%W`LxSM>-@)DN*UW9>Rnm(|%^QWJ?2q79 z8frw%LQy+@Z}GDrWikdfe$%W(+f!Sh2~Or2z$dIv`Dp)mMTlC;TBoy4SIdD}?@vSS zk4mJF6Qs7ZmZ(LvTJpZ#?lxV$R4t;JZ8}6PAxtf&A6+qbOXrxj2Qyn0N=`9lyUU$W z#9D`B(7L6GiHQ@Pvlc<~&c=r9#Kidhyn};7rg$Lo;mY69yiav?bt%n)kJ7bJP3tWt zn_1SvAJZ0*L}4!V0gX10ns-c^$=%&0B5?+{#zc)~R^egkj_~qDWwbJ! zVt?ZtIZ$OzW`Hamot(_9OgbWVe2BPHzPiADpxdq<(?1 zbR~D@oErDiocKY=@{Q)XgDy)QFP3lj@AvTt)2S(4_C~W)z6Vnw)#_BU7(jB6_aVZ7 z=aG0boLu;uj1uOF^6jU5LZR`06baa$;8T;@YE}lc|9sT(>;%Wi)K$=y8mlwLBwu01 zZC5HezRXA*woLy1K1u9b?O**0L&n?NU3T3kNO526a)*3mF|$rq@vqh+aXfTZ^*emK z7kN?*$_70~#%r4CkX0q*g$E#ybFNa+NUKqMJgWtz#eT2S!b6oK7UUpg<<;_77GsP6 z`)$9zcLO&$Hzd1ao(Z1I60j|<3)WY!Uezf(Xg#Iu>h9LahsUXjD=Wjfyu4IR=DoX_ zoSy#0z}ITAve(ep@GB?;DLkeB@&XGROJ;oa^JnAwTmL+(cLpL?STy%gE6j>vRrgmG z7BkV7H&#@)qDb%WwXtz`_PgU}g!o?A#JM%Us|ER?BeN})lui6+Cga%6hjlBT2HgCm_3223|tY{wJXU#h_f~nZ-yWl0w4sMBi&0HdfsW zs^Cz!!spUb3TlGI3%^xcF6+=viEDtNYg)S7c@mRq-s$EKSW&Kg(9) zJArm*<9Tgn`Uejp$@uKwUC;DnyI)nVDuZ$F^@sVw$dqg^oZ%4>Ts1XKDZMM+;%P5H zR4%Pc#^d4PjT6Kl65X$OC{W|mPGyB^yPa z3COA6BIk1^mDQix;CJ_@D?;_cc?j?^FfcqmGqJOmwb?}i#~9=>o$pX}HLa}dGe-wT zszj~X|NR+YRs%~D;B_Uk;rZ&8zkFa`v~sQqgPVmYEJrZiGa+2vNKaMl(>;1 z+$j|j_V|3ZH{We+?%+^9a`glNB>reC`c0mWoOwF9mb4Gbj)xC{unPFDT-H}>cB}8- z7x$^_hJ;zz*yx%2;3IPEU%$x*;$Hm66ICPFFZK1YyYb!}l8Zl$0YSKyb`Pxg_Z%yZJCZ zQVL=Bn6us4?)1@g->XEiqL-;kIxl~a|1)(Pgxr(rwjd6&71Kb9K&6NUu)W4{WjZz{?R_V#OWi8HTcn zFrG;~(Nheg)A5oe74;RY^SaDODn9L7AMLDV_)+2ZZBXQTwEo@wZ`J$jFnNUmrXXRB zaeeh$xD7>$9KRTB7PE{dR|>(A&IF7v-U9wWF>A3i*1*7aMJ~NF*T1aY&DLbmdf)(U z?GoMHiL^xR?vkhEgHCs>z{|kbX1b+C#q;&!lB<0jQEc|bYVMWh?t;q7AXhsrIq(MA zSy>WW!*wX9WP)#5^G(5sD|EcRDNOG}F7!S0VeIhcM%eNECFE0*>W#Oy&W7i21>LTQ2RsifPp<$1d2;PWH6l6GD9-D8 z#^a8HuFh#O{9>ljgGOf&=tmuYLql2qiKI$||p! z|0Q8KHm$m~+pW+5C7X%e^NL)YY>(M(63UonlYrS{NEcJdE4GnJgZ%}C<;A}|6D z?+bfh?~_f=ru6;fe+2^I3%1BIefMqT7agwiY${G{-WxJU+wmlN`Ih+QtU(nZFz{?z z2!v!*3}4DRI@?O$hDN>9AeE8|Q!iIGw`}|9m9K7%b7YD4QnFjVz_BH+%KRlnt)yR1 zEC)!H!r5&uiziiBRztS+wmv8o47?8*nDq;!1(rlfwvXu06O+4_^wa=Zv zEZpYU2m)s-z{I4{o8l!+y2#=G6`|}@PV!H9o@5mRcCaVYKhHzEj8g zxP8XJ5az_NEQAn?T;(4m{I6Yw1Rhcr(Z%6$O`iy~JEKlGLj3|xM@aV6n%=Asp1D&x zIHh~|_wVrHVw>?Yp@w>my2aiZE}*iaeG^jyQ70xQ78%r(J26-fjeY57W%+d?)6nZ= zVE`A^+%(IlB%_TkW&mlcNKh`^#hnptXJVm#O|n>LE!j!nmaM9Ba5~S*G_lKupv!QK zN%w1%@1u`1SK^fCnYYEdr@7SORQ&kCAfR8fi^PyN6s`&OHP#24fA zv;u&AbK(9pJY~+wPER9{$~jf{pHSVu7(8}2JSPl~5G~V}ZD_{53O4EQ8(@2uMv8#y ztci|sBml`Su^TkY4K*GzVtCBl=D%7jnh9mA9HKe1wz2MxE;kTDkrnhX6{Gktr2xim zlp+Wnbv&3~?6uw9UXOyrW4Y9JzX=jl?O$Hpu10{!5R!LAQRpn4&duq%pyrg6I4oWV zP>=a$5*ikBqs_eRsrb)RQFANDY!9{1LeZ|a+5-X9ZKh>kzYb4S$qCr$sAu#(m+=OBd7 z?Rw|C8DNGKAEvvmxIN+w*nZQZtZK^i>Ywl`4ohON&j+}b^20oz&)r1DLCvSQ zDlDRF4(ICvH!%shyDR8}sQWwS#6&G6&6)*#B9|y;1=0pFAUUZG_|cTz>!OUOJ1-)z zdVU?PZ$9$a16dhMfSF6LNpa||y_Ua!!Dd^aku>ge-oh~|U~`Fl&ekiu-}m(K`*t;f zLUY-1^%vdArOwddJ?f|o4FNw6^R}$ZwW!0okLNkuBrTyr43vBrEs*|$4v%(qtii0J zwrIHAnti6y3iq^VKmau3rRZvEj&efsno&9+>yZxT1+W?-jo=A11miTi3L z5IbTIHr~H-eb&bK0j4AgvIX@-WSVezU+%jya zk)ak2=v2boj4AxLN_1*$b1p92XPUhDPPZrbbBjbIm4uz>e*`>OkSLKnANY4yqr!)Z zSVeqzl$Ah>&9wcqB$uB`kxEPo%|V$(7&u}4o^a`7$d@!fy|N#%47XFS%7e<Y<3p|7`Jf-ljk`0B(w@x^r)Udvvl$4MDi_h)^u zDJU`&R*7ExdlrI7SN^O@oQqvDg^sr6Xe8H7a35drKwrueZ*OJ=4O9z_C;2MdYpOg} zJ8OV-#Osa@L1ebEL@x7Tq5Vd=?TM0XIE1U%*jUv_48DuYOThl$-FR3nHaCr2Gmqi? zk&qUr8m_T3I66EmsJWi1w8YEF%NsrUI~qAB`BU@%#T`^WtZ?s_OUNb3CF=uPh|qYI z8sW0;q(!KmwTX?%Gh<_sOc1fhD$L&u=6#@L<&(7k&g7OAB*JG4qMa;gLPXg?GgMe} z-RgA}r=g!&Wj#sS1O*(z#FhVjP|&cEQUfVmmw?Fm-n{I{$cRi&HnC;L0-6GDW4zg5 z%CCsBGP}r`sS0zPHE3gF^v}=0$OW;V?*HpUf+c$aTNid*eW_jN`1JOA-`f)uas1@< z^}vMSYib@)x3H{gYHzWP(T%0l*75^u8ek9qu_iT@A~eCv({l@ptn1Qmb|2^y@kvR0 zH;U+Yt(KL-IUmZf=f2NGKVbLQv{K2p8Sj z`T{$C5^;!mNJ~qrAf3-tCzw^II{%z`%s>iELjI?O1kEXOZvtmF5I0ez+#j_1Bj|q5 zsn396NaPQtiO87`rDZFowpr(tDUhHBpdw6kZjNMM^5g^vw}pt^o~Zglb9GMUgmwm2d!}|LA z1D)pEXb&wxfc00&c9oD&GaCBz$^7Gtm^e}!6sKg!5=*aOj7wCkRgwE!IKiF?83}15 z4400deH(;;zsYvZO94;$M%nygh$u@RM{AU5OFw;Dc&_-+lnFQnQAJY-eZ@F`@g#^E zb#kfJVa1|9fs+L_O~|dZcP@E+ny@?h(0E4q$EGnU^5Mhq6W-3@6N=n52p4RFK?H% zD9U|hS;~59|BZIFDR-A?&i8uP`D9a>@DON6W!giqR?z$G(E|!p^Ntpw;$oJ&i1P{X zI0XxL;JB!VOlz3y?2utn2v+uT5^NDZ2yFi6yUT<_D7XACOhYQIerq^4QY33%Y z5#zIGp^|z?E9F3<<$2giq*XhLbVRphd~pCg!u-up?aj>A6{?D+MI~ZC&BBbIB0`;5 zWV{E~fMxpTx;t}d!vEy{?%Gbf)}AJGqMZbdrUH0$Ja~CGUFQ#0_oQ#`?kd2+!FkT& zZ&9Lo{6|;)@Zo|yf1Z-seMoUi6?8EUo%x+32L{~2JrI!#rBZrc7M#78hvnXE6_piA zw@`|B4uj_u;4@O^=jVsM^m*h@uMbof`Q3z%<|?do1DC3G;Up9sN|p^p#GbN?1+RSv zT(}UFd&8Lsw`a3Rg&cox9uc`^)K%gxQnkZZR zAGD*i_r|pzN!o#d6wk}ci*OUDpr>yy*WwL+&^h1TT%Km>nVXwKgg5{{e5I_cyyYGG z_3PIy7k!U40#_;5?TJVy?lyvgVjY4I+XjzgvpqRYP0gw+_AxA4;2ZWo`A$NFnw@<= zca~VpR~VR+Co853N`p|4cVOS%NkT{g$D)FSvUc z+BLR%cF>Hp10iZSdeYM1YthbkeP7jK@JnGnJLTOc)iyoVfCSLBK&F`;$Nd>xFZnO@ z@=xf=M_JuiY|OBD_pWm(hasTc@F%?0qUaYr>yStODAN2&r$lVhvfV#!eA)&$ttVKp zkEPSv0s`RCF)>%Oo&bCMRPFw8=Wr${E>XEv3U1a~%@91^z70s7t!on#;3U}u%_v*w@ZkmYKQI^8~LX!ulS%ZC6 zsa8eEB6D~k3=lnV8!KNJRZr3;dav}yt6^<4QGj65v%8kK6%YUMPjm3kGDwJI0PWuI z-@onZDfl1b3Zj2y(|cQ@v=sx3<5FM};luj;`7^(%=iXeM?nk7!EMQ>c(s%8D&dl^S zn;-f(%mMosnE7W>$MB3zOnN#yFLP(nFt%T2X3{usjah1g9!?OmiU}4TEt&;E@-Cg#L>ck0L>^lUzi~Wcq(~26(m8po9d??8?CJe@VE^4i-UJtH2w8CGpuQ z0u8_oKO5Tu1LT9d#a>!kN=|wETaJBX^;hh#v9Ze1h9}&x|4K5R67P#05T*aDtw|#w zpKK^i1Y_J60U15hKG=(!|GE3(-!PRg8$gR*K^*ZamLBj%0u-X&2^b~B0V+#G1Rfxi zIn(@$DgN`g&=`WeyaI!mSo$#$DTa`c&|n10-L0D_km#25+JKbUv#^i`PEO<0oLN0k45vtZ%&OpBML?OT2v>!6Z4SOKF{<@Whljx3_*bH^ur z>@Co50L6Z+hyLf`l-N1WkYfKm-Q3*r^71_+BcIUG(HWjT?cCh0u^bHnIN~cX4^U|_ zl7(JIL_nbIQ{dd>xYi3S`V61Y($ZSo-`&x`74~hNV8ZWAv zDeDS)I5lG!G1OO`Lt;L|fsRVhYfc@6_*oRYIFA>l;Ru&~r##MbNYrHsuFc zis|BRb91wmatUt&uu>vq`?s`O(+>D5o@4Yfwnd%C@6ZmyEnR)UJ{=8f1be$(+_!8%Muwgp;Q8uh)+Q$H+t*i264^L)z&WeO z9pgJs)t{E>PNW)RH?U`@^EA~HMWa&2Q{QkyD?7G}AWf+wzQf%(wANi+c&X<+<9 zlh^V6_v95>qE`hg%f{ozbVoWVpl~EY0-OTYv+URJot>Pr*9V?f1aewh@ApE{IbEZm zOp@*(2-1;P(Ii~lt} zod|4o`dlDAXs)tg&cN%~RYm`FTho;`ycQr%`UJ0Z6ujAp2KYj0Egw+LNPi3bl37 zps$GJe8lN;27L^-&((?Jeu;X~+rtY)2np%%9@N(?yyj+RD&VgknA+9v3kE-g-I~0o zrK7vN&0>75fqWHy>hRtIXLj2f$HaSUjB#+6gqZjxg`l%iP1VCRj-ukaiQhKi1}Vh6 z0@?}TL6hz%^>p(_KG<1wV-Bd82&#WJ52Xrqugo_4cpaUeZ)||_yf1wS0)gxJ-ad7i z8~~ny-Kgi^$@pwn?>X0dHo}}d{{DWthj2F80zuDtY^Fx&9rIYhjzAK_F43;a+M90} z87oi)^H1sEMuxj2(fb=N&#i)ImTf_3_>`1`G{Zd}{!~=Dnl~q-Z%#n*HL^1uJ^WCs zi%li?2XB{GR#uimI7Q-I9b7@$+}4VWm($Lo%ykcQRtiz`A2u%R^0QGqw1reu&FsJP z+>3Y>#5_M!N;q2gh#~tfl(hvcaz@XV%V4ui%1UzkT+go+&6!LRkSjCs-c6_)` zuSOX%QQwA3stbIrbK3Z!iBygyfCl1Ue-=TI;>lqkwp+25)Ilp z#dV?frdap|1nY@nWsJ|TKKp)tHenQ_BM>e%BKmsolv&AFG8j$YB6s0kzkuv1K`|=g zGU%33uIvW^zR1AKsnFe!AI5s3rbO$~PF1gFb;jS=(B) z*j>*C{z|k9bh$=kwHYR<47xp}<}aMtfk+j?=og$SdC!*`}Sm~VyG~fNV*aMW=-j}!}+7S`fY^1{ie}- zYIt#&`is(E8u}i=SSS`yMd9x0E?E{KCI)!g+Ik<^sFW5w-mN#P_4i0(9@QN7a>+`41l( z34inGkF4}@D3E%k7s(a{$pp!FA4h+n72cc5)W#7*PFVVl8Q&F+XoeXa{_zaUMEtPD z>6)?iXB@IuXfFqv1ZyBihF#SA3@(y*=;Hp9C`Iy3!V0pLdp^%?qe!gp;wKqV#a#S# zlj+rNX>iy(n~&=%?G5O~CukE2`0Hkrz#2L;ALhOls2CH8Em%X|T%6j!b zo{b>%t*LCbvgSW}7Eg-|A7%+l!l&*Rul?!t+Jaw7Qd()Orm5M-q<`r|we2$mm*N=? z2PZLqb9pS_Ol*wTrQ{@51=o)so{;Z%O_+1f?~3}dSF@EO6qS8omnMv6j?gEB;S3<& z-&OI>g;Dq4cF4YuKJ>>>bHb$deM(PXh$M|#F^<;V?Hd;Cx>gc`x|7ne@v%XY-)-bWd4_`fzbHlq93zWgU;XLt7Y zeg+HZuKeN->n4VYO@`&-rxIcR7~>yVBJ~^|W_jicZH2@{|0W9vQo%0?6Of>iDbDI| z6DHjnO`DGZQ}*c{bC}xpu3{xoZwd0QTGCYWQzdt6)k#Tlu$;eT9|k*9=lU(^_$E@4 z?npEtl>9o9L9zf{_|NNFLzd+x;d2zT> z>2r-u*vBpXbp{d2%)3hQx$0mFYHxcr1+LXNIyo_oCpx;Nk)MlsIGHx$2mY-&e%-x3 zk1#P|@zlZ+V^W(tKIik@@Tv-a45$vT@OHTsl02UB)QlqU{;74qe9d2Kmi$_XfMgKmpq0z&!Sg`g;8EpQAaHcw=ad> z&sJKt8`DS`?$S!QL)7vlG+nn>r>bJn4#Sit1NVo5LFxnKxxL%H!~hRE^uq2AK1YyJ z4C_bbnf(1QdA`6fbxed3QsmBB+KcJU= z9gfTL4u2V*)$_4$D_(z7IB5^NR6jw@q^tj%fR9h8kO(*5C&efDzbCgs3M|#}f zo*ySL20K>%6nK%(c|_HwnT6jhe$B5~8LDLE=Tuq;L8vJ(Os|v8pF>8)u*aqRT7dxp z{AF}f{h$GI6ys=Sep~$KT-immViTpy4PbI(F%Qsf5Iv4rB1hmifrua~XLa{V;31?P z(}#@V`-tEmJ0Crk4I{BDTET>nL?NjrV;^NfVUc1{zAp<$*;`R?x53+=2+-|so)J+c z;X+ffxhVN;R>9AU`;$h`-Ree%X1OeO56NE-)V*#PTsxu#7*V>V&E#j9(COho1agl6 zDZHRz38etkAZrx`b4?pR`$^D#jskq{??1v2N|`Dw$0eH8(~_EnngCiU z>acWTGTj=J6zT~QlSOx|$y-pE2tpVk_U$yqXQ0y2h=}jW3ElP$dj+dW^W0+e#mXX( zaQ-x^Of-eO?R`G)=8faeG?bZ{$&&Wd0Y!sa!p)91h;(Ui(fb&S$jpECu`%T!=ZuD* zQV7R6xMdO>Z31!p!$yB%y9XXkX{H6*707Knq~~aZ5kXa-n4w#5Su;Qe$%=B zpdQ*1(b61jj@ox+ZspkTO!VRp0ydva67$?Br4;1Pk_6QbOvEa`4>D3>`an2MEC&`y3gQ2j!AlkO=`naS=kt`^I=O(gA=R zZ$)+=&74}Vo;Peo-fTem)2p_6qOyLV9gb!_%=_DP+gA`6`>cf2;4ZYd**}q8SN;!* z9G9s!S9}D#*{B+J*N+%WKE6rqRJ~H>gB7nQJW+4EDOZO3i?h6$n)F4#fxxz9G|?7B z-e1fxybwu$;YLq2TUhiAT}q=&FE5Z2sq)g9Eoc49@3dH z>Y*Z6cV_ABwxkwSF2+Z)E{v62{3iv)A}3frevkYJwv5@_aV+*EH4MH-=3)>M6w<(x(dKHPsAYwiJihh-nzx>R$UlkH-!X{NdVfL* z#dKlBD=U3W^44$jRa>RueEWHVW%?7;`R>F1gEkCb_!ED(UxI*sS_#Ziy)D_t5m*Kw z*`(IX_PeX|eOU;)Jtf+mt1Eho)Y*j?B&IuSjcyR2G=BR8Q8p-*EO~|ye~s-e5a-eR ztx<3(Xx2M3_U(U)a|uS08Hlm$_cP*s9C0OA`%doY=*ZLomu3_-UPklh!0NMqZ8Atj zUkj!sBuwf25Yvqx1oDsOn#Uj4Ai^*;P!y}^syl0BVv7$WR zu78zQQPVG=|ASWLBkk<&_AE5h&CV0VBxkcwWxuxQz~o?i%)^dvR37T2{Hq%^b7Xc_ zj^Z`VfABkQ-oHD|?Q~|nrI?9fY z=tS@H70$^V;Rn-O{G52vC0xXxzRUcpY=_jj{RFKN$h$MVC&-+nO?{~AxE?jLHP`*K%9+Lf|F~_#-*B3HPF}X3rP+ICyxLn5;CpV@*xW>RC)l zC03-<6uKNYhmB6_^YQb-B3}1YR#d3Q64?BQdmv@1{n`$hI=+983CjJNiL=1o>ipb@ z*LC1Qu@sdMU2_Rp7;=eLm2|w+>zn|V#r`+AZfmGnNuY2U7=WDY7S$(oAQ^xgAnNQb zSpeXjxzZhdoJC?=^4GYd)3WGo3BN)1f3~3#L=paI(yQv%aHeFw%`EQ&NTwtqVO+8Y z$-xRS<|+U`!QON>V=Y6{2tLcP$Y`bI=&C6VK|^uu2T; zD;!40`SGQ^lpcmKKR4(8ce(;a%30(CgTCEk1hYn_oJb)Px6{y8y3OuC zNM@!L2O4I~9WpL+f@$eMA@tj>`I4U1pgDk9c%@ziwuJytxG$eR8C9MseG=r;c=sNc z^iu|ZTOJ)ocmv+hsL4|M6R9^aQqBUmg zZYZ;pY;BBzr+>{nZ?K@-o)nPAW8}>hSljPjbyGpZfQZs(pD8H2E_%bAYr=O{-ocYq zUf>q6Y&c|SHC-%_gKs*z&_|SCk2u}jo8G0V9Q66@AEaITJZZ=J~kqt&T`rX~#2}pZRsLoPSh&;${ zN#%OBr#8^(hc4%xF43=_Ww?1y6_qNvD!zf9!%}@m+0$;(@hblw(`sMWYrGgp_{rYN zP~<|i=Laj;8a4&rIX+=iiOM&5o_M-aa|OKJ?Ckns1>8gPCE zoyyMVorw}MEK=^UXRXlH-)FwJ;~EBQF6R9S;*^w>Ct!5-@Sfv|;SVnW#jLKbs z^n9YT1WQc593Doo>k71)`RDu`mr)1%Ky2#h?EDRM6G|`qdQY5>R$tBhc!vRSw%Dyx z(DTZ9cz86XmHL`M78o|h5czu>o4Uo?s8TDamlKOpIAIY7$Y{qv`%3!U6g7H&y25<= zh5f8eOhJepnH~mZz-_V_(H2D4ZSGc~ z#~Qpc0s;bYY2Dl+E85fLe^TB~q|t2Xdx!y$c|2l!)AJca0QBZ+Fr)8M%bDTnSN-|A z79CNwYQ3#HsfPz*f354SV5+=ahQi@9ONA3<-@UU|eeT9uf&roD(SSVxcW#NG z7NG$aNIJ8&HUUEAk<4Y+m;VzX$#Q+Rt5LSSyxb;sl^~)ak*n;YZ87!dCNv0 z>TiEYkE4Y43^}&}+{`i+91`M42Hjmg6S>~0n5zbiwq4#0jssHc!b8>7bl64K$X?rO zfBOT_P7l&s3{eY%1`3~yizRTTa?2WCHwNva;uN9~@#g*Eh zG?e-R9PuBH?OgbQtHgNAe+F&|s_eaG><(&+P|cNJBL52xDwhUa=rFfo>m$PC1M<0? zN85(bIK?^O{?$C9io6C7wBM~DokT{`gDqpS!Gc~0_~oizU;1azvt#~c9~e1#|4NN< zCwdjE!0salc70S%p~FD&swS8iEU6Fy&g4hFAuqJ3^5X-taz2m@P+Y+VG|yR62WzFE z^y&79^b(A!>gs3AcwAPte#UGdS^e3nvi_o~@{&_Sh4HDF&h3qRi{goG*=+vzj2M7e z*$KLA;X{{#{1E?`B@}#Q$V+0x4h-k;$p<@u2C1qiOpB*K-$=myAj4Cy|BIDILRWDz z4Oe=Ak>OVYu5o~&uVHZMvP6;#1h88H7JM+ORja~Qqbz!8Iz_-~^OG#)($MVHDcOZF z{vUXLmSQ@dMQLekK;{|Fcp-&anhaxAnGM$Zh(;bB&Vlrdtn}$2xnH~eSiUl7nOzAD|4cy= z;S@n`2)bPQ4X%-$;_`~j9&O+v1S;AAkf-`hzVXl4+c*q~oaYBihH2H$6kzJUc~Fc< zQ|1iWhyQ%%1}gKd`RX6OWq@X!4@?>lb{H_(yc=Esm1&8h$QVEwnkTkqYuN9jIp^zL zm?NBF%7Dgvo9)0Cl$65dlL3{*MMlDxvd6P%wMA)sjH7vB8r)N$8)1wI!0NtTjYZ7c_!rx97B3 z2tf7-8SdcKvq*6BvI0FZz{DMwH$cl=>9#LQD&nc8=cbwuuM73G1&8Grh>as*vQYzG zlaY6N7%9&`DHHI{7pgPgeIh7C>GBy&p>j8K+L_`6*U!8Ln)Tea zHh65R^6wlQ&hSYA%Wc8;%G(orR)>@U>95Hf2bajeQU4R6+F!W7wpQ`z?^+Ie>QAJt zk!;z&X()s#6BCVN(jX8mR>$V}0W^ z=^E~eB=ev@2div~>-94rc#FhI0ZxUy;vsWMBD9p*Um86piVdolc(F}aTRn=Y++@EL zAlQ#*=%`%hN-X5c@&MkR3<~Xkhau2BUTTbUfWXBHMh8PUH1wtymewMzzpeh z9eT>i7wc*uDw`O53C`;am7n@BQf$^FzLlYhh+tN%6Vzqhf|--O`A~p^VP(ri;-70H zAc}pq4>eMDG%}{g5{v2SCZ;lYYeX8w%db+-@CQXx$F!r9E4&RgE)YhA>ItYQYy(rK z4S0{Y)LkI=I1wW|qAW=uZcEJF9<)O^V>Z-Ox$tbmSy@>Of`TDKbimpUAud84f9I!3 zm@B%w;&Ik11FzaTzX*a@)bMSBiXT@|;$&e-BqWI^!;&~EfN8(1dt0Kr3E0Q1;$r5p zTm>Cb{h-yA09-z@gbyK8{|M!JxhY?4y!;$M`>b!H4{acQby@%9PXONr}}* zXXSC;YISlsg+U*mk9&pCWIz@@2C_54Wr$izn{#lDL1Gs_Qg=;e=+Rg;bY*dt-~{HZEyzM(MRqhEPj zG(U?gKfj+D7>F}3I-Hg;Hs?Q$NtUjA;V%SRqJxoeaaGi^qWZpuG{aoQ2~pc#TSVk$ z&lkHV0CvfPG2m34g*DWc!() zsk!n|@L@a`P^9dF9cnxfAC{=Jj*Lf%{;3AHzwW#L#*59UrElXI+^s3f64lkyyS!4b zd)rnu0l3()V14J^GTCTK7H`@agioaIKF8|=EN$vlEjl85e*$qt{|NghP3oeLiQb2CE5*`>*iE@a0JAxlvB#3Ntu+S=9 zkb4XVPamWh_92|>s4bWQU?$JFxSUA&zc0;uqk&))5O5?E{-G&k2Exzti@?gvg&EpY zC;u!u`7m{Z8My;`l%x(&O1(e_kz01u0Q(4krNi}PyK<*3K&M%ApydV6 zAQ-{yi;F*o-tk!e zU;KD75?R?KD_eH9jF6C(m6?#0t!#H>MOFyeTQ=FV?2)~9_AX>*eb4Rv`F_i8VB#d{hPrg_g|qLAWN)ox4SsB z(SfLemYV8)vu@%WwUN<60QJgrsX0!@t&^SRFl}FNd=uu_7HRF=!cAAbIU^tK&ZF#` zdb)zL`X`$-cO~n*n-${ZWGSf1-X9R4pr&FK%~PO7j@b2(4=QP-+|Ms!+afw`D#tzy zd262-^d@hTI;okz#$j`PGP%&W>5@#LbsgdFX}o3sG>fWKcg9{E%G}Tg^PyG5Q~f9b zI#p}hWXDR3smcuFetpG}R@STCm?~=E&fO9vS(||WQ6EW4U7f}MMJFS(3DsjqBPnBg z=S?7kP|{pWHJ6f-q60E&P_O{zQ_8dBG&d@e9&F31l_-yo$HCz@f2O?juF6EbQz6SN zEn6_JixcHLh?ufXegf7;B_l0u*Sd6ecKwT}tD0XQNt2g|ler=7+${%ux?34?KKIEcU{%7O5Z_;VX4FieB7UHbckCvWKnm5HOfheh!m~H3eyGVJR)1?z^znv z84Efxe&WpFqYA?0KAF2TSVdr)>%D++T6xp2d0!Q&Dq_$w(Ou2e#G%5(wR<=J<;Iv~ zka0;vn(~tB9>b=TAu|seoArSF-x?*}MqaeBt`<`LZFRqfmt^BHbURJS3miFU0GE39}WpY405JLj8(TR_-!Q`j3KwHS| z_a^EUam4mJ-izdip5p_+SF<4?@{{Mxi6~O;oVdZ&eRK8Y^D4gSkEB9TB;8=1Bb!pk zYArG{<}Ho~+yf=FDVNOrK8wEJv#GFdg)3d#tgg|#h3*p@5FP|=ZVjrEQs#jb*S2Y+ zFng8J5ty#{1hfm1%q{u*?@-QhEb)*^Y^dbt8XVtqh5c_5w&j_54v=Lh-IB?%7|@?I%P68|G^?Z&+2ykj#&UV|`)G=%<)wP@o z*p@^`sjeQY=-o~UfPzlPI|Nra`o0P%&fdw*2ln`}gxr)>Yr z&j*idZypf4CW6s(C$t0oL!7SZp=K==DAh_qB=~~1^kMG`aLhoY281t75h%C5KEn9Q z6M-p!668elNs{!7&Er%r`qh%(S7ih@^p+dye}tiBgh~+qhd92E3L%Y((JOKV2s@62 zmgK!1pAwJ~mk`*9_)ZwBzH`S-ZTd1lXt%W9Rqm{%Sk_N6<-EPM&3FPMbsyU*`5+#3#O1!mKew z!$bF4lY!&2pQ4$G$slCquBsB41u-#NfKXJeX1wb!Koz1PaL^||KRrqZ#v=a-7X#9_ z?0Q?_E54@NBDe8)Hl+J3RtDbK741#s&)Re~FJg5|5OE=znUPU^OpjU4!qY?^ocS!< z?%;0@Mb2|03hdc1U|-dlGrAn^@3U(eQOGFXDxhFi56fjenSZ5#q?h0|RzQ9ioBW-OAAl^u5tHF}{qLd)J$8X0Q7{Lb)CI@e5*pFox4m z6FXE|WQ2}EssPgWU2Q{RQKVtv`{sUsgN`Nx-P_2DPK`8@FS@}{?|x(?X%BQ4KKlh< zjAwTqnNLgL-@?LLkU`N1us5P6B`v~@Q<9Tgvb)C)afL=vFl#rfeMx>(nVOz7^0I*1 zczB*4Q#^-(xdL_7e3Rx%g}+WW=ci(daVLq{!<^YGs;%FbK5Fgj{jr6vFL5+j6$dVObv6 zodhUYa+7v2@fv>5gQ{O7fa&UAeak`3BrjTPU?Ap~2b*uJU)-kPt2%y6_lDiY_C2`0 z5^Sx`&K%4TW=zM0mYW8A%>~5vs`flJ)zu}(99LM|(6#79g#CT*C!NQ~!NV2S@mC~` zr$or8C#O<^-C`&UM{8KjZJ+rKSUYeyF=f$TrsUgm>B2gR24>^ z+&#Xw&kCcsOc}NARv~qWj}1%P+cG2|SlA}DV>7#$r2{*w|^ zPSap>A$tZkY7~4_Y>P`v(|-MW0r(*{c6C}A9hcN=Kw)n)+`G5uL-!a9vwRd-6Fz49dmp5;d1Byy$1PJ68VGtbNk|dA{1fxlzc64;a!o>WAgtL4( z^yS%CO?=ltk@Y7w7BvgaaLv!ooZFP!+uNq&SGSw=0svbB1A{vu@8r;X<~(52==xn5 zpF6T&yO2eXOA_q|dK3-jNFL^g9cBh;EGU3Pa~L+{zvW)we28VdzP?^}=b=ZHUW}0< z3L(OcYd$+e5T;kc^GjT9I5B1($d>Vt?aH-807)XXT75C_q%!e&{4$|}bO!Hn4Cthp zdh?`#NOLfyKi4Wqy?TaA8}YgaeQat0bbUt^A`Z zI?4ML0rXt@>VD9h$M)%`k;uscULk3WAVf27)>JgtHDU5Q>i+}DpP!4O$wXIaGxB9+ zW)46!=c@WHHjoef3++%+k^$n5|NX1Y(X+F&^J`8!gHuwHUvUG1>S_5a1O5?60S+h& zq=yF}o+zeqWQjdwP~dKVn9PhH3dJq^~I`D#BeW$xUN^MU##0#~c`F zYDx=tr? z4<>Z@ew&k+HsLlF#ZFs|aTFtWq7>nkaZ=m@FgpWW?-0;_zow+Xx=H4krMRd8Lx~gX zI6p1+Q&v1Q7eypDms)8}WS}^3v7V5X&^)G}B=Vi4qfPf+dHp22C)<&wQJY9w()<=8 zUp!9XPk~~lm-pxWeu>9eZv||Jjr#uI2A=;68of}Y!2qRlEL_}`@Kre2RDdD830s0j z9Yrs|+uOU2nTRw-MaqYcC)ZatFc>(Tbz4)FhV>j$1>Ly{%{^-hhlg)@em6ahOwgCd z>wTKi@>A_%4yvmMHxXrw)MmVIh0DYLN%{1@c$Y5NxJIGh#h$9a>cDb8JBmNKHyxE5 zeShjaiD>PWYzV;_dpZLpr(xmmv?^ctc>R4<5l+R#EW#GBc)sc$_mL`fgHu$4fe?d(@P(LBc26YTYDz zcW?Xp_llt=tU0};Juha7UKk2qpPwVNn0=qLv~40EQqHBI_z`K@^P~T*P7sHFO@Ey$ zq94v_mIn_)^z;(0)`yInl;|@gKYNY<#4q0Yh)>q-+vdW7`Fk&vx|Vq`S_J+37O+ho~qGsY~4i zMTF>*Ob8AUJ0CZTR@n&Hru(OTBn=vYc%jbVGn<^$2QZMM(Ffq9AeW^-RqJ zPDpc>RtpUql`Jd}>qMladAM=@Q%_Dmb3`_I(e z5-XB>7Tc9?*)qILqv2D#Q=mJTw>Y!bDb6uCa4aR?!@@us|2f2l2e;7?0*EtrG9n`N zE0O1$162*GKxO7ZS{1>esLizCO-CYMMl=YV6x$F!o#^O-B*diYr5QkmhwbU2`YsZc zL$0+IGnIfid$+EiPY^${Pa^?%+Nz}Dc~{e(%L9vo$z6rN*r8-uo9&rf9<{~1Cv7xF zUY{Llu9dg1GI_fcuHf`^)Bq`28JTBrvLoF%%`kUI9@*Vc2E}td@H_~po?R@s(+dlK zA%*)O;Lp-Gn*6EQ^n#LJw>M|{gZ_DbM@Ht7B9U*KQeVYr88cmEMM9@_hEE#xWpooe zxCzTEHzDaSdAKnW48iat;8eibkB^q9t*iUY+?<&ctAm@E8d0Lx;q-EWp^zuUbhTIC zk|`rTURQ_-kzQGe2UuyBxq#ivp`a7nzyMc$XJF0gO5|h<-49|u-4YmWVlOG-eltT1 z4asE4sJfqKeWq3bJLvT2aX-*v81&%V-WL}ar$7TI7(WL`mang`1MSc;wMKRc>_p}I z!r)+q>LyNn3Tta?(|t;OOlJ&!l1~cH@DX3G^RL|R@;s!Z?7(?#X(`{?$r2S4!%1ie zkH+)gqxmG5#YV_9#DbWmYNd^7^)SRfxu`ZRXaC!3rmHVKJWjBNkX?s&L|s(s3*Wy- z4Un_)R}>KzmiHQSlUMD0b793g-|N$VkBe6|lb^Y6cf$5Hjr9#L#Cs4I`TqMfJUslr zXaw!*%@zNLK>CUWBO7!}*v$SNr%06{dw0Wc6Pmlo0m5-1_*;+D=SM% z8X|%r>f@UZk(;0y#`_Ynq)gRM@Pyxv%Wp3W^XSqXGX*f#6J^;xN&%16$$OY03PY3P!Jye-;H~W^PKnL+=h5^j#+Lc+Q+{DA92g#VEh^LB*CT1XOB<1-=qtbRRiPR73 zo+RYa9v@vi)(0~w3)@`iCcl!f*f;0+%IEFzx8&% zTp%bx>IcCSDCx}0Dj_MVssJ!xhiD_2qd?ss{USt8%Oh0!ct;x*z*UG1D%huW78na=^OPOqA&Dm)RzS5&zhP`o757XH*m5aq6U1;3oFt)<2*mubUr)&Ksx(ttUMX9 zky-im=pAjD=aA07i@!(5)fUbVCF0gCoR+>DboF$m?i7lx%|1@b8qdKl`xTbVvip*~ zy5cY;?nqQIvGz#wsGH0>LD&o7d+}$PY4{R2#6BS8{nfhm#TTvvTr8~Z953s!QJnoA zrpxxQKVEArdpmns;)s*b+njB?4PNKJdA+s|-KkS=J~R7Tse3$D1h-#(c6@Nun07d? z&-!uqMv=G{?UE4xKhdLek0lFM_6{ZiXJsrKYNd2WMOx>+(mnw}YF9+i=ljQzy-7k( z{Lo#Oput?q z!4ssHyRv*`Lcp`{z|K%ZP$Ty%f?qSnF(CE(c9JS*k`l4E!rgOURtTRTaEt zza39*3qn>vK)~KrfMBKfMEVZ-F`9IE>#a+9St#GV(6hC~#jCv6v4!<$K>ZxP`Q7i&*hSy<*T-%B+gQ=s~=Nee%f zv|rpXt)oKg2@g%Yh2`4Y@JXgm%;Scs>8qTv>I9bv^q~{Pne^sif*N*p{3u6u*qmEj zp~3wTZ2@nPE0EgM;z%v>ic>C_)`^+Ib2&_Xu4iE||FhG0IL#FMi|C?Fq9+jro{deR zi4DT0w-M#Iw_O@Z*SG$U9`0jMukNz|K+}3*?e8UQR*1E;Vq>XYiA$XR%!VYtuL_Td zP%UiY`~35#V$jErOEN!(hokE1>%06E-Ce4_JyJ8*+nOqmzQjQD8^pHtkhrf?kx{jV zU1qTzP|DSZ~zfA5WN zx+5EffGguU|0?!d64@kCS;_5Y?G|6bo3hHWmc^KO_R0i=)UGQUZ{K8PA{d9h8V5}5 zJ`rd;m)FGb+`XV=XZ#WuH}vh&J!Y~3J9QcRGL1O+!pNSeu*>-&8z&~}$DT#bIwfw> z-hs!q^&Nc$x+QXGt&GoNTLXHbW4@%MWEf)etHUhhPPH(&C)HmI3yM&GUkuIxdWb5Z zd{==8=D~Hrd_+P*g3J2w*PlmL z`GuverZjCYuer)Ro9L+RJ!*xFbpwL-FWf-asPhpUG}5t*v_H# zKEp=ivBgQ^U~LuY+7y^K!{^XsJwoB=m(hJQ>XTEPsHewQ<7}HdvjtUz^oLs}yF|C{ z3WfTIe)%3o?fLt`WR1~-WfQ~Hz?rG9RXKq$ro3x=@vGJ><7LIRHuJ^7Y2SEttP{(? zuZLJTl;YxuIZB_G30DcM@YNY)E-}u_k%s?Y9OvVuf21pSnFF@v+j(o2%D-?M4_= z^7pDZa&J@Bdz=l2-DhWK6D@jvQdNbh>d3J^+uP3OL(D2iAL1;eaQwPH+y>*9FmR|J zQEJ}LEZEcy-CT;?v-Zf6c`C3NyXFn@QDAiYL68X+KNQnOKIatga zHuhKZ=IUh_Gd@k<@Co0Da~5y0mgpC|QxX6hw^>O6&z71($OelvT(#q;9A~BHN(kg& zVWXqVj!W};7XF3`rbk(9%xx`eZ|AXm5Hw_jR}mlIcXEjS%_b{tskdip!$5@S88Us4 zG~c0#(Sr_UPAp~}6jfD?=Q_kZI0M{5LUA#GgdNnxPO}h_YlI>XX#$ar*yP3&-)8^X zqu+h=Ep~MF<$uwhn&1yK`3laZWu<9nb)u6M_77yXCfdR_dG+1*Qxg%o0xFua!cVCNg8#moeVxpt z)EJ2_lew|S9P*OgwOVL{wfkRFuqp#(6a8mUi2oE)a9_W(OTFv~und0L5BJ-1*=D`c4qt)*kfX2;w`A>r<^^Zwl>9>O<~GloNd0h>jA+84WMx#4&_N93tougd!Xv4)_n8d*5&M?eXZSLS`(%X`GX71$dY}WqV6w>_Ym7dc_+e>wBSIo~91C-L>G!Vb zXy>*a!O@8A{=HL%;r64~-Es=^tKipN=f0C!Gru_Z@e%z^Jq_bmp17c@1%GB-T3gC@ zModOU5e*ID{mkfi)(&xM>VB_T?#5uyBkoIo_x|1=5i^P85UaK$jwQF`_pPQvz2X{k zn^v#+(9JHAJ@b5#kBx=ZG1?m{BV%1$l$Xf>G_qjXKsVDqfd>miL2J9Nq@87^yu!zt zx|Uls%PmK9eW@T_G4M=T%ynqnNDWC2S!g%(Ix#J{Nr>!+f+Ax`BO!?T%M4{}iT|mbvp_-!=8Cx*NZe5lKe6#1|~VZe@_|fcxc^ zuLXdEBk;Cli5jT7APTk~{VqjjA~bb4p(IOxguTuLNiC6l`3(VpPnad~j@2Prh@GRk;Z2OVABtjD+b> zX#s6Y0z%4JuyE*~NIAo@Mf6vxGMxxNZ7(wOb4_4b+)86&#sYi`E@uV#{ zNl9Jjj7E{%?Gc#EkfQdzrpd{f-tSc6?38wr=WG|tcgN5FUIk*kAgtQ5;(fYfx#K&m zrXHW8oaAIq;DCH-JOaX(O-)a4qJ|G0<3>bj(?AI#%~%`y-cScEx5i7}QwIRM(=BB3 z3J9lQfb%s2diw?e4xgC!iC2T;ICcL0nLhMm{|9-#e0d$I6{MN3{d~Ow)U!Q!6&Y`1 zv65k+NqQQM)b#fP%2-K3RPK{PMo4H(B*`r(=zE8XikY5162{W7x&5w2tP0-Jfg9)q zF<~KRIu)$t5eyzvMsSWTy}h9YGjijF9&yO>WeDMt>^@BHBaP9#LV|pSZ{W%puc)>- zZ~g6Sl;GzdO?bNiQUHtUw=uIJ==6GbIy;oDJcR6ZK0x~pIwU!|m4)RM%JxVADW^Fp zViVn{?>*uMUg73%Bm!Q3E2w6zn{BkglbOMwG`&ewh!`Rh1Ay^aiN4l6pPtbj0y9?z zG6+F%5Rw7nhfS&$&u{HQ*H|IN3gC&3+|Tar#XgZBCYFzP#lEzK7HAXwjJ-ld(iuQ9 z1v%mdkO|0yJ9-LUz5#(#s8%AvKYhye`WQczl0vi5pDHFYst??slT5=_f@R_{BTnQo zNNQ%rR0>fL6b3kY7k<4+;PN19a68?ubSd=${jjKn1SuFCFCae!kd-J1G3tq5TW@S? z5~hecI(l_gdXPQ$1L-$sB|3oeZ7Mvlk?R=)weHA9L}RjWI~^+}EHU3m6FZY~(n7JB z@y(zVXz%B<7?cJI@AXylkD;MP&g!bFsRM`5_c0IB89w>>`PJHLKw1lK!@vBvuOpQQ;|kRE$9d@@qy$ z#>x~aiOLgu`^-x%v#Bg;0~=hV1WI8oE#}De=szfTf&kHq86ZUav3B)FA~D@D0OrU* zKz-^8QU$*e2pu~9xPPWp7Y9ylXYT}!*Jlo1=6$n%hI0KkQ<1n#+`1_`0xgyHorfhq zKfm6=1A6-O|AwkwRca~3Imxt$xp>A($>%0aN zOr5Uc-6#Fo$_VO@}Fxeqrjm21WQ3!kZkD`#eAMz4Iy@3qG&4@gdy zSBXMGJi{3Gtui&>CA#@XM>D+nJ^g`>4!6I-^VA%8y;txVl)LylV>kvAlxI`+hlzLu zDgilqrFN<`b5b6{Ml$%-_{MX^IvpK(D&eCP)kw354<9}ZJQiM+Cn-Rj{lN)PqC8!d&`j-xxps7sWFRO}q9i_i8xHao@=6>w zd`Q{Y-^?00sroLa#M@Voztv%xAdGKJ- zy3oY5|5Kw^7D&qTAOtEi?w$vbz0vDug7XOyr$_5wpA6?ecYGL-SabAX?f4B82{WxXkwr72Td*wgzmTa${O7$JQB?AcFF%`7cmO7+#BqnDe{`e?ErCzAX;554Plh||?mEfufH znHG@big@pr2S+dmBkDZosr;+VB9yZCB`zBX>IfKP52F#IS1u26#4ftr*+bW-G)Y0) z*R_tO##+DjBT3JxxA4K50(^ncpVgS6*>o8Fsv73SI&U{2-uMZ0LhJWu1)R<&AL#6_ zhRIUKtn_I7Faoj2Y!NeY1&+esP76B^4G>Ix`IO1dp6x|}Nh7YxWP=9CX_~9_eG&1s zTAA&c^|)xQx&6)wO$9$d$OzfHag`eifna$*Y$QIUmY6T&qtnAw57p@KaJk*x-K)kW zwA7oWj(;ux9X5}-#Qj~5KbsCqzD)jC4Kr=mX72vx#8>J)K!Fa@Ksj>g!e@FZY8?0zxwtwU?rqjD{~&i4<(!k_3Ej zVi0s0zBj8mXN8&WM>C2z)_(hp)`_xR&M7g`=3hm@M^O1LiN*A3uCXKAOHn19C@{A% zdUD}S8|5Ih+h(t?il7=hwqUP_i_`7z=dL8T)+4If-{_;G#Kig2yUNB(U*5G?^xM6u z|4{f~D_cvE&xy*KRYYli)ceSHK`pA-4BB=>kotS(JTw6>fg@r8kh@+&Yx`s8<8Y)$ z876rotGpu9dH-lO7;k8(2%!iHb{N*SW`DGQBS4xQ(bd_z(B6*wJF~zl#$o)v-V03Z zQG+=$375qNLBX%d-zrKnN$%^a*&GrhCDxBb59yEtGb;*pWi|OLkVAhhDTkBv9ir<$ zC&vA-K0p7fMSK_+6ItLq)x}j=tR@cgi!ysxVK%Al9WDOL@^VL&Mw`uF=EL>_v*LQe z+K69t`5VW1r%7C8VwAe4tYJOjZ_2)I3Hs?8#v+S^cMhiu;#sBj@zH*e{pYyTuINH^ zVGCsz&z_qgbsT;Dr7ZWB9WJvO3|I6%`1zriZOs{4teh*WN!Z>)9!H^9bQyeec3AP6J8EG| zKqwQIeJ#=lIF@7BVS7X4?cGr{lI!sg(#xW{EqC$Sb8eC{uyD}9h(*gV1r7B#XCt1< z!)0QRpha-mUZta&4*k!Dd!`vO>Ui<`KWp`?tQ2r{bF<@!i)2D5kGye)XFyBUNf4|{ zMhd6Zticgar~a4|Lf+6% zoJ{?DCyqiMWb>`e=02icpuWojlhD*6IcU2+gIZbE(Ss_!+5;*@h07Damz)WiY;oj7 zZw`rIrk5E)Pf~lX;+oLyRnN;OAz|H3O`oKiYX&!D5UP8bXf+A=k2gPGJhMqmC#YSU z!ZRoss8W~FXg8cWl72eHi{@-AE?nhI8C>)vhGQ@G<^iFhp@y{5>-^lSL%Rgu3JNz* zv3?Gx3wFcc6N|p28KS!eu5`}uyplOHbNA@55o}f@*KvMKH~IX-p=w6wsmOoc6)H@$ z_)Y{*v0+hivfAQ7fLNvF_7j*|l*QYQ7h@e(=f#*6eNp5*r?VNF{1z{O>QTPb!HdRs zFDUjdw`Oi=KO3XO*a^c)6SRkB5wyxtRqMR+w|O%fQx~s$R%3K-$;+ zsd|Xv-=HgtPF;rRPK)DhZ7#XS*E1N}l4Os**o*jYe`eN@l@d7`?vnMGm?HUm_lp)& zTH{Zxs|e(jd8Fy!QSxTERT;{UwCsTF zXRA+yvO(3XMo_`YsVqSpVc_%rnbsX9x*CnUot;n4VtoSlqG1R_rvhhvKBr}S2qlv@ z!aI(V0@$a&v-_&(9oD8FxNa8m4Cemp5t8X;+EX%0W5aI))G+icvlNnxRgILSwbJr9iNBEIFSKS_Md&DwQnIWH|u-b&ji z9c4>uHc?_6fb0Gnl9RmnN7B+uJRd&X+&fsS%%Al~H~8(f)_KR4P^dkQwp+TbiCtCo z@i@73lqnhWZPkWha1gskM=_qKhuy$S$TWGPNr_LOdf|IQV0gKvpe6902PF^TMkv%c z_}8dFjz9TvR3P&=!KJvsJqB@caf^YpY6F8>{+}Z~w4e${*F^#W|L2#jLGm6Rbzb30 z(ow`$U*k8DM9a>uC|&@=Mc`AxtXhR>bLnYmdNV|HUG!HUfmr$}i$Psgf{3#cv`zlm zSiy(IA}|f^ibk-lA2kP%!~KrFNRg91`3&qYU*EEU?mLHyuvpTr#B4+#nDe+*?xlI$ z=i_@b{uf$umZ4f!XoHKqhH8Zd^IahaX*D&q@n&hK?yK+9tZ}mVs#)+wNsWqtVE+Gp zTQ#H@i5mgf-|$s6jga4EU~V3WI7A5$BSc=vK%?5h^xO-C;Ist%0{5@2*Zn z`ieG9chNI=ijZLWt5F{qdo(aIpIlxXtx4TSep1@i!U%?|3UtpmtKPo-Nf@!L{7U9A z#C9J+LM^(brG?#!oyI!>d`#U2=jH zD_@(N1>~|oKH5~l{X<6sh?ZML?|^YHgL~z1{w;d$c03;d$~7FH62TG(;(jm*^S=5S z4*K6nt3^XYD@Gt+AhYuK{*F%!3YNzRJ5Xa|(JD+BYL0LJNSeCKI( zXn*s6fG%5N;k$qPLw$U{Kvw+(dQ~#N8%}Mg)H=B$n2$WP`zx$*44&{#CZH0FTf|9?P1iUAj#@_ak84J{#9*aT8gfVUD24! z?w7<@t)iq}`bsdR4=Hw;`y7`V??JEEj2D7y>U>B;PKbqKEgNUP{k)z|s z`+)JkSB7DxUYMYhNk&X;dgN77qIDpWh03a3{35h0B(PMrt{@h`2|0bQ>Q(Wo~it86xZ(1@hJ@ zrKHpX#B9flxu+OQ8IXVIFeBf0h$>^eLG3ZFB>lU!x%p9}*%*<*S)PQn394pEb8rES z=%E9T;WvX$T4o47Y7O*KFjWWPbT(9{S2VvYy75)_E?uA?@Oh`E*qT z8U{ueI1mRQ8XuBgz2G>%=is<{{hm9N05%lwQ%}sM87T7n+pCa!_wLC7!Vkwm7sl*F z$uoHBmiG3?t7>``ud96#etzJc&h=+Nd9+4Gz-Iad_3dR;mdo>8_o^D&>hQ+KMu4tl zm6AkR!2AVpytAf_M{+evJx&~k`hW>EC@*6^k{iuuJ3H+(1&TW+Aoip)5GVunm;yG~ z#v}dXYO=qrZuZ5%TCG(ek1&b{mU7V8=rrr9pb&%L81V$Y`U#1fw*%Y%)<-s_%4SA* zeXJ9H?x7hO>1OR~|;N042t zXD7>pRJr09keWK-ePU0jbn0&1>3frqZ>jk-8U+=BAtxsn_%)5-=)v{x$a@1>L3vwF&HPxKQ)r-50Gn8bmOzJ{ zUqAScTI)W5_Qt&3s^~{zq$x>!^@1bxXM&Id$oAzW{~{oWIJHojHEhCddE%m;Fg=r& zgEak#*PHW#Lw_D-Y9Y1oL#vxuoH2ra{P>Z@DpQBJ;kpuMHaLBQmi7hO2((_l&gJu5 z_`u}kG~$hVWB*(MSlB#HhE{N@C~i~mzm8pZyA`JlvbK(M3<{suoO_dFop+5X=;)Zr zEh7J|&#d(5Iyo4@julVbz}PtIFy6gQn5jdA`tvxl3$#V*BBB&{R|kI)Gnw z%5&Gf$aF%gsq-}Q+EVvj$&ikN3H?S)ILsPf&$b0hlTjl9L3OII=~;%Nk*$7?(QYUk zGH5ZS_x%vFSQuPX8Q`mFhDb3FNls4gjYBGm;1G9ul9GMXQ)zYBErFNu8HRHiXvH^x zWJ%_$o-e|eE5LGDMqHjIdmK)fWu3~%%5HF(Ycj1^BX=gxwdN$F?MbdfN`eT=ruZC@ zFKFw_AM!XlHpI9KZEh2ozE5mlT>g7vw(l@jgI>)XOa+YzhybxwrH2n6W`S~dhD;FA zKsEk+%LhV>m8KTfUJPFZd3DkKD(V$IkJUtHrw+bc{E{Z#pNS#@Gj^*0LA~0`@1(NB zm7zT3WTx15LzfkZ}H3dg+xvKr5=NMV)C>C3`16yrqAf(wy?2$>o0D zf2vh3Dg7IesM>z*+;PwE5Ym<; zzl>LrsRG%80<`_3qp|t+91bc$yA&vx%0m3N1WlGPfD^9k1;!E*a1jad@u_o~Ej5gO zgdQAH9gE4buXj)33@QaN*k|Q=M!;iJ%R(rU!`XS4dPVdj^4P(E5JB$StEZ;t|8S5I z4Dc*TPs0K`dR$!HI&$3Q6{gE0OJ5l#{G7dAV7MH7BGU9ASx6Z&|#gC5!k|z z)$w)ho{-DoN)!H@u790lsNM1?h8I#(&obpL{a&gMN4!SlGcRI+;EnUNeE<|*ak(Oj_& zj=%|6SUPUKcTPulG@66(Y23F|m$R`|m%}=7hYY3Kzz>VKrMp`p;0H()JcS4Xd~+!m zNHebwqz54BoePVL2g1G|-fgsM8G34v%1sm-y~ps+A!!Nfhrm+#uK@%75sW@4fe8fa zoMSnvj~W|6ZimNZ=fy;wD>8sk4|rkhP0GHZ2H_my*&8~$i z^3eb+f}2}fU1V{7fHPR+$lY1`YEDCl+EKsoo*pUFYBp1v9$m+rLJ*ppyxf6A0YBp^ zt%NkQ6G#P|H+9uT)zYkO_NTu0n(%2ah7GN>-4}Pt50HK%J32c06IkZ$-=}d1v!n>v zT0$cv4u)5o2s8N?jGoX@I4=>zM(*h&QoRn{fBbA)8?Rt3Uyt)PN#AmRl_FPpz4;pp z;+M&7Y3a)1$-n+Mn+(87@RUQItTuTL%fkc$Um?{X5NeZ%2xN|Q>_J8ZptfTQG9}0d z0~e(WXFFo>PXONI>KYd5B}U}2KJzk~&i^VQAz1eFdw!eHwlM0cvt7<|ARXk$kJ%t3rz%pfeu2E!jFuY)$4@EgUSuxjgiRq}!w$7BaQ>1)&|Go)2^l+2 z*GO@*ZUpAVOG(?jgSR$tf9K#J`tyC=4O2~)+Yk&y)HdA-f(!+jBs`ImvwPzh$Q*;r zTcTw0!~)>F2a4rs9kgxvP8j*99#$OqL`PnX5HiHrLg?7Rbj_VHxo zsxE#0zp3RtanQQ0J%e&op$$faE;5;O3WhuaLXC2Hdth2^DPJwH0xWPBF`L+`(|70J z(?W@aiGd02$k%}l;oW2ztS%v9BKzvvZygl;UdHj5W`G0Xuzq9{@SXSvTM4JWAJQ&K zn4gzs;Ci;9jlvuu)8wm%oPwkwzc;xB zBy@vQDz45j8?bsYRAdm%oRa@_e>Y4y9UYs2ggP30g`A5^Rf6yvc~}>ASa=6GLM&!# z%DsN!#jYZ0x^6;TTq>5M`Clu|{O$8$M_Gsf!pjOBUj2uu#lJw$eG(B0V>>>?#KhR} zx*xu-{|&N8I_J+JRf9hdu4pX=1+9r{$LxxF_}E~Y4EB)qcmrH0Ya9A3mf@fP-FRX# zf&DpDJkjvNg2T{Y5oGx|Ls-J;Oo^jJ>GB1kI%y{f5J2Qp+A7Qd)zkkM*Htt8hc!oSQ)34#dK_n)D)%_@-Bs0j_{eSVKcV9F{;u?*8- z{(z2-zb3G=9AHpUJ=J_4tc@w;Bsvq?IV!YBuWVqeF1mn<@Gv@sh|Ur-ihO)EO(vKx zMLOkqp630;$1wM&acl=0Wde4`Qg*TzkG12k?J=96uT}(NPaR*#TzX$BCKRoI3(Zdo1 z(VA^^_a_eA8o&kXSYzfe|J^S$`0INOpZKNotZO#n;$!$K)bkY`ldq#=bqpzsTj$D8 z)jAjXD`8rzeDLQ)l|l-!bm%+JM1QR~Jvr$Nr+tLXAM&>FmBcQN7by-=dI3B!(s}o8 zgFnZhzD5*OLfpuSU7G{&Vqmw(Lj-FI<5KoucFBe-O2r9?nP)pz~>A1?&!sA@NOxZY?izD7b2tgmY*R?92cu$lAzw@Jj@7Qs;MB~ zZq9z41>J-swmmj~dMw8l+sU(&6K0Kq|Fb~q-rRnCW{QM1dHe66Ye8g6( z^23j|zhZWd#zPv@{JY8^#6H>8Vax8Q>WSpE__6{pvcdwfOvyT-k{DRs$9w99Hc!|j zo&M$aX_MVF$hasqezfE-n-aC-NlDC!lK$nly?fC?mV{GX$wFS|HY&=X&|MjZt4 z`r0|r<6o5<+TZ$VihoB>?dSty@Xa*o<*;T!(=;m6;M25Vhqu!h7Z+Y`B9kEq*27-n zzdXMpeV{*OojN`|oWJI&Ws0^M?j6A#>+hFYy@?{5@(md7tFQCs?oU`!`VUMBQ%jt( zYUaO~#G9;s)nmCnk{6@NA#6#_7;~_*Gwi4+CLZRrY8J*jHRX19!d>(yV&49TIEBY; zKiZbrSp(spKLj!Ur68eOu^av3@dCCy(XpsW#)z}s0Fc2_V%3nppV$|)%KdP?$&v7H zZi@WCxWJW17x}*FROjDnWp0eywDoSR3)5={#dE{zB1D)}-w#V*Zk6n#D;BU-a<`ik zf-prB{ep^tFSfpkaF@u5)Zn^DYTd^5{I84&R~R+x{4JMcdr-hze-qn`*IYu7_0r_d z>|#n&AvC|b8UDoka5Q}wB)4pvFaC z_{7B^*yEcocDjSr+!b?bUr+E@qdvs>&gqycCCTG;hNlK|2%n|+8tNq6(5rTM4(?W2 zKOeQRzoM6zb_778tYnpF7!!l=PEY5wU=Bz*1Q_<;<4oC*FaO#xw`J$Zt;^o@9{!uz z!~0TDF(CrB0oifpJjY7Pck!0&B)2Xi1f#HJckiRuU46~M z{yOo3ww>Bmaromk_oWWiz1{ZoH@&y_C1W@epB`0?nW3Ou?EPsB-lzVkO8jAU1ST;( z%}X_1{!2zHQqe9NbTm6PXC07rh3;PfU}}m(q@3I!WWtv>e{iO2Tc24}&y9$onw=Wg z(aV6oePQK!(ErOrxjh^Ft3K?TW4}>@aNTJ8DakFzH~i)fBrAWK(|9nWRpfk%3DMcw zM7`g=O~)eiCYm+-<$2>e8yTN@I8toWiKbtGm*Bv^~R!*ku}I=X(an zQC2aohQ)Eq637*ES-=0j86w~xC;z78W&i0P1Pz|}S@Fegz8WGkSM=i8xVj<)E)c=; zEUN>iH5zMvT}~zJNZaeDxRVaqa+dMGW0!7VH7&o#n-wU>re*bcO0Uv#LPl72{d)HH z6#WCm(zk`(JhI zb7~)MMWs!|=4Liw1BGN<`r&+--~~;B0L zV%KN;etBN=S1{%flfeJ5KR)fW9BPY@tT;-a;+xEi zF?h*-H^KdL6Kc+dKL~7isb~D8D124du!(X~JXd5$wM8-5jN+S5SzZSiQ~VX86D+@l z$lIbCbD8tq+_`9X(0(B6O{@2uwV^=USi3+=tV+BVDB&JdXHLUZgmO)$Ld-hpuNaJIH%yZqY(Kl^(eSS6{x-;+ z04Bv5DkJz%S5W=uqcK^ui`{&aOo0loE$M|^6gzpsD-jP0@6(rs*U_Zmq}Z0NWxvGy z6?QB4;jS`Po+3HdK;G_+9|J;Do6ZWOlPhZ;I{~C^Vbq*JW{zy|e5TNv=&6X5jRVbQQbaZ$V|1mj-&Z(y4DoQ@bI&+oQ~W9D~#lpsic zXk^N{NQivNi!Ry;=*d25cak7igP&?bc4ic_UK7IuVbX*2<`g6$Ri z?R8~=@stS1KVn17arSvJ>g!y(>{EU(`uFO?%K1%~^b%*X>n|!t5ucyGD+dbmlkQf; zYbtS(Q=v+TYMx+H&w`$okn3L5)^znFwm2?v%9US_=tBBiJecnxnnJ!juq`w}i=}Rg zy@AJ2!hFF0`HAw(iZ7qJiuep+>66H|EM*!8cgkIC;|3qX7aS&;s882)kZx##TttGz^q#1c}g=ES;`7unr< zd2VyHx46`W=j0xFf?8TJL(7(bB!6%~Hu@+c@GN32*Kf~-H#grcJ>H2w&=5O}2Gs3W zDM8Q9di$o`k6$}M@$!8ggI8wsWev!w-R#EhZDG*=u7B}tlc!TD0VCcQ%IRMs)Fsw< zQIOVVGQ0_M;LSN9H#drQaiLe3X5ryki;cflMUeZITld|Ek$+^2^ZEEmpWb#r$n+A7 z{c`tR!?HXLzxK@p{dk$}eR~C$!xBm%ZQog~n9Xq-nVgZie(|AB+^hT;$d5IDY*M$H z5m(ceh`z3WRJC4A{2~nuo!a46H9j;x2^r-ZKF+E6 zJm&AFNKSCQ48g7IkdF5rqWX75?T1-0UTsAuiguyvo#6HybeCCNNW^5@f37boGcM$Y zlk|QlqxbfDZLHsD+3060X}V~vcR>fZ7QfSTHXlCvByca&vOSaP+kvy?1K~i1Ve*Z@ zmY=}A3{-HVt6#}FOq4PwENH9+Z*6QMElRI@@=FHI&}#J;O34B>epBiIWeN7QGXEqQMcbc*}c#3Mdtmi~~L{Dwo|ACWzYeSNoo{MJgk@eh(D+X+GrG z0)*^ZF%<$Og&=_q+Ss4fpOaX}BDd2pK!jO`Odc-qT7RH5zIgq?_vf^0nrb}^te;@c zs*hH>j%=5ov7w&i@a#~}Z|gRj*Te6-VbW)J8-*X?a=hz-h`3o{uU@rwL7$-f z?AslNih2j^c?lRZ_EC6U2#vCjg$jdf#@*7{V`4)4=8qy$X3=lxPE%y}2tfi<4uai& z_z{WHG3>laA_TF-&Fwe)3xDB?uO=U-eRCw5CFQ`@0Cc>|0QAB_BRozuTV)G7_mdn=`P z9uUQj3OGjX~w2o0}Vq)Z01!Uj2|&)IPSK z=sxg;_va1iwzV~Ey#2tYR=vX;hXY4Pd6Rtc>X1pB)sFP-6bl_RjcqpfiNsI|F5zWY z$VJjg+lkw>`I2exyy5S}XlvcuXwCh%k^kJ5Gn>CJ0a>~i<2I+E5Os8kS3o;eM)i7~ zKQPcLMGv_XN%aoXui3pVK~f*6%9I9S@JRmLIObQhSH>QK4kLy$AztysdqLuYS&o|? zgBO*!lV2c}kf1K1GY3x-W5+T~asCi10Pu|_6vJEdc2QgN;f@$I=-VWZ;G|@axovV* zwn>FHAGdYRNbzol{}XcGP*23iKcbiCE0Uj?pq_pgwqi{Z=42Oia90$d*fBodv)8kB zaG&@4m~XSA&sC^c%|dbC=lDPgJXe~IN=uyc!5jXlF zKku_R>jkCm!b{!@5<=~_&m#lmMw z?gX&U5zt_G8$&mvj`$GJaY5#}OG0!sxigG3nVyc){{X1spyeTu_l3(KQt!Gb_5vTW z^FJ5o!Y@$LIr~v1V4_n1J_ru~L!Mj-)9tM~VFDaVow_{o@bIA27+NH_zjH9F))7@e z01_fUTd8NyEdC!`zoS9@a;_`sGg9N1B@^O9|7(0)U(aQpi2{mvOo!0WP!|den$Ir} zz>fJa@^$)-PK8r`p+&EPjZJr|zZ*>9y+T7{wM`E3zSSsv$LF&3Y?S4Wn74OYRg}~V zUnwid75;qqxA+Q^f-r7B3^&YVpgAYAbP9`=x5x&-)$Y#^sqj{`kP>UF511fV`3E=Z`bMJ!)lG}* zpyTM;<=Pp7ybgMRV?%xEJT%TLsPH(>b=~eHDiP_S`(U}s`rc07XIW|?=uu@q zAJ)4v0x0GUjXWukKxJd-Dk!{zz`_`7Koct~pn}(`^)+ls|5M)kHL`7YH65=}1m>0s zj(Wr{qqm<$tRu=A52X~SsdoaUcyCy8qMQyWL5g@Dj~WNx%0QAB&(Rl*$z!U_*5(=3 zKZwFh&*6ug&D(CZH>gGL`v;GMcigV?mgoo>i6`vS-KA9R=i5Pl)(ZcdhGFR470!0q z%x&yJLyD<)iH<#XmNc`a1!gS~je>s3LHDYNm(&{%WFutOg2^M_K`KZjq?P>VBJ@jZ zyhRK%rpSG;ul@PNYwW}I$W!hfPkZS4H$$kA%gAxqj}?#o8yO-X%lt zn^6JUiqvvCAM#wC(kEY3TbkF#LE0u_HxoE|C~P5PV31gRjP{(6xG|q+)0XhvVNvbN z0h&tq0i8jfn z`};;l$@u&^py`463LNdnu&BP+(HrI5ZhJYG1=tHJLYNvv%o2KWq@Lf7<+mc|F?bDH z0_9E$jO#;hor&Y-32s=vwQ3VtpmUuKPz=9ZICTS6Xo!d}QM_T4a9yZrV0C1r4Gf%iJ=Gjv6 zLdN!Fm%)j0Fs}ze;RC0#visORZWHe*#;$61aCrOA^7`LO^sFBfR|eKf6uW@Qc@?~UmoknJ)pI5aa^quv9z3O4&^hf>vSoFB)|e?v*d|wiej&#jrz{J1D^F5;f^vqta3?b6OZSW4k~8!fm-;`1sfwQ^~Qy`N@ zUX34rKBa?bwC-XnvC3r#@4xqLS%v_)mDMk~(VQaUqy|k&1RbisvV8-L@cb7`2yzMq zG1De5J!6ZR;zMEQja8R@7zGgmVZh?L(SD_*huh`yq&GBJfka7#Rj%xDFfSj+XADy( z`E16-*+4}DIY!#6k}$v=m{6XJaIS>9>;pU2vA%f?@Os~QBs7Rxgz?v}U(Us1u-@Xn zbaHc}T?)~A8`)w1I?6KdVOH~Xc0WCKau4_3&s(WJm7pmDiNwRNpccb- zKY^s=ZI57azUD&Dt&!5rt%7x$`r(y|%^>Pqpx!HU5PP)}Q8MOoA009&hwV%<^8pU$ zN+dJp_Qx8O6D7lSEsiA)0ClV21wY`k`daDS){>4+TrG-{OKHRyANB^`avejn`1-k3 z?5=WZsrZV?z`vzIG@i?Tu;k~tT}ba**hOJgcYnX;N*HXa2nQdBO~twoh(3ovN37tR zDNamOicR{oHU`aTZmvb%`lh;UTe#hT_f<*+aT2j>>2jBi{Dbt zB)v?A9|i>K;OKbb?ep6bL`1_Tfb|prvs!twQhxY!^CO6x9fe(YvLbG1hQ-}4B}I>Y zoo%dv9%X6ip}Fb2ydpPhc$<$X-GDBZ%`Tqo9a)vI@iIN&aGeJ^vj;=b5sr1$@g|!J?%Dgzl?QI zh%UT(Ucv%mE`MT{ExtboMDyZR`^Q_#hbx`I@KPx+66)T(Y^fQ7MGYPEiFOp zEND!7+Oz$Pjp#mf?LsjoNM{^dvcLS@4ZN)Ohqn(!5>hr%E##CmREDr3-9W05BED90 zUbLSC$~-zC5fRXuc!a}1)6ZX3s9^&}`{o;(1+wD;RRB_N)MBkJ^2|d;-U{C5G+F;E z8&D8^WT!l-*M<0gK0SnoCGDNd71=?-B-y9s(v>1;DVUK)uvgb2)&887NsW zW;20!xZA4gct^XEV21yOV&dzQ_B)7bDev?J>n8CM01K;)x(fifFQeh{L3)h#cspT*hnwm_VYI`2Jr@cYyd?9-ue zmZ{c%2O`!YPZ(6Ss3_Z-A8NDp&CQ;Mx-J{+gS=>sVA@+*w8l_o7r;CaD{j)zgpQ#bleeQKD;nZw#tEcbzUr%T1WxyLkGf=Cng8<<8H` z+(<>D`@JBLw==?ovgww4k?fJvYZI)4kj`qJ1ftcJm^J2$HpP&>^|0R%U)JlLj1O)v zJ7g6cJ$Wm00f?DXPGaT?0HP^Au&<1;R7rjvfXvYA!P`KsY+Q zW{5Y#@*~g4>lHlPZ+sjY$B{lLCZ5&!W!MDX;H%>pAqX(F8Z3~j7xxOh^N)88e#tc{ zu@`?{AHg7t4G50E3-@pe7U-?b zJSp-(8ZkAQ($nKrgi>GyhBLvo%Cd}AcuCPp7-kM-$I4d+gXHUNdxmP}=V2sQuX5`$ z;R2K&!3EF=#67;^t^@)Gyqm*C&%f+y7Fk4|&^1(X(tva+IAB*t_|*j;rwYPz*Kl<~ zUxt99PJXoo<^~8ee;5Gr9i=fr&{2bMDLhLz#xdh^1qBRs@*eXM zQotsDFBIhT*Jrse`*Jwi5j6&%>aCP5a=F)A;P198GbLq>@UG7Zcpz6`9g z)eMAkbo8wT53i966oUU>4 z{*9$6PW8fEJH(`RBiZxbjI<-jvOkzSr^?~935uc!BByJCNe&>3 z=}iEoW(z*(*U!s5!*jx0nV4Vz>HS?hIy4woAOr!ga4Gm?^<$`b1O~)IWSCNvE?M9B^dv)t zE%Ol6bw0l)ZTRaHYQ#N@R}v_MG1vWiMhRPK(&JWbCtl`^k- zjeBrD(zh=IgQ(7kd>18}NRsnFupD>4`*jFWEgd^fzSQNJRQYs2hUsX6?({~aP@F5# zCh(-m*z?_!C9I1yPCA_D?-rbC;2Ic=v)j}?x_fZC{A?r zgz!&@TjyvpfcwF2ecn7wv6dlAs_n9O zGpsV)1U^tYI#7h3%^1By)8|08(A|yP=U42*IpJ;cjHNtsg~0+-ha?JPFL&#nk1?^0QaZ^V3;ZiH&%wW}~-MQ&Xo&NVm1IVqmK z3ionCpS&@W>NEi!UPTnIt{=DD9_&tQO@-1{law`iBONqvfHKpwv1!s_sgS|B*CHCd zh!E)aC9-!`bn~(p`ti*86sm2nSelwT%G{iQT5VfK6xXyW(yk#n8tUW&i9px}p#$Pl z%GOfl+;6J5wkJR?Lk?}=NG%8-Qb9am&OBZ6Mb>|E@W4kTWtoA|_J{4=&FleiBjGC- zW6HSc-qgMLjw*;wGJeIyjmLWesr&fm^;NnI(@3;}6%T!UYdb=1(#%Aoe7ZCqJZrng zr7l7uzGv_H=JAQNjLcc->A0+gHfK|UJg-P+a%}}`_|>krbE5BO0??9X-#v1pfZP#G z8NY9z_8D14_Jz0ReqC$oyjhJ379#=*&BG~Kt;Z_lW|3#S34R~JmL#@3UailvO|~8a z-#hKnUjRhd7#OSyyD#MEy$^>0$a7S3xJ*?buzoa1MB<>K5P|&xI;y!BRoja~cOSHo z#Ie#bB=a5(4Ta1u4_`9{kOZahzp8V)M@o=#LIiF(0Q&P&`_bX8lq$y>&w~xY;!}nU zSpcz@3XG^73jdMW@$|$&eF65h z|JZ5ZZ3C4u2_!C^z$f(`SrDXKrI(q5jO~-$2%1xMSuQnoBm~IW)Ol^!62nk0M!9zu z+Ocm8w{|)(>|(NYshDRwk%XR2PPMG>XjH9rb>)}(VnT2dG`kaL5E4xr*VZz@P1P#H z83Gxd?kF`pBrJq$?kD?Xl$bEEy*ZjUp#|XBhb1r*?GBe-#j^v7-P#eCXk!AyD{6Fd zYu+_P^&cTRZVGKF={rOP~t;d>Kip z0m)*>IFgX;?j;41PbDZVAN8!=yAk`Ql!Zv}WV_!!&baND)$4vLD3giI{){Zeov*ti z{tA+3lIY%959BF9T}_ou?(i90ep3=?(I3&8NNI?gzm_PX0COuKuB!$+&OA>6=!EAT z(pirHXa$r{5pQ-0`Kn)C<>M25SORr1poX#+4Bui&W-GhYKtgV|b?^&Zj9&1}UI!aV z-=e|?+z&s)k^a`b5UY);pL`HYmHq6z%6;e;c;<(;1=*gY=GE_zgI9wUz>(jr(6dDv z){k|Oq$!Df3^gX_>7-EW_5onOl_R$zIs8b-A_5r-2K(Fx5QIG8_Vx9J87ICbZPAZY z4Qf3t{Wof?hYu%gJjVTlu`Li1sewLSmiZ_#~xNbv0D zwEJ#a&eI{tm{;MWZpDEG2#?hU^c;9R>% zE!qG_)rPRD$o)}v!wqNGJAwpPAk);ufVNd*W{l<|7|ZLP1(%}3fW@6iZhbwF)h6{m z!(PdgdY3JSNhp=Hkq!HSxpZyJve?%oeOcM>mcyimWwf`4A#c>u$GwEr_^!h*-3c42HnV=!Fs&4 z*HP#Vdm|PKUFl$EHUX)iGK-G8tn_dJvs#31MJ1xF{_{tyqYqfgPG4y+3|~~CI1vg{ zXJTOy8~9S9Ms2jmH}f=BaG9HC@}TZ=XAC=OdvLH6k$$69d`8Yh>W^BB*RU0YpwZ`QYoXHa~pjBX1 z&4@tM1e5u$9v}Z?F)lPJfQTMPn^xAQ*+1q*k8w2zp$oF*>_AuaWp6L9gVxV{Z)qz56r>;~78uh4&1j zpf4#bZN3W!xP3D>=}QdD5|3k1Wmdn5v4JtSM{+t0z~pWL6*p#O=K?!9#`D5JP zdkm&%(lA=$8xEl7c9F4{-@{J=AJ8^Yo!}0A2@E5pp$w?$7+QzM@AgN~7V6eqkjdta z?XPGd*hC18YQuUn`+>5N15tOl)~{d@oa}td;C=SaK9d>p*LkbZ|MfGBg@%fu-qp^R_Uv%zSjHjHZl18)T?rn zJI~`vSFHJ*Kuz~f`7cr_gA!2F!4%HJXh4r(Qy`m!M&JKb3$*Y*Ky}$ zAR}HF(=ZL$cYAwBlK#6~w0~Zg+kgP=wYDO^7D<)!A6S*@?1!Nq2iIR^SZu5o#xoBc z*Aj*wa&)~J4tDtW&(q3e4UB-YQ()QN9$!NTUo|iqu{+$kix;8qJZo?N*az?-4Q0m z)Ii>Iau>p`o7dgB@b%8cSs;8^fgp`4UnvV8o$`TVzBG4#keYR)_af9}s!7rpk4@-E z7@&)VB7j(3=***H82x@?J$fAKN|+WQI^+o`94T5lm1=;05c3@ZH0v1zq6`9Q+x-pG zkD?A1K{UjhLxysC&oe2N`{qW=qrP4VwuaHBxgdU2nSK0YksLRz(GIxy|GpH6VNDl) zn~Pe)Y(lkJVPJW7yFnU5eh$t_yA%cEOYo3n?iZAkI0w9V0H1`Vof>9?1*Hy37HqFZ$ z@xBM6QG|a=fN@XL!>vTTd{XG%-Kq~M0RUn>7>f`q_lc6$ABeu*6%&U0eue7&G^m7BNr>bqI-&O3- zXaiTts;j~*+46uckoGtq=7=MjT7}O-mzS@>)5Uc5iT{aYMj=D6gwX5&bq@S|>d4*D z?l*EKcT>1T9NYZG)LWBU&6vP+^uQ`1%vQ$8*m&9}Zdvkpi~rIk^OVzs4Mwwrnr=Ai znAq6Zw1**LBZ3Nb3Ni|5FFS*LBP=?44ozlIk`S^-=0e`57j1I)N!?fKduw z{$+MvE>eFutW#!x&xZg}M|oztC9{-hTO2U6zuR}bLL&H205MW>GAG87z*1P zw{YGLC0nS)93Oa`9>0P|AVVcbM^g_T{bJ8awComtXA{6v5WNDGxDd({ zjogI`Xu2^q4pS`R4({M_Pr{nE?gb*88*cOlln2k5j(~j(v$n2*_1OYM%V&nifR6g` z-Z7=}i~(z7D^x^jkRstS`swELG<5w@GE+|Uf;|PW|2JjLKP6AwBB9LI8gp5EnAs#X zO?@uaES@6cc0aVUrZ9$gqxss~toZXg0U_A4FQJgz-=Doi$q0qb@4{1%zR|IePl&5KJ-_m z#9BAz*yy=r(9k}#3;|J5Un=${FMqD$n~AX;t0={cz@F%`miiMo>s`e2ORap}1#4L_ z@mLshrr3UF-QM2yPD1cA5FL;HfCv{^>+3vuuVKrQ)z8b-uO36gRFcL2z#)Bwg5qoK zJ@AC5Y9U1yT3<~sWs+SJmL;EFjw|NE=tuFZzAR1SGHdX&0cWLMNloLfiFho0Wk~}C zn&^8hPiij{m^zu~g6k!L{ax`RnvRi8S}$0fXps%%Y?&2U;ZwCsR=_&YD6l&}Rv9Az z|I4(MKP6;wx7&>RZ;Nzr#6x-~$X3>o*?iUJzW!aL9b*`>N`L%n+6h^Z+mS5wNNe zVB1m0VRotwz>Q;$J4+PDL58_AaL9eeAdwbtHBKyh2{tM%RUeD*a3vNMNB{gW$ZQ(V zH~#Wpoq$Z5(x_U#k+;AuZ|>6W_IA%Iq~?gm_I;Fi;gfBwQ{^`JRib%mf7m59cAm^G z2%+Ub5XohZ&CMIIM|?VjKmbh$9m%fu;vJ!k%!0DIQ?cA8Emsc5?5A<)M?v6D$j+Vx z+>FaS)txXwWNPl0@sqDl>aWDogbQ{ysuRedSwHxFR}MWW*-=fZcfa%NqL|d=uP@c zKDjtM%fg|a69%)YZY;koJZ7Mnw4@VuJt+>d8T0Mf3YhkwE+Ur6|D{eIX038ZYlp-~ z^jbuHY-e-|;il!m!H|AU(?-6$oWYasc7{$T%L0X`3Bj_m_6V^rO3P7H)PVc3NDu$A z_9D8^hQ`P+QTy})q4$vEC*erjr<)wgrwMrm1JG^TGlV!UKk*f#iqwOy@RzqBVYh)3 zr}WqAlTSH4P8whsq1F7prf)^y$+L7G<6{wtKd2|O8`e}+))i!qdmUVm;g+(2ZLxt6aLqq|Cf2uwxJ`_Pt+|V!?a4+2E!+CSv=c)0E z?2S(wyW`)OGEHXo0f{yT*BYdrsJk|%uEMU@?;Oy^@|FdP80-t|z?pnl|BHZg%*Vo; zwk~nBeAndrH6lhM1~gUSlNvI66OQ&JJ@@UKc%_O=eURm0-|I7@Y7Kx%RKK39?rLxg zWJ|jWw7b2*%yI)o%H!-m^{29J&gzhCls(g#BQXbhmdaCzl(FxSGmbQKF0xfMer5=8B_t<%$c_ zcM*>?b{BX#Yq4+DPdO;|hj@M0QG&h{niSv9lc%^D6L|+#3-3x_x>Pz3cv=V@St3?@ zyq-+j^-jvccBtdKN5^cL920k6E;9aF`qO&%mzF9U6Rp^PvX&*8neWugJbwJx*WKXq z0mchzvtYwa0?YhYCqY50>H1mAO@oe~DcwwW7u` zV;gF^+1KyxyLR5&tg7m5s?&?vctoty5(K3PX3qbLR7EBUvkq$W!Gbgo!iZipl&TqT z!dn1Xe>6HJIm@Wc&J6eb%{qpxk>?ay^iBn&#q?|WWXzvwS=^&c%P_7X+rk~*{%{X| zt;5g-7uVLt;Kp@U0zM*S~whSn~h>xu8;$ zfjVzQ4U`enfa-*0Yu9fp+gGeHf%jm%d+}M6?^6ciJQBQ}Ezo?JLPhlP(^@RxH2TMr zBqqOp(QF)T+!GlZy%`WeD#=|n@+Ax1-_e@HVNQVbZ+_O~(Oe3FgSXAd9q15=PwU_T z&hP3{#JkFSrVv4tR>t^<_>if&NxQL&N`= znc-#5pKXV+`9qsSMTVlhfNUdY3Pi`r5a1n!(8uJz0bpPrqrYkK`vqEGH@873#}!BV zM_0n0*xKVaG?E;rIo+-rf#)_kt4W<4j?a#sGy1+6tqI_SM`Ng3OdGkYS;x7nqyIK# zKdF;H@fh3p*38kp9|p^3VH#Dhl`bP74g~B|>9}PXq_}7b(i8CH=I|}0!Z@^m+}zyW z(&&_wlxa|&JOST!mPa~Y#cFF5H(FHp+>(UTYZh${TFwI#D4+;QM=4+|eS7fvHK<#B zE58t@y?7mkTV4Jjh{mp?@0n()m>Q&45K7WDy@6p^6&0t*3Dy zN)0X@Vea0H{N#1DJ9RZMcxylQx-EbI>0#wf56DR(Gll;9nzW3~Spr!Eky%G<=$}6^ z^|}x_#>ri|^#rL}{4wqkld5VLA#^5(iykl zEDN^>B>ik?U1Wz#!lg6N`w*6$&}(O6NH<5j2sF5(XFL5_o_dnsVFI8!<9QLB+G>Em zc8>%N=jfCsmkhe{zx~_v zK%ikCBu_xlbd$Jm$jA8tR4QBKb66MH8b>^$qlny10&&)Mb{_RhNJ{FDlFq&sGX-mzYEEtk!4_1v;7r|LRt{s1665T*ARAaE^uU@z<;QXgS2mxOKjVth@^Lv*kW| z|28pk>Ep>;1Z68|mGTU3gBvIxs%^Qx+;RHR@>h0e4;~&M*Y|>`{lln)WYK=6pFu;W zYZvU-TBDe^+d((*C5fUg0n|^eK!348c2ZZ~5{y~sOT>drO1oK<(CN-M#)@f@bXp5x z%c~RQu2`#JBbWB3kZy!(FsUR_z#br=a{rby5F72d}reGQ~YmsXO zi2CzruyqRJeIj(EZ4&LOvuY^|cO^z?d4MCW7`>HG;AVw2vC-l02Q zdU%uqAuRDuI=lW|O-|HAlN7-Zp#j_y6@NPJw)uVs(2H)#xDj8_+DE5xnG)5By*8)A&{K6d*PVq z2sM~=XKC`!13aQfMoY^ed5mm@2U2YM`*^~R@d0p23#YgLSZ~g7ItJU+xPxq*1(kLK z2Yz1W+6_wZC4<+z84jW?39#^Y4SO7|v*4w};lu=yTwRU>p6s&PR^^)=VkS^q!G=U; z-k+2G_152}Q~IPNt2F)U^6fG<<&%)rYC3Mve)Fi#BXaWkVZfwVyztwkgH!@c>+~C5 zXs(ST>Ljon$kVGYM>FwkWY$boB!`})-Zk6@1;_TrI}#52s;OW}+Uz&9=WdIuVK);7 zs=J*sd`#c)}=?w-RX}&wOJ65!GwTriQw|WeS5!Lqz z?mMNZpp@2mipaM~yUNYmr;*NmD+x2#>BOMpk)5zFSXdt&+Ch52e1@)7{wqr_?@E_Z zuFIr19@x>zADhL3|N6WDJxeI$8^FP1%MThlPzps8L*KEqujplmGT999aQs$ifN#BU zSrR?B9D%UFn?VR?{@`7%BHV%)_J?p`b5xxG+$w;~i|oew7h_O&434s7G^1AP-m9pU zDWp{g>Wppj*9_H8;r8=S3Nc@j$6KhB8>SbUPREo67ULbt_r?(Eo#VPD@MGI2Bt%ge z8$fMG8tDK*%46kXOA$1YaZE4Yhza$YQ9!Gz`Syv*VQ;o}zxAp8!tbB<6d2C{X^0B0 z$Dlg@y#G;Dc0C3&0_O7T!oo!d-Ge;8J{oKPeQ=s&8*VuH5W1e;RS2u;;rZZaD|DnA zCn;IPR}Ob@u$c8SDy`cftl+J?d;<2tg~=Px|0nzlR=4$L=2MPvY8D8zZ_4XKBYH)3@vxQ?;LG%&ryF2(ZX=K3$rQHC9h5WI0`0VA91_EY3L^)-3_Sk$AbY4 zfrek}U3zV7<`N}#3l;CbGH~wrzutz3kjA-fCq0qYU-|383{xF z#_{OUMk_ZOPlhID_RNuQdP9t?*~BUR$zw=?Qu%14QO&1xN{k`BT%C|#3SN2X86GHeua`ULk9d3 zqsa{MMeM>Vo=Igd)+d=naY<_XAjQqf$KeAHmL9BFhez_@c#~==;OmM_DQ1uwDKPzp zFTfI2cISbgK=i= z`EMjW$;tKbSsG)|Viuf4%44pp?(6Fxvt-iN8;NY_iI(hFM(zz)+0EjA)hP|D`YB72 z>O9bsBL6rp_)2~BOS-^kFRp%OkU9Z^WU6@Bx+iIDbCx>< z>%v~)(J934hBe0Ppyq9c|AZON4w8V5>G=mm$tlK=pK}M!5Dwt!`lHgCFzAqudSB^u zdm-P`$I;(PTpWfYS2b&)QJk;tv;mkUHyT`YYEA&tXkij~paNXRmj3wD#$CUNEvv^apnEF3x<|0!M0E{JT)b~V#|+!wtlf2OsXT0(adMe&3|VL z@b`mF+{t$0x-ymoH|g_Cg|0xEgLqehO{)-U0IG~6hOq~lmyef<@cP>!(jII zq%O6`>kKpn>^JlP0$WJt>>DyGdS2Sv89- zOMPBo3w9<{C%T*8xMPeT@WtJJl@q z@0O9{k=7EY<8h1i(;+z3UrWN9p|%E%y7}0|5=2ZwHD4Eio{g%R5_w^1DW$-1up(IS z)KGZ8ppcm$a!V17_Op$TiYh_Wey89JyH!oZ)}UCUGof1k50k<4&ozqdZQQW+0P?NM z^P55$lYBGbiqc8l*^6^`cuEo3T{|OOXdV-U_C$r79Ch1?nh3I3N>V1cSW-h9>c<*z z*8ZfxBgjn5a`Ksj!|2@h6{f6CU4ZfjGm(J00w#7u@54$(n6d7A>h)SdxgSjdP;|nx zeCv#@^*vsz557W5$_&+HNsh<8v(F=IpD8TE50xn$YOc%aRb~1Qkz!4P64c_jm%pLX za#-cpfOWM6!s_gYl>kj7i)d0Ge-4vY|A$ch+ho$#$Y}!CQkypma)nmVnoL964ORy_ z6pdrmFLhc^Zi7G^P%2Fi@aC8CODI|ZHx)#KW{_&Se3v57jS3s5{@F!>s2W29j-q)8(6yO@2>Pr|SIWs|7I!}goZ7al8~FqU$4ku^RCM>U8SaJzEJH zO2q5e|9mMHA_F5e?6GjR?Fi_?2Zp}%hygZsUuy(Xv@TuNX5r<9xmjrnS0H`*DOWR; zO>-WQD3}VFAyC08_gDoL7ojOzwi9*EXnZXAc^(f#+iO#41&8bb( z7qUFVH!Sh@C5$#&L4xavmS^8$5ezQ5YR{U8Ob!0}dl?dB`V^X=<26T&HICmBNU)xq zoRrwZU7CvDQ;+v!O+e#pud*sifmjKh{$r1>I94(U!YEV$&;pXxu7l`o1NMAiExtS` zu>rjnDq#n*BA1H`dHZ6%mAl&B#nle@o(Ky5rwaC4racbm1}&ANk#A(XZ4uicW+0)wGhm{L_Zyj$FHNi_h{El&3)*C8vc z06#qF{rk|z5){{9W9)1Cqt*!z+X(Sl@ph@=7f_**KzZpvcq<32qgQ8)XH+^+=bsYX z-Q9tAYv2PFe2)XLRS*?R+t&)EZbZL69rMeVFAoeO`G*lIp5MiQlox>OF#E0-@CkR( z^Ec-w$P*QwJSl(-l$6ixLRnf?H(sFqQ!`-unIsO4;X`tkuAurfo)fN!Bv^Oe=&4t^UEBwUZBeDhR^!+**gMUG3|B{Dy>XCcc+ruq zZ>CJ?&g0r*EZUa0s!*W7p!OUEWW}oF>OHiPpW9o^CH}Sqn_BZRYVT>02LYdeqE3l* z+!o9euZQjRZbM^Z3%YT@od9Ao(QajbFV#I00{uvOOmSUr7Rw~gwe8G^zFNsr^#=9? z1)5qQ(ifTXCX4Tf(Fp1EP*_JoR`P-lkU6~(&?hchrRRaf_uZXMkvBvp6U9LO4UY)& z^9WGAq4c4kTIkPZfd$=T_ducS>Fy4isW+HVX=kUly>PSpDE3!XNkiY?fDqE#xkSw8 z4n#Q4ZXLnd&T^qXj)!_4f23(GH^KNLJ@{r+&u=k0J$3-WH~qp$bJc~|tp3ln&K-s58@ z3=a?gwsm&3&yr!?E^sd?rD2n!dH!Cdt9j&2z>+%*yzs?eF2dmvE0M?Ug$yyx?=OvvF{W{|-QD0#K8FH$x-l3mQr?{2dk%Xe;5 z3ZMuX&S+Y6}aPOtm1FD#0(8Zl=91IYI>A~@r}!6V2C!oWzVt-4k6fejfn9{J8) z^llMw!`6JR#=IV&MSnu(PhziI5IsF0IA6G=J$pTg6q4Gbi3xybNVc1%xcu5+4+1+f z(?A*mndpCB9D=T%O}DI2t^DJe+23Lj1e%`~c}+;`&GNrv6=xz(re}^kUcV~`$onTe z{i&dGr_2!fwhT?>6rlf6pfwy^x@;Nn^)`$Xc(~jo?g^**Zv_N5w-~o|Y1Go3$C&i^icY>wy2-T#EAS3?>_ z4gz_~O7S!JZ<0CaVSY5Naid#uq?HH;i6b_TUFOJ;#EnmHE$-^;>mO5ah#M2d3XQwf z_dW!f1K9-N(#dY=0KxMCt^}QP$)n_WWt%Bj85}pPZwoPm)Op^3n8~(Zr?*Rav+R6# z8X6i}#a40qRWp^oIzfAGu4>JQFt#L|9q%&aRbKn=QH0IVa1pYk^w7X%rFiesX`T@Q z7WK*oPx5r;&7DWO&cY?Nd4J%tELQkN96}|loJqu+MPbK2xn95d3ErLi%r^a{*d{mv zHb9-051bs=?zlx5+t@m0o@ZEjorR_RY-$PodJ6OGs~Q8O9RllH;lYC}B&Ya4W!)6^+1AvN{$vV` zs7HVPb<4Uz0n;}*KhFk*;T0;XGh*?K8sIuhVol%xx#;g)ef`-pjQwoJ3Hnjaf?ye8 z7TnxZ*3>;y1Ax02QAqG2mJ1v5`l;I}^{bZp4VJUz(p^)Xf@MZKZh=>MJaNJJ? zjkvu9GfL1QAsqjHQ4_S>WPAcd1YpDlrJ$$=@o{kF*)$DVSv9owWt;{J3;eiz{IA-l z`AoEAa)t5}2)6-0y@C)E5Ay%}f)V)W3-Y1d3BLQIyLUt2+1WW8yFf&gcJ?u{)Yx)h zuEVXfFbG-MdGstw769c91BB(G*mkM?{1sP_u%SQQXuT_I4ng~9HvAMUm;#Sumz}ej zC-8!(VAanOA900@=4{M>e?NjOCVKNC9sv->1R<-SZ)X6;-I(CtYY}=0{eTKscC2W= z@&6A+fLinC@Dd-0T|XIi!sQEtfg!E1Z*b`8>8ZKS>O3g85f~WSAZ7$f-PcR06BzrI zg&%yHQ`>WKy^DmN(|b}Gk-KH7aaXjLi}m8so(K;pcl2QB0cgQnP{;?|Z2s@xM?$e* zTBa$x9|i+nI^KYD@})UwDNqH$J5tV1*P3?jK6*4+E^+n=S*ieO6kXZ}MRf>lZE2;) zThrH_U(IL^zF>V6O?SnV8=)g8tu$mnoHv6E*0-PL!L`b9wh}gOe4tt7Rtl+jkpvh@ zTvKoZL0B9Ht(cDI+xsS~`Dg2d6YalY6v;j4N=>2t`@G2ggSjQB}s)7dP4Jpji!Q%r;iNl9zOHE$i2mlADt{FonK`y;jBfJ97aTHneH)$ zA*|&FIB%xQjiwgm%!(-Ya+tlRj;qps^n}}tKv7`U7Jp0oY5RdT_qg+H9N3^rAgY+4 zJb^Vz#CFQh4I)HPZ#V=Q$5yO2^02`qjbiEmDmr=UKl$#H3 z{8?mM-R0mYYCYH_Hcz&knx01(bQiIHej8O-==@f1Y_b^Yv?BsdlOM!6fY%!)4d_;r zGhdm01WZL3>e0lx%9_~w?lReDH4-x{bg`PK-@W_nQ*V6Kib5R!?1`XUnid; zJAI(cB~eeWIL1yLmS)F5nM0KW1^Cq{;-LO%e0&M@FZ(T_LB}w( zq!j|AO(!xqwc@a|pPM|M7bhBgigWcb@DIdvPHbO^Al)T zA~~DRo;XJ|jP>i2w5<(w<^K6y_S&i^WjwR(3@zsEnV2}AABj`M-8k&j`FmapUW*+8 z2k*|xs2R>x|K?k0a&v~t*W{>cjK!v{ycOR}b79lmf$hn@<3034(K+QaG^yj6cIo_~ z_b*&@x;M`#VY~4pEVe54#?AYO>!I|J$U;m*!wD5Ex?uvXWcHZ2G!*t)7`EXHOy%Xl z0_5xw$JY}Ev(_tHWLawnCw-Cjs~t1uL4HkKvufbDWY%|RZz4uX-VqWK)=YHBS~K(T zIAp|Ts-F!w87G2+=>WlxkGBQw+Lv;PhHKm7KDi}WuJ4=W+$x?Rr(rpEs7|j%@8{2- zUr$}#gnRKq%h!Ph+jNcXJ$ryuZ@Jh3Mdx|1v6|!bGCM-=%ge&Y(~#GJ+d& z_JjW4BEP}?>I})a512OpvsqTJk20XYNWEw5JfB83U3$rNQ^!WP+C$gKm@CF(XMH{L z+?$I%qpP-Cay_Qp+%{|)tPTx}u^(b%ud5pyZxtjUulEkIkh^-}bRFn>&8acLoDpDN z%`x!dymw@uCJ!=%gZ>K~j_Q;G=?Swgi$C&NOUs{g^z<9=?)(nr7dRPNJ9qm^`M;Rf50RMX#EAXvyfL`DJ!PV-D7Z8z|IH*}|Kec~ zeB6x~NY(jxt{(7k;n8L2NrC?$IyQ1(oEAXOf5rlyS2GD$x~l^8s%%BH)Ht>0wnEGa z2p+Q$lCzGDNtmy^;^gIhXo}Dj^ZO_bQ$CH04xx|Ni+3r%_B}VD`jiuoE$DqIBL>FB zAFW1JZF_sd>sxE~-%t0xXHG8vH7=^`&tY0vhV{W(<>BF&TOC>TtsfumWO6L6kK5ly zyi&LQ0!#$jll#h6bJNplyY;W^py#_nY`3{hP%M+ic;UjI?U?ELz+;45cs5Y}Qa5#a zTOBICzSP>C_;ORA={A+5+h6Cw0^SEkT=Mtf9j8C4k9{bnv9S|Q-Fts}D<_K1#nMkD zM@y#a&?rKu;>Dw?1Jh5xt-55BxphPItEf1hf8Y+AyZ?0p(JjS^oC@+FP^iYDj zhsUNJAFJ$&Y5tG6w~VSP?!tW)Q4u8-P#O^>r9nCs>D+)c0@9$A)MiN_ZYA@d+)W@fBxrup5KEx(FU*727!iFy+Zg| z>rD&}{upr86YQF;B5VmG`ant$?YSw7EOs;ONUdTD#XYlqxWjH=%{7{W z{Z$XuGL+xSj-v^IqRbeM1)Q#y&$WQ(crfvnAW`D&rR0;%o417Mk&f%veL9s3OiI1lum7O(-ZOGxa_lkwXR#7ewHOfiEGu)&XN zK?iIW)RG~vvb8{ic(!1`py#Lp?3kOKQUu|5VHyD^@k;Wo*RA2F zWn&!!zwP|2?a2jD2{a%!1z$U0p5O6QYpzyK1>?yRngj<-IGKfs2!q!Ey7E-00A77fiC9 zSqgNnn!pW`PfXC~?~3=1w*6-EM|O=vaMZ{{8(sM9cnegScSlK49&>b22QH~fP9SMH zzKxOVCMMpoz2Ku#g&~M%;XLTS%3dC8d^?tl@O%Q%-3Skey>^a%g#9YjsqT~z(VRLa zWz+c@=N10oMLaddJe~zvO)mz%1!EGJ>iy|OF6G}cW_|bW9dKSQVs73<;fu~Mm)@{k zeRjs6%a<8qB7<-Fs&A{^BXd{1zPZn|zdPWN*SXs20NsvzV7ECwH6MB?X+IemepunL zUS@V!Wt_Zf)t_cQw3bvPigYh~#cV`H3VUg=^IHw6CAaD`UF}~BGE8Rw8ibz~qxpRc zRNCxb`}%V^qjaO|#kx6CytB#9){$Nc^o2G-lL=K{OEQWqb>SJ=tIm$2A_apFYc~5P z6HJ>&NVwc~)hv6mw~%=ref+iYgwVaU_s8p=OD$q7wPs@xtD8qih(QMmw7rOB>8r zep(u0l2|OuWT<7S7AJAu2xx5E{>hcdIGX^;4moxW>>5pUJ`z?>fz}mtiI$c=v=l0e zIH_;ykb{Xz3zl?RD%3q4X2Z&IR)cbFKKn6N3|-eUbqj_%+dHdJOIt6Ac}i$&he2w` z((LI;7SgFK@ByPO^J{fl8`J%baLTb@i=AvJR^S^O z7wzZ(Dq7 zHxASN_wkwjQklS1-itvC3l^BD15GT0;^%bw=24<(!4^TnYCWjH6j2Bo&h})LJdlk- zCnH_BVH>O;k?eD7w3Py@y?IuoRiDdBLqZ#fpFD<*tTc6XNB zX?}VpF)wD9IS4q{*k5a5x}j0Gi!WJ+ux`1nEQ!Jhdh zUHY0n-zUgB{L6C{1Eb*@t>i$afCiG-_X$8nS&N4-LTG_r&26}8I+p6gXn{ljH=$iC zoqr(=BI=!lz-@<_+-b+V6FahCk;Zcxrh4o724aEC^CGq%&W!-0oF^G7vImI$13w0A zfbR33?hUG?$vLBgUCe#&ehvyM{T${0w&cQx5JpR#bF;t3^wm_V@~i<V?LGI?qPN1;8)obB5;j|28ZHo; zwif*PTR7~jBxU%Mxw`ml&huR=B6SpHo%(j`zpIx({iZXirY#>t;nkgAwfnxWrEXp7dEN}>n|a;M*#RZ7<>u~Ghhqj zLf*X^c>0LL@8nj7^7q=^OB(VKm%m?P{SDJAiRH#%dgqu0B+%>Ra8xZurGJtVQ%sPi z_hr&6>iR6i)1cR=jP~jyV+>z;RRudp-PbRsO;Mu!@*-hek>>8w)7u6*)i^22Q9;u( z2~KpRtsXe5f-kv8_rB~IgtjdYG={6+yJIt}c1uKf)#}w?lQsi+H65wj;7^n9*^E@T z@&JYITz;+e=@Fm*8T*Z6&${8wofMj-=O)U^>`eNF<@+c6st?**a30HtFqsdXy|3Sz z`4e1A{`-C;cWoM<*pFy<~b!;JIiqn!A)`TFK2Ok=EB%vzS;Kx2Gy`81Ula;*v29d7i9Cm?d?256mtLFPL5$c|*w^ zOkz?QwV+YuwD`hT;doMBR!Qk|=;ah8W?SWx-)*L~5hMNR%Q78jin%}2PV2vrd!{|5s8TGay1AXrR(eaa#I9F6RYAOT zqDpgTB8pncg&GMiB1}Yja_j@yfESCie#u42iR(3%7>T#^LC4#fjtXU0$0=2 z7*4+4DyfE@4NSipZhR%2y{k=C0@6W2nh9{Z&%i{y@W>rUDv&6aZeh3*jg+<9T4avF zAb&}Cs0b@V4y+UgWYQ7^cPecPE^moEB_i{D(!3Dq6DC7^K1rZ8U>~GJDJA%*_b~qA zKJn}j=_ixDGw^SRcR)TTB+YR9#&Hf-J2OGx_r0skHl>Gg4L*KFfq|GBO|OKK&8$T$ zsB#alH;9PjgM@bv7)1ALatUU9*~R+fit{)*-J{kK7RiM8wVrja9wVE+Ze+Hui?Jfh zxQBFe<9f#eI(IXw3;*oZcK}wDj*-jk)eC<%Jbv)-H2kk`=99w5O3@F}W5h$5)eXq` zEa^tw_xg^0wXA>awQBEcA#3takh!yFm3f1OD05&`Y=P+~;Bbgs#(kN zG~q|5=a}SH2@cVXrv=Y6E`hy7os0=O11}Y>CWdJdJv~q68TXlJ?{WfH=TIIHtZ8X! zM|ZR}%%+e!|I%h2W?IgdbZ_LYu}5>7Jc>AaT5p-TRQ{}uoQgPrS(Y{P4aW-rpII7g z-D=3=8@XlRbzp`;Pi9jF(6yyLs++n$Cl!5ui!t7T*!Zs9@<@r}B^tbDC5)Lf?Poej zKm<10KlX452|rr1MQKpmecz=KC7S(cj8KQ_Bln1*ufdRH|MUAKAAqY^G&4IpW1&$c z;68#evVb!2?sNkZWAfp)>9(FPKKc<$OaxDf00F1j7}$SJw-*9=X}M@3z zvZRM`IQ`T}+h*w{4tBcLgewqy${VAE#~&IDlmgg$e11Y)YwKKJZ>jE)Gi))-d5 zkH2Z>XY7HbdM*FS`+|KrCEMZ*299#z`%MDEXYvsy#;P`dtinTJgc>D+VQ#|+OAGAb zn8aLS8XEh>-n1_oz_Do)RdseeS{2DEB!WAYdv8 z1fudFjM?VHw!Hb?^?3gZ=rdBC5Ky?loY&^3B5YX05)%{u2owC;ki&L|(132fiJOI_ z(!V%4s-`OTc0*yS&;kO%0_ID@am}{SKAM`JXU8-QfKl1w0Ui?@ zv6A@FKjV;1sfhkC83ZGf&XRGCe8;sBx1lN+q|JD~mv(85KzQYSMH0A(u2xR$5mXhu z9CgIKEZ9);sGg53@xBd zqT8o0;tZ(dnTY$r_NYo0`tOlLr(glZ`27w5ZN|Wn8;f5d;y9NHDuA~94w$&3FBoPa zI=mUS(tdlZMdPxsv0e+x+?rzp^`ZYIdr-f1=d!`5UrYQUMSHXe%X&Gt-uxYm5G7K? z;}J$HRN~It{_HzPWapS$>=40`u+u`UPX_$JXXH%Zlv|~a6Z)~tu<849gOQLnI@(|p z5H~HLaZNikoJbd}afd(@fgG06QHGc|7?mGo)k!wJn1J@DGBIJ;3q^d}OpwX_> zc6UYKaE_EjsNIH!#95jQCU+pSdx#nyj4X{_pf76)g!>rIt1(TDvTcuLSRk_QDz~1e8%|P9`nfSix{8; zEy!(phjXpC=I-T_Fp@X?@-)AQn|MFfn~*r#eMwfmuL~yqio+A;TYX^w|6&17T%u37 z_TRptlH0=47w5J*&N`f^nB~p~QjoqDr@*?PK8yjsU+4$Bv92uy$(a3X;=`5POa}7> zHjsOETNMGz6#1Sl<8Ao#=^KMbywq4Czc|b_Ry;SVkCg0bz&c7Ln6La(jYU&UAEZx~ zjNCp#Aos3$CInfcY{;32E(=ATiX?EF6lz0Ny|qF8+=K3VbdAYtE<7%InPY`)G65`x zeS89f1fC76+9P$s$F*K9AwNkNAIZYxBAJ6I1o;H+1c0t8>{UN+{><=JQS2V5*Fiv1 zz{Pp@uBMt=wzYFSCuR3g$y4n)Xajtk`}1f#Rx%HWF7WFdE4L=^z?)0&RwtlL6mrF zOI!zLdv4%u)!4Iaeff;_bC3?*lM$=$5JVJcAujadQ`qpvoUvByhx5x;r7eX&Nj7UVuV4?(rKM@67Q#AoUDFD^sRiz)>WX)6%b zK`;!Q_u6L^;F?XB3MN`GZsc4ObK7ilyQ~~7jF{m*IDek9rg>qZ1*25P2siw%BRzcI zK$~gxoieJS{zF;@157nkr6g387`E&s1K#P}f=V<8=Lo&HDr z1cr~Sq-6Xx@~?u*v_{@Wt)qJw6)2b@L*v!~rzWx&3A3<2HuUK$UI(*e7+Ioa32Wi*RvA?zo#!pH<6t~oI6U#PB@l*Q+$49qc)lJ>I>EL;Kd~p;o z%-x#9k?tQqTc+RX!e424Mb~+A(+1ls^|7>yfK{)Be%;0M_l7|04W`leCxA1U2gR3i z$5D;<)*(06!)q@eQE>RiS35KUmE4RfaAqcv;z=<`rJHNV!e8h-^KEFX$a>#gYnw&j zb~}EBcco+c$FlUB^6{d?ZQE~xtU-QUmnN^zO|$3~`(1h&M$<`|K9;TL9}Fj-PFCa3 z0udi#lj6L*S074Zydq*>lanHkUSMC%r37wOc?H_3@7cRZ9~c6e?yc$TsQOLEG7~*V zG}hv7cidcBNmblEJm2Sq(a0|ks5?F8su95U=_fVIbGgR4_GWVW5d&TO6-N;mkas)L z*t|6!m5}h}Va3G3tMuONwprHWEGMrG?;?%N$>LiXEmN+Q!~XIW5pZqI-Q;67hUr_I z-5m#duu+5po_S$>6c#$ugVQGfGr=4OxNjJBGf3VRY_x^1=H2G3WHs&z2Em3ENgOxF zwGvS6YuZaWn}Be!TR)H%->|)~Y0T|h&BN9-i&XvLUFN3#PhE+!(@yiI)OWEYnKiV? zRcsepOOSZ?ZU^m>0=_>w4?*K)r@!T$uJ~hc+01&mD7-dfo=!^z*+h^aP zpN{)LV}9tHJX!k_k>8d2!->yEA0-zWBY&tHxQBeU1l%pE>VE6Fl%ii~natJ<_IxHp z`kZK5h68B?AZ{cM?*V~^61kK-C8zz_!Os*01Qq(=a^%rpdfz*obfTj!U7`0IyJ|0Y z7hKp2EOFTK%%f>>K7ll&Dv~t(o+E-Ead+_BXr*&IhDF99f4dzBFnQJaq2gXGdQD_VksNl@+{n zZ6Auz#ZZpz^S8Jx3x5`MV0?AeZ!c5f@6>bV*=LRf6zWudYf(6|r-P~Yc5J+{x^LpE<%WyRD}d|W7TM(S*uo(9`vE`MzJf%uF4m`n91y4g87H0@57gsCw7)Y=}}CH z$Ce{Fe}5sJu`ON1+POi(yH)&k0|Omv)5hCbutRl){NE6A=R35quM}c<3@#W7i;}fR z1sj}Df4-!syUd52aZ2p2_;sF2c<2@^Gq0BJb`Q@f#@xvga{BV9Z5U#sjQtvp!j0*- zPv`L0$FojI5ME7R5wdH{tRxxzxn+n+dn>s!Ib!93QAz#C&2@&(UYsGc`!F^vbr8lz z&!1j?1jBupIWoT@$|*PCc5_Y3}+_y>G5@C;kcq{j8@!EWbCaSY^Js$=3P`b5QD{U>e` z8ck^fJ~4CGpL`F^ z%VHrTIfjU^J&I2?+Qac{$y&(3!Oq>N`CsI6!N%MQ8Lyc2sc6Nr{$=kCf4mI33kHn$P%?jeX{tWm)|2!~Rhf zL)mRU`RQ+Q_%v5F?us6cP^jg}S=Eo{jC;n!Ev|;x7tiOsO#Q&!VKK< zO?~-O2F& zA4>atrm=Ux5NG63AT=B4MEW^!RUYpBrm$Z)PD5~Nf%uaB`UyNWP=%mpuEUGT2Juq) zNY|eF=>oPlm_rfl`22$1W~t zTbyBbbq$zEqMe;#xM`X}J*XMz9Yj3;ewTLQEr_u!5emmFuBJA&$Vy-CM`FpUxn`R7g6+~Ma;CoCt46VLYG~1w|Epsk7(=@MBamu z-}wmUeuE=o7?C&8tSZ}3vRCPqGWsHmRHw}a;~tI)u36^hICL8O)H#$J&h_en4&?}6 zr(W95Z^+Ed9Ra8fD2J+aac{6DqFiv86s7My>c?x3Fr#KU_Dk{cIdWm6c1niZudiCjxK1##ZF}xlw@8nxL z+sS{N-?e?0HROXEl20`;Jxy=MqR}7Qb1SI@h46U$r#5~R%$0eos6n{&e6~(H3;Q90 zjZONs=HUnHn7B6AYAX%;XBTCTWR5!Vr%OPO@pb%W^%O|-LPyK&m8hoMRbCf@stPZF z@CG0!ip>bpr#^BJp}bR{W#|;7uU(L!#gf4`pWE8twdfSDeIQOk{U#SGHS2wEzgZ zvhf`#b7Ruzz{hlw;)R>UXc1@a3r3C0!BR&~N+OQcNi7lgk1k>-mb7(cO+2uQ;l1)g ztG-J7aB_5aXktZAey;X+fWTFHKJO$qBArZW*^^rmb3N=;EWx_{Ek6#poeO3kwMlhf zlT~WjJr?PIFeD~9vl){9glZ{z7^Fxtg(uU8C??1TK-01QAY+|kVHfu%_Ynb2{S%fg zLNyUcZcg54B{%V7jYS0UCGMmT0Xr#pPBirycbMU&^1^CDW1GPB)JASv!u;|o-oo80 zFf{#vZvvyKxb_Qv=dvLcCiz?&w2510;8N?FEXTyv@EQNf<8G)y|D|(%HMndhv)Zs> zt-(wE;JJ8Ftz*+o(G?pcKI+mt{{^wFfxx-dymz=7@7^H$4wtY@HKgJ{6R-YWe+1)H zN}v3LTbMesc}p%Ni}vCB5U^a2hR(Tf{n{8={35vWr=w#$f8TdD($fd^;VigQN#stx z;}RjhMk$(i6YpccBKL^P+zidmMXL0xEt-$B*4|nJl*X67a^uQspov)b^E|}{I|n1> zM2$?H9;EkE>+@dG@^j_JM3>?NWOJ_vX1-~F3)OIFyk9px+&ein6`M8t zjZp#WDErXc+x+)6M8Y>P;r$H>8my;V4Q-! zrnixuK2N5aBit~i&{&zgN;hhqQ*jrjeDX!zoCfw#!0FBh)Rp_aa>M5IjpOb-1!0@T z!-Os`jfX?J#n@<{$+}cE=?&i{nO2JM!PB}IoC9~}RC(sm`I)&q5GwU#^}2@XQ+x$P z3gTm^#ddh70(f3Cq;qldjQ!aQ<22#9>3ny;Ef6!wR*fDw*sbI;9(i1$mu961ZMH`) zKK8u=*EpSSLPw;fH>T>_TwK)5arhU(JG*iBVv0(uVsFjw+}*Oq9n!|uO?jlwQsULd@>bXFaNE-Sr}$?ud*dW zmb&wf^h+0T4LITii6y8sh1RxynS2h}NOLF>TJOVchA+Q>>u*g-4{_y-tZS5;@3Tck zOu7lkZAjUuGq(h9_p)lI=Gp}kI*c|yB-Tz10!VJ>L+h35H~dE~wxQj#%!q##@(LUK z($I*QLEYN;btWp05r#E2+ZVc7UYKnaQ3+=&m7h_Q0pr_=#!=(@BG+EltC(wK)0uMl zaKivV$9EX0uo5h!0S7p2#(Cc`&TDiRyLSGCS`!-ZLys2GhgH3RJQ;Eay4c!ydYpof zR+8AyFp*B6tGAv&%x>Z8NS@mT+WRuc)5r_VH&hk=G_*qeBljy+uN;k&ai!**Mo<+7HJ|`O&y9UDPMJ#qq90&-;5u;|?%Fvx7eNeIT+i zE?8i2Oi6k2_hv(biVo{ackGj)IN}RFxSZoBFA4f>nAUcRf`DC6prnM zt$jE+{fLxY#e?0DGWYy#$?E2_g1+$G$#TJ+75ZS^fn}?1?b#BI!A-82zCE++hZfU1 zCxbYWSp{(#;SOr4&zBLoUv@^_2cwq+yPF{1W5KNT(* zY!_sm&LIj87$)7@8-3rH13z%N9DM z7>6UkxDTg@;~m*m^n{o8#w^tBJg6$Dla$D=LDXJ>SEGMt%a|z98{?2U2$5(6-6ao4 z9d7fZo#-UCsoUa0);8dT~%jo z*m>)&DZdMNaMy>y1iukDz;Xx+dw_ALYip}-p2=&9)*e6OzSM2ROcsRG1mqU;=rBSRZ6)?&iNO!>Oq0_X?Sr35wY6yIo`+ zQqnC~!@6@UH4Vc;ZC&>3M>`(e~i!?j&N@FSmUCbItQ7)hF>XJ&N#`EUI6 zKc`RJ|HPMW5Ji%ash!8AAEXU}s*_tEUec;aYkQNpGHt00nu|J-qCSH{Fb_YYfUKFw ztRGl!1-K>u7jE<4u&DVdW-m#9d9V3YKe+Uq-%n7Mb(WBgUeRnVEO5_1phW!F&N=Gx z@qL#9q6=dV3o1Rok2d(n7!Zif#>(AvZuys7CS%p6wH?Yg4ts3(&v-fO(eE=mhI>s{ zwAemn8@+Ia>B;ZEk%E`DE~<`P^ihlveZi`X{r)C7MjjdiCTo50L9JxFC_K5~$PFX` z&H2?@6^GVk-x&W966D`Xx3|P+lWh1T$=P>!n?-EFYv3f?4nzn-FWus(2@Id4*9H6 z{I!_Q6XxLlH}ztLjdd?uO(CM2XE%Gh1lm3rN)F49XM9e1|h>N_Bsj8wB$v2b>&0y@a>ifcdFR*3u zLfI^U+0_c3=`*QkKaDuJK*48Ee=qQ16TE(+)8Koxp9b`0wQo&w^hlN2*_m{NwU_v; z?w_8XcOP!|Q=FPyWOAn9;~u3!`7LYR|F&B+N(cH&_fhDfsU;{${oUT~ogT0sl539? zMgWT*{duB$*6Cg^TU@?Rlk`uT#}Yi3Zc8QE}Eo)xHc%^3ri4rOoK6NSxdIXCCW_Mw79OJUUo-t zC&_6LH<`IxXXpFlG_G02VM@4{Da8oi%^Grk@rNJoV$c&kkFl^cB3Y}0M08up%Ae~U zPrFsxh8tvR%l*f_ZilwVe97R{GVOjDBUhJPU|CZlJC58fE3yxU&P+J>s#dtz*30h= z8(UjsXRolPR#(}|3T?lwHq9@m9PEgoWV1~RU`ceHkVBKb${;# zp6NkZ{ngsvpX(?Pi7}g77i*>w3;0r8oZ)cXNOv%~MQ}${v^|Y)f^X(kWu=!p4b6D( zv`^N)*4>X3fc$Qql`loMjJq6DPVRcp*D?qQ$U-}m`KtNJq(+SO5wb7oVn3b^=m@+6 zlbX=Y^>L)RpblHW-L=Yduc?guo8(MC9@pYg2QOj$ZQv0q9xHu%NYyz^xL}8`8~p4{ z27k4up^vy-wF4!*E&SK}w5SM?*Sc@`xlew+iQN!kHCK)af)--)yBGAPFK7CDhZESF zhLSAjZS=V8OX~~+oYR2`0LSJ9%z!U=cx#IwNG66Nxz9OO98>npHj$0>TRluwEs9e( zLS`u}|6~Se;$WrU^w^_G4W%f+35HMc9-E|){PQ%f#oh6I=OZ4mv(sAbE91F3Lrx3H zbaC?v>{;T{A#~~UD(45{j-rx}==Y^Aj-mrazdVaswO`H(RqZPBtRCO25sG;nSMzYY zlwGDWuFnTAqR`>brF>*^MJ!3;XTMsKJ7QZw^`V(HTuA>Co*Rl8m60|;7pqVbZ8LOv zZ9Hz6%DqH#cIjUiZ)@#x)Y6t9UPQC)%k6;{9BU#Sd?*+G{@v+YR*@+7oU~aKd!9=< zR;3$Jut+<)Rz9F%>B_tN-t=oxQDF4)w;h%w{Q-mIW&TWq&v7RydR6!JJw_7{)K@~i z^h}?)2ls?8dr=<6Z5JQDx`D%*I`92zFZ%pj?hymbO)I|qJx1YPQo+n?_1$MF`hkl! z1PSC@;Tit!9D}AV`418nRkfVjTy3eQ?%Bl0c~gRV13Ix`gf#asd*JQ*tDl|NR1s0+ zZowh`d4`(IHft@5SU*BSq-el?q&r_Eo5e6KLbLZ4vqqX-sa~bDj=sV+QMxS(? zBSSd%&!V{`*b_uT();ANw+}VVoX%XcdsByhZF5UbdLw6a&}K%GpuSN{_GG}5l@fFr zSZZ1-SY8gY!@TF)a`hP4z|3wrS}kL$H-KVlcGirX_yfDfIhVygWzUo2wlx>}Hc`UF zC*Q>g>3WJ{%ITrFv2u>V|GBfvhsW>p%yy_HSjvM}TI!s4x+LV8<9&;xl2noBpYiFj z&7GNCjGISH0}CcPe;C?ScRDzVii%nuQf`qKS`DD=rTS*LbCAU9^}O24GiAy?En{as zJSO{G)Z8t&H6L?}5bNhWTT&TGQ&jJ|P7|T#m7QK1=i<+htCvWE z!&pKYI5{PX>fN3iriSHTl3>G<*^-mfgFqYnXHI-tui`%;smZ!vD(OMadFU*i#MUi1iPChvdxIu6~D?@mASgfYLpoR4D zATCPb^=(pzCk3wAlz*Ut4A)*3gXi@lTbL4uMrOPA&Us2rzW}>|fns(EoCEzWs6STo!LDSANwhzWOfU~e1#$O;+B&4_}!RVVV_AaW}e)xWc!pVnek;4^^tef?O)6eLr?wl^6 z`~#ImiXc8eQJ zgth!>$LZ*BeQm8e84jm!U(EVKj1HUmujbad+-8o-)>|1uLc^D^ZGRIQIN~q_7%KK!vMt+IaMV|sjPGu}U0hIrV1Mjy zZy6W+Wrf^wu^YbAXWjSnKQPV(WUUkhu=d-0*rQq!q@ zH8-~vY9`z4m5=Wm%CAXH*79e5+X%2WotV%9{37OJiPwXR1;`?^Lf@oZ>@R9EJ#se0 z?COn+<~Yb=%$)V@d?$ZtCk=*&M2!;7b+7dP3~U?bd{_GTuhFdsGpML9|M5O`{~M4V ze9EFL3xDl)eb}W$fAjtAhaZGQwg;((wZuv7)%#2v+>bCMp5m8JdM6jc#h}Fk?Nsia|;6q|8!^YlU-h=U? z3s>-WuqFuKfMxiXO}$qs-AKQ9of?_J;$OTPBIJq^-KK3 zYjubh-~h%lV3GsJVd8;EyA}K@{HC=5!%k1uYQq!*oxhZ!pTp4F^(zj%oDYxD!ifeY zz3D{oEw88nPxT5uet!#O6|7j?<`4e*^$yqsx?5n2+m3uQ`M1qT;muxPe|XiksbGeJ zn3|*^n!ee1nV@cIFKFrFonN8s)9^Mt++1BBgV1fqL0THS?0cgkC;_yHuU}`Nr4_dt z$OdcS1dA$soDrcZzD}7@I$UBN^7(r5&q8jiDphM-V0oEx>3!5PscFM?BGpeESPwOX zs00v)cNI!sTfi{V0)v7b2haf24G#pk+COx>? z-Dm1HpYz2*;I#BB(~2$bE^Nzw=mwDYCBfv1Tn!V6h5=x@2&&%qCK&_>jd_;J_U0x? z76qRT=V6cn`$|EOp<#M}tZBO~2C6%VJWQ0!&2h>myJKrj@^$Ls&-otq_+#cJz4*+L z>+~%z>l^F;EUT5rh8`bEyQOK=3}Ec_@t&BBNG_0u2skf&#n4p%bev|0O4sNz?vkE4 z9Pfezi5A#NVFI)dJp@b}jZQ?`{>dI0)#o1R1s6R-B7-T;(5$nIbZT6Uy10kn!zDA+ zCN?AWN+SNEHY0cJTtetE>V#H#m2!OS>X!CoC@@MMvZ2>NTF>P$!zciX&Baof9LlPw z1nnOjaBAOiIIn@HkW(&_@^SAS_3iQ2ke}Vz^7G1Cz3g=G| z#vhG=X4WT@+9qmQBbgC|FAHVzexy9=woz z))CF-7R=IN3wn9X7`q8!!T82u)E$y^)M}0X&r7Y*jbDBbdh2g2T2JrfltM!y+62zo zrVi*GGQt`*W%v3vb=m$tc9X5%L3wk4@f^&=F!R}c> z1C6mKr5)w{GXI`^hI$hn8`ekYBrRjuzKNU=XKClD!4rR77pkePm6H3)NC!lMgHm?F zMwq-e_O&(gfYBG^$rgpwwWCLkC{O|25pr31{@<1kBbiBTSiM?C;ig?ZeTmZk*>KtQ z+>GB9fzxN7A1SIu%u9YvlVu2r<4QDbd_J>L>EzcffWx3<`fW0-ma`mb^n6Dj-jjOW z|IY1z2>FPVy~7ilJ-gLW>V9=9=J5_^kVZ<^1J2zoj1>ww0uRLI4)xjLz_Mm8?U~0pIB0)L7G4Ejr2Xo5`%NDwfLAo8Yvn|z z{$U3CGnGSQwg3Em?c85u$QfE_HNU6)%_2x?cPO5mlsv6RX8{66GvA^se?4J-@gOD2 zC0(ndG4sh!5J89*DMcx5j{me>-x=^dKmdo!h77}8CllN?{U9*QYzVS@kTT~iyjDDI z1Bm8AfKX+qrxa3oJ|E-sf^jzRSuKTNdPkfSE{0U1H>!PI4i{7EORx0i3Q@fslbVF= z0Bf7${lB95d2mnmQUD#j`P9K6^}xuxp$2l^^x>H%!^3fY>wX?pw?vR$-9?TY;GA5Y zPlx>YF}`q94|ddiz%B0nvrOBSsM()`3)W1099+i-?i(wNEG6WA)JRUx69|~-h)I6`2jr7F zpwi}wKHC@r1Hcd9{EvZJdFCiv^q`Hu$0kq&_plOj-gqJ44If=C=wz`z?+mgsI3x6} z0Y3Zt#0@CJwxgvxnyD&rbp=G9R!@*Uv5oYaM*&bC!bP(S(wF^$bgxv=c;m(80sGvy z_=254>IvN;7g$WZo~4nd=8qOR-T!2OO6qvE)Mstuy!LkE7*yK(Tk~y4O+`s)lu=ST z-wtYLx>E~S-HRv50KnjTF=b9|Mdk7*P80BDALBYUCf!0_0DSEyCX$39dl0mU?z&Xy zZBEU~V^RMB3+i&nqH=Fcrki!ITI{LX8vrTBgT)d+=-gQb55m*$i@W*_>7uS9FB%{w zdG_`?Z`Xy=gilscP(g>bhh&FBfQwrh^!?j%=({SF!Z@mxL=R@_ws=3HA+p?yir?b- zgywKJ;o?0c+O;NU6bzToR_N1gZ?qeNDM2_4kTeNgbSv3LMSjb1uE+zxV&f3_f#K<|{xJ#Mv9_y!j~Lnj;1uE&Rjs??y{TT*5uFZ3_>1msCm=9& zSiA=TD0^Q{6|pgw<=~<`A!tkSia4Q< z)Eam}z0{!&lCAQ`BqRuLKQ><-a;7e4?8LdDz_g9?!#bHkLb)?46rXk4Eu5{S0 ztnDq$iKuC#$u6WI9!+1ox@HWxB}Ml(q4kd&6w`Xf@pg?dUWd1;Bzgl1Bq>K978(ovOhtvkWl4Wn^~maM|3^&N%J+N?0>=<5;+sXl7RmEJ(7`y`+I zuwFxySlxUAi-v_V1+P{9sN1~0|NL?}Ch^Uojh<47*md`1%ArsFmtZf@zm)kfi0PJA@>UAP%c%Ykb!l1S4Lq# z*o`a260$9=7WraAe=2C0Sx=9~FCQML6sMhLPYAUi2N)Z!7f&mF7jXP$NUtn*l8=W_ z>^>SA@SV>>{$s7%*kiq)(*V#Eh z`tWGXSZ3;}Tow%DHs95}N{m!&yvhF1Ca~wMo2DP*u_mxQdgR~%SoAElq-K}tfD4#} zyIb?mG{Rg@b_P5e%iMkra(4)S;aSm~%q#3FT1UaT`{GQYV(LB1iD2J>EQxKx^HV1@ zQ$CyeBf1H#(_67d>gXk)>g{#-iVxK6jh_YOw}EfDQ!GU~XFveyIa>ayWr)2Xyzl}0 zVCq8?ye2=8<64A|0o*K9zFwEqk=7v=V@e>r5ewu0;ol!`O&iaRz9cBb1ofZ;DuX(! zs9-0xyTybnyAuJ6Ov6!-XpDWSWf0AWN~6a~9fs%^v6TrXiYNR;n5)R;5ceVK<%~Bu z|Gji;4J0dN=?;np>?b2M0pG-B;K1 zlRe$@BXCX5)2;Mr?I~)Ym}e|IC(e~kyg{xWzeHIrCTr7KK?sba==~vIh%2p;;x7RS znQ&{##G9>(!z_Uqor?&)O#aTKv)CKIk^@yw@z0riJ8G`jQLo zG05F0dT_%|&q;NxM2%NHMiha7RfF<(zSCp|`&BLralVJsf|?g2x+=+-KajE;%;c1< z7V2J~EWwJf(a0Oj7%)3Ezvzm)Vpp+4O3<4KWE6ptc5){+$TY3(FIYyHs7Dw*)&3+l3w1g7 z03dK&23EQ+#1beRw8mm4?J`)g+Dq57bf^|>bL5_gh}sVEtP7$h zN6y`l14~de)%hazX)z=goR+1VklajGJ6e`OIpTI|6l5CZ0=ZK5wOM|EboHrOsD4DT z&yCWh;xZ>>ajME1**S!w(zV{1^6;swZITO0C2K;tui-M~^H)V~^X>QUWz(#F5N()N zK~zw2LxwTeM?nm2_{=N;xx78wS5J0UpK&#z_YyAYPC|z@`c^W+LPA+&KRyQH5Nov{ z@@#t4Q?M6?`*$c{E`UD_SoQ0b-|c`&_g4-{7U!2Dk5Bn-@BM&$H_5H!2ICx_+343B zeyMUYwM#sv>TyAK%n2c)2O;CDvw}WO)gPsOzb*Ob#eGX(+TO#x&s+E8_0*rdY0t2y zg>k74hwj`^-${b%h4HVe(|*#sSk)Wl z3olTfe0HA2zArEZ?co^tZE9O<1m&4-#iG)ebm)-(hJPq$n|jC)<&-2e28KKLSH-4H zYW8FojV6awgqSrns`{)^QE72;xCYV#d50gF?-B^-zFyCm`_mFw>RgncmHyKq3oB}f zIvq#7{zls+B77N!aM;Z&(t#nZ~OG91eK3MK}as9m4%?-Dt zCJVD!E*=;!WG0_$bZWa-G!Q6zqG%f@8tN}9Q|sY3#?L(TXwvc*xn+s!lv z^BMhe)&yNv=5W6N{&25wB78b>R_YhqC$BQ2uaM$>KM&`XQ7Fz0-eV>Hc;f}l*!TW~ z@6$>ZP*2k*RB}^0CHYMQtR!uNK*3U7d`66Q{5qYK}Onh3Ev0uhxtBINcyj zJf&vt(zxQ%#yj91mTYWo^;WMo3iUUYt^jvBzK_K{>dpIw)5VU`l22Q%W0kgYg9D19 zHYg|VbX*FQo?_%aO-^x7P`#6}YWAKQZy46iHWKY*g~7V#LxhY=J87%mN>4Oy{h%eo zlc=#y7#tV!&e~`%*DItCmxG@#kap>#5!H zbYF%PI`CHG22z(aYZshFV0S!t>DtX8*As|0nA>{HJOUQdwB25HW!*q(5#b;L$L9v_ zmL1wh*@XJ2c-%-HA`KSm+l`r#`bY#Q} z$_*gpLvnr2)GSN5GA4jx9@{gCvo*~#3B81Yq$iCJ{-FYG~6 zo0TOe+z=gmUW-R9m%gb|8@;n0Q5n|tH`&K0f&g`u4{p(AF6{#IHhuTDNb?VRhZSqP zc4q6s&0V&Pgxs%@Kh0*J-=w&60nV8H=|LpzLjB>+-j+c0jfpe|Hk~9=W)U7~%@Ed7 zrhe?>^iCWn?(BnW&h+=wBf2Ra!WZt!@%QMk-qtW$oZ}T6?x~daz583hr)cc3$oE-S zv)t&mFB&H#)Hsg-H3<7RFN1>=tB3`{aRnY>JrbJ;sTFo)F*x;|x_20JPdth-od>yU zEScRIN$EiXGo-}ub9(H+Qa z;EPA`El2!?2jz3|3o)hQQo*%k#Bhaoh;L0Wji`%VZ@Zp`R-A`y_$|?Fu)RYg5&2rfE_kR1s0F_Jm6 z^^-Exi-Nt7%Tij(VL{q+)wpt>43OQ%T<_?q#5mlX2_Wk<21CKGCV_+^goGXt5iCeYFi~SUf|L*yl2DWT z2lu__?S5xJ+8bbGO)#s>tv%H4c0UzuwO^e2jx8g7b(u zgB?gWpeBfWq2C7XKT~;G!)bEo#-7!uxOpnL#Oxg5XdP-3J29G z?MA-Cg~im0f?ar|vxkup; z)65LtG8*oep`xfmB~ty!)~o%y5g+ag0IXUSD%66I1^1ks{@OU{zR=*hQI?V?arOZJ z9aZr5{?Ua=61fz*V%eO3y^$`rCKr*>b_psyu#tL@)yBjzq8d}^VZYu24(zmaruB_gR$23p5SGfWDZ8+(IWLba zF9_K06A@Pd-{@EEY4|+4(0ok7*w@PhEfbg{sUEgYrP9IYwnp|5{(P7M6%KY( zm17Y}t&b&>lU$x;br9n#;};wi0Yf^`Q)9(OqRk#Oa!(>I!k)3ntRCvac!YF07^L7E zol7PNXZHuz@;Bg*fEA0F)7EN|ym^jOvI6qM+`IA|HH(;{#(lYWl2 z`9hwd_GK3vzn!&7eL#_!e$KU*r1>AMbf*4f+b+gaSh zyll_qO@#~(cJAm{AI?!ChqkVCyXU%Ei%1(M>#{Ms1*J&RCHC!F#o9Qnde4FI!lavK zgr#nHuYuU_^OI&c$?9ew(M%ltD*nv)&T5sFvRVP;k6K4f7y!8Xfe;y%aey7S3)yP7 zg3LX^UoHL&geq|4t_WD|RS*3s!!74QV)M9i)->^b zY?TK?5vp ztABiUc$U54Ti5qEDed>E%}9&zH?&D`A%(>HZRI?6e4r@TmCeW6OJvax9w8n}>)14` zHm|<$0VAzj?@sZ16(M^m-ir{{d}iO709AB&a7U}k>ncf6Lq}GtOq`Og43PNtZM4E( zHm<-oHeK=9q=w*wR(*{dRsDvg4?jC+Y&5~m@WSD)$DUF(Z^TVy5qcfD$g80?GomL^ zKLnfZXlwRaKT_{S0=X@fu(enyB|DoDSUu6PcC8SeAz^4=-_*vUqxa_*oL!U*M5tVf z;)>|sMD>e_t!8%EJBa`K?UQye`$0v|h#~(Sg-K_193c-1z9{mU6Q}%*mDF$U4H=Yc zSpQ$q>#r`hngAkH>tQIPtW-d||H{R_|WHNlt_zaqL_ z=m80ne!6|kxBEMiC-{dD8dAjqy@ zGW9b5DZCYKHNvZb4$%qfQ(=Mw02f3a=t2Q@4!mhXL>N4T2>PF{t}6xzU62k^%`;db zWU|r_NE>wp$^T+d*%1uFehU?`F(vL*HuVWZ5g{zWeioMd{tujiVX%#!kA$R) zAA(r0?V9!%#cOc>#;}n-vn)73j{CmKOJ4b7OBuXzw7_0Jpo$txj#J(w9T;+5g@l5< zP0OE=W%WO=C&XhIn@>XqAvM`(_IcITS82kKef}LsW0GekWd=dqlNQ5SyMtE&q6yK3 z`3D`1VfJ-E*ab!~mi4>`CzEI(S;=hR`zh#UV3^Bg5RJ;QQaK+yiXGS{A62|;=PVAy zRRXIXh52`7XBfIVq&(_6#vJ%D6oq}rIB__{Oa#>fc}M|?c2|m@H5B|eD#?d;u5Hsk3}gz0MJc}%-YN5gKQ|95j-bC84VH1zPN=+ zg3u~tA9K%X#xSxl78wjimYlrH6n#$pD;C)-fky*-Cb|9JEmmcI1-6XmV{PJ*sYhks zKCECJ0*CKt1xbsdhAE>WV0*^4o&?HZZ5y#klgV>D9TQrB*`cRVVhxs5 zeHeO@_bnzCG;9nHhJyHQrhLq|93H^YZ-FQJ5xkq(s$?^t3@ppKP5j>%$7$YVm-H1! zn~~3GKQO-6bc2LU_PcQ5)L5Prdzj#I0ezQLE1eHs8_!qjkMBmDmRL*r{>%&eWLN@r zAHel&ElWZDq~Or5=HA$kmzKG8W~IgW+$p`T$)q8m*ewq#38k5lZ$Ruci`ZnIit#7l zoEfRH+&=+gRmxJ7`t+01V1@YsI|qiZa|n$Ek!dTZ(4dayosM*#9eRDn+m0wb#)lng z9(M*mz_L*SG+@JJ@CaeHl{WC)n2&w0aBNE_?}auJkhsDG9O;1+(5Y+29_+;chpOIb8 zlxQn1-s@dJ_jD@zQ0nFJ-4%RQ)~w?dSho_O@7$FP0}?>Zu*89F!NzGoy#;sOi<4HR*P<_und zJ|zuh0o2N7=p=TyitUBJ$*>NHF-3mi9_JA0FI!_;Q|@wa7zJju?l^M_N_Gi3U-&wOY{w8p`qUU}y6 z_a#e9DI)2RfjIh}kw}pGe?9$SWGJ$owlHs?8_Cqu!9N+9vrb$w5PMe9hD9CQX~~vW z-L$yaHJu42W|{4gS1-+ZZ2crzwPh-A%eM9_$TY0s*e(j_q`d`nWg=WNK8FrG2_L2T z8j;y>7tr%pH#v{Cn4v>R&dVz>#;HS}dq1y{MKQBYmJ*(7xJ#yDn4&-)h9&I*!LE%w zsx7t8h6o9{^l$i~>E&pzyUMmU23h~zZnhyy-*oX^h>Qa+135|Y`}+FDCer4pd#$%t zRe@^G1x3lW5}X^wkD730yT#4#3-$z{$9!iLy!utZ`{Z$8FWvg;Fo;E^Q(5aZz0`Jo zd_`R-^ysvHPb);7ZMhZ|0>%u2I)*)(ShSvM0;CCUtGtw)OLZ}=tNv!Xw^r&#(M)kcEsv`zWEprSD9!vD9U5>1FD$>;?X~2FHQ6rR8@01?*FIFicck zFX^5^Xiov+k(n{6Ox9HILu^h>o4#(Ps zH}m(we2j~CsH~+9MfNpo>A&3M|EI5r4&+YYYN|?{W8UnZ2E7-o#3Sc^`gnyG-5V95 zt>qPNe0@XWCf(3t&$G``KRCzO6k5IRYfa~$Yr43^xjJl39T1cip~k8MbR<92ooo;_ z_U5(1g^x=Jy7qIA4y*;miCE*tk#B|?4VA>Q7DI@~oogd@DhhB@-O=H@1 zf;tpf%*IjJEnwX`bmQEiVd6UcGLl0tYuEE@4%B<9`O=3122YRfwrsHR%^kul?~g=b zv<|thzuA3Y4OM+16H(~hwwaU!BdAgmM;-`%K-_Q-(of?#Wwg5^3l$jm{&2=Hj`vnM z@LGTpDtO8$h69L4o68%+nSa_aD;pv(IV`P#vcXtyXiV zh4h@%v%rVM+){9SM4qkY*{9ZkpZ5{9ux+F!r!B>}72#%n%s5g=r*##(ODV|q^_e1b z>}5M#dZ^$i*B@U6E(}()R$b*mUhQ4P#rf5wxZkdY)@#>er(XCer|R7~vS;|~es}eJ z@n7>#Y@BA6wT9sAuAn!CZ~5~Ic-ii-TI9UNn$G8#p4BBj+pi_einrxFPrd!??DDk$(>h!Qvd>u33zUu&G0*tJ^+7pXtE9P*Fre_cMY-41G4tbeuK zrES0dy*MZ-{i}Sj7K{HWU+3?YDJtsUEfVVgx1RIwl=*jxME-M4UwlmDuXyQy8KVEI zrZ2X9as2<^NBv(T1oi)?nl9?si`)J+;axq1tIpp4?Gk0=_dTL(mgY8xN=CRpjE;V2j*VRY(!v#l#bvUOsON57~Jnk60q2RiCe?gpC{xX9#*~SuWjYy7rGq zxVt_MR4z|uEkAeV;(P5~CKsv4Rai8{9ExP!L$tik%-Ds>v4lf)!krqq<$nNEp%$gP zdeU?msDg5f_m^y*#@dzdCTeb@X4u;3jlE+XZKw_&k8kI03jCgwfvN;7tUrhQyyq=E z9t{`WYt0*bONl&{dNRgsk6*R2R=>S=fJRbxDNoJLknH^a8|U2W+iFViec_s%7zF7S|K}db;ET$swV!sC#zQ?o#7v@h!K*Da^QDdFfdZbFbvZyph4O@T+QBkLCvibIm z@0CT8IgtpT^BleskPg`%`zv{3NESLi>nQv#U#RZCgnDM3p38J!O$5a~hDnqklZ>a- zR9JjVkjHi3sqd-@ah)+;TOVr^Cu_M_=^G*(gDBemQ2$em>-K5PWACr0O8${H#Sp<$ zF~L%3Z00W|v8MAS;E^9#Xt$>kyqRUumrNk{n%?OU^DB*XwXsXnbXN!r06Smq&1h!I zsQ&)_`)epB$)LQcDRob8ubPq)8?b~7Zn|FaogW-box%pyUKm%Fp(}eh{Lm9+~)}3W@8<|y4m=pnx<)m zr8H-ng_OwoM~?_z5H0})!Y)t&r`HHg6jXR$G7;}od0XRBTpfI!O8WahY?2f=JRxA0%Ch;2%yVkas?{xg168Mu zVS=^<7ODnuI?q#c%lXZ=KVVyG8h;d#X%kym3}Aph3AqByqA>XI9IUr-7EFiSFCf)S@cq@+OM^vl4mX z5BouE-5$^1EAi`AOYF;&A^n_gjBL_mHRw4w2v|*yXF(d@l4bOHD+>Hu8zwW!(q?ig zC9{COr}HyIe2cG9n3{2MBLY=O|k?h!GZ!hJP_y?R*&oUsA?D%nfXs7 za1(uawoXKL>N~at7WWeGStJ{mWgA@D9$FyL|1ed{Vt!$~fpS`#@`El6{Z{g*3u{r} zJTS7i&oN|hYb$YSoXhG{n|gK5=;G(5P(+umXzRU`?OV}DCE!_TyWtS?aHywTV+H+i zLDo?OEcMaN#a&gDkOES&h3-;Q!^quS_dY`0ETNanv`gn`F30em;aN-2ULf>)awV{u zZWq)Soqai^Ro%@Y%pEh!ZmhU|lr>z*sL3}`xlc=bU?rJv5$vOFPI~MHpPavo7ddnY zIH!eK0R_>~uWcrBkrh+9s#{v$!H`#Fu&b?#zJOHyf8|?6XQPHj6Dyws_nA^D$gTlv zPDY#F1{4T*P_b1E7O&_wFW}*Z7C8Ld5h0Vq^8{gkengs&!SsGp zi*^$`K7V0vCZZX%tid}6O|+v$(%0!?8)Y5YW7)1HGW$c zglM_7rAM7=NxLJ_dUdu;7ekWZ_=TysgX&wS3f0zwlz{6R9_^priL=hMkc5C$ztOQzNfI?Y%;UIl^PEs!>?6h~y^euK zp64S6cf@FYPbmFzj!aP=O#l>W-u5U zE~?5d!n62&{VVB@e4X=%%cX6qef!;o1nH!W?Y0A}lK}>~rU@)!BYXlk=q-7S;302w`1=l!)%gH|XF(rO0~%CkOF^ zn7EjNxh!9WefJHrgW1xxxj9W|r5O9#l33aCxXMa)!gcX@yu4rEmJz_9Bjigh6=xs?zF89er zj5P9^p4__3SE=vT##m=biCGzPi{zd5Jv7`(-|X*1Ow}8O&CeA3Ixf^(2xExx|J5}= zUinxqAvm#vHWlsBVVaB7^_?w-B<;H^fU9i-&EdqP5R719k)x0Fe?;sbUHV#PFNf^R z$?57Y7xTo0@wBkF2wZ*#1 zBk+1+v!PD{I}Ata7RTDg`a46I!YqriM{u~Ws{qjS~L?5`S>3O z<~N4muUpcy3nrJ@mpcxjscGl{AC23u$c4|J_V-AQosxg)em&t1>3Tq5Vqh3=!9mu2 zo8o5{z5XRiIZ4AfDVXB%{WR~pU0x1uD%Yq<^SigjyXIz}yKAdM7np4y23`Dra2uhH zbxYA_j*X41w;9n1@Ybc8A%#Wx_`h53l(m^N)rCrk{ZedjafYN7g8HJ@fo`2_Q7e7p zdTmk?qt-WBR&M>Zme9W`y5=Spzs;hmDDs6z{0(E}RT^VXEb%^!lX5P8`#fUy`<}&k z+aD4&d*`ztbEzBtYNvARX1)E>vD-bSqD8gv6N|r-6@IRZ7P#n{j*QAD;jzmG zo^-|i?=Et}$WwJ`{qc~%*>^`OLay)9bH@y`LotcfU?El?I5_kBjD2IJ$Wa|Rw%Ka< zkgF{&9uxYfjFSZO+veQSpw-D970_W#TKP!1qU)2d)5VV1m;0)p$JEswl?iaEV0K0g zp`+xOpW{KfQ{lzy0ArOR>hiXUw^y@u3>52rq;%ia77)C-r(Yi5(B&LxOZ(7^&h3{H_Jt?>2oOuG7al%(l%oBGld1?=Z12Nd?W& zk?YX6=GGymRz0u~zb9fYJ26(l2F^SG&<1@Et3G>P9`2k|Y~{~jm-`Y-QiO2V`DRD# zJzkse(0M-~frr&lu@IYL`_H^0EN${erXZm_NI2h6G2dA9A#&;A2{$G^N>r^-M0iJI zp5sUm3EW11p~$qH7x^y+it|z_p@@d+4UhI-bU%RaE0cJq_-2W&|(MXAUP5$7J zF65FX28LfrnOZpBy>xgCC zU*;VJ-MP4rhloBHJx=Ly6H+d-Xb-m`)(R#Hf;a28GCs{$Sw*y^zp)ebx-_}iuIDoA}{~PZA(HFGe4ie%)%qu zOwgMK2TKR=(}@1~W85$u#!!ns;8tC+a(JkyrKOda?w2$dQ-Fgik7#RvOj7;s3tLiMO z-7e}|2{@1r?zX#`b|!6z>=~WNG^FL&&MmT^!)i+xa+73b$P{u*T<|yqiu_;mI-WHk z-y-A93j}*O&iimD{*;fkjvmls48()@kvyLaM@#dwXOwyA=Plw*ktE5K*px)&D zltj8b_*)AXbEx8EGDto8lrmJ33?qNeLC81-Q81s)_6iK7%(v{r1&~(kD%;l%@ePK8 z#UYSC^YZCdM7eLyUUvOPrIP0bjAg5tO#Jqh4*4~BHs#)M+f4s_W4gB65mrz<7i8u< zbXL#unu?v;B@4(_Tgh-~JbWu?lscpNGFGwpRSCZ|dMZCcJk9GvYr4dS>Us;RH&hd; z_dG~fIZMF0G)rFBVc#KC$9l7)u7O!lCP#!zV${{u#c@9&rX167c$CpU7mUbCAJ0A8 z>78)q;(FN-XErzNjfyk#iCYu#kVfXS)%B>G+cB5`FAg{smdsfckSEHZL>0&EIoCSH z%6UR~i7juqm_><-kL^nURs{w7O10zT#baZ4#UmJ)gGMWiI&wXR!778JZPHk5O7LQX zfy9W)_1O1%y|ea1rL$K>TC!mCz1M^{)~06j#W+uJwMjzX(w1AWI@ZeNmmk0J0#;C? zq@Tbq%>mm=IkDJvokpj(F+X`S#TObkw@0%C+}lW~4;q^R)0 z$JhTcX4V;-j^1c>dj{4f%c%Xmcz~6V&ZzG;6a+*BXyD=HtK!daFgN;x79be#GL(R9 zv0;!dw4Wm=Vg$!||9y_gsHjRbREsX6eYpoJnNh_xU3~eWK7s8JMA}|M(}{O9+=^s( zkp`jt&}1T#F)1;Xx-RJQT+tjiI6mIn_)#IAUa7Y9J>40#VP}8@>w!VA&a8lBJ0K#i zJjZSX{v4a0T^gai^Dt0bcM>M5^Pnmg&e^4+97+c9Sd{C|IFYLDmU(uLE&@@%$X1jy6S-DblY)La>?`ud9)Kgv0h3T)r{Nx`QicgJ3 zmOig6EDUIlE%Uqd`a~AJ)7J01ci=dkpO0T{?q&PH%#>lfQtb~`FR~_r_vCR%`x=y7H9H;B;8(_!o}u zdKYjPSrPsRSP>2d`$F%B&4Dm$Xvt-r!^DTteLk-)1~w(Y>~)L%I!yRtQoYV|orlc@ zF^rM)i^$01t-D5-hll&BL7FeG9ps_S58Zk>v@g@x5%%-G;LBw_ET&PspIb_-%+bc7 zz}?THzVb`ecKCYX4e);})&`{sKto5*g)8P!$j;uL-lE|fq#UfN?7Y0DgQgkZ;g~eu ze&BeF@b>h}98fKo&V#NRQGoUIjFiaJ>(tM6FNC5BsoF*>25Ml+W$Yp_!Dq zqcq>_O8&akJGBW-j2aa_KKMuca0G&yyw>4=zXLyG zs2R`$RV+RN3Xp$aYP`@$lsRRQNEh|~@j-3s$j5-WlnnmZ90wPUGp>=xr-Z$uP?c^} zEUdL>8fxm&R^~v;X%k76{{~0H$jFuhZ+3p9nYqoij3k1{Jm=Q+bPxaiE>D`)ql66h zLCH8zPfyQ9H@)M;a%X@hjZ%O9Jj2}{y!|ds&Jww2FV_=FuCT~kR`n&MR+?<15G_5k z=Q_Q@&OW^s4d{bnxQoWE#gOopvtO{p{uaqeG!MdAG`Xy1Ru*THD=y=L$ztIdK z3AiRSuwq!dVf^PNamsWv(lhIqf>dvQ)4&^c_j3Cc)IU5C)u)a1B%V}}>G1mVEhdB2 zIJ+-1F1NN%NzF&D#D`2MIV)M_RFwlJLK8ll8!@iz$k|QLdxcKeg1wq*9 zmH6VHfq@7E!!#B03YxXj=UO^c@kL1&1}#LWRs|$}itZa+X3X>f9pG>04qN&(ah(lW zqF|85fkAD=Fe_^@C3}{EaN73_2%^1FOX`uY6|pXK;Y7fjzqt-BycqfFxKns+{y^bu zPt_zqgrCQ`VBS@Axq%%~X>x+s*OQQE$E7A&Y>{gu?MU|0jGHKqI=@i_ z7rQlaf*%BRmcKi>>?U<={#KJ+pAN_4)_JUcI72%r>pTyl^v)yJ_(^{7EB$TrsBp(YK-BMKJFJewpY5-H1EALqs6 zQm}ZYegFRE?sCY}dOGjz#wOI@@u4>ctCHv_Te?kGA1|S)b2-FKv%c6qtvuCN?8$=EaXfsk% z2m1N@m;Sfez>+E~VN+po3Cd!eHPwyzdq`NIPJ)qv$%ROp`x{z%13GQ&M!98eLt+{@ zS|rC!=)L%5JNAPlvn(Pc30e5$VBK#W>GR6+@`K!CAJ%r7){Eqo;6CzC+WOLZ0`0)f zDRjC@m8Qk}ykOyWu3FhsphGlz;d)1*T(FUMp5Bu}xqL49i6^Ve;|L-`^J>=~g{?d3 zoIw2;C#c9jj_rZ;u6bkId%8{Y{k8AxlI=r)U)Z4U@Lh04phzajJq#VLEP1_bcpMCZwFEa2f3 zr>DZg#FS@-;yE=f^VAJE>fK^*Zf{QdPm!Cvd{fEod`^k&*omG&u5cuo0SHROjw)V6 zMuc8%?j1=zhQ{VU3i3<_)oQL~*T;~7!-DQ{@HVz5zLKTwEPIPiN+>^5@C&r=En1F< z0>u78Jv|FpG7@I-AVMkN`GFRbTsXon4MlZh*X*LNkz(>dduiRQw@ErnRDQPMitC`m zIx!(bYG~_Oe6&KbSkr17K#$2+c|<}+o*K<))lnhkvD0z)lmP_`gri1oR$1KY5p$Z! z)kg}WcIvf$Vr)M-g=!G?I=*mt!<^E>BMoN)!r+{8=660{f6cPau)Ws4F7R`Wa554^ z@g=}wc%6&f>95$`tGEtYu3eSspBzk;;!x4i5mOXypHUKIU$(>_B)NW+sVqen zZE7qOzOzf&|549Qnw+168HWf5P*zXEmU|KxtIs0^wm{0R`RC&z&$L#4atSE;LT!v* z!@i`U5B5f<;i53yEq_P$w=+RX`je%}K+f`Du(Ha&id=Zi8*nuNp(VfPkx6ar}a-TGH82Qu(<_&i-fEwkq%wa%!EambqOW2P$N}+8!HzvPE65m+9@>GEI#`F&@YcnU~r~9H>biZ~o zzp?HBcS~W%_LZho{!V+}Wad${?@edkfi>0BGZdH+YvLeBnV`gAjNfR64;fh16JDiN~4yO7>Ed(q~ zEr+EqYAh4Za8!gEu^)R4?M>O=&*=~za@)Xu%0))r9%Hq)Op1y=%EI-fnMt*K@|AQe zH*$`M$@WT-$HLc<(kH5II)~{FeTpZjiWo~*Sa%%xC-D0CQF&t~b6#SeBm_w+%knEJ zH7QO29C_?1(RW>`wvGzVEQ?C?0ty9+r36!BS)JXc#0KA3^-2sDdcTlH#t^5eIGa#q zhy;WaJU+1sKdnK{Z9RP*x+0G-5`=sk%JO$Ga1xUfMwTC)Bp@dkNK*c=kyD}t9vaq= zK&VxrtCRiSz!)>!DlhGk{A6P}N}aEAUsYR6gN=1;l3-f-14Eh63Ggf(BMZ|h^+FkMw9^@LZC@PL`Cjn z%gV|J;46m@tu8i&;n1j~5UuVv49*>sBuhF;fe z&))2AQL;F;fhr1vb4}8sK98x!fgg+dz6H2@M875r5_vDJRKdog1Qp~TZwZkv-X4FM zKE^6|PJC$4ngVwh@h?Mok@_VBuWZ`Kka8*zWlXN>Cj-f~*KnDDy2p^I&&Au{UhYL8 za=Noe!Mk+mny_=_FS`%u2_}gl3Q-EIH?J1)sZXFL=^ho7$ zhe*c|tA!aY_IJ<8KMF-!|DA`PI-+-=R2aya)8~IE&KAUC6|7q~_zIFep5+c`T(=27 zi`AxJm_*oyK+D$w6z6S7|HxDZ1-+r1Id74?y5=6H9{}ZFn978U*iz9z-@ZCv%m%a^mR=il4(hGJMBRtJ*gfS-!31 zj!n&5#}ye%G#yRLWUd|${kgHyYd*oon&Xx(n;yXpa1|CW>wb3}m(|guWSi~yKLtuWQEI-K?yqi&xdn~t2Y3EBYNVd<@Q*ln z$lxM3NfoXae|}0puT_$t+WSR6azlbZWh3%)<4s`&s-Mz80S;4eZu*#Oak29(tberM zVh|Y%Y+^)(83&|3_r?L@ZpFBWyrFPkVRAgeOxG?5!}4I5(Z&SrsL?&@#{}oIZ;S+t z=dm>vszK_7iZk{4a<6EQh4=pXO(^C{(E=lmq0~9uZyonx1E5@c~L|pHrrSFRT4ToxxCncA6 z-(Jjt$LQElA)H0WED<2A%?u3)oxXg3`gP1as)2Q&cQp1NCmMB7>>ut*H}-^+=Dur+ ztz$Qh;91_cpKKlbMq3o&-s1*X&5t_Dgh3=XyE5bJbxa;@=flA5Gi3?Y1>w=YF5uWE zro}V+&nCIMp7UmLpw4+J?(Wl!v4+)o>@3DS-E8P*qW->?bdM?JFwKVx2~T>gYl}~5 zKlB2r=~P@?U7Cw9Tr@lm78RLCB=3z3t-IIo4`wxjrQv5n90bKf)oRYDF(U3ImHkft zlOdOl+HH?6ya<5>;X#}X5^W&f`216ir_-9ep!C;m$*`IY`!PmTJl zluS9-&gbCnY#eGkD`QmSPz;6GbY}0wzG3`Km$3@)kAyGN@ zK~T567-mA%d$#r>S#|8lD1ouA-3$86PDu3|o3QLA_kFEV2%k@#0`L=Ff12Up955&_ zvPw_t0RaTTI$jvd(S?^85~IlXyupU>T^!Lv?&+v}=3tcS#D64?$KT9%9)lhElJWsx z2^9Pnfp4LPvzE`CXtf3uN2vv7kx;4#{^`}?xTR69QupVlm&YDHAz^LzD^0fJ#8&&U z`BU_^O%Ws~=B^MRXbs8fc)FfLE;@$&n&{$dE@mVm&gzKMPBv>;>|v38qtZW884w4q zQc~c z{BpwOJ*z;l52}H&@O_i8NE)Lw0B(j?Im5?Tg2fiEsDK|Me$G4@a2Wob-LRlQBohzT zfeElP?bxE25?#fK5U3(unLgV0m!a+)3)4EIOK(sD65JB!xmq zZ$khR_g8?QVZCieOQ(Adah>>{1zo{16f4V-w!0~$3(@FfsdaYCKX@K$zl*n)qIbg6 zXx{IP0oiPMXH_oet%Sz*S)nFw)~9trVj;^nDJjKt=7R{UzXM)^@dCUkVt^I2@;M>@ zRA<5F=D%>@@dxlc6fWxG$5UNFnoIUai7WW>X~ulW9ZOls?003GzxORS4IwY~-9h(g(WOGb*%qgPRf$xoN=;Rb*0KIFz!Q3v1Eny0Z4WJw(1wTC3YI&)vn1L$ zCWO6)&CjqI+D8fY2*6<0n}v<85DX0s4TS>yn-M}JFatIY9y2P;sRhlR%7(Er>AIyN z8x`jug4Z}3ZZhp&tm4+)Rnktwtu~LJJE3Q$Jhdj>uUM3<5#~bICas|5G_1F`%EZ72 z6Rr@rRDS}G%;faU2R!k1I#oz(D|>b{2U}^z8>sR+CT{hXL|;Xdv2XI1Kj<}{xy{sb zeAptoaK7i`S$l|nAw?8$xBS@v_F@f*RLbcCnz&*9auHRdFbZ#z!_Vg(6uP8lOp(ID z{nTYnbkL0tre=uPK0dryGQ9;;W7B&I#o!2@CBd8Qa8KDs4a~-j^s+L_ zN(yO*a0*|~7W$my-0|3gl{?Nv%hUZsf4*OrWlPV6YDH-sdVzC@@)E(T0D;+;`Ktr{ ztdeIQ4h~voTat2E)sE;axXH!)UR>v<`}tP1qQ*ey+t`sj}KM1}9cM zJtz^Zpv-^g3T3W4wYdZH61#84ab9On(Czi+re#7>y+;wJ3oEs8KAr!oI3638kkp8z zBz$jQUv&cmQYk4z^S)e409D+AD$vv$(cHAF`JStL3{()cMkzND^|K#?<+Yxke$ssl zTR&omDT$N(CvZinl;{(f?A}d#gf1gC4-Qj*?YDS)tH}IqKLktZDFQC*Ui@aZ>oXc0Z0cP#0h+);xIt2#ON+Ob8~sO*2IffF??ZFu+`&mB zJ)+M8yd_$*T5el9eBO8WXV}6WL)6O+B3`HP@6-%Xo%Bw^*J{Ues8I;RS!rxQh zxU8AYh>D2|dNTrqhTSPL&I zCqxSQ_U+R`lQYe>>bn-@SJI$hISHg57a|UOq3vo3&5tk@aQIshcT(+DDHH6COrI0} z!?gM{BgYwz#B;r`U$lO2?5qvT9;lKLA$)&R5DIGDDi5sdV)MZy`S=942uN>|Nz{J(1$Fo) zqm=c_B-&bAoxe_*SB4sJY0LQ}*?N>w*DDVSZb5Nj{h^6Z&X0fjl?$~cr?;Mr&-*o5 zLIy-4L(mdj6m#+RLuAWktFYnAs;asQ=fhb%X{Gev71CxBy&-q9Vq!0rd8K4z)WP7F zg*R~OUGy3bk5FKrE=eb!8@5&d;>zn1`H;z8xf}X`zPU9!F^L1m9m0O?UW^zUh`~*H z*ulS;OsaY>FbNr2W@5sWh;9G>h~`#KAr7|c{2l)@nB;&)LF;dQ{VKG3f12ds%&bgv zLhpY#d&^h#@e+c1ef6q_;zca^)um4+Cg7*10Jl?9ybMv`>q1?;-)}gY#>#)|7XlC? zGc|FaI?))TDJF5W$g9A%;Bk|>)2yWF23r)?#=`&5Ih>xmlhAsan!oGH{3o_iaPVvy zoZ4f43S>%rL4FH48^^?$+vttiH()4`YSrShN^gMve*@}{ilO8TPTS#6ghO|6vKJ<+ zs2Ou8C6_t-{-ABHR|F$a1wi7|NEua7ZiU#7 zWeLl^wf)Y8*1dUYk@-$;yZfR z!_2_Vs4Hy*+Iwjf@Y3AOR(to*LHC?J|DAD8$*28=d^bj(61fF};1bDyFS5vP4`|E& znesyk?y18a1OgQ$twpDV4a@EEP(bVKwYnyLaIyS)e%x9vwMg#+OsHhnAXYwmL|$86 zk&5H$&Eawl+$*PoAxi4tl>~*a(=*b`lZIVpz^}th4zYKNi$2}Zh$<;5Rn+X0=iH&b zwwAzBx>Ij}F*ft-;x%{*{uSf{R5hKB6!_KGkw zDj;3rC2LTTRN9YpQ7mzTd-4pptCwNJ?8{?E%S^&-GoB4jssqk@F|nxj;SmCyzbb|s zJ_GI|z3^_I5`$U3WWfBh5d_|oSf2z>Xy7`*mBP@|Pvw{8f&KZ#fPQ{`RGYt3AKFY* z2Z@K24y?_alh*Sx`|icrnfuP)B-1e&Rk)qh?8B2kew0ycBJp_c1l6|BE*rLeXlbvd zso$TCushVONW(?JI+w&;Q16G^9)`BOQ&j`kr;h4sT^0ha8%X&01mBZ8+3OGHM^`-k zH2!!;3VX&^Bqyo>wciNZh^7cbtn2`h$VM4edR}(y^1%}m!E4pMBy%`)SNP{k_0rK< z#HzPCWH3?*{7_4%Jo6OqGcshnb$OG4F4%iq*kCANRqt2?w9eY+bhFotq zr^+n)$tms1?NW}~P&S-K-&f`zi%UtShUJtrpS+@!LB%?C?l zB8o43Z!~s=Ksl!=Xcguwy+J8IQ(b(&QrYj?s8Q1zD^dE&(C;nyf-EfaCQc=Mi<+9k z^+G%VI*Mnp%PZf8iuFqp9;=TYu}aeoW}YrC&YN>s2MY?iDZ6f7#~uOzPr89Yn%XhA zB+wIevBQZc9UTLs$f8wA&wi=RJ1CZXUUQ2>Gx#4|9}YpanJ>aYMrx$%d~rAym~%Rd zypB7~l=z*^c+ITW*<)`aZcdmaAb3(;y$IO;VzPI6etvG%U4#73DX6Kg?SwpG%!FlS zQKY1#sEUgtSXfxZmzO^U#=^@`uUa8;&qZmm8$3MyDw<3Q(_s;b2LtOJv;Mkd4ctLb zOi5KTM7bzP6$cxM{A+A$mjhC4NP47t{LcAp?vQMzn_QNCno(hSz{8-ufB%NPRuOSi=65>X?iyoh* zn?YgZ*UOe3`N?FgryMQha9$oxGOS?TQJu>EadZDKy;~OaOFxcJ5;R zG-fB3{%S3fBQ-Q+v?Qd35t7X}N3cm} z7UXsz*vu89Y?>QGIs+ckE!!X1qJn;PL*t}G6{?J7qantf4-~>z5BeLhKQXC3H{Vj4 z`I~*b;tQ2IYZ_G1KHPiSXJ4h;NFYN!N^l^(<5)T1KdKCL=@1#=~m^i7p7 zgP0iE3VK{S;11IfgsmNgn0u+^(;{xzwW`zp)yCe@fPa*bd%C5_B|1O1GsFUTmdi2p z`Ic0_$JY(NA(!;W>tDE#VekzR(Z@oijNJbIkN z(x}}0T>(zxY!b7HoY(LKE$j|#m!s8&n=#sny2)8$lkY&Zz>T23;(JoOEa8}> zR$4Y{;6id7oJ7xTC(>E$%WeeG?ZrQ0hW&J~loQ@ajaQeSX4R^?fo13BAEcZmmN8Mn>BO;+_#&<)CuCFVK^ zxg>7{)-iO{{*K2HY`OJg_5g(v#c6 zxJbSHY5&)Z>1tnN2>jR(3JeO;Q4#Xx`R`uiQK|ql12qeJ&hI8waD|Yf)70c22xF_z z39zq}^YBm~t+3GHf_O>B{nMq^g<)-8c5rM+-BHwUk1tZlSPj9wt?F& zijSXFi@DZ`y}7R;JdF-l7uE1EYbIJxOr|<6;odk&6Li1OdjCe)X+hFt9^cwm({flyJM<_u!nCAWSM_{AoYm^H;aE%{&_ zRxb6$8{QAV2EWIFaf4;a7pmhj6bJ8X=BmE>AsTAkx4e_=tG*}L#xM&y`TY&c{x5fM zpDiI9BvazfHfE~YKWxXx8O^@xCm*q~s?UD}!p8RWdB(Eb4;kE?kfB&7 z`QYz%Fdxs7nl^FA{CTgZYF*IqWnflNEsbG&dY-n*pU>wPtLtv8tU)0a(|M(EH1FcF zCJ0()g;QK}FwU~`je|H7)|cft8egn&W8-IqkwE=#%Gsjccegu-xFW7G#Jp?cz$fIo zkmLN}y4O!^@23gv9L+vME+4-fYm7vYkEocE2S7BtEj3vfk#GWkqDJ85&$7YEeBP#L%mdgdFt7? zeAiR4+ta=Cw=moO!cObamtXKM9!N=P)`KCSsNx(rtm23o{% zUE+%2`68P$i;f?cEt^{!hn(T+7Up?|n*qxMUJ~y#zpS7WZq6{Hu`p0S0N(eZ_$>3i zQW@K@co11g$)*p!(hr7R>Xm=lo+kahgQSKGh;S>9Q}@?29*c;Gw*FBm1HYAHOn8Di zNj{=P{2jpZ=_`5#Hs1>zIb@TMe+dXHnyP>2qDj6-Ra@EHG+$^n5hR;$iAqmv`QF+{ zAH^XbkRn58Suj04l+axb%(CeW?h_K=O~S@Hx6@eRb}hWM36k&}qNbreY%tJq3MhMU z#ev5REGIy#?x3_Q2sYm19uc@iEnxV!0cHzS{$vD%`zF)jm z{H@kcHy45g*I$y#xexUkb!{Id;ORZYhgMp;wNS!}mS0-G_Z|U=GSL(rxkH_MkAU9I zkO!b1>(7g=&ai2<)uF{N?}JaicbHAx5YR8*NB ziNm`+D(=gx6>%D!Mxn$f_9t()=S87BWPCz`iAoCpo-Pg~9s}6p(iE(?yu$FX*8$a+_47au;g;<$y{A8%?sEbj@z$AeeQM( z`v(Uj_b@)@XQOq*DO@OAnSZvNpr8PT5K___Q3_|jyZ|DOUxvWDcNZcyk+~biUr4dk z;Zz5=PtQWqW}g+PPzYrfI&5gl(;Iahv+$@e?^Ou=P^jAGx)y3+9V=U!=f0X0KCZmP z452x#9UX^`U2A3=I=gE4{sbiy8Zk}5#W8UW+GMO=M)nv6zH_bjcrqIB&{3}PMV>)`|1Uq#-;z3qJo0Xi|OH!QiH~~ zxn)<;yK$CHuDXZ2kFhN?G8>|j;hZjH)RHaUQCb@ZYnC^HgMSho3_2agIpCJEW^gZE zfnR5CGeu8vj0kMkYrjGr&aUqfsO$xuyu2=Mf!YJ5*A7!)c?SHF&^%^YO`bXt5fO7Z zF_4v&P0Xxl0r275Kz;9EnoSbiB)>u=fyEM1&OBF4(TzXndqYXk@Su-Wm1Z*Dg!4e` z;6z!s8m8;&Yi4C3_j--Qgn^}OJyfcsgQgYh7pAfyWkx){~4|3}zc zhE=(JU!c+m3Y%^=pmcW$$fhj1q)WORsaG07N|0`)C8bkok#6aflJ35XbI$+6@7@ph zdBjh;_shH1nrqH6#~3s6545@x|JzM#5f76<$_au6>{U3EY;3q2&^u#eAA5X{DR|4~ zkoAKf<%xHb#ax1fa*d>q@GISfg~9R7F53pT%({%*r!kA>ladn^QliADi|Or&kJNT& ze)94ypEHh4KMj;&qNdCW%M9^n@+($1qSx9;nwe9*^+}qL5-;I2xQ5_*b#dPj)^B~D z`oZYqaOjejt^y`SE?aWy8W3JCi;fx`=^!7^#R=#-7in~cAG1EPPvUT3V!=UBwtTZD zD890Sk>T1-_r0aUWBA={uDLn*lD}xWT(f4n9n0k1<>0URkPeAHXRV==@bH%wOD4Ga zQVbOHPEQtn0tIN=Paq1h53}hGs*6iHysz*UT8Vb`vh1+mn{<9);N-N`bn&6R8pOl0 zq3X5d-AhYONh_X+NlEoc(hF$Io9WtGxr~M@_!tbWD-CwvB z8`bzbKM)-Nz;*Jr17e#_0DbPGuYA$5EAg{Z4* zUR(wYu0H2ApWhdUhD#WnKdqOm!vCZO)CyussEGX3zMxXi9O6`T6Q-W23i8Au?H@2T zHB&M&60fV((8ud$kQb|s#y+5QTOSX}kjf%a`&sSmK!*(if7j(+GZg^Cp3Po<(%)*0 z_}y&H32GW{67#x`uu>eqPUr20lRpUl1Y?e2ly8qeuINMe%5jBFltT+E{JaF1m_j4r z68&T8UPnqq;sjvh6KsCXv|#Iw^4M9?5^>za6gwY(`RU_4?xMpB(b^4W7N$2w1V(*W z4=Dr;G01e?G3$b-OWyvXIk4R6IM2j>TZ^zG7PXMAsJ^34)cv&7d?=onfT2)Xf?j0@wKbKVT&ENC`y zKQgNBdmR-&S_g1A8B)x+Nuboz6@Ejx*oWz*u|8SMxjkE*PMM}#+4?!C5Cw5Eobz(y zJ!5))#gi}=N$!6ugD_7{CWOlig=ddhtyx8&%?~04URvLkk@5l=>d!kDnw4<(io?=t zCH+6YM9M0JjXEH4IbERk7l%St3EgWo&f8|5>m9$X9OVfx4Pnf#L$i!CTrYe%&@dAo z0)~;3s8u~ii9w5GuIEe?>F1VaQ1~7F?eV9LLh)YkBc|fE z>K_QBY)5QvSVzQdU2vq`c(jcAzeFf-gC0XpGx#NwSR+Lby$hjXy_^P71#z8;YS3 zZhQVoGS7b=tHQ0H@9CY4HVo-sMzdbF)?viR^Ul28%YUxB|N3wWdnq|6XY&H%{KWf8 z#{siEE#MIm5z+8`i+4fuA5t#k#(L5)?rpM7+?n?P0jw(7cA0K#mR0aj+9DM_UN7Cj z)qM}zJp!6WP-j*D_ZWgR@`rUOM1UjPmo-ji$-L=%j)6MDYw!IkfwSX)pQunHB}s?W z^;Pg7RYtS`Rjm`>3CcbdQ30(7OPt`G(D>Fw)vk`nDdqRYS?1>nmV^2CYwB2rB8$^d zM2UjDQ2Mw1P%tb3PAp55UqA8$_~z{2jCgYl1!dOM-3tDA2CAUKbMmFKB)uYnO0FSg$+IJ>rG9vUL_tC-rmBlW$jN@6_q#HpkFDPtB)N9O7PV(-axVC@cP|u+Dh*oWY429$o#Am zO;8f1P7I7V?B|qL$po1J_U}YW*^0n(3(96RMG9#L{H>vbI_x?uPAA^%Y`=g@`m0>9iFto*s*L$jyzf#r%qgS5nC5VyGdEhz{iiImbh29ffwoA@1h* znDdRTb)SE2)=5nGgT-F}L#GYVxq#0#Fg*>h8irBgg$Z15$W_^O$9&#DYvuynqS5J# zcZ1IIe!8&0iXY}q*GojY-?86%5t*maj2=Zd6ls>u71n;m$6a1twh!-lH{CNa5ps2P zRiMQS-OT^~U7%w3Zm1LbKsIH^ljY_|$0*@*ArON8*~-b$5l`Oh=r^$6NYF>=mQeac z(jXA+!yYS8s+E1pFGMZXKpL4`PqN%(b5qL3Y8R6=$bk@j0A?b9k{W zq`-OYK=pwdY9bfxgp$}TQ7>%i3KR$m1tb1+?L?vPk{_hF!0RB-dS|0(z=?hxsKVhX zdb;&9TVLOe13Szir`PwA2&X29Dd5RtSdUrLIX=B~*T;e+vT#pFlFwrb?4f@3I9Ro) z86L}MFBEDKby~kyW-8xLF{3X!bYg$2LpW=6^5bBSuLTcXAwA{(1n|-Ppmgy^A<+Tf z3SsY&+o>txlyOk)nf>PKkH}~8vhxx#QhgP?rIxGYf#G`1p~ z-_7H!{E~t6rDu1ACG(ke8{D=vhT>F^xH%O?OSwuCV4e?#l^W$zSrVY?ElheH z)d@1wa)e2}n{D#GyEB)dPm)_Fde&q2xwv_k2Q7W#R*Ap<-5-D0HBL|Sg`dP`e{8vt zurN{<#@Y#4wPdGg1#E6(#7b-n>**+-22$l8p#$lu zDTVg^SeG}aNd3FQH!+v?UTNVnq)eo=KtDJ7b#S%4UD~z7^eU=lzmWlk6|<$Z`b2uY z0xm4HoAs3CrEBts;(O|J&J_nKN{aJI)8$cNtQ0 z@)uoE@H`?`jltd|Ue;n;>AI}z>&w$`FZUJDI{f{S)4%le^)+qRK;U-rl4=W%=$@Ji zqohjfUZp0HCj!rC%=G3|;psC+(_jn@!S0Ftl-LRmBPKSAr-U4=E(UksBfRiu8+>>T z3rCT(^a^6MW31}E#+;PB{qBo_E_%%4G~sz)X)*K%v3qt|Dw08$v5bntpklZD{tjtn zRo$)sS6DV?7}Wh)$YJ5$=Nc*Bn~^-l5s;{9{grl<16DWaiCjD5#jGUG^&~M2cXG)) zD#$2;nCDWs96&stcRV*A*(v{UEVwQ4&^*@1X@w0;1h4QoMNHxu$eSNtfjkj6W z{T*t)i{a2Z9{%a8^w^g;8h*)Hh#fY^o`3X!?$IMi_+cSIBHWzMlY47D)2I||`>=1s?ghTY7W?y=;!IaOta9sfR)2|N&>alU+ngN%$k zDx*q6Cn75P>tUMGa-z`kbDjeK&HfgjW9o=hzJO%U8GW`ryQIr&#?j&dLo6%3CYh?8 zFK~!IXBV-`W!7skRbvkq9d2t=RB3SgL_iiik4-{C^5XgPtd|M+-CbRKYnVoT89pb% z;qPI1qAu%C(?ndeiP^QE^*oTwNBWYRI~?;!ZhhfLz?Jaz@x=Vux3JOs>Oqfx)rC;b z!({>Ht66laqt~T0e_;~}v>_IYxR9E=ASzG`2U`8{!`R6aobyNn+xUfEgWDp7lw$}c zKi*4LYaZ@`8LrE?71p?zLvUwv6iOPjc>jj_I?an0DD0syHnf=V5kpq>*uGrUqhodUe(dOy|pou8v?{bsTUG4c|O*cdw960@){gr?ok=)&-q#?2MW!H3D3Qjr@pOpsmNvL}AFCH_J zXp-}oVF?R5er~&T8$AEE$ah`7HoBFU^LQjf!W$7KaVzk9a_j~@2CYZ1K3Z2 zF`Wm@HL6f7(kC8V65@_@GYe~%b}-3(4ojQi#9nr`d;!(z$gD55wVfh3)=u;Ps@+|F zzEaE?>1wlRMNy0fXDki{7{-P)TB(^I?DSd(@dAI%ryD{tBW|(r+ew*{5BpRx|N=Udf7jG;G!-&GW=u z+2&{^q`PA*?F!ldrvz6Z{!;eXmd_i%uS&jsv%Y@fj0;AnxB%%_PDkOa+42nY`L_8Bo4N!%PGNg*idx;D0% zVoFZS@PSVCR{OHVQFB460+MlIRRnu@nB2*>+UafkqR(ivb%xVGor8O&?R30$^#ddB zJNw>GJgFxqZYw)G3TS9(y4{lSL{cG7HF~CM>pc8@G)OZ49H=iHab&#B4Tm#XqNB|p z9qgt789tEnE4A;B1h%SY&5Ek#HH-B;Ac+)%%UlZXg1(=c6Y#M7u`Cy3La;VH)$G9H zU;Xv<%g?(R(&;ziap@mlOly4210v=(rY17LD+3U;MAxrXZtrZZKoYXDxFz#@qGG)! z3Tn>fxb{>A9cGWT^Z6^pof}c~iS6k0U*LuWe7e@imNe231*c_x?k*34r-lW6?^N#u zQMoSrE~usRb&9xF#KZmqoH|l~bkhxpKo2tn(*IJaoAz<0zyG2RUAIN`v9kjaVFLP` zpg*v$W7;w1v(+n)1mv?plG0}A*VaEqO>Wjsnm(P?K*MRp@>_UHbpY@pC79kB@SZf1 zZcZnCUUc!85bx>lrAx>y8Fe3pIUTyRd_GO(2<|N6YI)~-v+y#R$C{ze>aYEV{o&8P z=>SihjnW$VyYmm*#DFz@=QJoR(Id2*sqLpDM`bd!Ud#9GYk#E<8Rq1dy*nh;*4B>s zR8@T8YOZ-bA(R|9md<@$NBTCb@fzi4Z?EokeMFj+rB`k)aHV{nTQj8&>IE!^BdW=& zq+!+4gTq9^lf4tpZ!NEJZJ(BnO7q%VYIS`fD=ZFAX#fNZVLzbZdq`3O{0t29=n-AN zva@|!Vtt-+sXv7*s$#<_!kg|bZiV~a#!r6`a{WNAgo0(oj!;z(IGu`PR$bq&xqYcq zWA_&%HLHPC-$??W7880h~vkBK}_|Do69Y4l(LZ|Ew<8JpAQiJZB)YvNZd8UBA*QS z8~4_Q|K(|PVDLxl07T8O7E&n_vscRY&deh5052Q{itjJIl`eN0r}B?%p`9?Pd6M{7$rq==h*jlVize3-%$Ir02Mlk`g{LymKUD2&-0Co5olq7>W7wG zd{tbZ@ezMof11ckAYNx(*5kap^ASEjI>*z=0bMXk{1P2F42*d`RH!{Dt0*@m(RWnF z!?vTj1a=H37qwm>yb+%Egd`Iiwc;0LeXmyWlccmRQHTtYeol+XNj90r|kzQ6gJA4`G!X4T# z^BFC1#FPAJ5RjYAop>rJM2Z9s zk5@a*UxJwKlSQng1zF;|#DJLdZp3>1OF1B_zv|OLSDv_O+Bj{rR%E}zsQr=B4go5Y4Fm~`FGfaY(b?`_aP)&(#85n5 zgKD~*pxkxsgzaikScsXxWO-~$5NL6`D6u*3Rf~?#nusPh}cCIu@yg)u)KV z0l`4zc>8&=XwaQyMT5w`(A7c=R$4;Eh1;9c8y&l$>KXJ-WD{hga-KQo;7)AASHM3+ zK_&|0i#-c zx8g7n(6FIxCW3~VP(LE#wkrp|H0vx8TQ^Xy*8Ky8J3J{R#aX}YppcgWh4K~G*Hj5e z67;4K`oKI5B>$jX;b61#u{%6?kT+ke`iA8vCJnMAo60*2l!Rn)7&XOc38bEs1=Hj- zFshkB84w4it5fQO0NGa*)v*6EFMbo;W*i`;qZ%%dQ)k5I$5idwq0Pd=mOXh$@|(>4 zW>o9W5e4Wq%M5ehSEZfUe0-n83|J4dL)>a#*qgRelA|L!ozEz`vZ7PcqyTFQ*mIQs ztz8bB6SP+W=#Z0>D^zeKZZchqt?XiBUtkzAh&xNB8Bx3d~v_kVaI@JUw$7 z*Lo;8g&1k6>Ap7UO+>QA;gB0>uPWU|_rMEm1_{Q#RQVJQ_FT^Sw@8{wZ%l35I>bNB z`YwH7v^<}08I~*Ers3tqwwf*w?T|^EsE;rBdebhKv4+(HokY5eb8iAhBW;U>?*Vam zd^c~XRW~rr*mSKwp>FRm0`~ari(~n5Pk=_Q()aiLQ3qtOU?Qd8Ii#wl%Bfn zXM%%%-V9>5!$u(~Bo-AFb;IY-tB(UE)vMjc!+D;x+)hJVTlu*;eL@lvMP+4WHZCit z!#@viZtYHJF%id^-gfpgN<`0#Y=G|8AJDDxR z%5 zXhM)uN<;RKE!`tT4C}I(=8ng#6EpR!&pUHo?$6Yt8am#9OaV-VZh(dNK!>cuHc}Uq zVrGZf+k^BU@g5GZ_4cu^ceuA0XDR+161@C$DnyQKJa*2z=t5`1Y4F*f?3=-#8IUEI z=SyI^kGnE%R%7^W7ii8;Xk*AcBe%e$YwJ?XqcvevRaVAZ6Ow)-=jgbB>JA(eJgdgs z<1#eK8G=&-RN-%fOLH93f?!G}Q3Vhi&GuS!B~VM~zEMtb6i7IJodJBWuXt zG(c=_phyCJ?MZ86QR@XndkGrrZ75lzqWE; zv`ahC*}%iY@=4ieyk5!6TMU1Bf90_;Y^s}cZgB^{i#< zv>a%tDr-Iu==+AW35i2YM&)mUv}?& zVnV{1sR}SFBY=%k9iMB_KQA0@Pv3eL$`PZQtBaa)-L)C5{RhsWA(c|awbyQ55Cm=E z?>kKkd>(AABJaEOXp_=zW{A6my>4&p&o(9%{3jUBh2S3P)AfxG+5_CWZeMYGH zSq5^I_+55plB#WfzaZh%{{n0s9PBzob7aDw5~t!F=)T6(Ec2z+0?{)TLI+TQI>9R+ zjDP){)mBduC2WZ6bVSwM6V~@iu0eW5D0VhOpqq;FeXdk1hU9+4@qG_i6uEV;{*t|# z+PE%>dcYz=ir+A3iOy!?H7iD@_+W9UqhB9?Vk26t5xZ>UN&E!i|+D{%d{LtG?lM)D9sO| zM;5TmIRi^yfT(V$xKQ?aFFr4P{{L$NcU-WugNbNb`Oh)=$TEtVPq^&w`>y(a6KDK& zB^Pl>On5LTxQe}Rn?VhZnHTg@(W&?ovLC-7qt33!qDUp1rm?I44V|~nh-1NXg%f_B znlgOu@{d}cOaV7jDY60D+9M>Y>asBh@9v$=dF|f0cKI9)g{-WsxO830iCXODB8w1jYn*~Cko^kS1T%B(PEwAP9Ms`j}`KE_!nszRP^krU+KEcuB66h)4pw1h%zaE%>n*o*E zX_?sneak&sbI{)2@OFTVoD=f{Q|EAj;wjel9nK0v{qb69MXFuemWvwGXS`-qnp@f6 zteRt7z>SV!9G1*)EejyKRSQ-^%Q_1G0QEWo`oDE{&U*`z0MW#KEA0H|Rm3dD+(>ED z3AycLS=R6+qZ;);LO63^hYTI{rNHl`NkM_}X*GBLdjH(%QyuN^354?2036FKB2tfk zz$B|-yc>9dIrmaEPhquVV&XJ%YO)2ASY2IJzP-6-ZGsT1w9h$vXe+%Kt!9NQ@k4ZB zJKJ6*zzSs4+2WQb)(ZRIfab3xDw%jVm?dQi*f5nA(2%hwz$<~j=tAc|XdGQgLgq0g^1su2a2o=*qag=>)pK zBCeZ+5<3&6@VbVEA_Ht(+&q9MA1))Iphu^qPyh|j(9mbOI}Ow+9#BR2`ub|yF1=la zgjtJ*pGlikt4}ujGZpa?l9HlC8$>m z8ZdD2-t%D=EUa>xzzZ;*1swRdSPyMA>3xa^p2DO_%fy3m;r*q|L@Rg#SLbUPhs!71 z)8F<&>hIn2-^b=`e2Ob^|ezu0Nmtu_2PTZv7xQUxHBsEHE2mmM92rwUe9EL0M{sqiRD z;g4)=Y_A^&(qK+3<|}``~JZ}gf(ACHSrKZsT0R6i@17;Ozs65!}S&HK4 zapPaLejz_P7*!86>%00nIvNKOMd{zae^YLFJdJ7r7Dw6f`cohY&*h;h~}s} zo*<*B(eZRw`MF>#2K?y zq5Lar{cj1;-zkkZ7=g3LCITqMDQUs(bT9l5oR;nrq0qKymg=u|fq0q=BG4fCz&;sO zD?|f~koE`|;HK&Oo}1pxPfbC|Xiw2FBY^qxsxdq4>*5EsumaMak=HS{^fPsCwEwf4 zQM&v38j7|-r^{mDJ5r_Ph?#cd8QgOthvZkEeV&05VTiG*vAz8OvYvthPJ=|t&4smF zAcuZqt!(Ai-@m;}iy&4qv9P>I+Z`MpR%zwb!Yw13@{%V`Ft+Ac% z^s$_-whg-ARKxwhw$t5&?fw*pw}YK5V5@C1CF4kp8HSa-*#APj;}fgq90O`A9&|aX zsz_!tooKtfv{XCz08!0K=MU6}ce8r_Z_SlZx_>ozNe%%ndD}~6)a4B5CQGAOyTZDU zlx8mz6Ql43xGSu`PHs`G70p%5=r?NaR!z*vQ1tWj(~VmJ51|xZm#m zyToaWem1OCSzg-J_?ck4sK=o7nyy6FR6|X57((6{Hdpn4fB?vQg(7 z9T(S5I|BaesxezWp_t8Nnb#a{qk(ccd52Npl;8hEpkNpU1ti76(eFO102Vyo^cPIT z`41bo@U^LewW%>>WU`{-;s{IV*hX!E>+5+F5-leU%{$ph%AZ-g{z}wK|Jtwq_ev12 zUfJYS29#|utLE+797j*3c~Ux4ubNL3XY z+1&Z4^b&Sgy!?Br!0(7zUjFG36EY_!=jKSBU`Pdr)`5LcTe|XFP4JK4|GOvg36&Fb zDr$F|FS}=EQbA*;Gf3luWWio|SR>d$7ytXg_kczzE+L`o9GevzRJ{G+7|>n4D`+>v z1jMvVTdj)Xce0JR$PpH%XPXgN7rl{cw2Y9RK{{(D)rWGQOe_mj6!m$_bxx}< z>H%MEXv^H(eB|oNR@or$;hUR$u7Wnj+!B(Zbu;jh{rYmX(08^~n$Rptsdn*!!&P z;;oz<#=-u6UDesgs3<{UAt7k*qP3~3vHbq6fk)HpU;|j;dw=|~wSkIq%O-J*Ke>f( z_gnEDYk@n#B{Q4G{V?L(hd>Yr+EX3v?G-6y6_QnJpk-Kr;;`5%bJR&uT2xxx*W0^Z zx0arBI_H(4qN>X3Gk=^`TPuVGGBS{XX}W8oE|%ckxyq9xp|(M|o$`xttug$8+q^vU zJ*TU)`^WVH0s@WArKNOy7t!J2;h`T+@9C&w-$)cO-Rl2UfT4=LAt_*So=Pqdk2)rz zaQ>8;n8taxoK+cLk<}A(BHlhaI4sc)p(Eus7P{+d>X{_=%Kacl13TVxF=%b$`cxvb zv9Xb5OUefoqGL~W1}DlD>24$Db9;Dr>-_6@&FCbNN) zMb_dQwf7Nrc6Os>S#R9(UnNgB9NaE4@4J9p3C|I2kvcXm<@wLI6K9UR4GhPgSJ!%K zIDI4cd42%QXnU=fe#|{7BmBL{3fV+cEp`X4^mOslHEl_1_nog*(Z*&7Sf$u|P>l(Y+?(y+>gEo(RO6Uvs z8%xXQRHAN=H8schD`ffo!+D3aB}(}uo}ezw(=r{X+GeqZ`%m{;sPkLU z)!9KgnE)t04}bCO5Q9@5J0>CmO#%lD_{###@*z+YZGd_*+rH&GzWM3^+wn;~aGBbMvF~0h?|VxVOf9URNa}rPGe)OG?!z zC&-ZS#6ou_ze>B42_EUU_8aSx>En@V85?k$zT1oj-KS)A2eTYt-_X-Gg>vK+4Qm}? zSO2k~#C!z%@$qBfjwd#9a!rk3I2>l~;#bD!eYVFkEfH7(4qlXu7^VsA{#tL+XZr7b zDT0dZ_1?#0nrvK_VWF>S5Fjm!1cCp{rvS(i+J8iQMC%a8)Y zO0}!PPO;0^qa^@ls;Nt{U?J{1AoP{ zn+#zg7%$F1eeFC?w1@*qHMVc9?}GQ$S-O}=Q?fYs9BJ1NBn?Gq&qGax%qU5q^Z>5& z)dYjW4pY7`Kq3gqDOQhGt9O-du8?Vq|X&NZfv{dMN!};`SpMCJf_${eu&l3rqWs0$H`A##7E5P>5_zP3aDB0i~J2 zYk2hS{8m8!&x-NqdYKRSw7s8ijxj z4J#`vh-xIGt>JW2NTK|SV#kD9Iyyx%oI*!j0x&Xz1H@eHpOhXmeU25ReksiMVf@5}9)bJtqf;-6^%2?PZO?rnjp$S@?G?g7GL zYa|ahf}B6>79YM;gh!sg42q$vq?k0hk`^lO zxG)yc2bi-KVGoHUhX%otM{tLXDBgdG?y$*>j*96D7|MSJjY8!~rTU<2H8d_&CgW`6 z9i6zFi_qEeD;FrsjfqJPW7ri~AEyooE~{L(4E@ zsd?UnY8b?+q2KdqEnoTbXKs9L>fh8#3vlwMWwg0)jJAq zCS0FXIpmYqys%x~Z;o`KYkr5*wK9THR5G}Ht(WhW$*(n6cn|a{l~jK+*D5qTa$Y}8 zV|H0)K%^C0cnV%lw}(u=Ru8pP=XrbZSOomsmBt-B@-aCqlIsPu<{7l*Sc_#2_$TW_ z0Z+srvEQpf-Vi2%pqZD{rK}Fj8|X$B%AMf%P*B?GF{5Docp{eo$NTo(h4CpNu;_Yk zm(0-D_%V5U!{5zeMhKmrQuCX94pkx}O_*eKn;32&5B&x9wy_r}2cNT)@dMaKP9`%B zc|h}xMRnFW>1CIrMLJ3jE=-6Lx`fsv z%m2)KP_-7C;i#^Pc_o=+r5UGGeAc7n{dANx$wE*y0;1v z)%%}0A9XHXkU-cME*~lQ?bI$re1fdy-(jW{vh-%ZLj;37J5xSI;M*b2+h4mKRqUu_ zf%%AbHQgWwH(JWdCot_Wm@55a652e60`&w|IwVGj!{K`4gy0n4LgzjdWc@JfCsU(S z-qSZyq~Dh6rM#YD1g#M*s01b^zD8Q^EMm8{jeK~_b6ZB zpUUT$x|hcY{kb#oeTntLJq!9b+Ep|O4~ehtu`I|b6EWzK^F+W?>e+ab`D~;mPSPYL zQfFjYKS!x}yOC2hI>nFx54H>?5_mE`H2H}EBcH=6NabrU`EV3&J&0<UUy>ft$?N*v4Tt($W95CfQ}Db?pwcRa^tT<_e_1 zF{&ELl~)Z<=*|h*@(q0st4a4c(eizmO@wfX8BvB$qHkS+Gvtly$1(sg<2U;cB1LPF z@#?*5Xh$*KZ|)FIF6^0j*r7w@P&0BMPhcJ68UburDrX8%sacBSSQ!lvB5nc$zqduaY z4MNA)1dWl)mjISK*Uj$X?W8#8QeH=IrIFT^uc6Toc@~P0V9NJ5=@JqHdCsQS6HQIc z9g>}gpPocHu(XzkVT}_Z84Jw)s*1Sl7V&qQyj}kD@ZeJQST-H{r&(mZh6#F~JO4ZP zvI^?9B2PST?LhS{k)wy*SGAaUV`My^Xc9;ze>}YV0tZ%v61a7Bh}x8<38#kCJyWdk7cx} z6~M5xS)@oyo$%llGxOGS{OPwTs!}K%n|H-7l}eP@2~&uj2ER_VO%571ahb*8&E;;n z6t?h^_{|xCo2g`KAyz^RJrWa2?}=$bBRvw8rtkSGPZSA96E+D)SuI-LqYLaV>Q3^B zF^4*%me8;Mi$5k!e(YNZGfSZcSYQpQ-gg{Fo6dw^peh}q8O?T+VeTvNc4akRQy{e9 zx!4~lIkFZ$%Z;M|Xwi*b7^H z!ec+U_LYOA;fE;BVydg`>prc$+15q(~cw}wb?u-K2C60?p#@2{kcSk$i?G`DD!Xl zsR+*D-4l#LzHu&3xVg(u-$1n-X*{MpKG(;Bl+|^1vm#BgD~R6@LVRfJT&2T0Qlf~eoFXF$B9@R>!Lx>aRR8->g_|)7_xieP;+><*; zTl%_sfvlC4BHgkqmRbAm`?Y}OpZZN1#)8GdjC~wM&dN0R_<1Hf<}uRhH~j>Nm5u`W zXIe}&X*fbznVX)0p{zE)r;l_1d*;LI=q1e@mLY!smrqeJ^l6B#YK5$s6~7s zA))d;^dN5V%~oI%XPKl_g@w(Fb9$LL0~OubSv=H5>S)cc6`eZ#0`4 zlO9v>j^xmez{olGZFr#g&vH=(6EZnMGP-Jr+_bc`&0-7Ie-=kc=SLMKL#&C3Nxo)j zx_UKSty+d(Ppt=#Hu7El>B@Mk3?;eQB~p^7i+a)kBIEv?wObiF393*gvfp3IF;^Vx zc+7DIW~>zwaYU>FCYlR?=Jom7iuv_E)C$=Sf4RSAO$hyqc3A<0ZNamYg-pod9>4wE z2jAOk_ZPslYuM*LLdMU_Z7BN=&aqePSpXU4``si4`Q*oppE>S_WpRjC((XK_QV7fC zkWbNccLxt=+**>4V13f9(pm5S^nr`B^Ky>$1jp43C_I0c=Lf#D4*LKaE~_%UGvpnR zK3|Y5VL%FyD%y_L9pwO zG>zXJHObX2$(X(#eUZ%6`82#gxLcXA6xPrbgD*zrz0sNBmb;-Wx!* z!p3y6Gkcl7O@hY)nh*_-B=NFFz-WhTa9ApS?E^f4QB_q{``iD+(^r5+xqV+Nic%s7 zh#-x03n(BVrAUKFC?QHC-8q89P$C@y(kTtnAT1yujihvU_qT`p`+q$5KKIc(%scbG z=j^lh+H0+iFt~M*J|jTbnk>;zNJ#i6`&ABK?^X6T=;0{Uxt}?rodWVQ2mhYgX*;xs zGtEv-iR!p+p#g(4;1kGOEl?M3UX$h9WU z!{0AY)``?n78Mm8R+@suNzi_wEB^hpdM`|Z5@yeg^mJ9nu^^^-^&T4^TRHt8;$s|~ zpdfm@VSs4FKi#-BeHMB17-?U~5tw1lhtPN*9v`nY?0Hh6a*oP)Kc6VR>!1ymR$E7EirV|7Js}yR4^M9{Z;Xe!n#Jc-nF64I{@8pXwJ!^^ zg!h~$H(0p7TMm2m*{6WmKh-lkMw7K?G>n5E3u1r%e5y_8@9%%;tH`Z)+?#g2maoZr z^B?tIB|AI&X-e>48#+DGR~g>Nw2USQ?Vqajj@=cN(uFXP30OdP4gCE4(nipfSH5dj zgwiV{$U^$8&jlFkq+z}B=D+&WV*uVem+bLGuTi59MITHeL;^H?Z&Mo7=jnGuj!@xJ3g7SK(a*dqB1gIT~E%t)ua2Y48elv8!mjWu_=0js9d{;)_fcKk}pYx zUHO72gksUFENYK@Q2oT(mS%TqWfQb|EKgGUzk7R6XlXwQpKglRE;vDJQ=_1v5RUe$ zu`{MtuZDn`*5HL-L6hz$K{+4AjiAqRJ3!76cU}3TT|u4yXBPk)JA_(^gbW>Xzi*-W zv^)#jS?DgdLEJ@uC1Ag5)W65ng1_U(#_97~KIh|Yi_fIkRjHsmk!@~yc0!At( zzPJD@t1Xid{9==6rABMOM4|Lz8p!1g(s=ydKp1`IDMh3~XYAGoHtTn|q#Kn!F zuVOnb!Png|J$-}yT3XQo>>6>{aRput$eW`IUJ;yxEz?f2a9a}ytcfDpS=yH!M%`H`5U3Mjw(z@ zjCwnQWXbGGP8oeP-((uudPJL#=?lS||2Sb#*1e1Una7l$*;0o^9UuSXrOo5DB>&iE zOs7yzABzxAJ*vAn5uu=M?(tdi1GFUDTO6rzJi>&1dj8mAB2JPbt=rOn>UaUhtv@U` z(>T)xs*gggi7Ii+UO?fAxC^(zZ^aA>RI6TRW_R^(*hNb;Fb@%*Bn6O}PaM{(Q>-5Q zJmEL=d8*SvdLJE`0Yn7DR+g6bdsIbYvt-Z;bwn zoXa?@io_Oo0vL1uN2DD|9#o83jO+ApFsc6>)v_ZqYWJ`5{@(&>ip3&Oj1|3HO! zNV5YtH;>Icj@|uoqqbjCYC4I@a@jDSJbkP#f z>`E5+P4Lq$P17L|$S3D#2RhE+xTcQuz%ynHY6pDT7}TD&%l%CDh$)NH;1zUzS5`K* z4QW?VsT}iJ^z)Xc`FJ#j*!82Ad5ECDlzGKGJJGabZ~6kS(tf1bpK`7$YSjv>`uijK z{WZ%POhZZuf%nZ4`kK_P2oujbE+9+D z&Ub!2%+!P(61#sUl!@8RN}b{4p04l~kzI z)CV+&XegdUf%2fSP7<{7L<& zyx;*{?f_s?Y!lOaUGwT1jKrp^=RBMe*Op|B7s&FW(zN||vxtWwrM(krsWFRPpL_*j zh56z~glnKW9$F$&-ZT4{>&_RJX|j)f#9e}&Rt@NJ(-dBrIbIn?SpL$7+}gfxGmuvQ z+9Nt<=Lf?nX+d7N3sCDr7E{^trYB1r4e^CR1_@;454O%5nyE&-I+S(}arShGt1m1I z|CXAn<(^&J#bh_}vVJZpx#dD4-)e=JX?cN911B%cT{5MfRR{fQJ2+NWBc%L?*@{%h}q^I<>8;`wYWW^#G z{w+V=>lBCgQHCwJ14xj)#!DIz(^!&$PtI||5{Yd)e8rvSzq(d!bQ`3=B~4v#6eUM*l$LK^)G-V2^)_E2F+GIz3%x0 z7u)?U5ng&S;tuiq0WsQ8#u;Ctfcf8)?5}yop|<(?UEl5c3=v);`To_iZ((66gEp3* zj*qfJE8n|Xy-)ra5DSbDn}MfSJh~=z=-5rLKIgv4VL#+N3H0}joxXp^Od*ahN%}az zleLm40beZGlGtlMQBKaIr22evBEzxv*MO~ZqFV_j7XtsS4l&0wB@+`;Fb97*SzEec z03B)3%o@fzzi6JE+_UFaSmncbudZCZF=QqEng6tlhVtQcCNBzLYlW;>dAgQ!lg1tB8E?91Syk{PTjQg^WtpIk;X|%#3`48 z$-C{B#fSo3jT3R)rse?RzG|nP@(pQ<+UT!)`$F( zZzz*6$V$w}0mx-IpG6^ISCc(oE$%*azxr9VGnsoXNJ*o0JJG`ohg?Qu?bUuo9Wf7x z;3NO(LWz4FkN^B+(qTC35L#pXv0i;*0|*aJ3_ew>t?$gIcb@zCMg5)2#B_JWr^v;M z*ng!KtJ;)U`5PKG@_@2Ut6atU=6+1VYqp%uPJ@=@zPHRvri?><0Fi4UfMJ$HVxj?N z8WhQF0vkr9ZlXvZIT*P4Qb9R=>Qh^tMsb3k?lgRfO2Zyf zsV$F5T_h)-XCS&fk5}3X?>?qo(e~}v%yiw{bTfvd?r3<}TgCg^b&OIbG(I}EURfIbR{OqT@}5ld zl8@W_Rjaeq`$cbhtf1Y-YBpXO(fmYQWj8M3vG#Gxv&q8uD-yeqm6+V;z;^uq*Xe1?9piOPVoY?+seGtWFczQ)FXF{5l;?iTbA70&iP&u|+&Agnz2PXD%?2xj)$`q4)X1FAFC2u#BO+J? z)-C@g#acW4?*=CfIjpL;{<*j8Y5GbZr+uXB&%Fpc3buA8DfPkHc9ZU58yx~X-(ALn;j!;Qt4?VDc_`W*fSu?-(r& zmIa77=`l!JcaFtAat7RW>)?8B#mxou^lu@?v~ z7tj-Qjy{!r)?nhr!1DR#_@kgD5rlaQX8=w;iJ9=x><932%|8wXi9<( zSPhyJVH9vrfIik0@n%K*SGMKB(^DnyCpp=tXc#hJ#cD#FQuI^b2Z6pWh<^XRX;55X zEh~@MhwLTL8ZpE^9_k{>Q$RB1-qhv+<`5}`HljQIO@d|wp6I5zFm+d(AUubU)LwdKg>&W`?7oQQ;t zkOcJ%(GXk-ibaHY-x_28hgm^YN)#zpEC@}WOJzfBab~Jf_w*Vyh69=x-EY?SOThXW zS-ZgyPs7gqj&{rmqqsGhNlcWp4=2h8hW8}gPYMTXl-{hD8N0Y`Hr+yRX2iPiDS}k6 z^$XwDiwU?MaxMfyg)uC&_7#Ov7$wVo2HBtGfeM00Pc<{o^6arfqhge2Dy|0gZ5eO31j8w9N9UU@&hnPQRqDnnG8u%?_ z^x<>-axx%0apFa+DCif`;fMl;%dcL~i$VV=r1ILj)5|`Wm(eH!cy2EAIf5xwIxP$gmYX=^7uQ@i!u zl+n}7EUCKvW4RM*eR#!Q$z$UTaRTs0TB^KBk{kXm`;zpR8A2=r_9CgkJ};8lsy%5@ zb%^qE#t^faLTL8c<|pA{N<8bdTmoO4O!Vi;LM9=1k_G{NcGM&wcZN+0Cpd+r)>Tn_ zCqhZoT@v_@?e*edT}WMV3>X677LwjV+=>#0Ux&V;qterex0=JP&CNOD=|F_%C&TOj z;X(gOW#yv^I`&A_XjOj?cvtub5$>CxPpLyILjkS%?E9CTt&kEU{9j2(#zc=l3qODU z1U@BI_);bih4?wJVCFq5eRf;`^K)8>R=|j>y}Zd)^H&xZGrL+dF@iF|g1Zv+z8J^M zLYLg;O!LbJ`^?j;4|?tyyrzSe!^If>VrC6ZOdMjbZ~$r30wr`r(L0-4PXLylYxoT24w6 zlTiNZwI(YsN@B)zfjbcrDWy&LPx@&gF~B?*DfeV&TDEsk^*4qck;K!dih)5vm(R~c ze4P*MVlsPvwxNq!ZA`cUYie|{RX@+h1?_Z^_ zk8+)qfb?B6r^pCJtP|;bL}_SgBj(cjgbFQ33I~j`3xR=5DrDhO2t5M>)p4ym*OMq{E-8mJt0bN@UU;w&>p4-A z0P*mCUiKBVYU48J^t=|M2nf^LL`rVkvq{%6Iy&gTB3WF#I!*7$3P6A7_4&ff3r&*C~&ozy3Z2>o2 zM}GU&Xw~vkW!=}9G4}TM)2_jn`((_8b1Ea1@AAPdKSlNEO#~Sq_N2)WLmqX%iZDYq zMiah<*X!G2X?PF4)1C)YoQ}c7=f&lLoY&quRF7cowS`@-y+J^c@Jwb+L7Rbh9g$?R zwYNu`tfdSw$;(9i@}1EkPP`S}`ss0v$7=feU2%A}np8I`D=N0o@F_v{5JnzQNtDjb z&5fFCPuyu~O6an+&weY)9K3K9ur4>YVnsxPhXFodie4^$no|IUu{_O8uc~@N9K{Fe zP^r1r>m^k@uWZD%{}1bHp9x-B zJO-l*a;nr|J|6bNlgYNdc#XSELU>;vw;%*>gI`mTg_cIw4BR5%YC_E z2mj>0QG5O40|~j1bKv&Qj-)HlV{iB~ptw}YAG?|TnT#t*2nYxeM<|3nQl6CRW(u^~ zu&sHL;9Xam4KZDae|{8K*z(bTn-`pZ;bCr|LR@b_^F@d{?<^^$Ds#bsQT><_N|hO{m^%J1_}KYSdtme zWmBDkokGjPm<9$KSh=_^7q(0A9Z5o-YWiJQP+*o+)^%It1i;d_#R#A} zexl2+ujT>9UWm^vQbiU8?DG#7lOlfM;Tp0Q>@w+f6bH$bH?Z!;Mn@M^>GWR3^t8;s z+{drcnTHW}pnlrlm{holyZRrSItq3h4b_cDW+UNIpo!bIf$*N%-_HY_^;f>K;vasu zw0-1f``jycUcxY0^vx%c~4QpOi! z>ezey4$-9B*r|!Xw%D0J#I3V|l;RZOa*vQu<-Y)^R9345MaE;@ZahN#eL<6cMob$* zFX!tGu~V`wo^9ype0PZ;YfMc`>p9w4a8mjhc8y)Cxfvq~pD1IiT2X|LEUfia9GmQY z#hW5Ims9gzA@c)BoCIPmucpW2SMU_tjCa%rOmd-6q`N4>xQid+^0^2oMmP8Lc!*P{ zBqwJ%?HCM<)4|C~GW+Vo5U$LdJsW<0{@3i!PJ=gs78i}+a8s8UjyCr;=H|xylpF9N zSh0fO$+1Sri}!6Yuv6mmI&+PU)o+*u|H?}7Os2fx@YaAZG4x-U!1=T~n0p^6i3xDm z89WimR2a^MKYpY~vc1_({z&$6Yb&ZmES-RW!zRL*6*@|m*>oulzg6^}sNAKk0 zFhGtVZIcBYRF&&v$fJ{!on%F2<%X{2L&r6&KFD>d$@r}$YVtmPLR|BeGWC&tA|N2` zK13?5yCru%snQUSo}~TOAX(Z>(Q>6&XXxn&?&%GXB!r9~P*YQ1KAdID%WZ86iTO?J z|9hP6d2vfKpRjr+K*!JFz7809czAf~t3&j6@1H%p!Ew2j%sza#04Yx{=Pd_X`8dTY!4|GpFi^mt=1l7rSaQ+s=RXn{Da3__#_4=$D1xxm3(N8xZC5D}6nCK`2{8`7P{;aUqdSC}sO~f2D&9TM$C_N*i4{|S5 z_O`#h-TSL!v6G1$y2aUBnQ)MLjW9COSU(3GPy4?oFO13~8WJw^<#c4=uN)*DPf7f- z6JJ({Zy^uEdoqTeV1NHYU*&y^KtUi68)uI9uDRB!rZR`;zJD20VzlMq=nEkc?ueXTwa@pVtQVdOklAQmJlnJr54uK)L&9rMbm%H)eUi`uGsXT z>hc7`zC6L?y@bRSo8d~61~@E2@7U|IO!cax)S4(Y;@sv`5KLlLTcrEZ{-_uVhh_a1l>Wo&s=XN{zdvUlG z*!qp`Hit#*#mVh(N2bpQd#$&1Hck5|oI_h=O??niZ$eai@9#Si`Hpy*E&zUJHKwRF49u!e#Pl~(`X-T!IV z2L<-)T32+aFmxcMng)`&{9 zAqqFmX(>dX^bM6*t}DFmmW&ThHM>9bCq<#IiH7`FcgI|TmZG|PqPE)3k*BBYfX$K9 z@`C&MGOfD^^Mj_=KRx0uO#Dk&51j~j1>IVUKFmIS8EeN_m&y#cNC(AF9Z3_AwLp(X=&*-QF@`C zo}Qwf-UALSNUUeq*3yU`u1!sK;l4;Rw?bHM;GT<6WzyB0?mzF(grTS) z$^!=bNj+3jtSDz{>DoU6(*ueVQedEJt+z`Fir($b_L`40zHDq zWK1P?r%!E_HBgXTUNm>42#INR2Zxfo#|WQdI)R2>_~>+Hby-&KMLPFX>+sf#vX(P2 zaB|z58fB%Ajfv^Qwy0I;eB<>en+~LxY1kTM-Z|Sf93|+w9}At1=gJu8r=5;xA9B1r{6+D#h`Prm3)P(r>`#zyOxm}a2ah@VXRVO21DYz z&0zDnq^yZ^bjX`wUUU5Nn@1yG+`0ME6Gtxr!I69?D#Lc zA4oK`e`suK3ja(l{Bx=gW+lMn=Y&Y9SUk!c2Sm-u?WDHb!s&ZsNUJd8b4rnd6|2VO zG*-rBtv>}yw4?$CV%{y9)JxK6T5^?Q3BtAg^d$to4lL_U1!pemg6L7P8iwRHfX%Y8R&-j2BQ3OHjDT-BFJ3BR? z`$Sb$ViA`NNxK{1dryO<+l^X@Fl2ooaq4Z4EsDrr6voBQey;kNOv6)iz>e8f~KR7@p9(=bCoA!|bZp^X|K)B6~?1CA%9UM$OZ8j#od+v-8;QUUzof-x0j}B~lqd znzuGJmqHg_Sy@q>h>@ZH>>24r?iCLLCr%@%9e&?vM23at1KH%#!o% zf)reC2XQiy7;S|7`A;?O>*nva_dFMmU+J&V=gDQ+90;E}PK|vt9;id?%nY3$psS?} z-fVg^`;?5|9m|*B*M7O>vlxay)o}y=Ic2x_J%og4?Aq7CKf^EjD$sT-BV_v5o9|NR zwn;w+pmVmnd5?2@o+cMPZV^zJSO1|o6$OSE{+7Q3?{R6Gs{`_reTA>-pO?}Yr$6!& zFz*>sm~90E-0G-pAs27V!ZiSRIs`vX6fJuw~;GKXZO-DPtGCQ=Y|byyVFr z9unE!B`qVvVlRbOov+j{iD!$bceyi}fsY>&m!1qnuZTxd4$Qv*t#M=gHkxhyJpi@i z<7pl|@QUY%;?SALW)i9EJq2hILu|mqQijl?K6$p#yKxy%rsZi4jF=V&?l^7+g@kFz zdT?Y&sVrgE8|myESj4Kt!s7)J-z{r9GclB+jra?``GTLJ4nn_d%wv3%Nr=t+o47|X zZoJE%Rbri?c4}n7RKAGwSLM*K;rNkS8wZo=`L2OarZnBBlT|7zni9UZSEm~2e$^fR zdRc6=-mPOJx%edM;3M_!&QRVeoG-eDAe6x%E@TmGT1mOyB`KY*~mXxob>$$V;Mr4^OR zvxqBt$!NVmpme{<{{|OSkI2*>-GakSKN}Kof#&Jvi$75EpzP3he_lJdWYXeYkN<1U zhY``<+a4Md<21?#O=hb?V!5QA@$qTfGgQGOebpChDsWepCB`@7!xVyR?efJx+N7v`t?gnSaCh# z49+M`iEbf*2%7G=)OEKTy)HVL*)lA+&DC$#MW5V!Ztswuk=A>ba#G0BlkbFm?6x&B zDtr?r?ohNwlcK$k2VaUG_V%pI%bsqilpEb!lSiz-!@0H=|J!RRh3+be^q~8HLL6dW zYTaaFa6jE*z`AuS4HRhed83V~e-JGB)$PIH?6Ja3Ko23-74AagBxa+}t(3MfmV|>c z!OMPD{I$oQ@d$5|3rIlh<#L>10+4a+4b>`DK20Pp`AE*U?%&nv&;dXOW@TmBPBoxw z6K=+@&&_2~KRhmAQD(~YSR?$G4ywjU#}nhe^pLD9ucs^5XkKd|#A4}Vo5gm`KG86$ z+ZGl(^sgA%S(!PH?nLzXppiwX6Ylz%=&vbIbJGSTL<{>^7Zqnwi3EH9&f=y7m%Iub z-W?M6(@8a>h56Fc^J|%RayM-L{aaLFT6m8CJjhKulOrO5C4&>YSBXjvJ#NmhD=rC_ zTtG#-3bHshpdxRGvtePc8v( z>T~&frMb~HVi^w zd78cW?nC`C=4(`lf8NKR$`AF|rOD}o{KX9Ee<0@K6>JAqLp{>Cg>EwTbT-)V@bO8( z{YgU{h>69H?FxV8mBA+55*14Sj=;eAt{z>w{Vd|IeobA0EXx-z>aGNkZ*YkL5Kqc*cK(T@>i zd!~_H@fa;)PW&E}G5AVJD#;Rl_4(J_|j_}O#X9)=v$2fkQL0bfgg*i}jSwK+S@4sg~*S@sJ z-AaL9;mUja%?pX}V(BP$y4u=Wz}0dBio;oBgc>&sHwUUVYEvi&^T9Dp{+lo@KoZ@N zZUjA@JG;C6d)GM6)WYb4;$sgE3^-BW_UvXUJTL)2TSv$8NLK=Ur762s@-msd<@$8~ zyNJRfYJ4Rnt!Vw$&+!7Q{8ea@jBkE?-(49}JKnDmUoaB1T`W+24qAVMQ7+^!C-8}w zUU{QQEMo#*Bwf7mZ!Xsf<$mB(E}C~i@N2<2Yf+Q8PP_i!lob?bxykjg5^R>ZEEX{O)=? zQ?VM{?p=bBMda5cX_)UcCg{RUkWfH3hB~QfXxc+XS`c(!hw>1=tvAm2r=Dm~*7nbL z$Nc?~`SjzH<6J|!`O_eD1QHAFcgFm}LPk!lcDW@r>H~P=q26zo(}~ANn1P{n=lj0hd1cL+jHJq`y}|0p}S71x3h^99&vj?W|=$$&Zm? z41@4?G2)XS<0uzACYmH*k58|!vjZ15JUTkM+8h@jzen!Hi#EO}8qXIhg7li7yG!}| zILrQ(nle4IsB`9Jk}313IievqGv!}+Q2Vv}6S8A}-m7G=?r#rAq*+mG%+bTngN4k_ z!F|KO6owl%bJCuvsj0(prVqInUhp&U@v$k+A{tmF!U@J~^ztPnjso*7xQqwCXMKms zgkb8z0^0oc6?%Y)^hcJ$T4$?zXlGCVa!;?V(F&c6v)uanqj&UfX9E3`GV^}Ut=H22 zJSKy$oyVQ(z;i^;MWIzIFamLYDhG*dnuuDSs2j zpG1ApcH4*;xfRP-eM_{zt~k9tFZVtj?_O*;^Gj{`CF(5owAe9Bx;fCHT&M*u~T+c1^lbFkm_m=5bqy4w_|^oz27858w9&Tc7?Ch1MK>?i1V2 zL3h!w?cq6844)|?cMMYi%6LWDh)B;J;kP><>?%}=fob21)H&Ul&rcfn(>fxD_B8|f zIfT~BpNqZr*5~t?b8CoV`ywy2{^bTW+ph4UjLN9+$smLB!-A5=ozyX1*5B5%QX>tl z_io5ZglnPpMF>7AX}ZTd*mo$xHAglQ$v6blEkb8!OWOIo+%4yrI9bdyOZEBl79+YOvS4kVC`)6cg{zw6XUGzc90-rtGd zItiX$pQ7fdJ@GEDsBBx!s%!7psSRn>xktTaMXbLywzPe?L(5a{AH)w82-RVgEmzCD z*~ha)js&-z_ghT!EQtFJQElPh>OwPg?q^L!*O=w{36!gyU?+_h9U(e)F(+mE2G?er z9Yls^PI>H8CGy^|<&I{c`yv!5IBJ{EW+Os$+V=WYVuY4H2`+leCp75>MlK$55iKF{Th6V`)U8@$|`%)x4yOK;gh5m@nouca7Xp+xY;~C~Y zfBbl5>)>F>Tchin2uGSsl)(^z(vPVxhBV9%Av7m)WWzLBYH00tuFT`%E8&-zv}qnW z_uoI>8_%#n2QL>&zxuQ%UI>pWO&8ccGb%uR3jV-}b4%P!ZpxGa~gbEIU56Mvc4IIr=`lY`})0sjf%=2Yjk zW9#{Tzl*MwcOy>Y!itTLI4mfa22b)ntPqRu{2=Gi`*edEk-NL)Utu{ob!52DKec)u z`@`7cv8?UBaO4NLAryiPfy|P)F7(N(Em#nC9&-A=`})XCZ>qt&l24}8WYG6E?9RFH zyt0Wbot80cS{-+>1eX^4W=hJ#^g6Y-@juR}1vFWzJg4@1_w8b}#Bqq8N=U$LsXo{@4$g z+fph;a;V@72weOYW{4aA_6_l|(Z*)}zb|+W@dup626REjoPJA*fud3K zWmh9SS_+j&ZW4FJ_fU^r^++ov#T`=1K1NR1vo3!;-QH{6K1C|1hMY> z%}H)ylH1p9WHkR90#hrKZf}G)SMWF1Ei^67*|8WfKfAqPBu`9N5&NLoHNdb^hs?_M zJjP94&koVG2`8>QXOq^fr^At3nxQIedixpFdR5L=&1D8pyxs~u`_wcu8qCN#@KdCON+C#?`1WlK;HRj#lN<`MP7Qj=rt! z{qxz~teJLtDVMNA&m2a7j9$@~av$>ZmCwzrt*VNZUk=woO@KwzKi-=ZygJ3niC z@VCgl)b*@qMPr%xIaxfy;2VL)_&085)mxE4rje$Hq;A{M`y_J;qN2vM*2&4ecMYg% z+Syql2n+YtzOm4vdcRa1 z^IFNbnNKnPrh_nIGy3~$K{a2Ys9Z&j*QF~oRb^(ig+lXtJDVj(#pCbaj2-NI++Hqt z@AXPuh_75#XlbOXZbFqVGrdWhk0D?|HflK9M!85uqvD{)u&J!P&i!xYtpZO@AD$U| zoKZHdJWnsXrL>5k!=f^_c_E&Bc?m>JzGV<~*~p{;%lNzdi1$`xLitsc{jWj_Eirvm zeC^liY|<|bUMtQuRP-qqo6~+h)63WSUW(~|bi5Q7^|@;@@<)8-sH;5R$hXpc^&%4DMjn99L=u6ox zG8&Jxj`;xG#xEPka<8LRv(f`UC&+|mFpv=_I1v9ml<%bZD+!~{BY>{_t3bCg^%V>2 zZ*d9R9lqHZr2i~K=`B*8KLa-&gNfgNEAl1c-VHzMg2CF*JNcVET-jNaTtc z%>o~{Ud%7`XgcO)j3=LvMYmA-QYfVN^b->kMHZ9pV4oQn&emaa4YK-J1gFR}3#BV; zkVMv>*%K07`Ma*_ETNqX_;fVw%$L_~1D+u;Ns^)(8)+}Ibx5}OlO_D_pb7~Td5AKV z0AK$m6iq66x}}ClB=V1fsUQ3YiItL=`1Xu~h$sRwuVgV#R64Fnziw_3CFre*!uhf46V%GR& zUu;A%o|3(8qLhRrSn*} zC|kE%CXzJ-=!d^PUUgU!V?(`C!rK_38wpoypK4UPLmK;NPC*ssC@#AO0@fA@x#|Z~ zT73TQfdM&JH@7sEtf%pVKL>aZmT!tdg#$)8Ieo6U(bTMfvWL ziXESvbikkIx}I$GQ%4|h2>iCYebGSx69yheJtf173L-&6S=H89umxyX0*Zew4@|Az zzg+*e*v0o66XFX|o7nxd9Mb$>P;#@(fgWh;?j0pnUD8irNGAj8U)#@pa~*24V};fq zx*?#cz;|x$>w5{3=p38o%e_MM1FJccaRI?h$VG%lm1t>?K3HXtN z2c;n5Epj=aXv2ihpU6i2>|&o@DYQ}4PPhh}*qORE@w zZZ=uo61K%-Oc7o?_9o((RK8+S4__&CI8mw zxSr~teO~(LPt1|PVn&<13WnU7lN>toU*dj3+D2oFAk)%9N#3E1^$aLReSf7Xd_uzS zleZC+KPVaL>9u<{?g_k*Ko1BG4tB4zrdvDUtAeVKrihw{$830~(r(4(1I-)MLrAWE zv-HVKeM z3J7Q*rVNF+pNxh?-Bj|VB;8|#kYHS60xDW&ZsK@1HLzk3D8v=ial%^Sy}WfsAlxXg zsAz-TGS{0Xv&wS05(qs#XvO6Z}YJI#~Rv$Hg-nP=8On2nbSL51E-P6#FY63?Es z1BpLH2L(}B8+Jx>iMt<8-L$u-zT6RQy4?uPwHVavu_hZ>eRnFE^jaY<%hgZ7rEGHZ zVcq}@U|qTH`n-xw%MIY{91e0^J(m;44bHBh{N zZ;kCjP)Wsj)<6iB5iN4wGkGB^8xEYZc{`AqmM=8P`ymln1h;SBj+e0l?aUo~eClgA zaDJgm-X1y7kP4i9$;6O4+fW;)%fBCb8`!xr-dIGlU_p(dNB7|wwTr0cX)*z_#C=u` zxM8k}7idXk0`9WOmI2*d8fxeqq9AqK3|LIP-!-^z1+nSR*G6u-YLuDBo4)~oD+}=| zClY9N5)1KVFiH2$xFKLt=E=m2b?+ej%+3}VUiXLK6#@WOKn@FbwI32I`JJ}0MP%Ls zZp8=8Sb3Uq0~^iNha;VX@KOo&Xm5{q=QxBJa$gOOoq$nrjE=F1$2fhh2vkC1^s>=k zl6nb6r=q#ur@|3#ktt+Q%Hj>E`0?&DfPjN8;tATGrjq- zDz|@q?)hnsw8X3zDQ~t6xWmpic;AC(b^9a`PJ-b=D5voDX<-`c-<6 zC!|;38myaks_D3;mEF8?WBJEz!Of4TAP5%KC?HMNLFe~ZnBYN&>%iWGI+SOxhcEkj zd$$LYaMKA2YKqj;LdlS!q;KKJ_k}7%3DerJBNTPex9fhr%@FN=zyz6r$uYSN;JMRWXDc_ke91^~W*&FLyMy*j@$7V`J6*aDgq-+QI zvklk^`TS;}qf4vWm~IZ(d$ORwT7AfM3qK@m_EZzm6PRzwbneT zv51m(Ish~C(zK)OZgOOtAjTP1u#2hi8t`5*tAn*SBS6m174Mq;mwa+Tk2q-SG+FBw zQ<={Oq~3uI@X{$OF&&a$ue)$}0yJNLW1>d6#@Vj#jI)H)Mr1Hk>67>pHWw;r$uqx9 zFM;Faxrp0ni7~-R5Hj;hwpzUmbGYS@H|gEAaug7jOos5{+o$DN9F09*nZso1?#LFhavFa?(|+|yuue$# z0wR8}V|JtqhmDt8`Y2-*RL;XA}zt{-quF<9g*R+hPvNlLwCn+ z+pyQdoK*p^a6qb0kwCvBOt;(yEMSWq2UYMaaV2SzWsUw8rGd}z3pKSTfH8(Mzw$qO zE}`-hXYCH7(n4N)1NqkW(P>{1hrkPjz`#z}vc3?viW#0#z4gQSY}QF~hT_Ls;Wq~y!RCpbjGVvVb+*m6Oyg3qo~tI2Y;rl!X3kSkjTRwgT) zNs;~iDo(Q@&r`uVM1YuPUgA2ABrY~~Uq?(uJ}up3ES>fVES!Ips?!4bB%R!YC?}s=?KzNp#)o;!1W)pbqFx+)VoqP{5FD$ukV$xH$WLN;9d{vw#8SPg` z^;k{mYI^xD1qF#Cue!3Y*AFYDjpTH4AJH#RKb2rag^aU?_UiCDs>PMz!W8$vo~;Es zb?)+O-7zPSnW`Y_Sb?4jBu}l?^^>fOgiyefpA6h(F2CGFcZBQB`qG0UkKbF}y=)5U zkcc=e4OL5MKmLSd?Di3&m2E08yy0)l%_;cR|AsuhsDv#+j!^!aGF4?|ER7i5@p0s^sa05rgQs)UkeSxWn{Hxla#>JB}whcpwc0n(y0(k}CN zbfS4hTL*_I7}hNfG!pH{zQ}EU)GPm%jMzv>AiPr3(~Cqd6QG}>(duc^fZ+ZQVN?=E z!S{>w1KF=+zcqmGbPz@Sfx0dUJUmsf-eEaWCzRXgVjF;gO5O@t0 zaj4{q`)w`|n*Vs=&! z<;z?$sYJJou^+r31JPGl8*zSqj|-l#x2UO`)A6pc1~}@Q!)>QSQKk2*a@{f7>)pHZAscZ*t1Ad&xCpUu z5uu}#bU!w(K38fB-gY_hm!?z~4o3L~ax`ozT)Vge`6udelU}E-;0m4wXC)pZW0+{< z!v~GtAL$k&5Kd$%_br$v+Pbe&4H^ z$aHMF`Tv-D?|82M_kTRIXGN&2h){S*M)sCjl93USkz}vzc_LY5R94w!WXmpl?-{bm z-r1Yqb-X{{+wJFed;Rkgp3n0<=XzY%eO)IIM{|jcwTqbfPHrb$K2vdj@q7rA5)3|o zq@tWja_k={Es?|OOV(@5qfx)2_+;%)l(nS+YJzKYP8n?FP|W1w+J2%CpF# zY5D90teY%#mX*g2$CPxPa6MvIMWOZm%oOWXqZ(G^xTZrGLp&6Jg-{pY`vH2s3$2zg zJhIr`*!Tpi0s?$}eboo)qFvy`=U&E%?gjUMIvys?@-4iO7Kn|?iBSH?_o5D?S?N)Z z_OMXlnIJ-P>NKsuJM+(1q-xZ9#-#xg*1)Blx1j(kACoV!R6r z8=JyLMwvN-sOEQVffaHgvDhU*fwpObQd4Cs%%ZwQ-CBH1OT3tcVqNEPLVc;&DK@+c z=WL9PBRynqx`X9c*pw0-!@Aqmm}j?OpgeyHf!0~e5_sf3;=?Y;+kYf<@mP`%AzvtN zRTK$dBUG|~r?yCq=G=vps+2%Zflo_A?Rx00{<-HuQQ>FwYX- znuUP02YgHt9-kvDgxwG1f9lR3Ib=sRG8DH2=Wp=GyU!voFMVBhT1_B&y(uugyjh}O zTQGUPF*q&+Zj%|!VYIaR{lH%1A`aKr53j5HM!h7Znt*18_hf1D5ndffAWq*sPLHsL z+M9Fs)2E)|cAzC^^HLOI(rXixCw&$<4NgQ_-T7OEOSrulmwPGH19Q&Px^X2aihbnqau^+$sfUN5-*PijaW`7w>%|DLQ zOnc?FQaDgxY6EFm_kgcNdWpA>hB`~L^uqaOu0G9ST*_5B>b|2h@|5YL^rv!wQ1%bk zD!0i!j`rfVE8gOZ#4D!27~bMTxU@~gIQvZ8IUg%7av}ozf-vKMuxQ4IZQ~6Kv+z0x z6P0LKmCc79jay>?{zTA8;%hx_+mxgVR4j(Z>l?xhm`3{U8q%HgtIwmJlOy6jpo{i# z%+DL$*A*>h1%KOWHxHFm;lLkank5s>WejPPIes8|M+cZGf(m^5L#pmf5Qtf zoT>7BJA{8^wb+yVK6~0M*RiAMVDwW~kv>IM)+Sa#j%goD%5i)Q98;elG2d(^F=9*@1=lGiXdu^#(4y^r zMzj9ybX6l!v4g5qT>ZCiTEa|6Q z?vfj{;An5(&BToD11P8I0xL^o%Hu1XeJ}yJO3b>t0OeDv^j{AvZbZ7M-cze*w|)Mzkn9(nMgvK)*Gp=@-S4L{HqO~ zo(h&-h`v4l7Mj|~RjZs%H@C8xafEzPj3SBUN@oU`h`*{!wsy>MN;sGYJ70q&D7efp4^LxQq3aXmaq zAA*k%SbYEO?J~!z!w(QA^=FksOSJMC*8Lp$R+&@0oO*nvYfgaX8v$z z*FgHq27fFast&6%qs<()Dn-KG{pHWqGws!MIGny|d!< zL`Y?Uvxe|UUxKnQPaYcN75Uvb(PMUJz_cDWyMBL?jOJHzzOzr0t7T$@0M8r~DqJ1d z-kAPfl^nT)59QExqY8&;p0;yhVsWDh)YrqjGO}^u(3P~pN<2gL?=y*4n-Vv=u2UyH zis(o&aB(Vu=H&Bq`R*7`;Uzj2ug45Zb^8=o3$U?M0cACde7T~XclX5acn#@{^!Q?< zi~A)lO)~P&uidPBdR6Dj2`2}dKGF)>ckCP>qn`?k1O#c5+%XLt0$Hi45ej>zxQ0PP zzG8p(-um%Ux|@4=1WnMEm#^Fq2{w<(zfFyEl}PMhp5egO_cB=Db5pnWJ#Suh*ApH2 zqZ5~K!>Qtiu+xL_{X912M0Y%X@H_%RtGW4F`_tXOE7XN zKU#3cja2Uyx{?NMh4n9vwNCIDep2iH z0?WfrSwRx#m#^Yo`a@ncUStuaQ{*7*nt9{Wra+=Q=EuL-D`E_K_k4G8VfR4S1g7{) z@TvqIVGZ*Z-bK|e(apq5tTb=Ka*_7Q<7-8=oPqn)B+<`&)OLc*%B*VaolXq|GOs69 z5oZs+7-ZA-*l1?z#Va?y>ceBStsOI%nsid!kIdo;z|ApN4|yZ0VpHx+t43p1rK6qu zq)u3nU+&%5Td)NgSMKw1+5VUPcaU4;LM4_y??b=$vqx09EBsyew zZPCD5cxGXH_x=PC`v)q7PXTQ6Y{v)5VF5yikrPCThO|*}aSVG*=2otm`h>*G1nZ?vURF^nf7?)ti$Q7&3L<&O|+gi(6Zi@Mje=rl0N3?2(NtmpDy62+4i z5Jr)4APpbn#^Xkd#@Kq&-z=$idma8SwguyQj-l}%O_jzTHiF0KRH=7lZgJu|MQy&) zd&Ki|#$xBsS2Nl*wSP2CV_nY)R(NF8G$B1#%l708`<{NskI|wai#3QSa--AB_uh5G zRGH_QlY8B7-4*R03jJbh?+~|hF#haR^A%QqEDnb8F8OJm{ZaJt+);q%3o<%4r_FXg zz_3+dlDeFQysSAgk9K+Ar~4=A)`l;2#KfumwSA(F;cYW zBt!^&d5Jcuw<#x_OB~l|Vrp$RXCLhUtNkdjBkTj*MHB28{NDJ}P2j$-%l|u}$9)HW zBaj^aiB`{;RsB^%4QtwJ&5|v_IuD}w={W~$-_XcM{_H}Iw41dThkrS)^-q@e&mOV+ z(LMFpGNW4o+(q+^*o!?W+)JW*tK}C-Tg;5#u-xUh`TI@uVcXne$r&myG90-=a@M`4 zv2Gg|R6<^r5|mXU7jCSYiLzd+mVbBA#025@>3gA50z-{qq}9#Jf;$GvFMp5JagC(nJ7>EZFhGj04BsC(qeV*ZH zjl)R5U}@CVcbnV7A zRmYK5y6X4LNq=A8R1;4>Km|?TY(YqxS@Y6cqRZX!IG5}{T;I-97fx`wxY^8O(o?6p zZK%x)$EX$>%AaK|xp3FV?(gTsMq0&7oW#aARSS5XO*~8t5O~+qo1K+i?th6mW^=2o zl?s}_78r~$i!@w(5NSOiJdvN7BB{h})Im*Hs8s3~PtsUZ=26sH81a2Ha{OE|)umy* zv0o5Hn-axEOgHr0aof?U1E2?w;+I(#K^^B;B%OShhQeXOa<56cwM*8+_^_a4Z2tbq7Hn@r1=!26chbkKv*(%Gl8soudYRtyMigbJ zvUMJZ!$L$8Dws&AWAl^Ft{t>zE48A54_}eIkdd+M4(W6%TQ2PU5!~KMbcb!qdAp5E zarnr{!pb!XSw1_MOM#Jje8)<8#QlWKFaKHPnx&Gy{py^6iR*3N(ZndJLI1-6BG z$LD~vPPMIY+h}f7=tNY`aKz974)Q(NUz`@9JmZsyMbE;IPU$Ed{vsNL!>bhoxRz$XiY}^8r?6D!>%mvYL$j z768JTJD4l9&eN0T!?dE0>lZs2WIaOkOFS&oR8os*$R#H>d#Sn4e#4I5>OTZffxOSJ zFQo85D4IT^;#m#)Y-ZhR;kSbV12<uvsATzaO5Ev~E)j z+OJiN6K(Hc@vhjPrFtHc4E7Y~(Q7PKC@B|O3$e`Ghj0(uC!74Q7+hxzqTWxCj}v{K zO7PcgphgQJbcSCFz$vLUNb`Z8BV|$TQu|IsBMc~~dG|w`Ga=8$)RKBzMo|6r<{}7+ zY=wwfy9awv)xSX@Kp&~*%F~lOQM?wP_V%1ET)rHRg@YfN@*HBtbG`uM6G!g08L4_i=vYHNEyH;M&Id8O32o8DyfXW`fwtQ~~u ziTyS&Z~r3aD$sK%gl7oH!cWBy4gr1-T-iM*E_)6^6364+Mhh6K94N9u2%{(|i0ktQ zIR!1q;}tESp9(C7)!+UCQsR#Vjy$Aw;55P(U6>4KNJV%rGFK@h8b1ca_-rdeZTFsf z`7x7E^a=w~dz{*$=!Sks%#}5XUa)Y?QHL){Jkty0Hda~lQV)t?k7y|@u}cQV!R3b6 zFK=&LbaAH%mA4^eR}3KN!J18)fLX{~|M#z}s;9A0HsjFx6tLu8i%9hgjov^Pv;x40 zqR^Lz11(4>e*OBjbkhEGqd^p;yz~In_3pCm4248SGQ)%)exAlj97j%-15}sFog~Eq zy|m%x+nw#v>@(D$CZlgjR&)hAs6ZRSz3h9EWD&<5Ar!5ec{KWKJh6BC&&6L43Isc# zwR9#dl?kSaNm#sGOj-N&?$h>$PEJlv^kMes8=oiI-wdJMTq3!J$o&80+9tTr|J#PXUz9cy05C3%lOW53xqM z2mmOp^kaX*jP^iM8dv;fc`!j*$J;ZCdGO7mU@ZW-J)=HxS$MB8W4Tv0pF55w*Sagy z0o;Ti^Q&99D--NV-oC!AVAxIu`}VWPk2BT>uY_%rG8x3}0>iZ7%iD?yaqNaP zzQR{YX0AXSW-^G?5ZM_>qF;7IAJ3Lz;(onI76Bi+8cYegh3>s{W4hzsQPQb$baqH z{Kkj9uNH^k+nI)ZNx@~RO(x5+vcc~sdw?s=^db;)>L@RJY_R4=!u?`Zx<%xy3}lIw ztgZ^OV;F@R{<7|l)Rvl{haB@M%k!awfU;1M*(*m7Xlh4twT;xT?}HV9BVf_y8a=;; zcXG6;c;m-=r8QVJ)m<;gnt;K&Lmf=TrvTa)yGR?rCk+AmT38)`eKj#SB#15Hiy%oO z`_&Q6hG1HDz{LyH&po^JH`=5Y^awA3?sVzE-0Y@li<*~5^z^CB4LX!h{|M=Nf7On^ z?TCs{T4wY+G1t}?hEZMH%SQCWlv1_6NwEa{hfhEUl%jcZmgUT>(7<=vx%58@hatG_ z>#86%j&9mftt*0W{+767D0iuiO~H#}6?T+&9qU*AgJs(o+Hr>pPNn- zJJ?w<6D;C7o|<<9Wrx{CuKyg*h&buJxj@C=fTJYGtpexccdRI->aEvAJ{CFo_~T63 zlSn6;&wp@O_?O$cKmg@@e)4O1%{epu$fRM5<938E=&eQD)0g;doq&3%I6d44shx{kE2ePQc!nqK%+LRf5#t61S|&PLuEv-Awu0GIexMQ3A^)?B7nzf zZGAo|SWaJ17pJyvZUE1C!eT5dRjdMQK1;*VH?6Ok1av%NDm_e5G zy-!~U)?X-$ztk7abX_gg@@0c(OAGMQB*{2*<3jm3bmyE|H${v(w9C!i8vhjyTUFkD z+6kPahOnK_8k>=-Id#N^E0pq zR@dWHBIt0DnV_9F%z)LoDnPB| z42(M)RZ@#yg_?Q+uJuRQxbwsIzj5HQNR)Msu^jBfy1Gy?Abm6vj6>-<~ycwz{UV^22-PRyv~qT|0hPO7JqtBdcxnR} zqEdga*1&)VC~)`@Xu7UD>95y?hF)_%T5kmW9x?sd4#;uFZnc{a+DcRorm^s) zL|3gu&N+a%>fkFPC6tb9=k5aT$I-TscX`WEd-f(c@&|Em5Xu!=Lj9 zRO3MYX9QmwLV_%y5I#TFy|_2N5AOmE4^DM|7<6{BNkZHEX=380fE&LY@cpLG(%!+O z$yD~RI_fSvyJD|BO!5hTyAo;(TBe~c|DGWBoXFHfS|Pd$w1Z(AbypPwDl6ka5YU=c zywmdU)iUhC3D2oG7%J%D@)f#DGU$U4nQ@5G`H(V{L9@Bboym1lglejAWK`V^UVbFe zne@%`Rgr0W-+Q7nav*zX z>xMr49_W;S^m++*4&Qc&-BN$M9c80<)Q5@7$RUYeLQSV04I4d&yS@* z6F8)vR*aW2kG}_`-C}B_rbd*@^r^`YVanhj>~0XXSnrg&B~ z@DJ|cSb1|6SOVpEun8*DKb}%j4tkg@tek2H7M#whJdtyx^|rwjXIkJ;)R@V0MF@tY zD-^e=;=Q`k{^A-~>X}*a9<-~AwZ)0)iV4?>5-YsG{M@gAsHD5VSN*QKLYl-M2i9-R z(TKtd&e_&FU(0!4m{tf~m8<>SKX0C$*PKT8qwZG&N01%cLmUYiTqKRT4*PE8XPN|hpHKtQ2T9kF-i?ws6`TjO!53KM z@@TKwP1qC?+-w#_N0a@RFsMjp?x409zk6`O3zxa+6Imsiy!ESe-M7Q+*2bRWFna4~ z+{B#>$J*Scvz7|+6(Hk`i_0oKPhyww+6vVV{wC9>_nCWPS-0#}H{TZWebm``*=rQ_izpsSP5G)LOD!5{;Zn|*>Do~_6XnX1mjV>X{9h=tj1 z5wz9Fqx7UDllu@HJWz@a8z2_!b}2dZ-l&&Pil&*m!6vT9lI}K$frqq#(+bqv>{>?> z))x@@4|WRf)I^4~0xtD?_^NWxEZ>)2BJoaWx%@ssHB&>G{3~ZsZSEw9^^w%!6sQmj zK6jJaXVu(yG=|6FmPu@s-V3-%Tr9Tp$6$d)B(LeBPf!vq$2dD#OtmX5LmLlSVYPwR zrY2Z{@ZIMPaNl6)+9#d(iEsm*Sh47GXPo0NUTLg7u@+`kFc_g#`uOMD!>d`^b@ZH} z0&M^N*UX2X1X%#FUpOZDkh=?OqlfD5dEno9R||U1mjl_ODSV2hShflYucx8f$?@f= z-S^x9tmnCJx2Af^%RWdi0FQ)=`cu-|OB^G%(DS{Xi#e_z;MTuq zhIkUHUpN5)lQz{E@--}7kyE*Funq2LOyCH5f6~CCdOw9|ylqiBI;}b-aUFA>yOE_T zRcNHoWi=*zLn27p1`_|it{fVnZG$KY8Ci-aeY(cM?wan+@pD&5lw}@1d|G%94;i+- zL}pa|kDXwuCHPbk?Sa9C^n22(=)k=BQ*sYPH=19%rtEx;LgSO?3&vYasq<5B7U|&* zA3Sf198b1hSDpFtRB)D&fTUq0q(6NuCM&beB#jX)>RBESd=uLEY_m14aq;r1kNYam zo}G?NroYp&Z=Xgw;>O_{Kq)0rzRzJb<_3~jho2AkSN?ncQ#GhUzr)s(x!qZ`_A zYGoYeX_rSu*P^3WTon`S%uBdu&>(+-h{y;vDdFMI0voK>f$!81@NGXC@VOuYDqhxM z!3&b+>tW-17#jyJUEJGzw7#(-uCoWFWM|HfjgLhZz1a28Q7j#LvcFk-$&Tky^jqS^jhYFEtX z+yiDWcHAI}j_8n(o9GCEZ<2Pc&MgQMe=wI!v6A~% zH*+cM1jDzu%B0XEt(BSAPqV3K2aHyX>!mrA_b^ z%P}}LGQy6i29Y)(TdP>7;&_KDi^4tytbMB1xf1BTdY`8T#uocOTx{sgb;}z;k5K)W zbaaom1XZt{faaqo`+1}fV!MNigC!-~j)yDUg~~7Ar}xSQiMB-Q)*G02HAiVCDX`N~ zG!%?&83W*Mm0^5*@SJ^0vIs12&7gECOe9pgyWesrN3Phi_<^|i1>Y4;RLO}>W)V@~ zJ%y(8Yc{M>Yi^^iedFAb`-vBJd`kNe(Pn=>;zLY6^#?-(9tO{yJi9EImcZuqa%*1k zo74K=lo0EKt;*?lDlcBuj^!hvhPx^5f?j%m#stuQ008pl)VLsCHIE=lE_HGdYq(wrT(C1J z$B5(BMKzMWYqYh1Z2wf&gi|SWR3TP4Im{oE()N}wbBprEjjURAt_*!FzZ}esRor{2}3Sk-2{;3>=Z!vRw`v(-)%j0Y2;^pa{4Gxc2M) zjTzP(Ny}>ka%rCey^F32MOD-794(?AwW6g{LD+&D#OXppS??dAivnnP#_eM^dK%bXZW(;69 zkqRygI?(r{(@# z%^9F#r(W)Te&;f$8>KCmLex&`WgGX^QlrPPEUQsA-j98XcWO^2&38%pqfuKm21-Gf znlM+bn=4LGRG&d)aqr&XJQs(q{{wgh9>MR-xq-$uP4##hkyfA~b zg!Q(_sQM&UitWEFP?z7C?;c&X_%gFct(~>wPbV}C=c4m_TNH_rL``!d^z=2{sH%@YWP)+^qfB z>O4)w%^E?p82PkYPc%oT9tj||zbsLZ3RqbRyEZKah4FSY>+sYA^&l)`E*9KCx>1<@ z3QC(EK+&^nVkfh~GB0*mxvs+OH#zoa%uPXByTXM>Gh?5_od4FXy5GFGHuFN>ff`%5 zYAIKi*?$Ce?1-v!f1w#U+Cn@};G>%i zxJ<(9%V9oN=KOPrQ=$&U0%v1k-&>L<*Z?l;+d!Y2?{Ea_N5zKVQ%!P?Y9%v*Ii8#i zq*mBlBll%rdLL@(R*2^RPI?@f)OEdeCo*Tl{4rbx%pp3Z-uPSYes~!*#AaW%$at)w zb^r>X0cTuASZ=rZv|_90k&BRe9}peIY(-vlRCQewWkrZ z(}4BJb`Ln!e>Z6RL>^uVrbK21mj`lkRtLr`8WLF{wc)jCm=Ro}qRBjDF2-@Iu&q0( zk^3Kay6BBUbOOE{5gPh3yn+~R2bC20FjxX_Oj-i~L>y|WPh_p}Vo1|j8m~mMwGun}#Eo zNFs{bM4KBDw+L?Y5)CO8`YcwWGh~LT)H|A>_e4Fpry$i2NHrSD)o-)$)Bgctqn>kZ zW4;#sLvPh0x-ARvi2vM$4g?suLJ6+?MyI7LlIyDK>8hwTGQIltLA#!_Fb=F0VIm8< zk7$^Pj>mTsVJt~r(X(>X@&-0yZ0{y+5cRzQx`=nw0i1T=1j+$Nw%WO`v~Za)Hr=xJ zizAV>J#QL`@9;u*CHh?GMhp&Fgd{1$?D$BL#V`C8AVTMJ?}naEs` z!*$E$b=@&H=}QlTK1KBh6>`>*Uu6Hi{;Iw+r^Ic&o?M}l?iPp#lH+j$LIq^v{lq`r zdj7}nW?$Nb+v)KxN^-o05Uc#Ci#MT#!y720zI<(e5m>3X^e4#y9zTKuLcmGz2!MmL z8(2!}a;-T*aN|)>+Rhf>BHd)@AbnPH8zEmA;ZY(W3PwRkRdHt*mllAV456Vdb&zi} z^9A31mZ|(;l49Igik$Gz1h8bF?yVRxk{kn$(CeL`@?p_FoB9l(+-e z(GAo&Q9vbp@g{ov)3Ng1F{)#Khu z7is`6?JxRW(l^aVTK_*&43x7#w49NK=y%>x&qPA}{4fgxIqXb>fQ*ZW-x$BE$bS0x zic0qEVj`>KfazTZ$@9}goG@Rf&7WPSb0GgX^TYsg8U{_?LQ4!>Q4aaRV)bmDN8uHP z&-@;--LUOlVE$6TCoyI@swg~q@AT6tK>r({Kxs--rd>$9C#|f0p!Yj17(utIL*jZX zwG}NCRUOp(s(LQI2kfA#(7hzr#-fIQQtIymD#>M5ZwM@Ucm{$5^ygRv?AAYg)2WP2 zUQtoWc?9}P?c)67)Hn}Dpscq~RrIIjX*GVj?fQ~utO^MsMg*)U-bhJHH$ypN0GR|Ip|ehfTPYgD1#6&h_woYqc<)8sF#Lys z^tl3f4x2_wH@77708E0|&?RV!_^wsbGJy}K z%R~ZAlUo^f3}JgNm@4E86ZO{}U2q{IrE{^rP+DAJ+p|>HV_yww1S3%Dzfc<3%ggKK z-aqo~B1k=$hE;ZjE(EgfdKcd3X$m1)jm7=GaOnyL*^73j(qbqsiaKx59(=8v&lpGI zGB+Q?MjTCW@-RUA6|f+TraFOGA@&2sdN@G0g0;@i%y!$pAV_QceWC{dX>W-F@vt!) zWz{_29p?vL_}a$a?iEdEQC_RDky%?WzqB+oD?{~7f%%{u+5$qT;diUw|L9}={N`V| zLuG&rIF?S4-AwhG)1ysx%31tqp!9_|nrg3afKl9(!a%i%uH*~9&8KK#=O?H&WgtuE z2Eqp3qXCX?Ob+TV2H|YKv;s89L2lc90~-xgIa(t4EOW#+MYex)5dH*N6wBrud&qfO z>KEJ8xw_s`{J{o|LC|Uk4-livJ5r82!K$+xtasu5C_u}oJ@&hgMbJSNb&(hd1i%t_ zA4QWONiSs>@IhlRfuY|ddqE|3Vw5pwwY1kylM14V;bn5ILz~|naK&_BN&5_#I=HsO zILBYYN6Z~Bh4FR3!8Q_R&wS?(&CGz1aWU3PBPU03GFNbF(lFPdn^Y8B6nvEQW)XLD zfB!K5)#GivLtrJ(!dp}^(L#<2MONe4)ejMf!$9KPS#Awi#fcfAsam9Ooa#g1;RjmnL2W{P!3jV z8G?5|WmBWjw9qGf=Z~w$;ERl${H44mIk*4;7f;lHp45|&thLji)WPg752}n?1L1E- z>XYQ+>S|_en5Kl#WwmrsOOU(5TV#ikEA-du&qq*6)55l(r1uQNU6D1;x!gAbsfIl9 z5`IP?b>f5XKgeiNB7B-8^Y})(R*F1jMk8#sOhtji#H1wqH170a2!Z;vDmoi>44HHX zA}}iY_6qi%@5r_P0B$nDzVn(Qh*t1tF68({N4LQY*c{vqJz_xt^T2T&T9+me-uLL& zP*?`a_0P6zy-XkF>m8uK{bT0;y)_h{!y`z)#8KI~KE*UW-)-seo!C0GJU_4eYt z^fM^_nh-2~@GlLS^av8IGVS@62N?h?=wuG!i-n6_nAn@35E6 z{n&B!;Zz7g={C{RqkMw*)q2d!5E@`-%;K}>;_TcUKzir)y?ghx4sW_64^sGt&v(RD zW=%!yCU70UD5aHMsZ%oFBK7%374|XQ{ar!_W`<*qYnHiAI4U-Fhx}ij+p;oAWVD+> z6BkX?@~6HzZ3YsO(JDGLDTF{ruh^tl23SUKG-C#$1tf1%`}6_3{rFBZ@km>=0N10_ zxLmzIaFW>5h3u^K`Up{l>7XOXJ6_@*J*T@8-^EU&vwNL1K)pqynL812DHH2DqOju` z7gyO)J(tixRr>P1SS+kwrMd!zk$;wZ`wr$@bZ4hSU zdaw69BvXBv66$5|M+-4TnS`O@|5&%zX+^1$zR2b4)L$!UpyetAyj*S9L?C*Y5(j@I zIm1v4^pV&1Pyqx;e{K!l&hM0kkjhR-{QN>&4e$rY-qul8@mLQZF4Wa%Z*T5qG#}$5 zVenl_cGnjQ&FmtyorR)bb8W+pip&a^Z*2KH{Su-LfppkRNtJa3zt39Zm>03AAHgjj z6E?qJNaaz)dqh$FDNDc1q_GtBbT4G*I}qUb93{$ilBniSR`Bz(?Ef>wweH`cB_~gv zOaPN{t!OUZ@j3pW{KnkA^F@Dz5ZOk@-{@O47YeMXp}z~!+JWGf;7h5H*#7&T{qleS zPkV-1R^IL(s>Viv_`hO3W41kIIaWJ)xdSPQxM4q%WZW}7m(rAz&_t=w3u#y4L|ltd zcb*ug#gZB*Vbyb!@3?`}hwwf6#N`ORY%EHg8%zcfZrNB2SSu0n*;r%(?Q1uD4Y8rR3IRw=^kB;1$4K=Od~yjRrsf5>~mhur@wwVh&!*p zo@#Y(@$mHY+yK$oLYE0^gMnuKe)ajarHkVwfhfOs@(#MdDj1TumCoGdKmzn~J^uM{ z^T++yw`WYVZ}j%nOMeajj?7w@uywcR^4y}R9Rq^>%=54M1|A3bJLjP9W&c0wd)6Kd z&`n+$?=uQAG@_2tkf?X~Vrzf7J|unYNjkso zDmtg{Ox+;>|9(ebpPGc^aEsV!+sD3)TC}U2;hGA69Kby}a zj_OT?1|4J6ckVbew)TZC{hgWQS1Nlw6Ho>Q8F1L&RZCY5gCS5(RW%eAOetC+aoh`z z3xD$7LQA2%@oR6d^`6UCDyp^#h>O$J;Y$^dgk0wTfZN+z8yBm!7%pB50hY80{G%}| zjqS@7j%#BK&?W_cpx(bJe0TxUcqhU5Ahi@17YASdkNf7!(gMgy z^zXFlfQBf_3pgP1n6mwp_NH`ad@XC;HF~rJlB<;INXQ(3jRD1Y8^8NOLFj+B1|?&t4)e^1~}?dD?z3-~p5 z_8hz7sUk>ZSg_a`Yn#{uxJ+=sV4){D87k+(th=z&zj(O+o|Tm&gn9Cz^q7O4;h>3vbYgWiHo+a%*Z#cQfn`w_ z9SV!euE7vNXxt8~;d#7v5{aOtH@D4}-Q2&)87d@*#$7JY&N4z;*mc~gXk|5%s%| zuiRkD*p zpN-<*ZwF0iY64|V93Z*P;Amh3#-S&78L;dAc*6TbfGZ?hjaR_xV%exhF{gha|K-;3 zq8y^EdU%R z{0t(6bUM=S@YB0EZrAI2K)?lZdZ`_zRUbkD+yD(C+n{0XRcvq}zv(YzvehCyK z3bl-~jkUbU5vMdfSjm%ykU}uxV#dBOCUU%VZN#eQ+r!texY8MPymgd2L4i{cuc7wV zU`muo*t$|QCq@3ti~Lii1VO-0+>z|b{U=E>?esU8>8W!7_c%G3bOeVS8yc|l8e5d0 z`uvlwTz!WBg`i#hn41g5hk?EZEqfnTa*5ANWSI>-nE@C5ygkNVCg`YZ@tEYuZFh7R zQfF)d4~Wwtr!0j4g9Ro^k%Oy*cu+6y!spTb48h{D)p>^iLO2jB2~ zWHh+JRJ^{m6#{~nd3VTq`d)mzH>G%8X&ba~*}9e4E4g@TenmqLU~Oy$a118@>>j}U zRa{Y8qNZl(;pvIvqCLbX(4opQ(Ie|`-{shOd1XWo<|PR)+nm7P@2esVd&gn(7m*rW z{bCf0dIwCM_}uoa%L%I^l#h)c0sfC_ptm=GTeYv44i=+H_N2kSFRYGfBL1MBq5k-6 zsxIPBg|zNy4J3 z`@W4(7E65^Xc4!675F($Cwd(Uw*0<8?kF5?Lh)@^S}}cJZot6044mp0G35TwL;gjv zDYx^4*S}#2_=9-%1Bm~z@*&9LnAS(YGvjIJ7b0nXU$pX~aa&oc!mp>(D*iFRv0>TW zoyrp_8Tpovbx)$paeGk>_T!eQPogMQ0781F;5t#QGvqs2IL4*X3t3OZtE)hYkd7pq zE%+e24bJ%-{eApIUOp4wh9cHf^_PBHf#FP4X7 zL*hN}^<$O17qPpB(dmcR#>$=*3 zcAm;~w)?Nk@Eu`-dgv(Pb6&SHHl5bI{Pe{22OQS>Q^8`~Zjwz#W=)&$i7=Y=Bbj}Z zxfpMbZ~c*T9dC%c^x8f~esy{5YezRx6H)zI%l3-})lM*r(53)Zpa8jYp9x2efPtl` z_p=5LEgYYA`j=8l?aQUhBOBw$J;Lm?(nT41l!W_rrD^sylW0%kv@+qYqf%L zj0H*PWOM-OqjA}tgSMk+t0QFDKoHv1M-NI^>jOrOD{rf^zR<0xsOLIP8R*W-viXgK zA3si%j3tqSv^-P1e=3S1YSZd(m{^#vT)jF2dV+od_x0jmpzs!OU_~dsch;yPqfGNU z#{^sNdowsOm)}efRd>4Yj%Hj6pdePIBd&Aw76MxKlTLZh>diG`Q(MlQ#!et4A&3Z7CKra_4CWoK%-_L)gpyx&5qHC;mEVrTIek6~%+>7J|4 zX(POJFV%F_{{V^so;)q&J|6DavVJ6)&X#_n4SJEh{!M@~Fe1;OG8B*mIX%6HgtO{7 zmj|3Tkle`D0uw|IB+ZwPM`6FSk5hm8gwh3{#To#bmpD{$wV+GQr|j3Pp?10wq93*gVrUoDw(0OPb{eXYSKU~Q;m%RHrW zdy^j-Ssa3n^%is5*NSE-(r?axdh?CgV}h^LM%vJRFt)yyLMMI#c9&_0GVe|}OI!ec zM%&8PPM9@zb7y$12^v-Vb$;*9kx5tG^{Wil50-L(hxA|sgVFnI9Wx8^g^5W95W9LG z-6#P?xi6yZ7ZxqDTI(y3X2<7ysu-DH{Oa*=*xFz5M+4p)S@-st6YbX!rkI9wmXh$1)|D2DUu))cF0=!sZ=O5~P zRo@;~E-5|tX7d5W-i+9G{qODX5MgAuGW3|72*JXY(U``*6ch?+npU;c&i#6%Gr&o- z%(Pw*jJUya#1Tq*XXAPXbFpb(4|nIyF=4t)S4bG(QIhyY&Zd0}awk83x{Z_k{1*oy z;rgqVXY)om7A2M)(WTd2=zdF4<#t_K4JKL$QPW@lO$tCZeC@S55Xr~eAF03>6-w;R9RU);iG?& z3ba(4h7jcRI9vPS@5ZYG!%JeVyvj0Z7?}s}=Wu+2uPTq#o|3y6zZLMM;xRS<>d4Q8 zYFAji|NXVx`xjBLh;v6%@GBJn`vDFBtcGf0A~>(nRP&|7T8iD$(o)1sS|mNUeU7Sw z@N6i?=#xH@4-YiGNRV7}gbs3$qlG6K!)f@2^YlLw(z|C<&iY?g%r#EFD`?kPHnm89 z#hp{L;jTc2!^ckZmotvJvDbZi?2QYUmE zMdO)ZB*tQEk&sfw^%3a=WC%tJc61nr_}gi8?hJrDV74Y`C2oTh$#x}DW0aDX8Pbus z2ZB& z_KzF2L{mt?Gm)J3FI=*w1KC-+(vOuz!KuSic1B8I0Tq3n*~eG*jK?wraso~1at3uB zya;rxYXcbi$&+mVRHL!;0T@0A(Fk~%7Eaq4L&pSoTV@$z4{U`%HW2v`vBwB+8w5Q3 zJN)35Xw7Po`Y8Ya8k|jsyW|J9HS>7h(eP$8>(SbZ`M0|p0js{6;qHA2QCw$iQ=*&J zV~QK@&n_Mc=v%g5BxRY_1pGB^0*%8@q~~51xcB<~W!F`B?`M<##z(jUt$7Br=pGK3 zYHx$}BpfK9uaG3q$37C4xTIIjt{{w1{_er!mJncQhuv&aN(jcAlz1CZFW&f78aU7uSAO> z3IJ~3g&NVjvkQS6R>RQrc=(q*NRlB;2E=ip$R4r#Rhn7U=|sIakaIddWi55MKT$2o zdpOoFpn2KZVQa4jE<<5Y9t4xDSP^7Y0#;u)Jbaka0r%oX#*;7rQs`mj(gW~-O@qDN0P z1w|?I2(Tvqz;ffCmY}}B-UJcUXN7Ql`U{tl-D)!sam{<{Vo|HVUewF&LzL@n0Rc^L zZ?}LC8bnP0xxiarsXi7FDgS0Zc+Z86f{Xw&4#rI_u-*~#@jZpKicH8AYbuCI8g3tz zKm5>$U^NbvyB6;_!!oLso$@SOiN3$zRXW5foFMct`djU{si~>y&x$gw&>3uTmJHg$ z!|CNu3SEjc?$~^R<>)gsvJ4hqL+-|#Ghlk=DkzrZck@$IeOYzN9^ezvnE%W+>3wz2 zxC_Un6!s8rpeh~+V)M|LY1={Y2@117xu2UgFGt{Xrjeww^b^~m|X3{a7ivJ$5m$QnvY=uCZI5g7#5hju2Vkfy9CgT+`I=;Ef zYn4XL=;#L@!M6dmY;9@S%qDBWPF9}h_$wmf=}&_{LVQLE*vJOh$o@at-a4wPwtE{D z1x0BT5D*a%l@LU_RY2)(X#}LZV~GJ0f`CYaba%H12$Bi{N`rKF$C-=w{e9<*?~L=u z8E2gR&sLvjvllDoea~xN!FFt+aoKEix4-KL>GNP~zz$H1U&nJ>B~zo=XEf;N`hf1; z7el5y8;3|^(q-Uf`1&y z8+AS`6W-%1uB`;n|D}q4f>13AKA~=G2sDBw+hvR@S>kUlZW~Rt5;*47^EsMH!O!02 zQvO4yEGm|~ANv)%$mTgbh?Z6{B-f)qJi==X#DmlP5%}Z_ym#*Emb$x_nyK_IcaK)` zW*c{E&UO#Lig6qpHw%w976DoWX)zn)9^9CRo2CeX`L2WYD|n7y zekVS z*t-SjU^V{9d-y<&nv{f6$fE)*rOo+YzsX))GiX1x-YM&BlN`!eY2h`X{!{)-_q!$S z0M&53juTSSEx_C%d3LPLuD3XvBNV(NLCKfI<* zUcACzY~J}!MoPq>QIs-bsSgzq;hRmmudauQ(-cY2&7w2RJ#s3|Z1Z~U>LxK?)ksfg z87q^gwX1B@JNqV~{(N2QDi)vy&7)7jxBol^(nDouT+O&wojjJQ4%~4X zOd~KJ%3``mw-@_AKe(SS}`7q2(K%5l8y3qy+!RZ?zO)^tIKgDre~_GKk0EJ4pwIpS(GC@ zfNWL~0SB#G=-}liNa|9%>Au9K)C^j@=|I>=|7OgCx^;J;>UyIr6kjIcqqR4xo4l`I zy@bD2VP96od3x_1m!Yh{pAyrsu5c6PbFU}zf!-eq&<7aT2RAO$(b1)P>~Cl;8?Qj; z+?!PfPT6VIH${xuJV*oF^{SEaamvj@48|2;yP$?Tp>5$zrWrFGWw7#x47)An5)=0{ z8SCmjm&Ti1Tr@Wmo*_cOP{s{X|0f zH7)b;_?xpucFQH`CMztf9%swyV|9(I;TI!Ck3kjEhM;Uu5;H6s`3@Xx%)*Z?FqeL5 z^xW#vJF4>?M~wAl1OYQ&D0;wi6#0IoTOD&2Cu0cxXF$8~W*T z*`)aA)>Ci;Ffv;`=Dzju+iPZ2#?^QFc%LnY340k@L|W@w&L?WQPg4z`X*X4|Lg28X z|8rQ^>)!5v07r3HyUkO8jB>Vnc!Fc!u3uqlmFE_K#U?K^vl3snVdM2izX9Y$e5*9m z2&7%~n~CC@e~vI0RTZe08%UfdVUI_6K*Z#u7s-H37hK|{W*W_ zV4|kQe+M~9gK?ZDtbPgRE$GfG>CIVjzcwS+)D|6ifq{|H|7r&4i3yp1vOxu3LQOvy zIkYybFyOY~E?_h~+f9KHH1$Pv6GlsWmMf4%%goHIT>oF6+W!glfSC)rm0|n_Rv)xr zS|46ffw*W}!kUi0T8Yr@qFAg#YU_U`^P*F@XaA%HCPPht>;wIu7I4!4#eHd;Jv(!@ z7#Q>^VB)~%I|)zaxz7G809&76 zK{J!HL6K_oRfHnuM43*@-?rREMbFG+)&6_DjOf9ofCPpf*4_}n#!=sbKTPn|@OnW4 zm6leKg@uKff+8ydwZJ`lS)lv|(L0bX;ynq(cjPt$gP-7kx2WXk*`W=CP13^8*`_8@ zzres3-DhD6L<$$t&26h$_#~RvK>nX&YeQp0h*EotjHGPA0XL4{SyEaW*Zsd^mY%b3 zng>>dB+#T#zg{4|XzoDj9QsN{7qa&j2);W$0l|RYna2oRgRkhnK70utr2s9r|99xT z1gUoD>*3i?B-g`lhDqYw^n2|827-VqZ$*qYoMuVxC0B^90-Qz@^@4{rKw~+s*p{J4 z&pnoTkcjoJVd(T^xN_y^HvJw^?#A8`G32~|r9`J)d{1^^f4HjEFQ#Ueci3N-&?DX)DxLR1DqE3x?zW zI_zg%yZss89ca+ADX>z_TLsreGFx}^&@JNAV{eKi#ZE6z(3W%UAYlX6Omy)pxTL5A zScej*)wmjE7ExMt9#I4s3PMwpleEwph5*JT3LC7r;ue&tRe;2j`rhQh5E zohMA4Kud7!pq11`zu2uJ=_=Xc)|_gEWxc-Xbd`Xc%!yHfbRujtn<0}p#zuzg8GUP( z;JO=m6~cLsB>|V2b>)Z()VW&tSJS1V7(s!Uf3gITlCTK~gZeM^pBNIUH@LKI$Nu`5 zN3dxw0&NEBh^wPpW})GFyghIm2K_BToo83o-_I`u*whNX{J~WGs=y8Tk;*hM^(#TH zHC{<#a`hjh^-k_RN5(a=+lYc}!?pA6PR&0CaJpY|u2IPxPmOp@H}!>E4?~yc+!4(w zg_`rQg5G)AuKj-bdtcv6)d}|!P`?epowxz%pwCp!46WH2%vP*%S--(c+R{Nt6e1Ie zBtL$0aPVUQ?((fF;r{Ptk?I}2Dx=G~3Ja=RGk1GLd0RXC5V0!Gt%&sMh`t09vF|@- z=+yqe%KwQ8m_*iBuEIrBJvN9G|0E36LMGmGM}t8%CsLJ(Mg60yN-P>-N))0EUDCX& zyG{|4Wml~G;O9>i(=~tHMJq8A4Pv6}++63ay0k%KTxp0(#;E#a%SW6jtK;q^WWzxZ z+afJg^InMkdGui|$_Bs^!VmAmOeq43iQCkXwj?v0J#|y`MGS-dFiHNV20S>^9CRPC zFJGR>xR!K2=?8*i1}KLjG!x-;EhuwN)Cu|>3D9+IZKx>?%LH!XxO-7!e4tfzT9_D-i0V2gKr!5V2lcW7OV%gV)DBXek`Jj2g&# znv11`kqDc%bKi(={lJvGNs_?C>c2bF7X+qWNEeCfN{0+i*Y1f!W?m55Y=BhQ*3mH> z*3#m1zbhZ1S%L%&-|27fHhGH>v}%3A(BXj#>THK>n;l%qFlRBfzjNSL_%-fc{`Go9 z-4@OEN@u#((9+`D80UB8y6#v>rX7o}?4e+nmB%yqEy+)LE2`S!oJXT34wNHG5X$%! zmL<+4fys%_JBJY-XXHbLE=g$L4#)mAWLkj-va|E9Lw(Cxx)PB_9|TK~3%EQ$gg^YJ zJSRDvT}>J7Du>S~OP>iI$g|hkKa0R(7H$&n`d#^<+<)q;808ohTzwIl7#~R35@78P z9D6?JhI%p(Q#=3KDh3~^Yn%7uC%niEStD715-w$1UqX^^|6EeCNGm9~w_Rsc2(C3k z_fAHE2i?FY#X#)bJ+(Y7w)asN7ZsNk+qc>H=G z1z3Iujxh4XEkA`;29y!}$A~6Kf8$F+{8`Y;GQ}Y*T>oV3xryAf_Nuk%`Mj9Tfln5H zcS}EAQc;Vxyz@&OU5tN07X*KH%3TGAscG&&+&Az8Gds)BF$H2iHl1XAjk)`FAl{POs}e@yW@I!^iZ zQFX-w_~=<2zUkv}eBgMdZb2YZK}OAT4*dOh8=dVhU%m{j`@e01GLcl;y}j}6nDQ+I ztZrn+PTeg>iSR> zsnc+K6It^I8s+*|UAN}RQWeAl99kYzjv>n$e@ld(OtOGu{szf(=7hCmwQM=h4aK9u z)0@BAcZCI%UuO-3uGZ~|v&0HB=^j6nS>QHfEM%LVj#&NPx?qGu&voa14U(;#8a>>9 zDm0Iby-5qNC&KpHoWE3L@Z-GYo9vhv(|XqG@3Yvfmy|!9Y}*70s7|G))%a=a*{ceKiupV9`GcG#gh8?Jagn8bo|CV{XhzeUa3NDWp|eT(xEAi z<9V>L-vEg|n#Co32+wM!s&G;q_8P>uF#xGL0*1Yd%P5{vHa}cxzj1Q7Dh1)FD>&YI z@P(;hyKe`R-}m+P$NSBlL!2*K2@!M-we+V@WLKry$r6n`p}&1w6vY%+>yL^?S7Eyy z0X{NgCBZ~=Pk|F_zwJ1OdO^YOQj^)@Z-tLiafy!8-EylG)4k{*$1B{mIBnh$E?VDe z?E!wlpq$l;)ue7x$~;b=-=CA##0wjJbGt8gw#K%-;zvgjw`x;Zr1=#;t=wzZGys$WGQ6dPVaaHFQyBIv=z> zY~O7fiJgHf`t{{oznM{wO_{iKB5*{fDinT;g!9w`OVc<@7s7+Sw0w8HF!=7lHu%$_ zp7}sU4$M5oeaZe!9UBkNC^C}ZY=io+_pqx3OKqn6K#40CC&KUl_t?v){&iMVl}ato5MWc$PhluS5K<-j z*KorggW(3R!wl=`-@D|KhicNK4R}o`ceTiC{a()8)HLo(t zE0xVY9S0r}1?D%1$THLnBy5<3E#r&964QB~Ta@xL*cq>zkp1zxmrPl=s8sH1W@%Lx zp|1aEZV8%)WSX%FL!IsIWw7y=Ire3R8{;GB4r>UTqT`FgV+`vI9>qibe3CwSrZs z=SqXz7^0mo5=o}cxE!V^_2Y-ybUAh1=hV{^x?gvDpYYg6Ws+)97xp;pR}PGY*-bM= zKWRrE2MfhboFr0JOZ+p=-LhLOkmVELFK)qI{HZeNJRh=Bg-4Vv9r3JwH@a`x$#R65 z)2uIioTAidG0jmEZ?ApV@OH-2`BnD`J@QtPy z_n9mS?`^r?*%u6PtRo! zrRvn@jZstV)UeDHx$VvCkJRGDf3A>$y6V!(E6}Ywg3*NT!p3D_W6E{zHX%OI_ex{ z)&e8%eg{vKHU*v{A;7QTAISrzYz&JbHuua&(dPg#zNn(IXYYcM0u!@>pkE~k2F|ZY z*56OSC+R%gE?AiFv9Ep5%XeLTAaQKXgS@B5RDb$~du3Nc@qR^Gop^Pvp%SF1J^#_w z)G+J~X{6Dlk9Z55BYvAla&cf0%4&8AzC1CtF`lI_DI*Zcd^kO2V4<18<25L7nc4B5 zSc1`WXgAu;SCOn)kAvT~ytYdjM;jw#e3<0+_noSyRpWYp_U1@Fn5gHardjyuh0Ibc zj351X?XoKLhV~K)x^Z&J@&Q^o7neq+tXU z-jWync>s0-3qrrBj}b6b$`ndmYDDKv@0ovRXv;;HUg;APKES{6Vz)UqA_C(2;@z|j zx)LIk?gst%qhM`ZnWD^@f^zn1H{Ew2;=>TYN>3lf@wI3X^rVmbK{LgBy^Z2W=@_7Ru zR#jOc6c#(tc(Wkb2z)S3j{rZvUzXOS5wHJ(|HVLFoR|Kzu{oMMU{5<)hfR;Cudkoh z4pc3!+^4{LKo)mF#aS84M{H2 z@08TWaBKfwy7BwXJXy-GSKIX;IoBm$cO1G$=Sf>;s*YS#tdi!f)q;&yTrc6Qqs`b& z*8*f$8riVQ|Ie>G5)0ZZiEP#T^gKNOK9TP?Y)msX_4YPi`$RZ>SDmU7hT448tp&PbHFwqy9ITYoM>9Ty8Gdi55GAJ;}eIZ*iU%OhBO!RT-?K+FnOPhiQL}VTs zZA-B}kSP88$_7pTdy??(u?2H%Sgy#l)s)4Y! zG%UrAZ0y2UICb(r-XFeEAb+{6UKX_a?_b!28*|n}ME@J6wh;x%$H;2J$MimAK&jT9 zUkM;dFU;Bm#kZq4N7n7af-B#eAd)P_z0>4I%b<;k3#bIAVWw7P$Kk_~OhFV-9ZBGN zu_O6?o5b6wid>+{HH%nSZK2+46_!x+ecH0#&xcC^MH4^lv>8dK;fXEBXbs>eP0bHcrgi08V6I zJND(=PIA)+Gx`Fq8z}ifPh={yX(Y8`;3V z5QFK2S=A}PGn~?kz3JtR%L;v)02oV-)g8Zp)HS<_CxNhemjb9Ce6-Bwcl@$qo?9;) zm43MHb)B3%lc@j(BDw&%Ehc2%H{Z-!5?bKXnt9cQo$QyMeinew}O*I|Vl zcNs)sc{|o|e5Jezv>{aN2c{n6jzGDg(hAnJ2Gl(a z-}h;T_&$yr2&&L)L3^QL0C->Ys7k_=tPsZIPj%r*3F-itrAFXnb_lBU z)`M-zDd2LE>W)qFZS8E$v!em6y+Z#cC%5oC5J=C;DI=m8Mdf16{`(6zj3UczVB|_s z6ArwW#xfx2X=9LBLheZ*JWkkgVL4AfEZEI-n4;e~y)lg$WBJYIiTkX#nefu)&%`$r zd5{98cyjEV*!hU4}nkE2^q~Kx_~T=$3!IA{x?H@Pl)LM3pt{qm=UQ zWT$1m!QJaR0bhUiS0;^sC08A@Mv<~)_!SPSO9eJqq_unCQ^@hMX&IXy*r4{k-IPh+ zu6R?aMtzrT1I^G+S7OLUNVZ5&oIp+82p+5%F|!!v%T!RO3BV_*w^uQzg;D9uf6kz_ zEYyfpd&Gwv5Hk9Zkmo5%=|Mo0AVFD<^JReUF2+1pUg9bCRQ^q*tvrz$;S)ou#^bgX z33f+69Zu1_c}N>BaqEf(1#9K;&QQq)egPx%YYyc_yU~G>-0D zv#PAV}oWj^I88jLXt>myM%ikGwxvtSgB*4 zw_MwnF>i!kl~XTQEkCc%2?QDa|Lf7Cfv7f6FQ)cEOepe!T|4+neM*XGZJ?O|rrRt1 zu8cpftF_K?qe6^~l6;V1W|gX%lTrm{bG`D$xXuti62dj~x6G0f(s?vA|Gs}m3?mv7 zin>6?Ch%+P_5Ae|m%(cxQ$KC-!4la-a!gEi9~Unlfk(@-`f!uLQKJ`=N)gGurxMjp z`e4w7ga>6jteO7&Tza>`rVZu`kzTUEXNT3_%*a4Xt0pB)r*}crkSC?ozPX?S8b{`l z!Vh(i-x)vxhKxR~-XHdF5&+8Upfd<~Wr%$QauQJo9Y&po0A`c zp3!XkId~<;jh>)wWVQ1_pA-UKk~F|Q>*qc3IY2|z$S4_`0ioyo%XURNoZ!s~wk z8c}^fArfJW4~kG(GHlIwNWJ(s?($UL?^utAFN>uR$Y5Ux0<+MIBlLe>9NK#@I0zrm zan}ZsJDpnIZE*vGP+am*F1cHJ@ANuGc2UCT+W6zDhndAghBqGr&y7@%=3e9Z3*7>n zfi7-te=O*btR=7gX|l^#vWy33QIpS+ps)78ZUF(JN}OS#)AAr6LQATgsZ(3!u_o@U@?Q+S{q$R{+#dZjNoXe;sKRMwiu84>;v0NySB@-mG2TTo1oT z^reAn<`Rc*Ryiu3hT5#kv|(WxoY-{T%7S^^U?n}_yZINNcM3Ne&NG97FEQfmOrTv# zPLn>d(D&kRt$T#(wMm`~Nz7sDaQBQ>b{{@|v#?sPN2O!nMln5Ds!SCcXoK&aSSqHG zLv(;@jzB7b%z&Vj;bj(hl?wMfBABu8)X(HFcw26+%RqT?8;Kz%^qizdNoV%I?_0fV`O8~h*Pq@iIxaCEdaA+W9(@h7edhH3 z5Le!hMZ}npCgv600DYkIy6br8WlE)Ihv)6V>^Q&QO+RwES5eL0sTN%g5T#RrU;qc!kXi~kT(Y-#DlLkA5EvQl{67;?j-Qr zw<$aN*?+C17Pb>dLW%QV{9)mmsktHOaZ7~X=CneJyNm3wP~cKyCHt?c<9GHZTS9Y8 z&kipQpV}SKXA&#-X4=EL&zM1&q1Sqk6ps;hD)gX`GMmmg&!HnV!PlYmvZL9Twd3+j z<@=LfKs@SO#zl+Z5c4cP#|*!;tZcvjSMatVAAB_+_pAc%u&M3?FLvP*exFqXdY2M? z*!9kr6_YocH?tL5=L~-+)2#d4E_rClHu&Q5@%t0@S!v`ZzyUzd4qJ%` zpToF|Tp__!zgmAPO~GMFpDuUfYCSQAB4@?tjzja%rQxE-k`dWoyfqusa#MD--$>hI zTIm!kYK>?$cXn#;dLND)wz5wyD={~+6&x?nZ*JLro94l*xQI*6*uc5yUtR6n5qlK2 zRcT)E+w!;a>KihxFysc)vh_Tj5tDN0{l!M3Q6z9IRl4#@s0;mL$#91JA$J$Ih2!pc zA$kembY_|rcX>XEZ@vcp=UINEYz3h<(fJq&h|Lg|F@21MW zA@p4qdGBm9CR=&K`G-S7-L4QVI1M~>KDhmts8Y7=Q+7sUQuVM~I*0kl=rzR?4yTj~ zJ>=!jX7%;^D|ZP_S2=;>P;}^W-E(nef+jC7k60@^esAwu*!x63Mf?@Go5jigEhlpV0^T%TO`TIdULL+pKb zSNl(@?09v21d@S#K+N4?<8Y-IC2xY@s2;Gb+s?zb)!;Xs^z)ct zxX!a0weE%XgdC6tA~2Lk^E{?tehGUOQoQ1m<6Yg_)iYOoV-(>7e}SIy%h~=AGN*~I zQh3QWg0Isdw^jx`H!Px83B7NZoiDz=!caXtH$nf}@X;$jLqYIU z8@$_9LQO+E7%cy*ysm7gM`<<+ov2&0X3`2`~L!p%s9>3KkBna zc|Co^V={>8I7mjW7rk!$+_&b}dn6H^;z`~4zEvI516}oUWS1+~ zg5!L%Cw9rg7!X~ZC8PVvlYIg2Z>dr8 z+mb8xd+J{vt|yx4gk?3Dl7KvQ(=WcgvAZU1)`fZDl{CffJIuZu-z}A)!%6-GbAH0> z#zw6VOK=yFobY(;PanP#_GJd`)LYN0nvRwken#2b${)4ry^Tb2WIlYtSBZ9n zk4FIK?=2na7qXRJ`Uh;eaG2YJQ*fTPc`*SRw9>u?-FX|};JMyu$%cu?Xp8p`a&bit z4lI8qi4}pzPIk)^aX))8cfz#>=<7@BKkyo*%f!qe1;Rutwd>z0DI{rAP}T-&8~hPv zK%4V0Uophd$)DT-ELjS)TBY6VH=ccb?+GSf8r1H?R+xF%)@T|YRE^)u<=_!*f7*l^ zIVg*lT14#3-&q>1lMqP_dqxoBgQ1q8tb)HRf&n`=p zW&6e90cESqSt%BvA^Nc3u|vU3o&47yBtC{L35x_1L6h(hG)V_7ZYd z^$%uEOXDw3Us4b13y?vR<4-}S?g6G+Mee&FG7YahRQ|F&T&W~Nhbe|#O=$J^O%@NG zw5SSA*554X{SF@yzW++p5VbGh0hhMt0lxe@-&-I+wx{sYzs{b8tP)yau<$EgHZxDy zBcz;Ig)tq6OC#H0i3H`cK28?3LaFZ>v5NPMNM)QUfVJ8(mMf5TIS;wnn@}Fm$h^x(w((dRcAP;CW|68+ix3qD} zqulek&oe0e zWU8&tOr2^Wehg?y&&y82cC!_s_%*yMXw@lrpa1O~iP`m?8ry$Qb2~)D9lHeoNO4oZV*MaUtXU2&z)*#(af7m+`L{ zBlz9)hI<9Y$9_%}gm;ooJ9LGk%Ug&U<%zB!lkMc#9~JQYBqd8I>nR~R$N72>sS(<- zW&C7PEA+?2{QUW*^KjgX+ve9bi!BK%r={s>OUWnZ9DD*X@+4SzCr= zQfW+Nc)DP?jL_nWQj1ajVUl@X%C2oPO8plr_)U65xkE*2@b3pWG71Wp)wQr1%og!S zws3H|18=U!;!{5(VR$Ws*)$UzBj}cA+*o;InYuB~JVwQL=8)U_vV!XfF6?_f2yiTJ zSu~RAG~?|C0kr-dCmKogfsve!KUYN9Vneidpr8Im_$EE20SGyLv<__MhvpXlE`=F1#aBtCj0!S?R$m>-02lfESm| z;ku$y{*T`Y^`A-gd`w^ z?OU}gHLN3+^`5(#`1ao)AO;=tzG8r~F_<`3*sJoG>1Gy9mp&x07pMJ_O{}HFw_PDZ zrrm&ZNBJ3TMx$Aa=c=cA(N!Up6|cibxnFP>hozXVb|-xJ+`2vS&}Gg>+w&mbPxxg4 z0C(hZ14N0&w)MnSf=^mGnMnQf6A}Q;84xpHYIx0k=wunT5uW9Tl$QtZ?Hvpb3+ptk zj1_D1ZP$ogkt}V#?|3ll$PR$cxyE5{?9WT@9%2Vw;p<5Coyfbs5ZK1~R{Fcm3}~zu zZH8dGVcML;Mx98{+z)(b(OT96tNW*j&{{!3Iei^>EdnYXky(%FXB9Tlgm4*IV zt0x3=SAMA1UT+{(4bTxVajPN;w)MbGZT`mcAv&F!k?rN24cQ*4Q`=Q+mXW z9Ou(5+zTG%H(m#vLqpDOa70`Re_mSg#nP=i+K^J(ehzdt$A*u<^PKmM#jagizDjdl z)f9EfTN)~tyC9PD#X@;i!)+lmokO(g*p?d8V6zf<=1@@^JcPdn)osZBlJSe{_Rw|0#m<_3&npNMIo&PNW@rsztcy1(&No^pWuuy z9o;%{c3Mtx;-8!k!^6EgQNsp>{$r5r7J2OZ<32V3&}hqqdDQz6kv@s)cxsM_QNsRD z4P^-sF}3jJ^y}Pv_DKaDAu&z?A?pW(%g|RBf+6$!dogi>o{~W~hM5kXEeEh3#gb6k z>&)sP%;E(GWx0LHowMT1*bmB$-v7N33LKYr+CWszz3BJp7!1vfR)#Az$^9xXLD&qd zviSk*kZOtC5sPr<5;G(krm7nyb zg=%-o@hY6!djSuGZ$LiOoA97@G3Dziomyw%jc1I{Dara|eC>U~vT=?^p*+iXosUN> zLMNd)I()+UF(}_hRMZ%4rHG~trVTxYn*r$Ye^)&Ht&&~wkGB7Zkkn1%DYR6gH^6_s zyz-p>SoAawlnvdWC1km+87paW&A3_HKYYyy=YPIkEZSX%`xU56=Zr1JYE(V^Nyu2O zt$E#E)_=-ZRx$f+dMjP-W<=v9r*@E9rnoI1C?+cQIc#3yvihYedov&uXI55f-(Mxw z>CGJ{-%BmJRrm6&tQ4W{XO5-3b8$bMv*a(gAS6>$%Y-vJf0FS;tJ)yMp<gTRL1GM65Pl=;DgTh03{H4D%=|~VYQG!98V!476!;0FslFoIyOQlp+ zD=UiCURMQg0>A~%?1PN@aqiJ80moVp;uZIX254;EoDjcsTC;q0p}_h-DqsKe zD0ZsgU1rik8pZFK#2kH`?qjxc^CrcN%-+sbKVD~5mKN<$zcEk7=Ui{oac1v$oklH< zmPv#XUp3k((KQ+k9J9RH*xvrU#?#*qLJF4#s}$;}kIQb~(fKtrJUnbPsvE{p!2xGZ zvGG2g^jlB<^5`d0H;|qRq}%9pWf|?djgQxhJNAyB?f*+J4E<=M5k$>QW;ZelK>X_1$nPSon!5ZDV!zoKVDShN{#_{3$VK*mXGc6M$ zyC)kYM)h-uaLy`FJ>Cim|8j3jA90sLw~E%5!1}wB@^S<=z2952=KP=Ki4nohI(~}z!T&t<^oPs93Z-Gzw z%kj=g`UdjH-rB5`_IK8pdfM^E2M()IRVGXfl|avnxc%)inm%p2$zvg(^|ey~BqQG$ z%K`Ha;nS1G>wa40l7mi5c{GWOxZJsqM8j#aX5}#k3R{-b4(awputr7*1jDTosI2Cb zBNTp>Tbzt-3_nkJuj_ZNcBP#_x7V!kX{RQ?#RX)rUa$X}>F=5km;*W4<%SAT&Gu>S z9}`(6N-0XW`7l3a4k$_=em&-Qs+VC^yPUTVDfshS#hu4ZEdTgk5EHzT~i!0zZdx z-%pMBMR$<6U#*Q!C@{3UXJyk>#%Pc)qLHO+9+emUu`z7j8$YV1E!%2On{k#Tb;;9L zq|Mv;g{I#AqHL-ZnK6KcY37*9ZdowX^y?l#h9+08Hnc45$(Op_?=`|reoAulyaJs= z>7~Y2yz6E`S*_EjT@ST=CB<>exn8%|-whsUe<@c=;n;&$Tc;5Y}IPg%hdw<3U}_)NKxXxnZTVMZm$DHTx@O+6M5DXBq^yjV^n!{a-h?aQwb_dF`X2%(kFYN76 zTzV%>pQffLkL63NRM{rIN*7X9{xw6zTFlIxXQU|>k?-WQ+xrS0kagKzw%F>J7fBLq zw$?B*wQ`Xv7Rfijq$hbbcRG23LF_!A1lGt4Wju0AI3!{Hw=%@WU+PGhTAx;og;pZ- zv=7tXspjcM2o7;eHKv)Wq*MfoX$4-9W!8B^^YiowBGzpTTLsWZ9$Y=oMj0fhuR`t2 zPY;bIE4m%xMV0Ty^Erw7=0p>mHecz!+JbnpV9-mo=jBq~F0m)bX1ZXww+NaBZP8Ta zzZ-lt+zjiIKJs}+>L&Z!i^1C`Gmr0(URvMYF0NcCV2?Ew=^NLih}EzA1{0HoD?bDe zN11xPj#abihMt#Byttoj#%bWdw8?~!_(ygPQ@5>tKue=i$7HV-5=W%j=LcR3iHYF@-HF+Br z)~DEHjS*cylzJ`WO-pKrf|WP^6l>2u7sZtm@k9L-alXk6pXr*C#>>&Hp9(zk((4^AEzjUH2&TW(i!#h<*m`>Sz zX#Mln?9a3}rghIu25nku34XwM%8qU4wQ0D?+t@(@-<|pHkppBnb(2xk{6bz!fsM(G zT*)x0Nb}*y?)z8)CsA3dU}80H?)g8*PQ9LlZHWs6`gd1`^31K3PA6Rm1dp>+0}bBW zZvG6io8B;jY?tNXqoWHci@C?W_d7QBaOg@li0y@FZ#a}7v1*n6;nIhX4sV|54kmHC zcsb1Xv5Jg8FP23_G-_YOb6Ady>LX`*Mv}9Hnv6%;Lk}!db)?jPr`T?Cm2o=|XQS7SDPGxx5gMl

fSEGy`ut}p=F;i6um(Wa-;KdhCY-nqG%h_Vo&D1E z@v|q0PG`{1M@rsVD^uQZadvKw{!2x@ZL$PAXUIbpud+x^alz1>ZBP#L?jWil6Rc7T zTs%3GJGS$7f_w#sl5zhJ=sp4vaR$k2lYF$vDydhu-LjlFw*x~)4QdlEWbvvH&M84t zy)`G(hu~5CRwq}RTQkKF(*xd<7y)x*WOwYu3hEG#t^3(SzMvvB`ks+SFlDm`L0(e8 z8aFEOc`a)C03pI}tP;TEiFcGeYHcfoSh( zqnS+#8?s|1x6_U-Le+QX>+`hVaHcvoSyw;y@W~N_SM$~Iv2!><44who)(v6l?1QPe zkMF@;@0y&=Hb3&DF1_z%j))y@p5$ij+@sUEiy2!@5`R}#<`R2|7l5**-D!81S{zHO z4l8N?qs#BSoI$2*{;xZatdedG*=Dn((B)9C$2^;Fz*`+Q#3Cmx+~8uyMT8ZrX8!Gz zYrg5din^;SgAL)@?RVwue72b^@R5N4ZX98q^<;i4s}lR(`m znM7~g1`cb4BCGn6T7koCwPpvnEt=$KV)^9s?lK(+KQoE!xf9yePII86!8?a$~ zbhLWSG4|Ome`WESDBI=b1#?8oQEhEe4Ud?gXm?Drc?FDdo3+mqiV{NeiFq2wl?7DP zyT#52n-m1D<+I5OH|XCT>l_68VnPlD6fU7HmWaw)O%cKk5CF>1?SVg^S6w6qd{$4* z#19IpU7`B5l!3+NM<3biNO)a47Z7y(90S?Ka^AXcsDzrwd7l$dtE-vw%KN~PNitot zx7WCM$hnV)>VT#8))fkg*#&ZU&E;V}+HbGQiZC^2xzdKJUM`Ts+(l38$`xx?uh>|Q zJ$LT-<{CG1Fame-gEeI-c7U$@y9*hNUhKh!@sQ>AIVWjl!WD^p>#S()*loK^p!x1=(*O9$d}= zpDYLXpX1}!{BePswcp+*>4+qS-2NzXI{3p^{(JuFWt~?Woyi~|4K#@UM4Xjff1j0g zm+C(Gr~P$IDp}nTQU6dkcTe)!dKgQJ1Fum0*fqj+u0;xzDOf?C);KSl)|P3P#1$Ih zrhh;!Syu}5n@Fg0IfEi!h}xWi5RV1K91o*-0q_1!qQlsS!MPEf;SaEycfj!=5*d9m zQVi@qMNsEei2U_g6?xdHuVN8nNv@Meoeui@;V%nc7?=2MoH|Xv{W=Lv@NZy`0XVPs z1UQRY=;pR3f*ep3%QWb{Y9rox{wc#c4L9x;QZ@s(*}Q>h|r4$=Vdf z>!}17zQa`bDr*tE0X{f9?j}%5T~SkEJBkInji$3_smL0?Fm$iAGBxs?*g~&Ia}fgP zRZlu)i6NGW9&T!w6=;dZV2>x7)03GfB~}yhTvoUVt3HB(F*Y?7fX(YnrY$plYusbb zx)^1DLP-HPh&TL?Ff}@jfetG!RgIatO7Z>e2MtGm@8s0sF<@X>Qowz znnsS8_5h6G0&C%M%`^%2>tNNNCAeWY`_w95ioNN$@IAyTD||;CF9IJv)P9<1BYR3E zKAUF}8n?j8syOubVka2fp#tk0Zva6!W z`;B^Bd};$hh9GhkiE%?#PTY{Lz3pIg{Ky2|VUub3jB5|nQ$|w4zS%QIn$pG#n0?sw znu2WF;y+Y+k;}XSH+J1tSo!|v~Jf9ZP^XE5X`NK*|qz%2am z^70yB#Hvgt)R!hvDV$!_N|tj=6tf?Nu|4_k&yRZ4a-8hHj}SCjkj-s=JPA(;8w3xL z+#y!-p$a5@grEf9-H`qg+*y3W+k|}0BCse)xPWiCK0Sqx z^X{ptr(<3tx3+xc``tMqxQX>GYz`Q-l{XZ`a)<&YqiUi9qY7Vc(h29qixfLcn6H&` z;!a)sH!pNQxi+N`QTdLU#Yn15mhCg^D!fT+ikKZ=9v2Q=)&6zuF8g0bsEsqqX%g$! zt(%f~ws!ilL5NL?$I{hpR%?DS-{IM0j6)d?s25stUBW7P*5!#qMMwYk=b>8dWNz14 zgDPxhtFQca^BtZKcMZI!banF2k6!w~G^o%vzf7MYQ5Riq@|1pKvJhk2TmNH&LZ)bB zSDvZry-In=0m~LF=tE&nwf?J_UPoj2mf|XGU(c-eK6!i_$a8;I*^-f^Zh7Z#`UM_% z`(Ss1ISA7nkYLbHEq}^%6A7BYZ)HUFnGjpwWk>Toim*=K_wJt*xs`)|`Y9itwL`z3 z^WNd%Ijo)aG3RtNvdd|xsj2&5xWa#^%;fU*T>Nm3I}Zo{kp1$s6X|zsTIZj3t?tVK z*>bgo4b6`nruM9wzMuE_R|mKQ2Ipi}`+-YPvq71lzkZc*=Og)V{^uexse4yH+~5C7 zrdVyT4g36D{&P$G7hnKyh5y`t|I>QrPyhXo*Z)6v%!GysWJU$w14jCG(0>`h{oHkR zBHAH=53qrUj=&6Vfx964pXq#2zW?}ne_Qeul>&PFpJZGF!qHG>^#3!$@lHSBe~WNj z9HaTqSNK0897-XL1AG2Q@}s}$g`~fEfO7j*xslI?=hNQ&8mtH_Aj^9>Ce|v>yYT0Z zB+Kiz9;s0Pt%)WRFS+l|sz?5QI=Tz;!+~x!f8#5<0h`?5HIL=D?oc>R0|jI09l6|Lq()_cmq#G2@o1kzX#U%78_E-ExC3rkUsESv?;~K;03$P~P z;=igG1So*87LUC7-2p>j+LM`R>=180ML4rMO!mGWSz200qgzf5W1-{Ar2Q_#F5x2$ zorFj5?n5v+s?tD`c>Wj?elPM>YTygmKmEvM!c%JtL8_rMZ(q+c>qx#~L*LuO03dup z8QUGm1_MrxuV57eZ0RG466A}$)SfP+iXc382zl70RMzndPL#RT!P*#pa$(TZSdK2^ zZEB&@%932Lka^<%W@)1m)k|`iIlqw9^oWvuSyuE_{MW$D7oOe!@?U?xW-Zwv(QbCK zWJSg>EHjqQD;vo281*|!ka{#W*uoD=_){+XbFnIVg!eUMa>cPA9)ZVX`jYY2x60Pu~yq>~*zIL<}oz_UxKeS2xbq_~qvHv@j& zmjnAD#as^t|B_Qef|xI6T&aPH>DF?<@ew-dCq19YBx!uOAtJ`g`wl__v2K`(3tnzV z02uo3q{?}kU`%(2!*QDw57^+3o+8DGsPN!d;?Y%asx-@e_u%;x0u*3h8l+uG5IQ}x zH=Ec1&jpLx6*b{1eJG--%oP#GB2oDAiGpn3hmMHglQ+n*Z)d`Crq@p>{!k@ESVkB( z6TDo){eST(h#XPL_KJPx;4YA?8Z1@QBc*tB(1Omo&wt1IZj6)7p%X-&F(52 zz;(SPPJ>6YYnUYCy*FVY^G1tWu*AyHfNT_uH^2sHlZ1QC#{QX5eq&pAGbQ>x z@VqY#Jst$BozJ6LK!!@N3XOo*fXfpb6t`7?aGb}tB(M15xZPP;Dzo5o30!`Oi^o)9 z1&?4~@eA4MsaCVU&tVSh;NrpQ?e4C$C7v(;lu_+2X8$wF!lI)6*hHccRDQn-*X@S9 zewd4u6G*RtkF99QByZ%(@_RP#TDIJr8UjfGcowSU7O_A4aO)`~Ts~%mxts@|BqV_} zgoEcml0+0vS)v^w0{d<*KnAG4)DG~$Pg#8K6c+3e(B1tZ3n;-ovo-%9!7P+`lSc#U z1?e1l0i2WL7qTpVN)tR8!oaJqCc+cYq^buMRR=SQ_9bx)TkDc&LqP(0=;`UXEMjjd zw3Op3R#pEFc5m^Ru2=bt$pmoDj}}tdBom$9)^c^hKuB+jO&B$J&YoIQ06>;Qwa0xj z5oDd-S~>VN32>adqX^?Zo-9F{_I3s5pUaucTH@U8B^YDXcZ&Ca8?Wvyt^N^m-x}!w zpF$cbVTbSq8$jTLf4%=_Ctr=yoqZNc;inQs3ilJWiQiN{02HW%IxpP)Djz}c&aV=SS(LWC-6%ch(&)wP0zUicq#{)%N3Y!qS zRDv>olE^485hl`$NobI1PlikxgZ`k_y=?OgggvVFWf7uL8M{h9@RmV>^B z9g{lh!;2djuFkX=lUQI!0uMu3f;XrQ<2JLo#fjx#BO^)7I7c=Wb&$QsvmC9!*%2?S6Jj)RsDE`kDvnDK>(uI zo!U5fpiO9MF$P!1P@P>qz=r`oGz|hY@vZKIpg}NT|Gdch1m?JTez)+=>Qb(W^3}D4c)|xYP#MhXBGsbGL`P3? z4gk?5Y`)Wpy`Iq86S^sg2RZh$|1d%rB@C{t3Qgn2C5Wz`7|X*O!NxX_5O4u|W=H?% zeXD~Ae%EmtyN4Lbi*PYJ9@+=qA4#;3AkNxI%0gLZ!{g~-9-u@}BITv|Y;F)fw*9XT z(sDq|yrIyNb|=hxwBycmb{qLhD}~NyZeVCgX+=}9yBmomXjcY>W%VT*UV=>*(*jfkaMt~ z`<{|Qq#t-(zbiZUjak|?cKMXR>N$C51va8!;r}|qT}6s=L@<5#IAqJFE1@p=plq!_ zuqL^-*r|AR)rUKeggbF+upbui`Gwnfd_FDr_U(@Y#V9=-vLP>2?PH?d7w#sYPNsB` z-L(@zVl<44tlz8(;U`LmpQLrKl>=jJN@?U=p7fDJ}xc0k=862#1&Jc$L6pJYd$`` z<*mGWv5I(kLEZF$OJ&LdS)Xw!g8Wx_hhxf?P{?;#R#-YjD zXmFk4*m>V6RWA+o&g~l1k7-m#sc5_@Za6G2#v$s3qfB!5S-39q{>$nV{aTLf!Rx%r zdPE}5ojYsBYe!D&+x=HR0$)_PpyqAG9=RV||0C-qWHu36;KyP&3V^dtk+46l8r~lz z+%Z?>R5bkyF=dw8A8y!hWF#Bh*>qqC=~Axr1cyml+6~6?8gmEpT3-k|t9PK6UbPun zor`mfwX$Hws+&7|Jdgy7WuA3ZRCZrz|J72uuJ3+UZ4Sq$e?6Y9!!!Qz_&=M<{0RV? zkuVAR-;C{FARm<9ZB@SYciZ+SlI)KvpZmMtT{Vo& z^RpPD0Un?mhG*tQU&*#S4WQ#NT-1DlYM1^#@?{MJ=FXOga=MgxH4To}N`$%x@Ra{F zvmLdva@8iCI_SX!&07yc8v%3Z5hBwT)Xn}{2zYPV-rDX+w{z#y|M|lR8bO6hcy%$Y zk8sm#pPC&rAnX$0WPaMxu!_su$;q&PmZ{U=4*q#i^8-LhMiIEoN_f=y_~^p$D|fQDrtWu- zcCM`wq0$|a7}jkR$C&=lL*D}lZG*MOOX5Mfbjt_fiWwq&JhKFSEMa_GBR=x;E;-;r zZ?z9sM9?isxlK0IV$7?A8jG+z`s>c!{FmF#^aDs+1_L7^A`GX;{kXI;%Yt+!gFs)A zhr9m)vlZ~N=y~;@5hf=H!6sbUH@E62G{oMj`ycQK;u6fPU3YhKx3KV{o!nOE2^l!7 zZuQR2W+qIX4_!$7Ry%@&7PIe}&VO9IKo5i+2%g@M97`j+KR#GAIcxn zmLr`ja~xA5;G*Fb&%~7o^w{3ANAUeZZ^Q=#J+m*RdV70Qx)Di6lS^-P+>=bJmX~JU z{;io<#V{_?{0WW&=F|KX1|_gCS=nIpejzp?CrtQS3MT5>?C0MeGKHio?8_5c9UW$P zFKC?!I&u))H|k=ZOWNvR=!#dkN$*`cwCyK*eRFJPKZe#UV5Te`(bE#4bv%7w0cAX! z?FBNj^KSnETXR*KyV*Q?xQS@uFMqh6V6Hkhk#x@^Y>&{jc*4c$&!Zgli$A|6{`-H9 zj<7g8Ncq<@@&xcD0judE%<3_(DzWHV4@?gx;#dD*dKojlQFnohkx`5Nxh8jbBo8>E z5G9fX&?*{T?CuV{f+RQYz+N~M{2CZI3h5f(lL z+C$u3ePZ?wOxr7Yi7;J7t?nmeu8m#8;)FR`b6mu|Y;0VJks}@!_tx8*VbVLEPj1$Q zdmOTmob@g%;L$6f`ZJmx)q`_H^KZ;m^sf=5N;n?*qTC^NF+;@BBSy{?;!X}`(xmFs zDlKqpCr4K9fuybpPvAE}TG)edktgGO{tAqyoXwr5$9{ zA)j0))(;p5+~I*YmL(iU3H=6F(yu{AXMXh$4*;7CETHX`c_w;MYy~_(6lH2e=G{lZ z_$yxM9=Xa1?G1Lu0Bq)cH+H{5ULQJ(WF0>YT`Yo$-86gz zm8RK6Ta0w=mlyAWqFazW2zzd%!>#H{N|O=@_aSUMvF7a6QfBEC6r0=5d!@5`MttA} zj=|ernM_hoidf5tw?lI?yH$r>^1!}4i2^~`X8OSZKpx{#ufR9UbF;IA+shO;mdSk-3oHBV1{3v!%Sv#LItavw0OyD#v8Z+2 z`oADca&SWB9AB&+kf}OCXPZlmU6Ybv9rONr!{w1S2(}w~iCkY+=m56PEW;jOh#>-v zProe!>il8(ArDef6cE~RkOPoEIJRQm#tUwJ^fI<*UXOQb`I6B$9eWpu88j@pxf3+g zeL?IJX&nO*Bg|>4foy5w*JpOkGcI#e7dp+h9nE;Bx-!)SwPLX7lwHJ(3TXiT+Iqnh zPvSHN#9)-~+6h5)h~j5mrJ>;|d3$p^+#5q!=cyMBtqK z4(f?l4fc|vWH;2bp;X+x8-k)_hz3^06)bDvJekj;0l85{03#F zo|iva!dLypCCp?a+G20)?-vU}P*`dRG4DmY6<#d4f!2#*>TYSE>R~1KuW&%NC zhiIp9%}LN0cm{=N<-*rKWDqcU)dm#tJh7>xwhMw;h}?~($-0XK-ajd>*5$2U?cu=q zyoN|bo2nvoSC2Jt(e$&1P`m{|@Dt`tMf-6l)3Ln(@qz03N%fOr6oYB>G|zpJ*${_I zbIE0+bX-`2@hPK4m{kO8L+QCa^fgPkPoK_*t?>Lk3bxZ0${5nHN zyA?gkFJo<}5~lA=tZ&oTxFDl$&!Dj!jeXdIPp03y3t^nq`8;J9HQ3D21|+b&R|38i z37a#ICWzep1a5x2NXRWqqIm)QYf&2at9S0(NNX|Pa6t#$@esWhs4aora`HLNZh~6h zRXe(@K31ar&8z2Fn#IC-vH>NkYp4i!55O3uNTAy~pb@ysW;@P|bSZB3S!i@mi2Cfa z4rX79SZmb2&Eo!W+DW9364{ZD0|Am>^8N{kJ$xPgPK^vO(!`N|yY(csf;C|fqm^?V zxT1$7MOrRl_*>|_0B=H@7VJeb3|!4|d4~elu*54KsZp(>;uMN>6MT+A1pm`hY|(9r zDHNwKP#*c9$P|JxOuu9hk?K<1pZa=jdc84h{j)uc&<^|IH2xe*#qO`r+;K31p+yZ=^~j9*MK0ra2iOmu1_RDoKG>>fIRGAe z{wO;8$#xNvy?O5e5CFh<|tu;~*F$)M?3xS0zCy`d*&AdS1NJa3#G)^K;@Yi0Ro|!~ih4Cx!JF|0=&L=#t zBqQw6zaw2kOH@vp^HHg(C%F4gAC1sa`6HCE9F|m%1KAV;)s4$kTQu64Lhcj7Rze|I zEX;=!wA!rw>smGB8n%2e3!!ua!OG{ET9|jTdNhDLpHqjT+xFJXex^HDEJI>dcdZ0J zAkt~haz6Eh9p0aVgNO3-e^M>JHVRjNb2Jicc0_e>h08cE@QM?^^zEo-cE3RoaX!3pd!@O8fOvM&BFJ(h3^1GnaUl`_(Qmy zbk|qZ3ew24tPkjYS}n@)H{j>=%^x+dr{;z5Q=2zaQVL!> zuJJ?8x<#!%=h2NY_rweNdwsPkwrnf89Ry^jrV}_u@8F@D2Ynx8Cq*7`M?dkRsK5@L zT{$1_c3wR&9Fv@Zs!GC_nyem%TtsonJAAiQ9Ele{13kIUbwwUP2;)Xl(%P>D?C{9X zxgd3#ow^&B)R#*9w$5Jh$;R~RswcTCrc4%rN6yJ0|H8kBobZpI&-#`yOdWh!Ey`ix z(t5IH&)H|P!3ZtSD%P?Ya@EBE6x+=`8=|(zt0$_)HhmjotKs2mhRw+%lS9}n;K(?F zA)>OV0hpA>Y^FB{XdK{USCQ1(`tb14k|6|bVKH-&Xq%kLt9zLXZQ!?6_?J=dEPKkq&AYwM?1I@>0{SL^KM5*! zl^C4$qMCm5gRvEo15M`DVGr!ejf15(Ttefk9MqxKazz^D!TDTS_24`8Rsq$LX)5p> zAu(QdIJ2P)t`&`kXXQ4O#&QT?~Hvx&|T@<%+8a% zg=@)d4~ciH5^k;|w}OZ;zF+45em!Z#=kwj-B!0oJ=gZ;Pu7M=--DL-m@65it8~Y?> z(A2^Aj6P-Iuh*`}4t4cu!^r@CBCQnOXF{#c0wyXt#%(Hh){Lkn(W~~ozK^(#{srKt zdjdhxR)8#gd!iXsbJjixTQUGe&P^1w;udktC68i5_D4nYxj*e7vK9D4rA`^Wc)*eR zh$uy>3o>Vhlx=RU;)s~_Tr^JEOiN9@4~Ih?i;HymTA-8{I+(>A>Z^w_?S}K5 z?E|lB#iJuPm7UBSop@|+?3|j#2qndN$zjRLWZ%QG$NV^RLPcaYczsrnkl8k6>`kF@gLpeJ!UxiOfE}z{n+t-*7g0ZO*RC0jDYjnInF&sVi68bxISb`yoqU?K!O4jH{p1F0mH$j1ZOkZb1 z_K3m*)cCc>)kCmvoWYf|*~my+GJ#qD)}$ymQ9@y_!$$=B-ZdC6 zhnVNo+mscE4jSPpj&5NgA800rxL-tnT zO3&)j>bP|QHjI{^&fAuflew-hw2@jUm{BH^RP0_`x#NbXh88W{c)~z_xM(an*Rir3 zllovM*A+Pwr~A>}SDO)YTo9`QQ6hkcII%1t8JVT{Vm9Qb4TuGC{ED%8J|NW&DAKW$ zb^9wjFc>wV6AIzV-vJ^?+du_FznJq}7adyrU`k4)_G9hfb;s+i+ux zC;}7q6XOmvI;CEFnhMj*k)%p#8GB*GtlE3E+sTV)KevIgs5?!=^=l@}>z&7J3EL^m zhXTRXC;or#*O1kgm0dc1Wd4h2IZ;T-0yDVAMl2*L{`1I5=X{s=Y9z6qx<(YhyP zx5M3(>z&V&s7%5AhDc*KLeSF(>Zi?+bu--IqN^^gU>4Mxt{3-eOWKJ+;jf4rM+OfI z8q(U%H{u5Du4PZnya!2&ugg^9dZHC(1T&Rm8AVd|1YCYt+KjGGlRP~3vE1iJxt#Km z0%onJjIXKAyqhAd7@9705}X18jI88&3Oaj4)#FyyfX^&%VNKJ=r{8af7CY2|L*p7R z?fYG{Q=iVa7*?ECy84eosV@H9(BI$ZSXkY$G`jK<+!B$*8t%$0q?p8GZBJbi@-}MPm7CC@G(s5x;>rYwI1JtFX1Ugti`U_?uS{c)Zu78oH4!~0{7#0)3IV~CJe-GKx zanN+G!oWO1d3ll>SAR0uKAOKYZct7AX9n0R0Z#4x#asW80QcNLVBl|#*6JG}djqNz zGEN0=UW@@EiM#;Uxm(M?&+?FE?fQvK6}fEq<3yd@vj6DEfADXsqQ743|H46kb=cwh z5gv&_=zDm5#yEI*B$vIjGs*npudfqc_N(1i`#p4REmQ5j1DpwNn>J0yxKhZSu?rG# zJ7XubsrLJKrUkK)eEO?bjqQwW?F6r`Me{$q$Im{mFL7-GIy#M_(q9;t^n>kQR97T z-&R)(Z?+Y&&c#nw0M<;<7Tk@L4{1DUwPs=e;*V#WL|^{iZ2z<^*^@*g`1iY$y+oT4>+Cn{i@LFU(zOkZxp`Z{?P!U8DDwXq}UjvJ_5< zatnuZI8seV+3C4>B;I$@-efAgtAK4m7?9}$(%Q}$=WM6Qfmj1_2CL@zN{f`(!{K@SN|1Kr{&+p|QFQL8v zx(U9Oyb0}Wrz70jIZr`FkcWI>F|@I`m@V(xiLsXZ1r25}cs~k-x5Zez)ZC3zKW|<_ zo^^1rw)cL!WNzwjUDIGf(;Pdq^8q8v!`!+JX^BmIBV{7%4sgGe5DM8Jzh&yAWZU=L z8SIOC?T>y{<#?L5wS+pf=8n`>t?l0FnP!LOZ-b^Qtv4ktD6Z#jT@uw(P?;uQ+TNZj zA;Pu2-9%HPJmFyOd~k0u#h&-v)xoZb$Jb`q{>)(g{m~(3bhGqIWV>m-pvTdrS9)vE zxc!KFf6i$ohm@k%>ClpG8bqYRdU)?$3d(R{9g~ul{@_$be@aJ$m7-58*5i!o?x`@${(c zY5i)irBCZH{U9cf!TizXknA0jdAwUK-0%qCqu{yY`-tmI;EVt?y>5IiQx`Fq4|)O`=-zkl4p%T zx=6WJCu3z6U3ctSt2%%)-O%p#@0om-^_%8;@+4@W|ANBhQAq(?C)K=ZQuY&*r5tc9^xPJJR&w?_`L#@7N>m9eNtZuKcUR1PztTy| zt}fS_HnI)%$OKGWcBP6{-cKFQeg_)fE?=aN@VZXW)gDhmx8x5%wu?$Dd4x5I@f zPW{tEzAagu(i{9lo-j~ZB(IwrzW41Kn z$(+y?@H{T+aq>8vi_}xLbPHiSD}aZQ@ruuM`^C2&My7m&k=#ag`VC|akGU; zhG=Iy3wW{J#|2WDUmQ>U^tvT|B#Fp zeHE{M((JmvD|P$l6eE{%x48+z+bQ}j}1C3TtXY$me61!WK=GL{@(&pak6J&p$R!?A1B1~_ z<88VkP|PikE9ih7>ydTteeC2wTT?yTE{s_Mda7QAOytWZTrS1t+SS_drf~*IB*ta3 zZyFQCvaYr(Rc(ln_42#;ZZYQw?*6Mf#ertjk2kU_KjV?Yw!|7C*xgR%LL-ir6+D? zfJxeRNA9QdTzrNVhs7MH0zoF0_vX&^Bk*>rm4){8dJ8?6RDkC!ArJF^qyG1OsSx$0ts+>-F2?b<^m`j*g z`HAnUfJ3a-iP}6DsC|ElzvZ1lroCm61aWA-_JZ~Of_#f*7t6e+x%}en7-A(Pc!Tvo zkyDNdqd$K2{Z95Pa(qUWgS96nWj=!z`+I3-&+|$vr90a1)Qon}CNb@n)a~8D|2&OF z^;ePe*$Dch&V6;VKqYSUTad0No3+_uhj;RCDES2_21dQ|=a$ndt3zzamqm0*E*sa- zaiL{Td_OY!4u;7Ji{--cLPxO`Cp*nG2(g~@j;3u`YW|?*IBB2iT zmbv1qVT=-I^X?r@F{8d^Rp~WkimlCe&vOQ)#x=q5wuvJ3Rq=7f_)sry} zlIYoi9cDAvj!T^V_OV-DZktMLvfkbA&dsTg>6;xCgV_V*4<-zq{yNQXS9v3I!usAr z+OKmzLhT-&DR6)Ad(^kEai-XNk8z4$Z=L<76JLK=!Lv6`GfDeZZYRi=tP#%w*L;JxfUHv+F7gZ9B0<$s2r1p!c({t%*sQUU}Umf-~TBb{_$HwftOm$4+t(EkWyw2tAnAB&}h_AOzx)yT{pnq4lmyqug!~LzpJ?C#rTmRanm^CDpv@LYYzw;Y-|6^n^#pB`qO zUOT!wf&0blC!3irn-|@uFH9V+5$FU{J2fOxH{UJVznO+H=~~HDs(DV2()S4EryZZH z+M0YkEW9a6F(=iJ-K?!|s!OPxwIMNz_;u#gPT1`P+x>@RW~1m?Z+Ld8 ziDvm)+9nL#R(dON^mPK}ZF39`RIiI=wVQ;%u-1y{75@e$%(bTLnvK#6z3-E5(k)r* zy$StMm7_lY%3b{TRfV?o3@0omqF0KKQJhjFW?e5cQ}d@}ItBdceN``OkmmZ@ZLGHg@@ylOtC@6WsI18raQ zd)@fn=)Aei_+ZA-AnuT%pkt`oAV1~OXnkt6E&Pqn3TZ9Z3CZHjM)iqLmOZ>D4NX|dhF&x( zp7070ct>d!soW;+G+P~+QwfuBj)evDi8dOG*E7xW=i~YxoSt-ezVSSF>y&QeN|a#uy^QhybBFA+p$@h-%6^9)DD7e|77TYj z+ZK7b!{k-P!>)3r!0lhTKnoI^NOumSeAD`_&iLCi%5XrS&j&hyLzV<`IvZzJ>un7Y zSgt;iHHwlDAr@!UQe~7(zlR-H)+WL>L~>)~LkJgTqZG-UzC&mCkK||`h<&tW{c}pq zR{{zzT?8gd;scHv7R=rP9b93DN`&$@Q<(_vj2T@j_i&Iif<=43wWP9cu>e7Z#Z+)1 zXNx8>XpXgz-fNj2g~sG+GqQ~JQ-;o<4+fA#N_GgyGzL` z`vnCGvOYiB_1x4r`$1xG!X(3K{-8Ne=eN~D*XuVS>FCv`n>7PI==B8YpKw~oihs3D zbF8|V>J5R}O}?@K_=AftCcitD7dY@d*~Wat?a|EG`xV{3Fomc~sog1qBe@l%?c2(- ztjEGRbf(iMhi2Zm3jt7*TpvTHidErDPBmOU)3H+Zjq!4>Ubg+(rMX9RS7VuS;r$}1 z|7Cn>{axD^yMZiuHUKtRp<3!yP7J(mDx?nSf3eIEOPgrRU7~KTk}jakOyd5WIT2<+}z&ET8RJUVmkMQl{PTGl%XG2;XQ}6v|3e4JrnRMmx-9ULM0# zy3%Jy{7Wap`%;W6pWVD^dENDKySv3Mi`N}JIrwsoo?T(z>c}H<2f58NKmX{zw+0XsD zM}PV1m&t2{p?%-z7~53_rp7a#FKeto0rpnhSTet@-L6%>Vp&?QE@Y@R@$sISDX$|d zCJRtnJ7B=G^gFdm^tr*wb!_6G7*Xs@uCjjUGtv9=B*g7$n*-}(GN-OaMlFw(7m_C} zIO~fVlBc{d-@7;?F5OPFkKnAp;L6JX)7)JduixKkhRGHB(;@>OFpM-zmRPRMkGehf zD|+P!rk|D*jY`4CtfD9TCQ_{j8nxPwT&}OGLOJO$xtMg4Nh40}^NAvRB+ms4>$xqC zESN{lC`*KRX4DTIPY2y~fmQO{LdxXN+NFi*QuEwxzL_(_@_^hctg)*mI66{kWqHr^ z#e`PeT?YkLAWXGN=)UI)NT~v7#$d1`bz_}-%)lPNT>IQoBNv*^K6&3)8{9+`XQG>I zobp=Ju4gV4O@yqkv4EoONF6mM)_3VUTN+3^FG|h5O(&Q;jKaw}Fkw9aIbwQF4)hcL zG|3l6!rX?gx!A6gZgtx*0R|8g;aZd#vvI0)E0dMB3x~iD{mKyri?M{b+^LN(HV*bF zX$*a=u8^|`Gujl7ux|Na&gvVrP1^9BmX9~>*uj;YBDq34e-g^z?% z^gCto<@zWq8tVFr9k7V>1^EW-YG;;rOde0Hts$_P8}l6L3Jw4KJ0@&Fu3|T@VcWDB z-}T=mD=C@{MxO3#nZ~WYRJ5@6O0Bz6{Dhvf!)Yl1V*=BC1Ka04r2X5kG%|l>h%bED zt0Y6RkY3Q&N`uv-zmkln-23-quF3uW%EvFSG`^zP)-K_){G#H8$oDGA-Sh9HgRU-{ z7@cDSTGl=pgPWqpa8F-N=h2A_%8-Z|KL&x@9qYZ`6df1RxW>`KuD?*Xk;-^tc-(k=w2%J9Y8a zudEzbTSf+%m8P@a144-l6D`8yy+04?Bn|Wk91wU#8FarJfNE_|P?*wuo_Wq(BbVlr zn+j9^4}0$!)nvQ1i=rSlKwo_=bQJ|ric+PkD4;YIl@20OLI^z|fzT{iK?QxD8ItMan|+nhj)l!!527|=2bUrr@Hu?UrMbetH9a?I73dJ22* z@{Y4zN&82!>a~Au_Is4lM{vFj=iSIXJ#pSMYXHe*xxT+G`TaI%xj8N)f@fSG1^ygv z*V%}L8ogv_^WnkJ#vq`X6`VVTb6^71(#1o4>GK}1&a6vjzQZ10zn|kM133M9)A968 zaWhH0zKBB>AdxkWeCAlC-~K#Grmy?wI#tdm%Ti48nYcV~s!p4lm_mvSCyHUOqzT6d zv}p#``WJK^-RP`=^o)JwZ^$)SQsYNI8*{aqSse0oRVV{DP%;}cdB!{089^itr8vDS z;aOm`DzqxSI_`aYHU;MHv5=CL;P7hh%khTvN@sA5+N0)k6grUF(&zX-I~jDfcJ_4h zdo+aR=;Xfl+e6K_Zs!Y7zWvDyw!#|VzINVm1KL65Q^TD+sT4u=JLYtMmW`0M(}#$_ zJ<4v^5mZtNBfleLN9z$Y7;`0PxI_UM96RvW6D5sk0qHmB+QDF}8fSDpR=2H9b(c6h zu;|>^$M6(DQ#{Dy$Xf~+>$mFJ+ZRI!2+6Z#unZ;|?yQLQMlPcppK7j7g^bw4@67VmY@BF4 zW4>7qi~&9Ds8Z|mZwS{$nn8neP9bFZT-x=np5f<0Sl0+qQG{0TNV5}Cqw&1PFQu=? zy&-|O&YZyI+IY6&&%T0i9ti%4JqV%>DH<^9v^Y%z!5RCI6RwVcaNn+27> zozFIo;ULmKm=8-py?){G3F%k4UTiHeZcrM^K)me*YcmO84=5&V2K@Xah^iIFe0U}q zF;b)K@tA13HGK(4unN;_f5@g?rBAVvVgb>zHF=KoORLjALXUxYt>o@=_im8^pxfxk ziHJlL_XD4$<@q0|FDm8|^399DSiv)?i&|G(Cx^fX?2}15Y71ZDV3EO(BmOA|aVF>h z9pO&I*lck|9Vd?FS9es3(XCgRfGj5c{fVUWV8;Ok=_B)=^juFro$>YJj*P8y8lsC2 zoFzMAUvcpM8KEObG%$0I_=J?s!X!pIEr22Py~EDRAK(b7=NmiAuh8&ibpiP7QxlhuU40odu>9E59yF` z?lzD_PlwBp8b3lemVM>NN0YMrK`)DPuM8rB-p1B$-0|_lUZ_98+M!S8;?mj7f!yR^z+f6MqyM(@B!!wus%w#u)XT8TlggB~cAD zES~95o#x^n5}P$i#Hse5jmy^eMiiae+*|AaN>JH%{#!}i#;Yx}V+jsst3quC^q3s` zMoDts!m{gv6PtsWn>~S(Flritucn72bfU~GDX!ARfL0sEB?KDH>Ru)-`s>7w? z^auduH*Vo6=A=Hoxk|lzCq<@@F*>TP^qs!G?xZey+3sa8EQqmDOI+<6gM&CqextZ>h7}V7lhtX{+iJh zx<07PNZfV)nYCS#TNezIP_NDDmdib73^v+b%GcU6E zuq>R~icv?r67(5adnmrtC!mg=$f|g_7SuOHp(+i>QtW9kvtE8By(n~@;62P6^Y{v3 z={s*WC*gmJ4kzi zK6U^M&L2Q@Q)~794rT4#H=Eb|3@hqFhin3nXX6(hE1@VY>Y{5F4o?N@ai3gtsj*~`9nrb^=cF~xSXe|ncY&pgm4KnIKE5G>K)RdWjY+boa z+j`nz)q<0TJ^#Uuzq~a@3bORZnCnf)4C7z7G`B^heSBpA^Tx%Ld||HLQwXU*g0rW( zJ&Lhq=DbF5|AmgGr4u}e%d7JO=QFKnRzEA(JYjKEw2C%1h7M_2zctPJ)YPQ}Rfw*@KPsps$+7Z%yqPTf8B+ zjWc3qb#)^SwTv1Ix0*d8*#HWklh=&qb9UjR2(4}9`!h?R33{`85LHqaWg9K>x}37W zex7A#zuI`4BeaFo+xD#LLi4)Xza~$hHm-Mu#x!vfGA-NY_>=BKoyqV+KO?p{P5N> zB8{?zR@*ZfD%A6)AuHQ3t?ka8ud&jE0U~DjGT|m_u)0YTo7=Zp2LPY$L+bpvg;H=Lo3CDbXbFpPy7zt5NvA?;$hwoH{#HXVtZ>eLsfVYLN+@Zfi*Q0{Cc* z7?V_75*n0_8*|Hw61>I(_3-U;Ur7E}n7@%ha+@Na@|ujReGuf2n*7F4oGs(M7`!o{ zn$w;GoCONPL`3JGB%rkeAdyg%{!`k5tPehGDf!o`pS{~mmB7n)n|1-oDDDWrk7AXN z5iyq>pb9VX`RpU8>JcHR&|axyn*732F*j+gFx=?k(|xMpKY5fNRJ)j_HPg^YPG;W* z|7RgHST;^Y1m(=)LQ0|4<)Z!y~q`p-l}k1)A-a{7_QRPaeMu87_* z`)+#|b-|nB?y2y!BYNLL5mM=j|5%hLCw>J88#tK5knhlYLwv1i0dLRkrY&Mu7Ep@S zl>#wlh3ueO8bG>tQ%^1~^w&g}IjpHK4@ZCQDzgur4NF6X{weo%Y`rI*hywHF=#Q(q z4jf+Ee_r(`fo}Al54pIiH*<6V|9Q>)<0bc>kLyoz+}Qu?h37ES{_FMse}n(SMLc`l z3gmss+E_`W$$LPZY2wW8;E>9wIquK~GF~Sb@b0k#q2+6A5VSNMc7JpIFmg>1CJu6h ztB=|g-$21#(N_i=;i-+GN;G*j6y#;mvD?k-hRh;@)>GA0IEIx#so541+0qpmVil7nQB)4(6sait&Mt* z$gs(wI(raT?w=gmd4C@V=snI6Ewv=6s$NMUy0r0laT-D&SGCaY7oP4n7E)$+NQm0ZBvDkYrVrhoRyD6PJOP`$5Pa>&QTj35KJ!D{g>E5ju0A#_gl}T*hL5bY0BO6cN=LVT4()u-D;Qq ze=ek>`1xODLk|vPi?=wOt#{V}DVgYjRPe}V zkgOjq0H5s|j)!>%GZ*DgpS8ZLxvpuO1NR2_N?^pH6bFLgEh_;M<4Q}1v&24jL@Md9 z-^PLK+Gw~G3mK4Yd>TdbLqNO?eb#S&MeA7knD{r=?%k~J4&QpXgb{01;l*Jv_udvs zjPd^v@gSq-;9uj9m*cKwehGqwIT>*18GC6s+Nr<%_s{1)8>6Lw)ANF7`=0v?Zw?(C zsKx5D7pLX5Fmo@yz8t7Jnq_qNCJ=DI)`KExu>I^eC9m&?II)V#Gk7n{hH#Tv!bCC=sDk->c zHv46*j$_&Pr_;~t4}W>CxQ2mao}YE`@e6f7R}NbT{Z8uruK66-QPA=TWbtD&>h0jz$+mQW_4}D)EM*zCTj+M%<8xaEQc5+L>JFe zpmn7{;$=lnB>>rU@i=k{y1OS7XYdn9QI|P~J;?9@FEBfa%!#?beeY#Zo3#3)$FSzq zzPM>`B0L#^OEWJ6&wq(S{qzX*cCxOh9O6E)LP9uzOYBj2>zDVpS5)v%XAADTmSu35 zBkDKhuajG>X!UkhBPkhvdU~K8Vz45B#`JgY5U7W4m<>TmXAJ@ANb>-WmAsfv$dLnb z$z@_ma2~6opRrbzw-h+P=wPdatS&jLYvs&0J%!EZ_3YIz&jeSELf?^JsH5F3#ml9T zO%0KlVQ_AwSFWpXfX$k9+Owe9U#8Hs9DNVTY@Oz|sY-}z%fDixTQSEAhhPpX0n&)L zGu}VHf~OfLBLFVSrpIDhmG}`aw5Vu2bsvfR#?p8$IcMd1{AbHGv5t~6MM>I-WuV0b zE)E3TQwlXNE6rcgI5qO26P|OUK)fa4VfP~1db!k7lzczmsjYW}?0T%#P4sISRKu4jQ95JAyvXKsXx%);I;SQZT}AMl1{g0E zI2{)4`)E|j?`4r$I~NyJuda1rF#DWnwTi_tOI zIB0p1Ut~ANOCT1?xYD0BI;KRT+u&V@H2{VPK#iG!7Lv7Azhe#az2II%QS2Cu?8tzg z8P_-=+Q*e2kdpfQ;+yMyGMtE@Z{Q?MfFpiHIk}EC{Va6E5>NN5f+>A7J8@yJYf>Q? zUyb&^nbS;1S5g`)#Wk_XC(NT{&B+ynkxrHOc6;4|dVdFtU9l9H(B{ims>+-~%Ffbm zQb|c-+)=D+TD)jF?DpmWM6sA6_>tyUg$9eyNrx5g7)<+rf8XVk+h;ppPI2mX>KS=2 zt82xfuY1shLweOV$r5n?(xTox$RJYAFhSu) z7)mMt*XeIP?lVs6sBFQLisf=CPn#`8Jy)>dw$A$M{o@=bchJ-4;J^5^GQP$wFPCX; zrX47fi|i^;0F+-jl&OGNZcWvy$_wb1C9B&HjDj{c2D}>73u89Z5 zDVl-JL@KfR%tGr#NC(!LzJ3?jt_VD0C>$4LE_R_y#D9T$fj_C2d*XTSg42~ zKe}=9nGY>HXY>*kuBW+oL`A|unCOE)kk8Ia8f@_dQmvYtjH=N3s&C$WPUOh>8_@}n z*F*1-hq-`KI11B0{-7L`+wsBWRq zF~O^}rGmYdO0(w_hq$fg3z@uBH(}?|7E7LwJc_7HMu!yAKK2}n&*O!zP-Nl4vQyUs>dkxB>8cB~blT*$%bG$c-6 zv=-*hb~=K2DXHxHWhDMmK3Dzh5dTk)en>h#8V&~g0(mIP6-67=b?Q8dnTwE9qv~w6 zmdvX=uI2$5Z4{HcEKL;1!ht6~7;CPjJ*W3jTiPusv%44V@01D;QvQl;d0l$~m_d8@C{w>yPU3uT!l2B^(#y%-3Mk@~A)gFCIzlv` z`l5*EL3zoVXvMWudEWn>)=dDZ$Deg34pOJZ8h}JBmhj#;z8t$_&DHtu5TjZf@ zJ~sWeM6*)M?~GiHcJFMGcETF456f@h?v?Cn5JELFmBXDsb)Yg;V?)+T)1-xAfyRJw zN0U)5bshx1DyBrHAEv4wXUTk0m62E?aYZM2o1owar>Jy4v5@AZle` z52$C6rVeN=D4jWX?*;TiZtQc!!i<%3c*LC5mxa;zd~$)4E?o>Nz0#yQJM#E*W~x@G zlJ0H9Ob=k81?c-l(X3^M!RqC%GEaNo0z~N5B$dJus=a+#=jzW11uN3UhKJ(d0;y{h zWE8#2w)U_tueG>q2dkrM(R6f{-H}9U1ctmz(FZ>b^^mlM-twxJHXvQ}-s!!Zr1E_G zn+^;_RgeBzTU-!a-%Qgha^JPF@F1V;kkN36(O`d>ThA{D!Mlt9zIUk%GBnP^S2i9~ zlTWS0)MPR(L5W+o@YGIK8JNI4_n2(v{9@Q9?xV+b4UB zwz4W`Qb)#{xx<$Xh26dtJHX}BVU`kcrSf&F*FdN58`dxd>$xqNK(tMF8Uc3c>)EiA zcA8FTNSe;Ng*$c)1i8PV z+P3bVxZ|AWZS~Q^##OoRyxpEXr=+Jy4ORvoES0Q+wP^;qj#c#F(5}K{-HGmk< z4&y0X%up{{U_5A*%^AU&LcxiJW=8D0%69iaZ%&CjWGlTwBA5Fy_Ao1z-FjeFzz%U0 zZ&)qn*SyNBaOdlHGbpFipp3VSj$a%MYR|ov{X`oogn7_Jln1Us=$kgQPzylhdNDA@ z?9F$H`V8lZMRXFBoovp~bPSA%C=8!pU#DiFsnbXag*GS{3T5PCCFLR*#>^mkCnVA$ zcZt8I0w!?>cf+1wLJ4lHKxuHx=TU#pv|cV*ok6`R-Q=FpF;~) z1n1J_NoYL^@vLv}8>afx=abj%p>z%}?;9 z7J*F2FK2Ai!v1~yYzgSwKDoZ5Xn6(g&U0PNW*{1DRNv=?_V<;o@>KH^ZF5#u`zr{e z8zAgn0!RFhQsBI%eUG;oAef zFOZP!aL((dfnl^|^sX9{4kic1U$&_W8DRZCPMp4Iu_Vl38P+&DP;32wtd*;|GdO^V zf3NLi4VE|=hURvnipD;JpN6%4_n%CscK~N-115DEB98ofrNCW6d!Q=x$MoXzjnsKe zu|vZm_l*!6*#qp%mGfm(Se*SuWyz?}wa!XgI%+D`#a52KmeW11>d;7l#@5XD7mm5qm_Uqe zTsyFC5Gh5l;&ZUYL5p%s^aHUfTJEsL7gQ+G^gJ^jgbRH&>z(@I3D}=QC5-iMCYt5> zzIp*5gJnpIrj0T2bqgGYK_F{tKqF_;b-;Ng&^+EUUN^q6ue1gFP~_SMWaG_oT)4YO zderBi%2!&_HQ=aMcDk@~cGX(nJifC;R(oYq(bqT!&tOX#yr`eDGK?12iYhHc1sca+ zWG+HuwS}ypvF;jlE!vDu;y9xPgJC;sVbx|ptZm`JN%D_L{aoru@!YOTYh0;GCu$u$ zx%zB9K^)P@T6;4lUzl4OeQks4)K$W`t69mOg`;)}Fr6NE{f#IcbJ7Z|5-iGIOK&dO zA!y3IJEznXgjAa$fB0DdRNr;fms2=tII+u(ZPZ3>WPNE7+-ccj-)(3(#r_1r0zCn50Rv zGsli-4a#in5;@Z$LdS)8+Ul@kz&jzy6jFQp*F(&y)D+az<7Ewxt>i@}I(!7Ia)!oY z6r6ULZB&@$pw&_K!OKq3S9AoH9fYg5jiSDX*y(X?yT@@E+gSCz!tnyAa$Sa7pC~>L zWZNXEO>>C-hKYL5{V0!qfB>x-b^%tcSy~j~!a9g_iRwM&9f zli$4mfDhTM-+S%8JSE-d&f7YrDwXz?bSafK#pD*7WX_dSTCRnFPKOw{<3gG%sbhE$ zPh`WPc$!hF?D$;!MkYEh=iDv>Ncbq!-8o??R+^Y{ zPSL=^m2}W}zHnO2xw<$7AIdCDkbv6PwbeOi?qDg=yHpE~#Wcy`dm~F7OdhP21tHf} zMK^%b7Z+GrSz9z!_I+J@W1_>4G08O5x*5mv+JspxbMN~&G~KmOM_QYI+!E$WZ+N9< zz%c7)6XBAhE^QQ{y`i+9q$y6}T=a`34b9099yqx^58cp`nerh)4Q`b>|JY%`1?T(T zd9a6M*BF&%W#7%pOmLJjH4U0LgGLKiYJ}>uKlw$AdD3jaRY1u!YnQM}e_@G8EcPI7 z{Pf#CQRVJ;Bd|%1wQH}mOls`JTGu4N`75rCSXU^aa0wgnO3>dl={#r*9&yPx1th z-Yoo6B~Bi2>iM%V5HMt!mQJ0A6M+=?Wbl(QC7=|yxni@Nx>DBO3}p+-%-tp4vFWU| zR=n0H7Cm(aGCCPjv&e0C0!UTPQN1$mxY>K8=~5#rg~yh(-GC>86#w$pcSaNby#)eA z0@?eoB=`iZM{QRB_m;=ZoAGMvcotwaNZjZ-UxrWJDjK=c#Z<3JOV{mlX?oQ=sneQ# zM_QL(s7DoLGO%ku!DYiEDjMiai5tqpok7z#%A7OIXk|9wKILmGv>Qcr74*X~l+&H& zOs~X~J7Jt^tX4c1tx?o)z`ojYYpcOqbXX{Mx7GAGx;lHvda)CBqmemHX7gedp>`9> z*R*}8ZxNZ}Kwd-&+Y>HMc-_GSS6b!FpP_2Mnej^AJayakD3_fBwP;}UexY>b+8f5Y zpOENK4=#%C7C59*nD0oV#Y)=;*o=`~HZUMIGPVlR$AsT86h5GSJ6J=Vvj8-yV>R8rIQ}!-v{fsv3`hbWbNC$q4f!k6*!fI6tL$KP|nR zNCp}y*jFu`ZN|wW7s5x5oJ?P|wH*tqZIq{lzdP`;=vk9+>_6zn<-W3F78r?iWswHc zJBc%4sy>=3vZ{wuYKm0v%fRHvDFhzkkLGJ{L=UJJgq>94YU>2nR7SSr0alFMaJ*}R!_%ppEsXhA=&+&oS!xn9E!TXz@QMo;7e}m z$hjjh<~8)7N?~-3%$ksxkit+~TYW7l#vgV6BjbTz{6ouqO}fy%=+5aPC|k*}|D@L^ zkzp(&h1USHjd zk?SSl1$G5!12#i)o1R09gNxecuVfN z&2Lud3wo*9eCk!aox*0}vh7heeep%OojYs%JHJa54)u??uWZfMMDBhxNW2b@O6-w~ zPhKZgU?i^LU;33x4|w2y?9@ajSNghFD2BQWO_yt0Er8kL&wrI(hDxuEJg=xzwqgiF zq}I$e5sYqsSHPW&T{PFTaSO*R$GL9`-Op~!2#Mz1gAhKC& z5HuXd%sw~3CE?yZl9PL6bdSP2GUoT2A?m&{0E}i4%J8}K(A?T!t0^6r1RwF9gZEOY1E3V;6+d9u0 zZ?ye|G3$+6d$Wtc2=UVtE1m92!Sry%D67?@@4Z~Am=$N4hA1jSO}G7|`u#)_Yrg-@ ziut`BnK3?d>cDx=^BOqs4W8>c{V8>sVNq%U&B=E3GXe?1`x*Y7Yt+of_#9IMx~oum zI^Np#)_VctTqk|{QLC|uD^3&h^J`3|8TODN_sh9WCu^p9edsEPJ%hClW}&KJ`j^P%!fz+=)`%{a`=bW6^^7hI z+41Sm)le7M0p3}Tw29{`jY%l>+_Mo4_dYwLw_tpsfrUAot4SIKO__-n)revwd+EuG z&A<7q@Gw{QdF8Hg#$9tAJXz@EO(Xkrhj6U#Pr@k1X?Ll)E1_T$Ir}U8vr8J96m2_lk;ltP~abo*f#F2a;*GO?vr};*rn2sC}^|o z@Sn&wZD5!QLyd^j#&oZX3 z@?kXkI6AuAHqCV)N9F@hQBfu(vJIzdB0_Dy6vfP0F=Spav}I0|aAR@(01u)~{FqH7?E85iPElbnuYe6Q=1C7`mr*r^9ISeXJ zGdwR%hr!=Jf{)f+)@|y4%_qZf!wgwZA}pVoqDStspY~C%V(7gowrR%`wkE0vs6%?5r!2%gW_r9QCRF_3;7msOYV9W`yIOkX%53!)e|U`c@OOTw zE;;c*cFP%LnwuIS_R_#ZjB%POo|hY6CYF2hX2A;}w;%led-NGjhg#(H#xj0>p5K&; zvqaQ41@2a?U@j-yz zLf<`wQM4rJxp8%{=Y?CIGhqVy8mXz}GVYy+jh(JtDM}a|P!Q~43NOs$G;@oPbR z56^cpS@CrIyhEI-3^r`aeLhN=7?|@JbGgBK<1k2_H~hzE-sh>p)8aOuSBW)@J&rJs zcdPgscQSVs5Fg3idSx$p=RyEkukvL>7azRkbbi2~^q%h}6WU&1dY$|v&)~>?YV%;# z=Rv|In{MP3dEL}@tXNx{D#F{-`{kkJ)o+VBX^3^Mm;(GR$c!%F#c|ZPJ12ouF0nFO zM|`SP6k19@a7IYkT~JRSF@_si`<_MqX&?dUb6F_6`@CYftL}x!$J^dEv{*{+g(sLk z0Xb}v5j4{29P)k}CUj{xeSdco5qql;QR0hQJki?6a{1-6rOiw472e3F0N0p#eQ3RA zx=m%Lt9BId)Eyr3`5e0uc%__Bn9K?=Z`S5ov{X39xPpu_Wv%RQDqI8sg<}+b%g)iQ zq& z<0yxBuJ`dsHTC@4Ry7mXyz;eAeBxCxMq1_BFg=s7+V>JH56>yg%ASJ{!MyrZ^ zTxu~!-`W==@Flr`VG;xfCCi&@oz}rC;?MlAtczgXR=^6R`=(NEV7QwGm`BY=855j2 zYsAXRYQAoY6L;^S`(UZpwmNPcB_6WWd1s$A#5#3<=c#!Jc3~BQKAkcB((NI(NFJj6 zK=v+E*RjxBMRjYmbvTwWd(D`)MLqlh0L&R!lr(G6>o!l{Wntm5=PnfYaaFSczY3C( zNrrd{S@Oi?e{c^&nGtLH9nu^xUO?xLgQaQXLLN?Ztw12uy|31)%vHsT-lCmx`tSDu zf)nLGdyfm&bh=gndY3w2spqoN&no6g?-K?}RbwfhUg@tiQfx?Yxq;Y1sZ6B65W zu+Jmp%6arCtM*x8=)YW3N3-)9zDFpGI4jdW-zeao7TbG2?qz zyY+)!<F}KEdV-w}9+g+j>Jghu|C#vVqg~NkQufcCHi_c(^gKno5 z75sbfB@c(E;)i1-)4YiQrhiGtf-VH>u_)A+yq6~U!zX$Nb~$@RYK&N#QFQLkbg;03 zuYagq|NRr6_BtSvz?%M=@~0rdp4bl|Q(tXhIbK&b1FvtS6DTezhvhT_lPgcWouy`c zn6v68$;jAN_FzP(-Tw7_`MDk#7~}MMi6=8lcIfKw$nE>z+0|6q zjvl4oa+J+ySG*XVP&g?%c+oSFw(xv>OoVV-of*9?&*?fl5k;}F9fajz6^-B@ha{5M zffKfPYDA`JURvj*K?r}RgIbh3Va#>+1;D#nho*SE$_ZM@tf$|t1Ol2%1g5VNU9ZMq z`%VWXXSaEw>&Ab-wcMkOd?TBZJG{G~s4JTJXBxhcSUqti$RS0$K3#{jQVlcaoab+uS!;NjUAaHY zxauy5-4w~7bfS{$I|<~y}p<}BCab^&L?(jF&;Go*XcqKK@; z?J_mml*5r@tw}Cam0lLIX>L@&lok0RvCd-`-TxVB>wKjd^N5xt_lfTPR=FwQ$dvu# zO8Cq}h^eWL(2GO9a}hNeg|ivLf%a8|ZiHW2%aI;KFA1~iS0DfryervXVVZ9&)dg^& z5!Y9+QV-6?@xKF*yg3pa!M;4#QQ}{>4`q2qpxh`0j4^dSacv{*HDV^m9hj%U)lsj} zy*H{EmQ%uS`#8I=<4DZ=oIIb>;qww}w#(Ia+kiE92@=hMe6PmHTKoHk=bDn$qAm)4 zL+4-3%mD*9YjEI|gq9&5B0rK?{UBSlglO9NAf>R2X>U5BRI%(~kXb`m!ay>9}B~fgq~)OFJj|3 zSa%g3c=Y)x^L<6Vjr+vjI9kH!(CZKI*fawIO z^Gb>jc!wAl@f7(FA9~R}BfWn&S5~W&D&?kI5(q831%zaNK7r2Ckc<;gKtqRX4|VJ# zfLeFWX1&lL@3Gj_`d@9chUT12hN%MYR&!{ZHEZfLwKl?<@10z^s`1V*WMgG$QOuV5 zNY8V8ZO+UyCR|GISs90+KKdoi|8F|42%`A4f6wB0XM>-no6Aq&>KixCgR$yn(o!zgpb4ovmk1JAAwgF}bxBj5nq)+$z_gDtx^##6ka?bF2Ks619HM zFV?y=lZrL~tvLo|$7m4RaxTvq6&*5n^<=kT(66r!W+9Md(qI@@KpR(RyRT=N z*R9S~8y z^Ys=mf>M>-m%^3Y=E4K_)BvqlQX?!|`~r8R8?^|Px=u~y#kd zpfZ6rg`(Ctp-VUp(_l?)#M#Y`vt2iy*fEb@jK^Cqb)C+`w(^pXr&zL2wN;{-_l|MDx06B&+pQc@x@At-GBHmW zq;E6&vfp%)vp13&iEIAg><8ZOgbMNWgyOlw&gRX;2LjUz>R;cM=u`J?;|DhLjF3=I zI=|TSblc)v;aQjCtU{K4Y@PLsc;L^sPtNATemR@tzN4!iIi25k8CspsmcrJA`HDE} zne{T5otbq`iJMorbVhN#^663J*YqEd{XZMwuVD z_jFVqyPWl$UOF0K7`gvzvf5MVf!t%(SNaI5rjLVHSY^%zVSv%R7B@_VzX5jvCB7pO-aHX?1z!zc+arR-b?Hr^K<*f0pOHUD!m7GEjJ9fVN}V&6f}5_@G||LUayVY}hA?7^~hY zp*uz28Q?>LBZcTk4?Ls>>~Oxi;HuHG;XO?A ztOHU(A{CWJ@pTeK#hWuxDSA4&DJWdVPVP6V!E@4efJY=o(ZIna0sDPwVF5W1q5dD7 zL7w&l>}$3t*47+5)Yyw@;wu`ID4uh5-AjdqH4sV1*T6bS6oWjo(cd|qk>?y#Tj zWa|J4!GCsbwmo|^_|0r@iCLM4s2~iSf!9Y>Ps!;9JEF)uc}kHj(yn_N2ty?U%b)Pe z?2Bo|6oG3s;Te62O0$u?kLWn#*3=4z226~s89k9^sTKI=C}EOhW9#y-cBy1Y^EWnR z3vS%F2=0?5_i4XJLfG=N_Ru%fRye#>?Vab1v1bfztj@~MD&?F6tf7wfTj&|G>FkI{ z;5vuiJBPs*^eLm$+zvfExzg3^lYvh1?_lyL*59dyNl6?p;zG1oE9+0eoHKsVed+tX zhZO4EkH?%WXaHwgREkIPhI@KZ;}ff*Wskd%-H-Q%D(-qPex=%KLBoHw2ct-hD-r3z z9;A%(*For5;jRf;_PGY-n zDpj~nXMHJixdut~sABGtH5dByOPpT`v%2&cf9tr`m+q{vTEi0x$UuA2r03pm z1>Fq(NlKx0!oo9DUpJR}t57MTTN0*fD&&q`m&NaQX{W(x?)7wUm>BlBiMUva=wNHF6X{NObCN1PjhU`0JuiaCUIWW= zm6fyN@47;S$X>sS+S+?rKiutC!D@e#T%@8EjyP%YFwD1123bQuGxzVkkcYljU~$^G zCObT4YU;qsuy<|X!2-anN5ePQ73HsGju{jVE0dq0s%XELd~-!^LKqYW)EAQ}?m&w1 zE5O=*R`J90g{VE1~bdH~81HeDd4Icf6WN;j83Q?dpt1hbuU;Aj)$>*I6j6v(TE#MLkC@TL`iq zulTAGQ%Bia87##2cFdzj{uGcnrEk0=+Bye-9OfTdk;Y!Y{QCv=>ptW={h^g6pNYD} zihn;hTYfD^wlR-_6tdvHo5T?x?n+%9U+GRN4UW^tV#-wC ztFv;F5_CpoaUw6`)p>dQ0Fhd*a|w+e{75D%Rc zbTjRVTv%;*_2}B@s%~J|Nz+emw7a4a7b6j!Kbj_}_ycdfCpXpG0*HT#@dtW?k6(P# z8}1`;MZk7U%Fyszk`?{Z;Q#vY{UZC2<FK_A%2Vg&Uf z(fZ$K2YUO|Hrlde?Ir);Qv?Q-}!&ZXrwt3 zX@CvC=7DR?O_n-@IEGX$LU(kGinpDguK@SwOEEdE-ymXuYeqf5V+aRU&19H)Wcej1 zfOgU{G&dB&Yrwkd#sX_dDq2iCmdNP3)cdaYD437>cZ+IZu2Tx_r8wGpjyUG!k?F4* z7oTG8{@doCOW`BeqeHMKpM;Jx_VxSQO&{(>{#q!suFU~RF9K{wscf^nYx~sh&ZK{O zBC2s6C&>9pvLJx&5Rmk;IpNN7HfQ9`@oa$|0ZOjlx%%GwR&g@XF5^xd(~lN;Ic4t` z2R(&#ZeLjdJ{W>XIJ#M|5H0~5_?r&}M32B`eLM1BSGRr`(%BE4KMqL}v0!_4L_bOf zOs-jei6Ee(t=veRQ*ZWj$JE< zkKEF^&p#RYsL9gS)N)2_lKiMtUU~Kh*f1Oed0GkN+{M?HfiC$N_+nBvc7mW?lvWl4 ze9ueJt+ygUkMa`U(x7{zoJV|X)V`hcAohE~Q|YpdXzXtGx2?4o{r?DY-4!+NEjlMVWkJBiZBM`S z`cy_Ej^i!AO%`~SD(6m374t`2h0MqpFg5wwEoEAOXLwzLH&)e^$^#F#=4D@(W47$M z55!;pT7qFiaHY6RlGU(QCTZHT;!5lnERNE2=^UXB2yVtZ_MfNjop9%14ihQSzDN%x3T(;w&8 zols0PLDokW$F5UC-=xCpcZ7@`(ZFY{Ndl66oUQ+T?=m@F_**%8N#KNDDh0es%tZPP zj0wD5*(Mz;)yC5>4s&2xzEqn?AoT?K(VXG4D+x%jEEQ6Fp$ zq>f#V&3gX)%I82n2yNivIxmhs&1EV9_BSGv-)e2ev@l0U$mX}`<&3q5e8;wM4MtUp z)dT93WsVom2KS?`N@Ht#;a`xr%kdYjqH>a*qs4Vp&W*vi`j*6z9xpL&E-yK*unv7& zzWQzhH0;Sh#*^h-ADDs_a~_V}8Bif^Vhk|#_Z}~jOV*LE!K`yKdt%@?;@IW~VjjsFStN#-gJLGzWB{D?K#WOFKgXTz z2)6Vfg#5QwI?8Xo+VE|G)UBtp2f4z0H*ww9p194Gst2JB+s+ZHI1m3SYPoRFF{3-G zw#4zy5&Cp(JaprcOA45KPNDM3b@YJogS4lcxn_1xVCsWDfxTQ2%Ka}Xe-Y+T;Owus z>DrC7gqzr&ch6y;_(pXBBOuo`4ZGE)KaTBoK5J~{iojVMi0Morvs&(@L`>}djOhRO zk8&8sFpz^=%az+L5KK1-hMQAweGyKMdKI6D``cTiFT%aEU0;X(JV6}(5nhLm{yww+ zUw{4ApZ|BE^#y(wq#FM73M)Q=nJfFn`jrRkQHprrpU;2a%*k8$kmHx&<8I6~- zeIb?Avwucgr8o&r;Nb*~jJXYa75ces>oWPQ3y=43B2&RU;NAb??Y-l<-v9UUr)X%A zhBS;aN}*6HJCfC2L`HTI$;^zRB70LxMuUh#_NZ)%GLliri0qO5y&gK}ywCgnIq&c1 zcf0+5x8LiJb55svd5*{9{{^B-W zH>kQ-28v%BzUS~PXux;qRp3E>GO2P5*oD4CDh=D0W04XLF;_aOU=7g{h(A|`p-0@1 zI0t@x(-H`e{fWs2Xpo{aBPMgBhCU&s)Hq_`T&XRXkKN5!1JZ0=qz>BFMd z7t%5zNuJ!NDoQGnrqde{K}vS$vr_L}L1Cs%(SZEP`Nk#fLf1aqQN>5IEs<77O91{! zWbQTQ`o@h*%D4>+I!r9Z>;MnX4SSChxoZcvTCQU@y{;-|6BBFQtlDI~B@Hi({2@Fz zh0(DrZMJl^Q|GMp>Py4TyT61>#mGK?C?BVIE5`B5uT`#6zpiw#wU62Dy6}9O%2PU4 zN4tXgr-2P^rHU5BV1q#ExrN^aXhCSX3jdQ}Q=fQw-uIf}1(V?qv zZU>f+b$M@-8Kiq*zeYkrf^?b4fTUGhj{c@+8d==rF0+TYiW9<7kunRUBbj}d4IKKK zG7SWu8M*};HzX_J7;l5@JRt8EWW@-&OVQR&T7R_@bEI~&96+K?j{ZQ;wL6akL>86It+O(W zhASfmL(x`rLkHv!&^9a*K-7HO@$Cy3ST~{U_XUr?gjv%S`i1>iJfb{BgT=po#Nw-W#dD7i1+Sl)t)a|aDGXs`(o zt@HTpHaY9mu|oW+#jW)s&&EZ;$ZyYdu^R^TszLe01*&E+6JeUlv8_EH4d6$fycAOemh-vrt=mHnC%HCe3ATjYM zCbtF)M2V>2fOtMAv0AxVZmI2H+byU`4q--V8M)QnY)+lq!rs5HSSX-ZcFX-Zw_SwR zT@iB2&F>r+F!~g}GUjYxB~A7YI!u4?KkZOI;T-#3x=fyPiO_4ZX8) zfGoxS){&gy14DkvjAAX?~vJOl!rkDq2DoS)4biYPy5=uvn^o! z;u^;jq<5?V#^w)_?_^k7=7Obbx1i4>(qIC4LPy^VjL-80P#6Xs-=shT%#Nl;8%+hx z+vLZ);v!x2SbH;UI&NI7X|giehl|e(fB$b6-yZen#Y;Fi`hq{F=)RmSeET*`fbd06 zBmgj#Vq3B4*K{(ZBC|@>ZCACnWx?A)uCYK4Ia=B67KDwWA@x^obbZBhwdv|FURCe5r%35fmmC+>;xY>TFLWJh9B;XGS+iBixF`&qC&pH)L2o-G26k{65PGWhi?&nldb39*&ctZAhNN*tqH)&+UCT zHyYf$9Nls(S(m;Gna#*ck{6;NjyTNrZUTCRBhcY z$*k;iA09=Vrt%s|^k6{rSXrsFXwmQJVf9z^;N!~bZ{8}inM3{EQbd81z7PZ}AeGg_ zqPOaUiE(q+>^?D{ZRcO#G;-|j-+xaf$Jx+oZBc6gmVuf^mf1ZG-uokbCt~A?p9U1Y z=ab9!%+SSNdr-*#((wK9+sp#|{@jPm$3=zr9IWdb{VBp?2A9jY_`Zdfti89_?DDgC z5>Ve_wC|L%ajdJ|*|aV#M~Z6p$Y8x`V<=e|ZpJDj^=PPdYd}Jh>mNA|yYa2|8)Jv* zuS3!A~hNPn6SI!YK-(ZZ1n1a2INIfY@w`?loAGgDz~pY zr(bbT$flo>$gqGa6eZZw1y9`gR>olI7uqSOHZkjM>8FrgaIGwilma%JaU5@A`XP2S z6~AJ9|6wfIF3wZ?+KzTN+#Z1QnmuBj2Ir@+D>*+-5r6wS0ca>$FsJob6}EJIrUMY%$a(c3jg{1`mL5 zq+7&{Jb>`+s)BH=h@qF?s+JnTqQCX*3&X)m(Z1r2Nb5D$%h)9LW3ZBmi#^C;7su}L zce6Qd-|f_W^x(RlC~1+@J~%SS;;<*rT`;lB>dA>XFZ;2kwAu&W>UR&Co#}izSme*g z!&>^LQJ_5CDy({&*a0E8T^S64%iZTw{f9q{NWDHV$uF*~&+EE5b;gHq=45<1U zTf^Zktft^XM_+Cx?KP`r$X*0blQ!t(+vOagpmTj;PwF24&XW`TcTc+>un5_tw$EwW zlWYC$b2k{k%Ai_M!(~2mV-O*k_m*Z}G1R!uC`pspHgOwRitFW*abgQ6 znF56Rvh=^yFWApkr2VT!^2@Y3e@+S7wBmuSaQ$3bl1Ti#8*_VUoL! z&n+R-?C(=wJkfJtisW5*UYCl(aYO~>oK0B4Dap>^f zeMWAqi!Y(`C{oBX9)oUP^?hlFfuND!xwx}wG|NJ)Ug!QBQfseYbX+FBY6EucHVFww z$*z^_3V+#{JN#|*-=aR$pi@3uR;ZrAU;6X2=m@Dy>B2FQ;`uI`yfQ>Hsz9hxhob&i z2sAe90OvSsop@n*IhC8T+56)vC1vyW--=I_?2f7T7%)6@w4ECi*ZLA`YCEx2M`OPPpbM92 za~2uHq7bp?d1T}(n*o=2_2>IB8O%UJa&qidPVC+!r`+utSx3FtB>Cal5Qvqi1S|^v zE+1GmHj_)Zx8p+FBI1uOY?J$dG-XFd0G*V;=HYuJ?ZWaAX}@TNn3E+;$1@L$cf(6l zz<+P~1Y8F%mEbvv6~#I$fh)7}kxoo2G= zjZ4s8gUg;W#F&Q7b)&=eJ0ChMO#St%7Bm#-nD5MwaImTe&xZL+?5!) zLpuvO+(Eb$?T{}keJ76#?mr7|?2de1hl!aB>po$x20A)S{$dGyre7JNy)Ug>#HOXn zD2Q*i(ZUCK!LbF)H*g+{lJjlOz8c0OP8QmA0n~MVNN*HzP}ygT7{;JEe+dlgB9p*ERGmq0s;vba;Cu*^7e>uJNXwrSyzm(ABKa!kP=fxP6 z;OF1C<)3^o(w*?^s6E@+6 zj!*dRCpK8)Ln0aEx^Q-2=t`5F{Z@401NJ=EncREGn^jW*#}S#S6KXi}h)#3!j$O4{&FB#ash$$OM#XD7?h2i=&uC%eaYj~ z)8e+>326k%JpTMV*DLG3d&EPx%Ro5uYfiRZ%>FmGYwNsN_io}+3iN}~b66hBv}U%= zj5;}gett>|Mk+tw)|P&5`$PR2&PFX-0_!Y&$BPDNJfDlcTf0t`^<>y7xyb%3$LX*V zM(|;FV?*4s5&d&NJM)=TF|dfKG@JgqMt{#b_T=Mg*s05bLhPsT?U_?|AEu(K#bFqW zPAR0O+b9Y7n@z~u)h5(N0NkJrtox&QqU9!aU_%G-xef5kQ9ZloRyPr>Jl}1 zkT3+rtwvH$2uTruH;c*t^Jl&>9DzF_XD9e$zqjN+zk!%qwGF zvUk>Rc7@Zq z*ihS-GIo_QOe5hL_I;U##lcI>+{uOzWQk zV09ab??yfBQU;XRlvumrxixQmcUa?zV!3#_;`nATN;O}9x5VIX%Y8T|InQ~ zvU1~CDaP|}?`$+83)*g^^dQ^2rO8P7OZu*~V>aAFF1St)7S85~9C5q)ub1}*M>z2s ztbS%C9YlKWVOuSJaCCzpcsS$jji#8Bo*PI8Cc?_0p8kR7pPA(pSs25;A5ZX} zdWH>hI2d&2u-1Myr(YWPBpiNRoIszCAU)A8GVg2&E9rh%Wu&EGL+yH}`g*#cG$g#c zO&g2_D?C|5HDKP#af18E;^DddOi_se$lm>bOua93w@T~|iJ@oWUYa`2sStMZll3nZ zG}btP&(Np#k;AifFVEqK9d!#f?t1|m;rh@>Q0B`p?;z&X(;)pY#NrYNn%i6%Bm$61 zDj~axK^sJ0011fX4 zLJ4?}(y$$fYJZ6uwFG=HPPJO&+OG1Nd%m0I8>wtwmVV54^9qCIBvLPg;f9E0s>F1( zYrs~u!$8~err5YjyL+#&4LlD&?0)bL)2`b!eIMfmEPvDn%HCR8)+H48rl@G_G=Wo-D!0c4{Hv+jzK!g3ZN z<)hhFou;4DrP0QNm?`Vq#R+7W;dzs#flotbh4f0d!+|VV=b(33oGK0-Lk*If6@(Mr zleUCGRhW_BwhL~piFX z(mY1DN_#fDmwj$Xa@Oh0(T%zozEPdh;mv(f3C;%5pwV-m@I25~e5@xqA6VZ0-6o&4 zrZrDQKgGzrAd*A?maeFem2scph9RFX#*HZ5%d(Aea6iHcAd4f*4VOu|c)Z%3^y>7x zZns|X96!vsD;AKPof~g~b)-<})~5up?We>fCP#)!m^>No90(k_x)}%~Nok1u#5U|y z;*nuF^2`{Ub+Kr3rhZ%ul{CG#9TMRvxjPqJ-sVpCIx+EFQqMFZ5g0(|*hmIn#oC7^ zor_m*Q`LN`@;DjeG!@C1Qn38D;gzlF{LY1>j-oWS!9=3^**UwRZ^7Dy2kS8ei0{h@uL^^YW8a}LaLTRt>BUL8{wLeOgVtg^^l=W+Vt zs@&maW??8iLfO>7wGQ@@UgY@v0GVW6uUi~)D}kQUK%0X?BL8pAi{H5|Uip8^ZO`g@ zSCOai*Jlw8+CG#^#kJ|lKe0ioVA8gyRdV5eyPeeaE4~=u{_}toqZ!7RKk&|2>m0X} zOw6t~ZptW`stgy9R9j7Dt+EuS*u~2HMc71=Xy_DBLVo`Zn7i|_9KQV5-$W1CaRR_$ z8#+kF4|cR7=pd?T0Krl)6u7OPW8bhHCye#yi3qFZI1mqDv7N6i62N-(f!9PaKnhoF zqq)nsaoxV0a(T-7K!W_TfPbELYa9y0GMxJj`?d3c2gTqE%pqPls^*61qzL;lGLS%D z^>m`f&p`uZ%lz{fuL{6{sWjBi$EovH8Cz-PD_CP&u3P3~gcApb2yz6Kzs>A)h9L7e zz((G!``g3IT82Vl-Y_(mD4yLR_CD8MdG}lG8c`r*^p3<31%2h6WJX~RtT^mjAWFJ$ z7re0sbLfFVbh&}$uZDI8KX}N2C3&>oxid_1YvsfUc1qFPNg7aCZ5AR)dm(S;RuCFn9Rk6#!gOiT{$Z{ zBfFi7Zmm=!ixv&9{#^)LlNd+b*4_c4ra2tLN1i>JHyl+fntwGA7s{l)i+{hYbUVM8n z)MoYB&$^?^(9*f5r7GdEE9jp#d!vaF*CI7=XlLr z4S*)v$@e>F(j6vKiA^k)=QboP{(!3XOn=5xkG30QH6LnU)}73|u~gAjNqFe?wlX#* zKOU#-05;T;Fb|h?b zLPu(qdG|#^t$jA7lWsWYDR{CxsPh8QLJ95JjW$-$=ugpN;7URF7d`vFXhZ?WYb?ZV~7$Z#-@%lgo} zJA{3$gv~SWB`X-czPQHeF>&8EV1zz6Kudt|&Wk7lzFTep|5M|N;}2!HEqm&Z!6%6a zrJ_ipk$(7wy~%3sE32yv--aRwNXLWXJ-Nk{{PahiK2l+P`eVJ~Osn!=+DnfN6tO8m zVLsQ0ywXvn*ZJ;2HAHh;k40UNjC{XT7VtDNRy{i=RFFfMpKR0v)1d)(tE~&~z8Y_h zG2T0Hbkn}nK)bnmk-ozgam?)Xu4Qu#<~%!-<(tR2ix;h=F=@#uoT}w8SAPlXvmw$- z(U<2?qi5pWK_h@CwsRIe!q>W+UO7w#AvB-G*?7sVlQcgP`>^l~@7Fz4**RHtLCb5w z=!Sh3Tk>piLLDG5c#&5&YeC5-{qnWk)Hg!FY9-!QgN>%Sp<^I`aDcZU*qFBoj9ks& z^M`{~Q|edoo_zPSZ%Hqf$L51xAskQ82+>XMgUxY;Zrl5Kk%bJbepq3@CdvVwv|;dj zXcwC5TVc|;?7iLs%G7M2a!Flm=Fd+S&7S`egKXwvkQ4)(MACw!^dC^mwqpWvwnKKX zgu~TtYcNheEe#$X@3{N@X=09Fv9Bi2#);9!K3zyFawNiqjr^n%55iK|K0B60+iPRy zhE_35(-2@_RS!bf_}A4Vu0}9k(VHQ*Tco)!XxgkU)KiTN|9kdWvp+~_3ZUuI+P92Y z-s&EnZA|Nf|FTf#o`*D?sV*1CUC!ea)L)xGWCwKlDy7PZ;xUk1B|FVJmIMn#HW>(C zEJtfh7e;^jzj&{+3B?}SnHw%_vI32NS)0d9FicSj^l4{rEES*YNnallqkgQ|^EGV2 z9B-pF`}hrCyOp2EZ#sj|ZsG`T^=Ux^OyngK1N0oLLUuOk+75W=pM8Jd9dMwks}{h0 zp1X%lMek(JO*VRo2d;?vgErzI;sC%d`9ZiyjEgc%8$UhG78(h%R4B)NizZ@pjhu2# z>*TWxn*l$Tuo5frfNvQpoXR1^Q?=T0#tD=*Prfv z@N6MJ#wRRS z4NC*+8d!~uMpu<}4BLI2o;1DW2D>y3Ae%h-CgX#v_1A9pfR$u1a+>J#Zxm@9Q{mJE zs>$JTbY>m0<7hTl&eTeIEm-!0G~GyQ#h=~x1QY1$r!gzme#n7KF{|5R0u-i@7JyNy zIk62o`10x$5bA_As{TfxtXJLM3}$Kw<4p#P4p?e?Zj zC(=P0E*6|8CA)&}0%zCBlGz^3yS&`HYYtc#Z-aF^^W4^+OHneH^K4e8gR8>guDZlX z(wziNXFCF`4;;_SrpA}FWsf~6!$hLKVIkKA%jOslch-v>(o!a=WB(T?y&oTpU@y95 z>rwVxn7kcB{Mkg*6fI8Q-deKkJReQqHOwm6Tu*xy@(F(YULdlOk|UDSx-Pt7BBpCv z4H{n2%;Yk^ynoDE28B6*z(Au%<5vCL&@GE-$f2x9V~@ z^Tv~>z(tsGm zxw87_-^v}|JqZ7R2uC_ByUNtEC+ylY`OX)4=`rsBSLx7n!9Ycy_BPW`2Q)7Vj~WCr zDP_+#FKk>)QKoX?i*WYfB``jJR!D#S)_sdd5y*5xmI^?@(n81c0bF2R#pmx@-H_Ux zovqWpVBS&5ha709swip7<>(;N_;HnWFXh6Fj{x+8z!h>;PCDeav`Y_D+LLXE)*$Kh zY!Ym%iqu42$J%KLt4P-uCXI)2*lZ$gQ{Gd&;jQ5WZrkIH)^;h<9bNeH4$IO7?%F2fHl?4Ma;Xo+K?&fBa~h7;of6{aZI8y)f(Zwso!I0J7O{CG zG@fcnp-bDc%<~iatKd?ehAX;mkW5RR`3V^0bz5L*`r}{-?b&%Q!{T|kHOLOYSa)6$ z5TaTwT~lz-Cx3q}^U7xO28;EH6U+VR--?jbyxC(e#^I5(e^qxscy-|Gt0Ond=@-eB z_+^{8RiQm=m)`s=Y<>**V&<)Rjz}`k844^fNJmXynh;)xVdK$E;uC62Ywoa!f1bM3 zl5gjp`cJ$?rM~)lJX=BqNFxFo|i$v*s? z!G1F;a`t*8q5*%Fil`iH-u`jw&e6IG0#GZI0U@5U*K}W0ibdk%erhp2A>A?yG<({% z!!h0h9pZT@{HEClPSe}CPb`yI^z#5K zv>9W!t0Wx-HKes;5+tXfYqSfC!3N`spM>DK4NL*YoLN|rftY$qZ+gO#BSRhEMn3a8 zpp!D6tX-xMvV~rTn?MxWt3X9LfvUTF%ElFEuG{D)iletY^hCQgh`S9FRBOy%ICQ>r zN0FUu(6@GlCo#GNar(| zm<;?Gh7HwmN&=Um>llJk#(aE`D=zZA)r-{NkLYu^72Ft#b=r!4wp9%VXdGabyt=(h zNVmWLEZ#ZO9Pv%R%kMzD^_?)w`X^Frt!Ae7j!%y@V5XtME6eVn7Z+PJ;7ZduI!Bh( zoE#yMSplVZ+tm0F6J!J9Ke|n)m&Qx~I(UvDZ~ex77Ds3Hn&tJrgvYxQ_IbpD0wU-U zH2JX#vvhNSJ@V59uaf?Q|7mu2lzthDm^{(}Ll>170*@SB7hr_q-l3VtAYIkO-mxO( zNC24$@%BiF?u_K+sdUV&^#F_OIK1LFNlx`YMDyWo))?mAcGabMzqmNNGn32Z0sn$O z-b)3-Q+=4!9y9RWwyGuvpxb>YOynX{r%`)lsLs6}7BStMU^lAW6L;X%bZn4muN*%o zG1GQ}A#wixCD<9J!_9WP%DvyXPL9Q(Ks%nQZmU^y59Hh+$fq%=LKRPzwLt0i{jXvR zs8)3cl<)6!GdTJI!BY!7LvGvxPvs^R^80i%|?^^C0{V9=5b#q)kd69wnMe zS4K)6`B9s&ZP$fbKLYbdz43@fQqZ1_`Ed%B>aR!z))TbIjUYA$^jBgp$!@L|y^ne`HC5g$ZdYD-3Nsm#k!k1(8kAg^ zsl3ORsh(w)A9ly)8{qf!=R*sV0I4pX+dGU~EW1AjgJ~GTV+T6zg?m5tI`u{fKbn2RkCg0BLrH^_i(8+k z_o3Lg{nou}t_#8kqCn&1C9GtSwUJI`K0k%#Ty@yTr=$z#$78C|eGyH}pn-316~P4m z-kR@JeleI|BLKrc%1}Wl8#rL+?Z5mO(a*Vc^{xxTd#!sTkTs@YsKKW!q=GGimwHsN z61+JNU6^J6kTKHDiK^>(vaCX89Ue5-`zX0xKily*!oH->j^*~XLAefRR)17iyw$DK zZeZih^SAtksnto_a0_qIf_2tf$#>Rbh?f2Q9*fTVtG4*GcrqjmZ+#H;=5`sN!Tomc zTcuG&WC1TdqBqojsGYt}exknHN%)){{3F}YV#0{2#Y1od1c-cLCgO@YgW~Tm~EVZcU*Ed;edM&5De)N6xsgmsDUA^tp z?!r5}fmU$JhrH7bDT(0n2<1ml!F-_LfYlK?X+jStO#4N<6V9gTT%5N;9^{WURMl3A z=YZKTakt&FF-5q~3pZ&>{TOX5p!O`QsT*)vP-4!^+umIcXDz?q{+^?8u>KD^f!U#J z^XBXIMznmNxYIp|!Sxkr4P-5+ta~Pr+{@@2K0JI^VrWcsSLak$4bSo3+y{Z!zI<4z zB2F#Y)@M-4RrKCsf8_C-w1Bg&91OlT;DYUaXAf+yhjNEP zVKR+|vL>poO*|ON_449rB}}m1fB7di86DhkE`qS$%OiH4%bA>Us_pS0Yx>5L_VC=1%w0nG zvV1~ikV?Yg5IcT%%dzvRyo_#5uN)eee!Gvw&I8%YuGx;#yN&DGzLp9jatI&!v0?Ak zlc|>)&L96Y)2|~?0*}%y&o+wP$zXL(yE@$e;I-%K6U|SL6~=U(;5@OirH59P0@J|4;#^XF?)@ z?}o#NzdS`Dpb+@vW4-taIwCXhAbcP;?<$alpkomaR1-;5ih8ZU1xk29+nS9+SJTIv za%2t;oc^LMDNEPmo^)-Rap&Hr-CLJ5yE=4<*9YH^u4n3~#iX{5^lKt!O}EZ8~>cHT)QYQ=T#6y z@~63vwjvQ2De6t6EAQ^60q-#l_SYY$L zg9h+;;wHRiK(_Lz%A#Q%$b|WdnMU^{o%rDj6@+3(9*}d4*_Q%8bj%sz>BVBCt`!)o zv(LM=Zr797cY@hpFw=5){$syFI$aPXHY5D~n+po?PZ>vemTx_JU+Vg@>jMJ=zR1x_ zQ6&+C7NcACmH2QxEW5S?vy3HKc3lWK2{JG&#<*Zh<%jy1R2psYOxjtqT{T%Y=T}rF zSR{u~cyq%w+YcFoB5Dm%c`@x3q>nFfwZ6S(2@+by@_V`cz7<7mrEf$9I8V7eI=)HC z_!hW?Bhx6xiUB#)_g?$#_+^Eqxbw}|>$?YTdi@qAwC;To`Gxn#d6fJ$coVJ1*_H87 zNtrYVrgn(b+B2w2m7r_l&7B%dAsoNLH6Ko1;4kT2;V-0EGEVYWn*d3QFI5{W7$8DZ=!7V(~L5Ck2$yi{iqLD^-#ZcTU&osB+ErV4`wzXo!M)r?$W050XD*x}7y7nU7 z%vtCTNUbY(XB{8>=zXBKQ-C^37XqAGBhsOAOS-&ajW&qcgK!Qdy^!)*P{sX-4uC;& zY70(Sq5N%#tA4138XTUPw&dXYcx`8KCK@*gV))bp`k+NUgO5o)=+BerL?l9zGxasw z%ODm18LO6K|7z9NK`)p=l1Xo1Eei(%3eG&IXt5Ez-mPT&0-_6?o@9`(2zv?Wzn4Gp z>2j{*zosdWdd((YXAyb+_YurYrU|f?T9S-0T;U+&zCpjJ*eXyU~=dD#_ z7S2(ms7B2xpT#Vfx*Q`cM&N3fU3YERYyQh;oQ83xrv3u=%GsrwmNm-mH`At3z}SeI zCKhep_nSy3)gLwOnRlOm!N?-9JDxlGYsjfYU{X(hY(SwxR>PoRbnBpxmq+Za z$*Lt94)~lYM@m#oG~oG%wyrqS%s`J<77T?$Dfa&+WZ=F4mqMvnz~iOw9^{TsHh^(e zJUuyfXq1(bDsHf!deCGhQTf@v|9EPI%@)1nBKqgw7Yo!oQj9sryh;3i5lM4>!?VIK z^t#utMOxUfZ#;dFRzSE|*2s!^S~JDZu+^hlDi{Ky@H}P@MCgzn-gTT0EezLJW6alw%mh}LHL)e#=!ATKp1HBprV+TRvW~HX9R~4;SX0Yj&DFq`$GE^`WYU zFs--AY1Wv~^Xr5SwHyUhc1XTXL2e`a8$QpiOl=STEiI7YPZAWQ$UAfR|>5Pq|Z&p8z85IlsO)zlmgdYUc-Q5$@*8mFiRo&flxgcf) zFC;ud)Vh+chYpM!&*}uVGecK?e%eI{>Py$Y(?mnMt9tSt(7-Ek($b(qq~?GQeG;H8 zQC>mCv&1DKo}xaloCC$TJ|9-MsHplaK%m7c&RW(X{hzDYe|gMGNk@AY!8VbLYgSgA zL@!E)3x?6hAMBr>*|mPx#8EtDPMo;AAvD{~LHBC-TXpqdA##>4X##z-^lTjdoO zB!DS*?PKWbBt)Kjejbv7nX86eOE&HXY@v&WwpnJLXNyzh%16gZzhEzhkB-dZ01jur zi+0ugUk&&vVbnc@tjVjU5KPtP!ms`O*u7_I`X2AK1J!LM)5QU!U{Iy0TVC=zV@Z$+ zlJ%DyUuPyvV#n~Ye3$w0lg})>ck5@OPjcw?8onRCde;pgM*TEJEt*A&A|Uxep?#Z> z=gh3mUESk}W>ZwklLNZF#{bK?OBOp&m?KcK@bIZQasu29#(5f&x46Pb5My0#0hewX zCe~o+D-@%r7lW|PE&pb}``b`)yCC69pJkEA^RMO&Ags@DDPID00^t-(wO`i?;^CX` zt_C=|TS1bx9TjU%9${4gw_;oJ_?ZZhuL-Bxq%9$6>as z`@V2t84jZgD`=1D0#L?bBz%|y!!2}!8& z_Jdv<0&%>C#Ph9N%d~eeyiFG3zvm0C?wNo)2ejQ;m-sY6go7B63y8c@8(th4Pl<^> zZpMwN6}p_yPr;fAEK1BeuZxUgNJH&$nu+tKsoPf2LtNEjxDH3ubN|xAy5n}16}lfF zpjmk-%(?ay?d{Xg)VTXk zaF-Cyp2rQT>(n0(W5RBW7zYc|kRc6>cTY&{x^rxqO0`}~ww<@Cm$ziE)@b%m$5Loh zo5uE4uK!YqlAzr5(oNcC8B-Xa^^Vzo`%<`&RGMLd|7)SJDcfcsLVZ+fhf+|FNmujq z5_AYe8`tEw|4rLb1F zP*sC^ncfQG=>WU6sMfmqfcBypz7Zr?Zq;iX)dXt+XBK$QPo%t&P5Ph zhOLWHzyI}VWdU-12^@o0(E5C+8bhPzv2Jwz5cc^aUPQgLi(4* z!*6-O-=63k3j0H*VqI?rlz~@2qtN7M1^`b7y0NRErK&$hq%T zef8CJ?oR`t)l!v-e1qh}a5_7TGJ1V$2T{#H8(}fgjAVin`o>F#!0_FF=J{7HPPm8k z5H=|JNQKCX6Z)id$&`qo3mH{Zgs_^znw zBYtp4`!&?#=B-#+Btgk;_%KfGC)4QXt-?&=1~`~;%KJ!>nd1%0QF)r zuHoqXZ`eW=_X6idxA8dPO7cR+`Q|MhHX!3a>?sb2uWSPJ$3w*JQt^<~5n8!$68PY_ z`p}~7gB+X#XpCSa0sD}iNq!236W4R$82Y@0V+h}6CqFq2&+qK)c zo}Fl8ScGEBfT!x=97V_fJj-75Xr(eIH0{BE^TDX|s-+bOOw5`!bo#2hO`FfxzK2Ih zvr{e%AU_oMitcJGy)V75Wx96!QbY2`Iv?d{#!v5GqFu7g<(l=b-FEyL?cJ8kZa>dD zykjXPD;9yLCS~|w<2+gA4U-h(<)a<6ixlVz@^pmdA8Hpel$(h_*G+^OWk`c#P}C(m zPVXb5lxy-rN6PCFFAgGXSIV zZE;USE&!cyE|k{o*+6E(#~Ie|Rwf`CsUYZ2UVeiz16a$GcGGifDsGdy0T9Q_CW~JF zGKd4Au(qqlAUGlprVqJ=Cj~NG<37!EEu_T`?@#ctWP{LEe_LK;CC_~(?bOj!X*0}3 z^(((8u0&vCBr1W(ndPHo>1o9`x&&Dr70UlbB=N_$If=O`%yV9J{h!`9T9G#8C}4H5 zDv3n{5uDm4pwJ;Cuv=^R!fL9JJB{a7#Rq|T7*banEMOp*V#rvUYNA$gaowJ;d+ZNG zpU-t7wj7#$domxe$qwT0z!jU_GG9(%=LLXjqn48Y2(=iYumD#QareqBi)zpy^tG91 zKy?7@9Yn5Svh4c%pH`5@?lsfOMMtkX>vXEIYDu_ABnYAnKQU3kgi#%^CI6lEPFs)z z@5(=l3P8AwxCN0`DfW{g^znuw8~lVs*s=nk6`hI9o}^5lTxHucQ~hR3N}%d!Ge+A4 z6$gp0qFcqne^OTJsP2}D6H>bmAB|nA*T-eo$9L4KZ2PSwDRep{5wP9X5&%x|5RkWbH z25cFmjzbw}m0~k+o(xsnx`_KMw&qudayd*^d@t2lTkXdw#|*vdVv#gVD#*ECECv z|4<<(;U=8?cTPS%U9pPpVYE{4VbVohzuQ>;g9?|`QezH8HIO{GPb^?xz4YUK>HB11 zyDghkMjfPmN;E6|exq;D%S=7h%n+ELMcib?-R1l*cXy@hxDQNaYo8PmwrX#4_O_89 zp$38JPO~{VIaWV2miK}v<1TD8nEb+I@<|p3&VKFdOH7Hu_<2=U3H!AdbE|@cl3$RS z!k#Z-;xpu++8FFi4HX$6z+7t1GO|)X#nh>~lU665Y6Qtc%3` zbXuXu5_!{x4{ScyxaLux>AMlx%vMRbQ@yvwB&c+Tc6&uC3^=4;$VAPTrQ9W zqtT??7}!`lrUBo*tCO7Cp`aMFeJcd$f=zMBNuP5ZL@SHL1(qDLC-4*)lgoH-Da?<2 zt!tv0l_j>4Q1iylo8$soiF*6vz}vigABODvTd!4o$~XVG_}A^o#EvT`swUz_1D=dK zB(Thh?XAPf5;4C;HDYC?3^msFXiVZF4aF%g(MKbH0a5A_@9FqQ zWt$&UUXXUF42Pi2Mh3N6YAFEU`(|Q|IrNxW?B0-yyjNaDC8S=F$nXo@MlxRe#&tO5 zZv#4&dQtPkW%w|&qcvEodOQk-c_PPjzI%SS(wJ$j8LxHsb*ignR<@r)u9Oo?PUqDu zlZlUGbwA@Rzbi7v(NgLG;{UgcoShEbnDiWtJOvw@^x-~9sr@oCBdNv3^5Zj;16S?T zfu!6|aeCC<$s}2dib@aUxY$O3;=Wk$C8+*JeiD_ENQ?b8;=8FjJ2~p0=HfCJ43!(X zkKEhv^lrjrl-JWz#m5e^;d_S;+D`4^J*E>Fa8mN*<5*%coeEe`6HtYI#>N#ZI6xor zMYNHhotaL!w6M|eoW$Lw7kw3G>kcXZ7&YJ%RCqerwe|vKCKJy9zlmdW8?||oYLy5X zqT%Ec#3LuoDvveOTWJ?$Z6>{RB*B3?$vUs98Q^Q7mUjI)!1vx-{wpg{~tg-(RW`4p%yn&c z!n8ytjI+4AuZx`=3*8Qn9O>rIR{(5mQX7njr*vcS>he^}-p{JQa$~%o-gAPyGv-8G zC22jSSOs~0^zf2?0f|GHi`MzU!3lv!3W0gYi*7e8Je8p^zw{B4Dk!ZhHCsNwM2b}* zs9Y@Oam-IGHQvsc(_cO;-A3g-8Tr!x#r1fWje^`VimKnxa)M^;wH+SB!YdNa(NgS7 z{bT{qfBSq7;E9Sf`+GD};{~ex(OOfYhWN}yCdzqdBbl`JKXBF z1^y_5RLI~{5h!mlt|m|nT^dnoIKMOifu6hmZB30(^Uz}#-FqATnT@dXH++k9N-c%Y z@4q^Hd$_=t;90eL^;YB69f-;@9uF77-ywglYdpt zqqO)as>p7zjea!^RloY$4l|{S@U(Y&o?nN)xYNdH7rK4jLV8btQ97BVwY9b3IVhnJ zDi~8ZL96oPWu2X%3Z-RMK0;Av-tJrQ``Z8lhd#`t@>&;Nzoxcsw{b{i22&)q!p(=a zwzdQn+|Yz4_t!^#0r{y|vX?EGDVfE~a~>y7PivZ6pklNtP-mdb^x}0Ws&*b_Cf0tQ z8g17e+YB`A?Ub!k=MpL}J*1n4dgf^f?>Eqoyo%J9<~9H8k&qwa%)yAB{NFw@|H0XE z!%O?yZ&OSELs-AoCHSEzMeXoHS7uKJjQB)#P?n_&*6ySzgxo!>S9Vf%M82;j^nKgO z^TITFt^aUQTka6J_OH*}MQ91F7m2T7rkpSDgw23DOE;X=UgF()zgp{@y#iOA6beNA z$N$f_c_}gbOD8`?^?1I*Dk)U~A1;1A)oN4zhUy`_Gv^BU2)Mkbqg?;tIXr~;D^GvZ zrcJ~1DJ}JXUl=<43$#oLwar++-E-^2JZcAj`&G($o6bhu=^D!U+fHWMB$0n7%xNtm zf8k%BJjSdIO@E`{Ioru&x!Kqb7+j!63zz=wMawgZ+l{=>-$7{!&=s(kG`+fV5aw$f z$koXx>l{9GJDEUG^kCC54I19M^?;mQDH<+HH&EzRDgrP(liV#GFs30bz2(0Z!qABU+W4S{%l*b&(P^V>Y&@FMvw( zC+a7&uU_-&o!5GD)27Jc+7l0$EJTmbtF}{kIS&u!K{ybn|J-N*q1L~23zxKiIS{g z6jgfHF&fzu$?&m${uZujH4PV`EZ|7Y9?hVm)2*BQ(U21S8Q!zaMbpDIM=Kk!Fu}}soYe6fzsBV4f9k(+QQlCzKS+^(nIRcIIKzhy9B1G%TH!ChOk_hG|>d=P` zj;yi$B+Elk?S4eMFI&&c%&-0~c=Tr@&o7nLT1;!#ZbAG09g93pG~*hbzWV1)FMgH= zmJPmPjx2+i2#!Pzr$-*6OB_3`o@FDA6O9XUDnF=?%8-lJ zZb;ViSh}{~E9((D<|V|K60QOPNR>)aCcmz#I)Wj;n-vuFoLR)7tDhNPRN|8_=24MC zMx<_h;lERd+o(Rt_hbG6v-oqOY28a&dmoFR;tuHuP2yHbbG`CS{p}sZFV8nkwW5gB zW~^RkT~(H#rh3&lww&@h$i6hp#V0#)TkWCGcF&peB_A8pui_f0!C@ZhG=-llD&4FOcYvk@+E zbJ9O75YESs%uh{Ej9?8JE2wb5Q;k?qm9p2@avlG#Nc>OBzIwAY_SYd%$ zP$fu-+71w@1D<|dne0aKt0((}9#@3yJOMyrD-nWGtHTobX zYbz2GxoB1wUmnB=7ZK&h|r6>v2t%@r}+4oUe!dPHiAC(gyXPB(6 z^Kf@}&;R3sTE=esFvk71ib;kh5cn*ewCqvZ09= zx+P4HG3ED#QO#MLJrB}u+_+JKMY8f^8cLTUTTym)wTPb&m4uNXw-`^pyx3lJmyfsO1;Yt~$9Sn|G5hA_Pnb0(gU zni?b{y&)ZZ=MQDxon^F;J1CGU$ujb!+1nIV)sys5213ayih%~VyZUm2yE=|N*neYB zKdQ)$=p5M?tLfm>w7l}pKfQ@0;!#ixUaV!( zt;L3m7@QoBme=I@4^-zk*ln~SfhL?aQ`%K(<0C=CcRVCk5`hoY*fMY|FtCi&aC~*E zc@|Ir=awz&ZxpKX zyaAFnt*uMHtXUQp>BviTt~YO*v4~p5FW*9B%}D9g(~ha0!WP?B;y)R3$!V-<)?#-6 z!a@n?BhhFG>wDY!>Yy90go+9P%|{~NE`4-N^GB=C{rhFHMQ5wyK*RizEc@-P!)B

wMWch}A)7@6|ccg!O$RQyo#e_uSNXH2UiD`?Qgr5yKC+5OO-oZkK zl_RfQE*4|n3~HA>ADJ`tV`@qfftf6}9iJy?(`7EN>vCBf7vmX!B_(Y#%Je+o^sSSC`tx9g%u@$VW+#LBLud5^<{`#fD zx^_XO>xuzKv*i&B`_JxRZLWKp|B5bANat&IMS9_Y4ck7EO7AP*ruIlyuFz?}ZPT=m zwIgp}&%)=&*3qNN$ej{Ap-EA1-~7EgqNs1kz14|DC#RU0So5TVy*=qbd|e7@)#fAj zUPqcKjMNkrsRc6)_Oo*@d)p63n}gOgl$OE2XXz)LF!RLIT%PIyyEHxE8m(ji>h#xk zv)dAd{b9#+Q|Qs@gfK99M4Bgypcp1W1F#*3!sKroHj)wVDgCf@<(tMvwT!XO3I$4w z8IeEc5j(R1y@f*YmqK?^i2nJ>>ynj~C3V$O&#T-2{Ga6CJLvwi6bOL5OTBVzx$4?O z)Q&y>rFPg|ldQL1ZY8zU>mSOO>VIpE{r(BNL3T58prO_>Ba6)o#CxTXDC7->{6A}$|E)spH@85I|Mpm##y`HIe-%=( zQrBEOxv8}q{>!ER>v{ezq>S|kqUQg%%1aSlK;w2O|Nq-JvS|P7`zY#vmS+DCZ;M!l z{L{+&+if*oG~E&QKahpFKR_12zdpaK`=n6V>vsQ-a_CPu;F?mXq*KlYSSsdQp*0U9 zGlowlv%NnMz5!+Hqdf4!3eJC0q>*WL2c$afe^&HV0N(F#>1x2OvIPy>$YLph6hSev5Rx-{t7{1!(YmC<}LgFlk0eyi4 zHJhHewnlOk`;m~EaC}7)G04?Mcm_nHP60t^2cXzKWs{;ilX76;@q+^th@k(&WURNz zA9Bnq{4`7W>KzWgO*C1QmnnNl&dC7>C>@6LX2%tpyC0bp2PCE#~}h?_|61sUxM zu+zCk7y|HXbPK7;{C# zi~JiCD;+t}+7^cMR1x%pdK8K-HxS}1dg`tC?>t&UN$#vU;vl+)`L$B+)j<=r1 z);M9pIMj zL7;tg4|^+-Msq~MvF~BQNKi3RM7q1XuWHmO38_m=Ru!ocKe8`<^QK7cg2E^>bLx)m z1?D(WJOFil_G@SGe#1_A%Z+YX0{cRR5Q=@}^*tS(cHq)14&GRPaR2$6H`}z`*e1Th z_^E_3*I|)gPEO9d0v8R}5$C7trUHwjGe`;6ba2ht z$R2=1<^o*6JI^zH(+pe6$iQ$7qd59Kp78BAEJ%v8cu!bK zvz^pt-YE2VJnk6K@FcD6TXr*SU;fuep!?dqGKwX?QIY!{9yTD*`$@wRDbFheH&iX( z1x<<{;~BNXuDyJO@!U7Y9gU{*R>+7;=ap@|3IU&xO!3;hxl3%p88t|{d6C#4X>kSr z$M^5wAt#f;5N?3X0iQM}h(?tno408(;rwi_b%@Zb2UB3B7#%&@38bqtx$FrUd64 zntU;b?0U!L4h_!hcxTX?^_-xr(BOq>6gb;uwqTNPcmo5XU*DG=E-iv_OHE0OWEdY6nnfZQM|<4 z-ag?C`y7(HmdRlM&CMVAq+>G+&R)3iylDoo)%)JwjfW3^TmY!N-0H#X1aui|s;&6@ zl~nnMD>I)wd4dHZQQRVtuiA$QhRPjJ22l>o`v5Ja@S>MF%EllSK0Y2Y?Nt;*{0 zR47M04jCbdN*|uBH!Z-f?xX=VG--r*pPWtQ;IkG#inhd7?R0`ODjS;4eq5c7R<^*%|mKaVv>dKT%&* zx#4*NPNKSFbM0bb9>w@uVaKB1&xv zx;E2!TPE}Nw@xw{u@3*3(o6w0ea-IGX*bHD>2UsEJUmY|Ono$yBFW07hXX)majv=N zbDe&Aejz*wru75Rd%S>n5fO3P3^LjF-TNQdw97Q5A2CUpLM7zxu2F_ekPoldP*3gd z%b#<$Xk{yfNH$~Pgr3CuEp4LGh-o5LlvZw8S=qvUAy$m@=U)X+elrUxj8Q_@G_y`> z<&SV=I}UxY^YAfwC=|W_eAbJl5ToWz>s?l@OLmvszp!JE!Kid4>9e~=ul*ny%sZ0t zxD4Be{LkaUR8u4D%fug<8*Ek2@r_SWpgF6e`apV#XyDm+uo9MF(gv>E?T> z6pYlVNWSWX?g_TM)Qa>YPa&TT2!d;?n@hME1GXbi6I+z5~gX#ok|a(Um&|V z!6ekg_f&D4}BP)`&W2V%2E@cAwY_bsQ}VDXTAli^iNu(jSaZ^^a`baf z>2Q?7Lv&BiCA5=Q)g#x+q}C1zUuz)~Qi>(_;n$Zf$d(d8L>TTOxQ3694+z*(*ol%! z8dPHc=W5)Tiy)z=z=H|6-7 zfd#5iHc2>rg(>epb_Pe>rutikX*hifEw1%iDJj*z48cDrLSla|G4qU&*!OS#!vFlz zl)n;wL>u>qum3#H&2duRc1s0x-~O9VN1@zG(#VmCW1!HL{c&{v`CFg(lTLN{+%Ivf zDc?M-h(htd{5Ml48D?)aWm#M(64Fnlj$@?I{Rt8H`EB?9X+7PKZ~Oa)`_G^4Uxzwp zi9E1uoyQyU?gJ^Iq>KO498Mtm|7s2&9zIb2PqWqB=wAgZ=|7GB*q$}_RU+u@=B5IS z_!rA;tUyG>*kv(-TZoZ}x zsAU_|+Ib+64|{XC->kU^s~xdQDt^0ua}TtL$bOJVOtYcn9>1A8yszymE zk@r2P5Q;9S1vS7gC2qE9duLWd|B?Mu(b`TOdKJav*H7GvPP;p@U?i-ut6p!5!At#z zX3iklQzHAVa;qtntIJamI-@f+&1SKT5@&xd_icE(5T$YLqSAAPFnf~RPU6JFB)1y@ zAIV;yUnj*mySO|*sgtD6M~DLW;Kj+XtMLk+A$?QqV`61x6~NUedt(&QXub?^#Ig^} z#!1A1jFyNG=PX^d z-m!ybiE`H0L9p@?platp z=WwD)lFV7~2bfkyJYPF6T(NmW^;q(;R~U|u!I(HH3isWsCJg|Z`)VMe_JkNzfedqP zPOy@JAG|@PnPR$F4^SzRH2aV-_57wWJKKw(<)JcTLtQ)`hTuvv2l~dq(Ty%YSk@}T z9d%wfkIN!|(!_McX-1KOl79Wdh4uX?u1Q}Iz29+C7w><{f|AQ|n}ZgRO~u4Ldf07X zi&9914j%Ya8Usij7n$dSNcOvX_bzFFVa!SxbOYRGMZppGpqcQycT}%=7CF+dRgl zNuF%mR*%WeCtAj|h&8@9gYYs4d^_YYJNyBGNq}KeGoQd3r3l^T@_R4w>~~>w@v`Q5 zhK^_T?DtGV*|MHbYoQw03-87qU#}E$6?N;&ZUCmaThm0?b~I(!o<8v2>fVEi6oXuK zj5b0TKWkeww=N%jbU=n9rIL9ga^A=~pO%qFXnd6rH{vkHp>g7?#|1)H{$3+ zozY%Np_n+g8E_A0UX>=*EamZ`c@*2McB2d@D%)k%QghXe=WB$p;JlRB2l;#GA8$ax zzKXY~Z)d;_&8vH=c$Ul4S|j4|#nPU|`)Ku$1!ov0p)Ms|2!3+yot9b-MKZNt{_Ld& zdUu~l$uZ>G5b`jSRf@m=65|6U)g3Bjr8i~Pg;r>4KuoQ%$RBc5VS?9JgP5|->LqQ3*3S=Id&&U`Af~%tAakL_q1|=w7i&aljmq*bE0Asm#=z~jM%~^a* zyU}Sq{)sr4(KE8|4Jou_Pn$UY`iP87cpWuU1|Z=NAzF-63jE8HA-&66c-r=edF?C1xo1 zev#H~m6a+al4!KQjM*PPxI!VVxI|T6yt&tLIeT|rA{0<*0Oux5<(Gx@QOAXWHk{Sy zx~q6?7lwHgE3c6a0%`*SoGUFRZ|JtQwXt$pw-w*;&>r8!ueisQ2C2XBdc^wLYszXJ zBu2p)nv#!@SrA0z>`;5QkHI5#`=Kc~Nn!MLbEbktoGWt3^>Tcb{IQu$E zeM_tT%fk+0}7a>|pgS+7X;PO2>}H_ink3 z@Z%B(Sxc#phs)!QVv3oJ9HiT}PWMgqI{^Y+^Rb)lZ|+dp%sFo1Pl(e(qW_`#0f-|i zAaII5Z8IDsW7pe~lP2_492WCTp6eKE`^C1@dQJ^&V_3Lw%hUm*1{ugx*;}Kpf`shv zuMA65JPJ5ogXm_^fNinTM?!=_o`Wd4SGVG0DyVUasX;hL^P24S`l~({BqYY&lWKTb~U- zPWgv&4F`^7RJP_vIR}5TuXW)^j;iO#LLPi5gHLMV3HuUAo z>&Ht_U$-tW$aol;U=qBPWQnX*@LY|>67?QxUA|bw#f>*Hi)q#NS1DEq+;iL-f`{g2 z$Z~aAZi!eiTIq!WN=zZW-QT}?@onF(+m5{yd8Dw1okQ%b&B)f#6`FE;QJR9WmsWT5 zEokC$l#>?-riE8(0f6ZgJhNQW?&dEi_l0GhnJzNe2DCUkk~t(s{~GJn$0}jFl~vc> znDh}o%)F4&@$Nq~bt>!}9A9}C2l_4{OfA4dALjE1Id+l0j%GU=GtrK+La=*g9b!bT!Qs-|;d?{Vj9KeaH`+Y(W%~^!U)-Epf`YsnOQ*vi4e5O#ll&}* z@#b5w5Sy)Ij zXt>M79!IkC)Qv?UC(POkTqY;*x5TYJzrzf|VS&HVC3gn^-GwdV}S^Ro51arvFu+gYl8hC5bmXX(f?mMTcQ;%m=v z*u3g>7ya61_U?%drMMeXGatT_YiJDekY-zsKOp1uVTLC{_y69)w8p}o6{%+><{8>aUF zelC=qjYvyF8ursKRNiuP^4M002vuiSA>dTj{Vo-y>?d9LC>;`*F#0Y?xCacn zT;{Z=-e;3|ehl2kmHa-9$@4pb20&=5 z8gl6$gtk8f$M8>^|5t)zEU)bT4msWY?~UBky@n(0hZ! zkZ)mCqZfu4M~@V+euuulB>@8P?2VYf`O1%BHVE0x&rT9kP;a}JHzvisge3)PdJQCI z%S3odl;_NeyuScZ&?qSI_^({R5_lCHfuFzs(l}R;Ql0^O%?Ir{*x2~6R->-02Rjdo zm=`R_nfMBv10F=K^~7rfV4rx7(8Sy%`E9CJyLMSC85`4p9g0@HwN;Dk4#oj_9gC-6 ztvCNPRIsS{;*0eUetYW?K3Zetao?JTVr-GJ4IDFh1d8;Z7JixHp(s7xq!d7X7qaCo z5(pv&S=Lr-=o36VGIAZKo)VBD;X9Fl1&rsi2r6Rcd%J0F|?qmz$KGuPBikfN?!qA*+e-~i|a^@|Mkp1xC<*fryVJ@>U zBIZXNqa^xxbO5tj1tt(u*T_!k6R#692#~8idLZPBT9@N%dCnX-6tHnyxOMPGsIXCL z3mJ`zCi^T%R0%juZ4zu_XuW>js1)$6<6{v6TbwF@nkPVaE_rZwmK9`|dgqs@Br*w| zY$pmaoS7<+x_`i@6?L=rlMWD^To%lDM#y7jGejOVNC5AJEZ14&Q2-JF9aOB=~K{(HveO_E*%gOva#O*G7?uz>tiR;smzvbP6 zVixMF*XN%V5bB*ngR%>ScVk*{n<1W}<96Iy=}&P4kC;MohkJgE^LuUj zk+q1zy^|ElUmQ1?SkVW9{}6%6x!u1MF>{d}!}|uHoQjLiWULF{ViD@Uay$!RPKMZZ zWF3~VfSEZI6F8#CpArB}FWtC^SS43%vtEN%B4@%G18XQA-W$qvkV2|*TcEWPc37o9 zTEmW%GJZnlfXujI1+c?grW#k^suC5`hm z)-g~@aJ|x37KM=~Dx9J8X*aPX)+y4BJY|vXDe(biFHbMK0f%G|SQV*pJARWF*!Ykr z?w44#sscwC$ExxV7`q7C8SmJy%^ueLb$onVt7mUQ z7}+cUGrIM+;Tm}?Zdz$J0I$_1o1$-bX7o5uLscxf6TH@&eKiuBH*3-l9DDKQ;p^b$ z=!yqN12b02dY&PO8LIJG^k5Awnma2YD8z<{Ba(^FSy8d-edNJ`)aSqm?|8(^$*HP)SBQhR!Z%m#6d39&m@YID-2*}uhq#_n$dCNG*iv4{F}Ac-7u$Z4-5h; zMGRUI%oIxhLP+=daFLix22cHV()lH|;z_)BF#t)h2VAS_3=7I6*{S35xl?n|<%$=g zXua#RF>Lo(av`;+E(h|*o2iggJmm1P^ZR}*h<_hB5)PucuiANN8CA8aJ zm}@eci@u*)lGy@NqWF$b#+ZW%H^C!a$18V}TGdk82{^`8yb3qYsK%<$7YzYj1j6G|p0o@;Gx8#}H+$)it&`@cle5?|C>ykQ0l)AaDX z>|9R6$e1S(E-w2raj{0Je@4#p58d7C7p|CB0gPZ|ATe=+;par6*u+&YguZ{%+-?Wt z&NUG&%j8T)$7}_?bRhrzk-mFYm`{d~6J~=~-^p;DQb>(j*VQPPkwbMkj>1WBHp(6o zreI%SmdV`*!BQ>j`H%}Fnf|oy6JOk3kByjCf?(fNLEnDAQfwMP=$($M&$!C8r!#5U zG$GL~)NRq?xOXG`2=I|KmF-FPF%=H9^NxiP11P499?($PpADY4QuPX|u(DrWJ>!&h z@=XId)(d+KY%Y(&l4USNEboA+YW;neeQ1ia%*ZNe6AfWzg^DRI%(yb#-~m-qu; zC#dL<1SEq(*L|27_)&7jThksq#cG!W*fhq~-Py_Svjp2e%#<*I!m{ae$BO^U-jL^h zmoF%M@?RsGq%LVE-F@|{alU`#iVKgLTai|{G|_~C?cMFtU9{&A=qURD;3F0u6yu%H zKp0lx9&Ykk&yflb0kR{}MY~l;Nl(p=FWYPdi2tT#^FuWloD;?0CQ<~nDwJp|mu@)7 zQ$G1A^_L_dRAFdN6EL;zL@`d|Cx5A_uV2hJ*$HGM6o@r*Q@;L6&pRri;t={~M;Ta7cpx_y4N*Tc?d--E?CCR8V^yD4RBXL0 zx;5Wv&hdBHAvK4b9U?+*X-nLpH%ezOnLlB@Q0J)y`%d*v;YvCT60*54kGoI&rZ72) z_$yM_0FR$lsRYTZh?oT=NaW_ZtAUhvGz&ORLpSn9juE|dFb?NltJ}A4BTLlP1-cT! z&nB=#;n#H}udIg~I2zJ3kbWgLIH`49WpJyKy54-hM&wPNyCg^B zn&4`tCBZ*s4Bv+{Wd^WFk8q);mvd+2->jr~XEfPIcI;R{?1pF?R+fbCG%T_S2u;&jjiuTqWDL_(Mi48DfcrcjpD{&gk)Q1>r`Z zh{)4)y6?(Px49^gD3g7+iehcTl z>Q?T26jWl5Hibw$PxE?(b}ZKpf>$>^IQP5^j8-r)LP+kEH;qCW55dlmmrGNE-gdrC z_7Vl4YykX$S558O9s5LO{cqpC;SS}GX5(P(4^rh{wDAtu=<+gdmLL#p{Vjc>!Rw}Z zK*)$@sp*|ZjoXB}f32g#7<*0x54}Ky0%2?X`ovjhk37`tefVI&A#q;orR&~Ihx1mk z&W5v4()k)O(Df5bXZ!u%4o`S2@{SJ@5EFZ^6vVkuX}{@~ucM<4dWI0yB#HZ`=w=wS zFI&9$wzzX*%wo2)i-H;V91K*WS^)BB<;huL*7z9e^-rEYb>vtjZz_yb+eQ!V*B<;& zFEc9o>8((ZW?{3uT_GwxC~;2}-kEcL(MEK)0t{7?{exCiB4G0Sg#7a?C%8(Lj=MvoN#X#KIkLT=e{@ksd-I~T!WwS6M1cSsZV6z>{>t%snKWHXt$q2C>`+-GcxvCnd(*Rk;o#fD32+NwA# z@<%0_)J?egzVEWDYE{|urQ$Dknd+)7(+@OMC6>*wWw%R*T;xO;IJ;fC>)59?@T8d6 z4m-D5C`8(*P@kHA<`45UFP)DFomR$CS|X-%!0%zW7H2w9JSai9!P&ayZrR)4|N7W% zex^jPR62^=>P4k7NJNPhPJVcm-`vDX`}#7qWX%(Xch<`od5ne-8&A;9gy{zjZzcM- zl;}+N!F^}RT$K(Gvscu(a&~;6Y+epzbb1UXcu#32DBrNGvEy?UH zo#hgeqCqis__OZ*C!A685xmp(uEceY#SxCHC~iaJUVc<`|3(S%>$d>E%}bojP(DoB z-Tcd__S3&Rrx{>au)yRWPy?v?e*cCP%6~ol{_;wv=+Uf#$lp8iZ$|bX&StZh`eHZ# z8;Liv<^M_IP0ZEl;iLVHJ^eUL#gi$<2mj{c{?Y;b_<;X+zVH&dD}Mly{?5e>)?f6$ z`mD4IKK_&K`^RU!wJlZrAHL%s%myW&!E2Rnpm}BQ6SmCj4xO=V)$hud^i4K4+z7GX ziKwL~iZs@#=4mqXN~zK}u}ppD63LE<;UPNBN5N3cSAY!U<>h_WS4O}D0)avSemUnQ zz=1B9bimjx#xv#ixb2rTKVsubCcPsR5mZVTy1kc)*nbSHOV-+yW~(bVzZ6_G@kfXJ_d?vb%z00ebw}1w(G4fE-XV zhD(<&1%b;1E*^ae>fw2GThmXzCNy-emn^oNOKu?WGzvTbRzVO-I}sio+mgs6LeLFN zKovRdo@=?dxWwGXEV0&7hIP@^eMl{M5q^rQs3-|H_O0%o4@;U{`8CmNE5jFQ2r=MtGIv)4=F-zerXF zuCeP-o!qLs2SvIXNic$f-E07e39&#WATTRP%H|>_IMoH z^zkcH+hn^z-T`3FDw?wc(gC%v?TV*9drg{av6ruy{XQIM*)kSb6}dwJj41K#LUsHC z-MIzhS&}&7nHudSvkU);e}frP-pPi{CG$JiNS=0iS!?LMQ1EYE0J0vkG`7X#i{`Xm z60V%$eRCHn;P8TXi~G4LA8F!1an_3E-p?QAVfH~yU0N_w0v;Mp_9C?T2rQ8Tc(e&5%-bWGLjg89`-8nB&O&U z_kMkFXLgKB0f9sJs11^J(yX%!(bkilbmbtMHUXlmlau3r+ugL2lg)UG+t?s{CRT8^ zdjySel++s?B>Y`ilM#pNFiH&oSkose4f73Fr72Lz4-~izOIC@!>phS(Xh@z__aKT2#~qZ<<6J)gUxoW7duQD#l+?3>o0Tq%vQUPp zC<=hsGZIN}LtDlWuQMSx( zuuVF%Q$Zzi@`PX;P_MpzWRmu=?#Cm(ElZ8VKHIwWWHU=d`+NBXBebbjL<^xg@JkD^ zPA{6Gb9Cg_3wM%Jd~)uEbHA%3nc_vc!9v;2m~d?oY1WU@mLmLFndH-F7w)1RcDhtS z0d&Mg*ybiDKv0~oW2nV7Ibw+F)Hpmbv5W|`ki>dt;+v^R)`6axvv6ql)$Jm>b|I>G zFih>D~jbXxAp=K5-GR zYxVn?7PnPak1H!RxMTySD`iGkh4c)m^G}>ao&cWYWpfkAq?(>HtvJ~W?eoq zbQDi-Rl%9O4ya%dB0tKp<1o!Pn8JI-dnD9DYW|CoviaWQi-3uWV|&r}00v62Jza;v zhAU@v5pDH6Lr{^BoHOsgUYs7nh_jR4KgBSAUG?P(x+T+ZaY)bQO97E0E?d1~PhTc( znJ2MROCH#D?j}6|BEKiW5A^YHi zV@jN>MllB7w32llxmZo7@yPZ_eKr$ET_x63uYvk66kwMUqOy+Rfh7ks!~FS*4`gUQ zr_QMyw$yl!3j9zx*aVF-*zy%zz)gx~!3UcXrFa_AmDtTcD<=SqBNPvLxHT4i?k5f@ zAD@M+tM22%kdA|(s~Mm3@#06w5@80WDIr7~ks7b-;I&Ir;x2g~0nTuke+l4Qv3dS= zfOFv?DsTg5<82gDo6=7&Dd75sp%X?U9lS^}seYmI@0Wz)_Qmpap&UVDuMyWGig$sp(~^@4Lg~ zkW-l^9{TLMggtwqwAt1W&{Y*E7i-1MRKqNrsE>{Gs3EMI8M45c7OY zN$`q2rhK0Mbr7bR?42eD;j>x`pP$buPZHl{e}Cto4+`h%)gRN-(0h`I1_uWnCfFRF z!wR}h!ug9goRXEbtv;6_7z@7IvGRR)w3@qnm2Xaoi|w`o?g*N0sseWZ3*%XKwnC5l zt8O^kh<~<~YP(QgR*{bP)G6`F$YB@_TJIg-}l?KcS*NoQ{1u0accz8er z$}u<%1L(D|!>&pZ8Ae}2j#B#{eR(rvGS74Re86W$O3D5|1Zs6`hZyV{I^OV9sz<^f zsVHO6`&U8RQ`M_*Y~ssrr%;rf2WP)L^{K<2hr0uB$jbVMMmyCd?I*7ntpm^gCoz4% zlEsUKa&}oO(-ntpm}Y*Io20Rhj1dllwJo)VRK^Fv;&;J0s2FiAa}42MKfcV%si`RF zl;+V;l~_xC%CY$MAIQIXdjH$RvB#CQoZxX40=Km}{97j6>GGvzm5h|-oPT4Vn6s)6 z18n&xFFSEH-1^ql&G8ow`F|O`^{-Zd|MW3Cx_Us!_{Z5^JBkD;N=fw}ZsQ-r+TN<( zKjipN!hXVh|Nd37i2M?7tExF${>dsp=3h(Xd$<1o`Ix+9$INnx?QB2Q3~AW|9e*F6 zR*E38wc(lbUZBxh)yh_Kb}me9;@h{so#eNgZC(E0NlEy@73E5n?;femU}+va4Pn3a zbt2x-g=l!eBRowg9RRvIG+a~MQ^YOp`Z~ERxjUI_>gBff3WC`4^Y@)={=)_QB0zm4 z;u+49uKYoRZRu;1awnZ5p+nsp$QAs-N5qda2bie})S%cUeF+PKj<$|N#IE;!0>X46 z$2LX%B1YD4U!Jmbb%othK7RaoZ1ZE6ml2{`NRZ~Ta3jOA?Wdxu$?ohT?Hq*j?RazV zvUG+ug<{~sx%++k%+ts(uBQcl2Kse&*e{G=!=uZqm>>oNXyNyX&OoferP9lHy8k?G z3_JrsyeRT2hi@I|6<$eFKCwM?gOR6%^4@^&Pm-N%t@)=6!^OI)vVWgKXCF*Wd~;Ps zE-5*9Xj~a6&TxVM=ES+P5%l1uG!w;Djb4wI93BiP`w<&x$>g5uBM#k@9I-JFd)=od zns^)?U$gT;$)n5K4~qpKO3%&-0G&KRtw zl81_vIQP}DflLGGTRLfdJQpB4Q-PxVC07nC@I;Xf&Q+lJ<7`pO`@hx+D-aT^Pmw_|(GnRASnQ52gl#Qb(Swd~~GGe=`{mLP4< z7)F{BkFSM`Kc9WG1Cbq!GH*(n)K-*JxsHDp#OBtkAXF+!uiX03pwrT4xx8itP0> zesqL~4|^5nLtt4jk1#5!(#pe*v5NDddX6<`p%u)U zl8USEU^u9_8_j$T4NvuTImEdb05B7PX(9@LncKAmyQoY7cL9VkaqQSrRkfxzd=IGo0;z}Xh&Gd%2X&5dt^MON4JxElCmQ0tgaXxe~Tixdxw%rr2pJ} za43<-AI(vDi4V7~qxDfPx26ZhqxSCC=C0I=ZTgR#zXp9C&*ZoS`R|=H-!o_8;m=^l z2tPbLEIwT@s+p)K5&vl3?<~I3s~r??aTD@rP5&qt2t(QXxO>GTYOyE084x<`L(K9C z#{CCD-Q2D0cotvLj=^5EvIp$miDgWgx96_NHk^$(c6RTa~Z&B5L!A=?SS!cr z&KhZG3SkalF;mX(M_=apX{Q@g-5RZ_`(fd;gXNC#%ys;YoO!ZYd0Rr zO>agpu*Rb`ek*RR*D{n1WHKW0Wu-7l+05onJFl%d)*;G#+Hq;7Nu|4 zJIxkIoH`bUH@<&(Mdqj4kWFEujzB8z*Rr?o3q7l#3&`- zws>?EGdX2H!;Q7=a%A#*I>~bSNq?)$&(zcWttgvpi{=MEgOB%~uWA%L=^Ha!FeU^I zch80(j8OWt7ml1z81!YfU0s7LWngQ5P)BSH$9SgxY8o2H5}yjjIK(FV^P-?< zPkbXOe$Y;uv&Y+weUiv^8&7>}U%-0w1?WdBlKqT1Tb6rs?lm2M+Ho=?4gV8D6DAnd)T z+5+T1rc!d>%@L!<6>P_{5K++!yP%M`={}r-8tV`AyfJ+U8)A7nd$@zyjT^5AY7QL> z((YPPeFH8dq4fdW^~>DIq4;P>^8B+OukhzpKjWkfxp7H8O;ny@)sSN&b|7Z=q z39WBuD2R%lj^N|aCDl?fqtq8w-P&eEMB+Kt=UxB|AyOOlxV;NoQ{g(p(QFG}`V!)z zT)IhH6{3-~5GMsU+>54LOK3`>>*w5DA1l9rb8`k%CnP(TY30_<+T8gLy=wphu-Vwy zAZD>pt7Z@y!eG1`D%dCHxGo$*P$H1P`bthGPF%npbjecc?M2fgHAe1VbDKPH;Vg8U zWmU@FXm_&L2g=Uy;s;-giMg9_iR9#=b0oT_@*RUrBD7D)J~<54*g?5jB%~Ob9?1@$ z-l9=)(ITNVh)Pe&T<9@WzW&a%elv5mRcl@Y>ne8*ew`$PA{DJ5Ir&d@em z#&7UUXv+LwuCw#cnBvls?iJg`sgJC}p?-pJOihSYN5X1wTG5JoG%Li+s*X3Nf>)?3 zaIq(CCbK0R0~ZU%+uTUHb*2;ld^y_Pq~i;Fk)(C+4l-*FNJ-CDmWWutdm~woi=z)w zqX9{0$KBded6pGNuBGJgMaG9;hAWL5>@|G0!vlA{t5S!oawJP4i5sxLDDjlEXypR< zFBQzfwXdVU>lyIln0rR~mv@2Bo-6{`T9(%yWWS`{UXx_N4_^MZN?`8nsI+qnZGMy4 zy@9NM81XiN>~|4dPTyU(eS27kqgmCUKtT@2>Fr#DyWhylrWUb35^Ix1 zmff=(d~EvF&kL-n+UV_8zob^(YW*(J*O(;KbI#wr=nwhZJTkwJ_vYZUs}SR<4tZU? z(A01WWQW?s>$T&kaPjvC*jXx8uJBs#55aSkz3jh_^Dp9A?#l5n!Sj=x0BPL+eCh5o z^`(kn@DWLW3nyy-^|-E-Y3g@sPxtQo50o`g4F3b^%H<^ci~F4WIalZXm{ZSuv;U_g z>>rkPWOMz~~IZa`l9Nr?3D0+WtZrlC>)T>0|!5d%2nBxNx@hxiWBv zE49JIkn;RAQqM@La@#k1^XHY9Wi@Ehxy|N0A;QmES`@_08LmR;DiZYL$2q4)6;6IR zphfv~=|?zWih8nU`1Z`lSJ~(&?~svum!vG96{h{VgBMuW-sL4eXU?1A{D*9|oDv(7{2gycq!?!D#9gu{0wd(E3oF zig0+=f&~kL2@8m|6eKBo2=ZrTq@4^*_!~pI{O0<7{jH+u6l3FtdvCzVt4QVnuU#Lb z9)4HpR@<*I1(Dr6Oz)bJ#b)}Y<3Lv#x4AM}!r<={SaR}8EiKwzOc9A~Njc#E4}o^# zuQq#fmVqGIFU+GC2BWR50G><&?ohE0l_O57AW(x!1_-?-h;t!G_pjk#tAHa}ILqQ* zSt`j4en}m( zRQRwuwBTjN)ZRYQE9V8jYDQJGVt6?WwjTn=y4y%E<7JNSqM`(pOw#ad1jv=+L>x+m zZaJU^Hk1e6ri_FB%HrIZ^Lg33Mv96N@bKj`C zIjUa}hz+~krhv31d*R6Lq z(QQUiGXX|#2A6e^q~pmXL@Qvo$*WJY^jeFUBF4kkK3!(GZHo3$to6NtzM11~ZEegw zt0^VnZ|I~;z1eXTX}sX@VrQWBXvW$yALG1th8!YfF9#P~G-D>>RErWGT8NWN2p zWS53)w?Yr2MsK@;g-hy{&nm<_yn4*e-+z%&5)4}?rjELYX-IeO72wA~Cc2{(D$Qen zr0=w>UY+BxgN-K>bdL*?3KAT8>xRHJBLnHO<1LI%$~o4CqcxcMqpGW7g_0ct86RRt zuP;KzZ4IB8BXnbQj96iCAx${VLAFa?_G3H)`>f3w6JkF{eBk0qqF?OkESh$DS9~$^ zm?cynyld9%qJO(bA6v?a9TIL0L9)%KMabY0&nE4Z>%gk~wh%=RfB}F?LYV`24(iLK zvHGqcun-Cw`XZ@K;CoJue>RkWms|^3S#?X3XQ_XY?%r<3R`A@54@nLF_S)-9BtZn_gf)*E_kE;GoV?7=#xC2fDQ1j z`gj7dxa)zWx7p(}-~1%A`9(*HXFcwDp$J3?)y4%hplO30Hkg{0v1bbXv9)BXn1`!F z^c!Ww(2Zn+g;FFL8<(1jrnxga0fi~7+aF$+>qSx43DwFGTCCLjO?kYsp;A2ZSOsha^V6aNu;EO z>WIB|0H@muDSN~})Vp}w&sh@Aj{Qn+N9*+|W!EE6xw3oPO)&}Ke;aB0;+0q=Ema%J$MeNsM6)iIg|3!u7e#JhAa`!HtcV zujFahY}!rNue=C*FZ>{2zd4vJ6%_m6$ukAhR<&^!SfDnFzl31M;b2|8$E?l@hU$$y z*{0nadf1Uh|Be<_XZfvb-QU_hr`7Q47;?A-BpxD?o#4P=~$@=^B^!?8)LE1ZAD?=}NGYM>@bO`CL zL>ax&O@)Orom7+*S;{*qudK7JNe)kOc)D2MLf%$yokUHZ+jx{-#nBK3dFb85P1mYv zmd8GFc6nZX^r#=k9_6u5RG7`aY#$WXeN}M%fJ5=8$9T*JG+!aq`0A&MZs*)v)A0p6+)|Mn!|x) zna}pfT2CRrJ=wp}-T&>~!`vTH@9LLnyz}Q?MUyDRfFBK*I|^*+ukSt6N)pR)FfTI~ zQFw?^q!L%y(OX58DARF|FGfd47exx{dv7#RQ3V~Zq}dKl%t#jFDnGmo%7_uvBlDwX z;=$F8@}^sq_(KD(U=(#Es|E=(F`EL3m6o|Z35#|7auD2g%IDoA8>1`qsJh%XLhWJr zUjK*%Gbiz8Grv-MECMlJD570^2W+j|NR~jyu=w~7W}WhmhCE&?howj)vlJq2>AiO# zK+Wk*v6n14C1$4Sd;Hg2;_n@v9`77=f-hwoS$0SAJ2`D{3m8n?1(m*+tfg)a#|VIlAp5d;OqK%+9k(-g5wWZi0Eu zVQ8c~9lSnPecK&I4b;mIL-EwyN*Z%5PorHBrFRZbW?Gr&uIc=A`tgqLgFNBrl zAT>4hhbQN}9PdQp9Z;H!TB^N!fE(_n_>IOV5p5xc7zUD0k29SIHo^fjF>34p1<0n2PB{Udkb@r zKmUn%u}g@#GorVY>PHN;c`&1KYn z3N9T>S>pMK_hR6XW>n@>K zydDWZe0#eXyB~Afa)H2qES;1qlV`y9lf}QLxoh`ezZbt@>PAFy4sr)sbIUp zY%bMY;ASSSBC#=%2+kcdwQo>s?1)ugY5N<6J!dQLU%eIdc#tn_;}rm{2Yz^iuo=1P zIrP2g#`zRZ(|XH6e*X3`A|-kG`Ni6%5V!jD(bKDAgDr7s44{_BZ}pecLCQ<}>;E3E zdJaZ8eHp^&cWltlX6j`8@r#jv?qnTS?4$Y9;6L`Cwu$|d3*M^5@zlTN{>_kRQ}SQA z;LTK{Q~tpPkCH<6bgffFR~kO{g=_-WDnQylQV~~d zwj>JSt*x_QXZ12&Lx_TAZqF}PACa|$w%67~&}~OQ;633!@*6#ntVrD!5SDAw3fo#8 z+%V(}y{Y44WsPmjNg+%GEGU~>y}rK{4d2qQBi;V+Wb0l~yvOqn49r$uGkQTpsm%_( z@5YXa{CPoGGqlg9L-E}4p2jp1r^iy>;ecp-AvJ$t2$&h=-=3W7njV+En%P}l@j)q= z7ZbXArkP;t$FOKG67j6ul0Cp{IO#yJXAT+n8^A{+jIrKKW77GRF-ars9fQWr;g$03 zC+GIHV3mY$yZ;oS0{EX_S_U?CCKS_8nqTaaxA1tnwoz1k;kBB3qZ{*hmo8lQr z1q5@4Kh(;JFZfs^PWz)r!jzl>~_z5~tCsV^l|NWzsSf{we_Vd2Yc;qSj(;i`Sx zowh#v+=7oPkjW*KSMD1nka`c($$Q$V*Rj?uH8VMB=c}8u(R_liP)qJsZ8+I*Y%ofi ztSjl2?TF;{G^2EQO8vfI&D;JWM*(Xz6adQCV&xqcsXnYTtspBcKaAbi|N417Kfk(^ z;9FT}IoLTCuSSAZo#|}Bj8~yX3(RdB!D4UD(r9{xc3S|d0+QNsOHZ#dIr4FKOSF)os|P1C`MOOIr+8~d z_}j^bd*XHY>^V43axs4bqHTXTFouA1Ha0ekg-8#$@-A=GVY)JE?FCY~g$xT4eRpeh z_*XEB<3WbgAbF4c-tzR@yFbLS$XSizIz!sbv>b2 zzuXeJl&n4ck!gC^y4nBFzu9Zy_9tG&_&l_F6Qx19 zU?NB{R{EGp91<;9dueqbc-?)Wb0eQtEMKwWWcJJ!%eRW=K`yJ<5>#kCzt`^UZOY6c zo^7n~i4)ksPM8M})Ax@AvHsx~kLTlOWbWgB&jl>?q4hIvjVD5^q7Fdzl-Yw;%;pwnQcz&p678r|R(GwmVy8WMo(ubDZclr$Mm%oNNZz*B)YN{1tiXZIxI; zw4{|7ryVw4RDo#)eiOcQx!u#zL)af{-ZfmKpct7q8gG&FX1VM3g}7Taac88qr5LT> za6>Ps- zk3J)GakSU%9P^3@y|&p7n((cT$pSZIjYtb2>DZ^--)N;e^{sQfiFJi5mejV!3fCf- zk9V+emg+7w^V36=4i|I{8;C7_aTkx5T2nT=jP)YdM$=GLA39(?=qX}!i?PYKD!9+++-$fCicFKI;uvomhk!Bz49ntRKrs@JyN8zfag zkS;+$K)R(vT0udP?(XgmC6ts_0i^_k?nY9&TR@TSj!EouuIGOCe(q8ICzuZHan3sx2kkXY13+;Cp>wQGMlccB7)ch~@WX2|En-b9?K+CEVLZmcQ`D zMCX{XJ}rR4nWv4rb5=F;nSa0C(`u2OFoMRz4sxA1rEF zPdEHVS~PXNZPXO3~jv5CP z!QT{>=$8ou7Zj10r)^4K)B!G4DgfKfByc~hQn*?hASG$!$iDpaWI+n~NzFa`s&1!O zVm_4pGgo2^N&>avewQ5+$8RG5fX-JW?D%CFsthciD^iUn!)&7yTt~f+4t>v7V>K6z z0Gq!HQbQuJ0;v@+R5k>S*>JRhxLnU{E(O}Z|7n9^UGBg7x{ZJ-!atqR_a3Y3^~pt@ zLM|WYm~g;l-5r`2B=S)j;EsX~bpVe|sl%KV@=fGvfx^cN`Ee+vU=RVHeqbvP-Bm4OC@5Vyps^4nN*G zths_IPb&qirH97X>WQ9*UF0-PJjJI!;<&es6|fL(Fl3~ylEiJDH*<}Hd3M4b*Y1$JD=r%N=!c_ z79ILSToMOBpAXV1kxCHKY`|H6@D@*Bb@@BsLPPaF9%&H_#UntS6x4Hwl{qioxHwDU zGRkatO6>pvIcLidhw#3g1w0b!633hkCl4D1Ms0vme~I`y1%c3NS4fC+eE})D_f;fC zMs@AL=bNZmh;>K-v!2TPCl*(iXu=3(-BitV`FeS^vG+LS>E`mUlOAjjZ*Z}=Jobgt zAcvRHZl+2Rmeb$RUXS>kAfq4sA{50MA>$bQdoc=JB6zkLKU6PBFa7}!Bd((a4jbVD zmNUOkI*)T=f2|5@b{%D&LYDIWww87#A5ig+5H(#T$ zV5@dYqtv_*rk?wRz8}i_>p|r`6Xbr(GWj~kB&)B!%a=$G^HIG%3>9)8>)Op-^3lKb zuFvDqS`#zEJv@uhddI5mTFv~z{=PVj3C2;MA`4Ui#Z|>3W(UWBMXD;fcV_;xClK8k z4~ji9eBk>Ujs6U@C>QfIi?W{hC)kQmcR8Y=e7FIRJTOQ#qF6L}5H^YJ=wqRb&p!*| z^7r>gB8=1p zUWab4ZY;VvJ~_AtQ@Ar^ddZuNcou`!|_dQ)9ar4yObal-L{2t8$BC-ZKhYh15Z`A9 zUOLBG7_G3;kwI#GhYg86sSEz;ERG5o1FggfL=@Iq=GbofkkK0}`Mwq)%1;3ERiv-@ zSc7|{74*L2%{|N*U;YMkBzu5EK9%D|BUZM5IjW((4EVEr2BLg{>Y;;$L zz^b^oI3(HV1tBTlw?e!xT8Sfx(yq%z{oKFv6&!P8wmz*v z901mzO1JZ-;YK_%X=_LWNlH3+*LXx5^`^=a%C142ens`H`hP6PrvJ4Z8=bUaM;>6f zmsB+W$0DE+SN+~=Sd z-E=uVC^K+Ij>9f=VN~I_HHwfngO+4^kg*crpsbHa-?-*2@HqM&c=cG29!)H)d>q+9 zSTNn|i;^a+elTf=R+3d=&L14W~CnX^jR z=Q~E-1C-+?pI-tex_C{qx?lL-b~zI8I!c=*kV#zn_#wdi2N@~edd_CEb*IHVFJ&au z%?g-RGpoQgZ(x25?md0j51Oh*yoc_yvlH;eKP}4W&*E`CzoJ)~Mhe#eI2xC~XuiqP zX#vW*u%t9bv*<7V=P(k!cXf#uqY&8>2AD9j63O_ijg-;lT=_A*YyJm0mnmmCX zsC$6C!WWU0cGyprXl*~o*g*0NQEo{21~L*gu9Wa2{k;B3i7MtbYa2nvL}9@u@&DnG zx6~O&k2EnOnOC^=sVAdThS&xeH zY$#0NzYdC(=u*^v_lmMZg9y)Bl9q(^eUd2No#`JhA>JLx;yyH@!uBppP0c+ILW)Vh#@Wuw=Qe>j!;YmKX-}?7T zWG^(*yOHbn0x)q4Ce?fCcr@Z{Sa?*i;8J`Ht4+EHRlv59A&ua0%`WZAqs1eZG5fk~ ze-kEqnfjElvGUfiSEBH5+0v|e_bROZM)S}f%VmDR@or;bbpiz zF$Mod&EJ?V@lU~YNgR5ag)pysge>8LV2F;N;0ZXtq78fmsA)#Z(Q~*%gBV;4eG!$w zfZjyf9QtZ@e=>zIz_T*f-RiQizBVv=ZR!U~U5HQ6&>uW@?Uqj}d4{rYYIU6SG3-7O z;o?a>#NJY$qGR7`OEYc@Ci1{;ojvnddSbyCZ~72BHT8T>n@zzv{_b&)SWUn9{pXr~ zwyThxJW6k{6VMzdi`|Yaf5V)iWsRbT!6E}drHOZ?Lmz>u_i*B~|HYY=+%0syiEbGe zh#tGRqKrL63&K3ztG97eQ&IC5XrLjNw!J%yti5gp^+7KBV8p};x!pwCqoMloO%{G^ zDb!BjQc#GVSa`v#XqFY7@b|1VsMnCuCIRNy-`e)rOUyvCfOxGPVt|8vlKQ}*0CM={ zLAU$dI1a~@kG=;^$KLUKPd+GwgxQ9OzhzLg?$f^}xMTqZ&cKqX!HO*U&iyieF8>KGgE_9?i$d!or>lp6I~WUG=D0g8}e1N_(es)s`yXKkp zeUL?#rh%O&8TMcr8T8#(XgqcE9wj}`(0~LzJ3;6{SvnZeS{q6W1!X>fo;GG zodbJdo=U!y818nPxABdAIo0rPcv-sbb8Y0fi`uxLF`L`3*ZLh0Dy zpj}INIJ3Run0sU=aq*RG0ZZ=mHE~KAC$x;i6{E%v;l}Ue4Go*t#g<=%hwFE}A?;t> zO4E6J)LY4*nmItrW5H{;#!#7|=Kjh#{H7*eU(h1{gUPS!r}~aGY>$tdOBfpZXIy%I zSiC<@Gp5Oq9_OUdaJZ>Uox5`RG>uI?n&{U1YY{Y3EEY;pjv3`P)6o& z*F-dYx9MwinG+o~DdEQ2bz}h;pgsTFD|0+BhzowBuJdC1s7v^X$89y~;o-XE)7*4) z#yXNRLeaGrbrE;nU#gJbS+pjRzgnQE%TIYx}vAcBnyom%6zr&nGq5GK^GY3d$5q?z7)14g#(B-4aeHJR#HZW ziW8qeRjG%b8~)C^`nr>++a9MS$P{KMXkykXHG8vp_2fgFvm+iG);JrM#^g_F)sFxD zw{7w1Lu~cw=IG74tjuVN_eCu(oPWrVoZyIMZE#p%fm8p@O|w{z*9#bTqGV(^ZY9pH zcXHuR-;wZULl&Muibi|H+_+XT)d#fhW+6cvq1HtA=2XFTpP;5T=j88H3_qr-q3Wc;O@J+AqJsyUH9f8WKhMt z6h{7!I2}V;od5ZbfBm5v1Np}4@G^&n`)=!_WeK=GMo}rjP9Q#<%n!ZPa9SJRlHOT`gZ^VcOY;husyh5WW6x$vyq>p1ZAfgU0-`{-iAh)`Vl$kPq!h-YBJ_)@Ow*@%tDQVuPPHu?t(X^{mjm zGjRDEwwc*}VR+BJY3?dC-rD>Q4b~=?^ zS@O4Fbo%XCrM}qD_s7&E#EOn8vB)S`WU(#aXi3mWqHuW)qwGnMA7`47iyXpUqu@lb zD4p8On|mo>j~+J==Zr z`gXtb*2Yi5G!YTslUQ*q!R!N;^Pa10*-0)6MZ0VEy%?9#6c#U#wQ}?8R*c1^k@#0r5;q^*BH<4_fz^|fqL(kx!2m;_Z{)=A92T)@53UnRvv|3K>Z&f4TpKILKij;=f zYtH@U-Z+4aA2;}(mS0MWnFx98F5E)P_CBO|R-%?ae&!?0+k<8|Ri$b_TX$daEkhiH zS}SZ$8EB2(g&OnZ-uD8pPW7j&Cy*zUHeLH0IHwx;?1$6>a+|Lvc_9wDu*`Z?d->#7 z6fC|Z6>P7V!ow9zp|fsEibFs1CEk(!uey7%i5P9~8+Ix43fciEW9akov2c~;aK(53 zK8rI~J<~hFwl5hTC4^V$1*PSHa^)$>RU=l35e`EFIB^)z{{Ee zaPeZ*Zv&|^BHKbhFNSQrXA84zqAd<+^q&&?ssnQ?&r4m%y1mP(kKQ?8)Y40cAS*iO zv-}8z$x|54emnMqa|3#c?~!vm6NR*7&V%;AW4nS6vy76O@F>)aqTlqcA1$pmQU+@T z1LteOTV{YI#!Q*e2I9-T2w5&1#@hr+W7RIC)Rr9Db&v%t_{q#fWL2T~*5MSW=(OMj zPsF1ZQT)@Y==uW%%^)FlQIeky>ak*-Ogb!mUNrb(tWK=1Yg|$gaVr_(t;{_YM{Ky{ zpDiW}|K8@edh7eFp$_a^EI+pOxB}A8&(>M2e$_gs-9mTk~$ zpwOTFLGbs31$-hWi~0x#H)o+Da*C2>N#8+!fuw{icXW~S@|JA03R)cRUoR>1BPBtTXR+m!^em-taAmg*t2rbD<2C`|@DL@7i3)E5!e@tl# zM1fAS_e32Jrz|pTBymXO5C@wMmqP2~SNGS)3gY6@v%U*V#QNz7IK2HCUvD~d5^)wu z{)b5c-`ph<^@9AsMkU(7?}a>R4r(*$oF78MYdOs$NBfWhfJp-;?A0kKFUM$?2+G5+{8(u7TWe>VR~;lKdxjzgRG%%D2%#vYHX-?qbF}6(`*pp^7Ea(up&*MIW-beo)Cgv)0AxT9>Q1dA?RBXa@I&zRMuwp7aM40haew3uv(b}Y*ILk9N7&B!{pzW(&V4WK_+;Jlj_~9K*LC7e{#xcIB zAJ1q#(8jdLY8i_@)d5!NxZm`0P?Gh@?+*fsyI@C|WoMJs9G8g;+uy2%o`$P~`YVWZOevI>KW&Xz7+PKD@Wyr5{7A*M`|20lU%?R(LPl@J z3ryUW4VB`TKk=1jjqxKef{tec47P=Mw2Vqx0}aWQC@O8nL8NBO6S1mw-TGqC!oVw( zp;zni6P|9cWVC;G{o2hx%+qjEt_Ro9$KJn*reo?*@}T*OML&ct%rFV|pO3rMzaLI= zXqTnHxJ`1bKr5@(h(6dK(_Pw#i7(wrw9yjHVdg|5+J>=ar4dsIlkkgv{O7fc{-j^R zA{wS#s2BUOMm5+-QA3aD>Zo>m5%SKE5Bt6DktGBWYd4V8TSZdK!xUp2xJVVC?uc+H2OXBVNlQ?(|VYQKYK-IWko&dXqMc`n?r4x?xW#kZPZv@vYJ zLscMTij2P{!9r&@T|QoXV@u4vFYA(FJjDNIdxj=$kwwed;kz7CzdMmuDoc8`ZsW=n znjb>C{rxGJElu$sA^_th_$7#@*`!(K7*u989WBMB`f}q&CzbK}bxv$dw>u=x8;J`L z$;BV|-Twk}it~$3Wdoct+IPe~4f_gSVdScR*Wtx(m&)UeLq(q?k9~#XVnH_jTS%(0 zxyWu>y_YW70uyy?vUGU>V*sdLE6G;`zJY91D-S;U?ogec>W%GU%?s_N{icV>stJB% zNRgzN+3RFJX+wivZEpi^gHZo>W^yd@1=90PgIOJazY2d^xPdPI$@aY9BsC<>H}~nV zB!LEAFew zxpnSToDh*~n&k)+3%JO+|E~D?kHDWx5O&{{E*8*say9(RZl*|Iq;ZigSRW^ex}@>w zJV*6{Y=sg(>OI7_veUo598?qh(d^7b!kDt#FlRToDklU&s(K+mZ5Dd8>Ysgl{^&bq z!Km4G0?FUBO4jC*Rv+(D(WYDv;=xQz97osg0+XwA?4P1o{O^QsCpIFVzU3>6 z#=e2`>wCnj*5{uuk;_j_J&iAF_w}fX)4pYelZ(W)%pMQa2zDO0$rsXhz^3w13`&_O z=5>)@1PWCFbK<`)a3Mt@87K~9Tg#7goG0_OchCit-wVs~>KT79zLm~z`ml)2!1QGl zjYRtBet01h-zH%sX}CV*_7zBzOi>(V3>$fba)6 z(|tZdp=)@ZXAO6KO7GEk$1R>*b31`{QA;-})};lf1dgTksEk+2&h1WK%po5?N~VPb zrZ(^%2=tkH&GUgpJTB%N~@jQtui z>bm=wq}sWyf96wGatK~(z2!ORS}VMPL60qkbZ=Br6%n?C?|s(jm_@%*9FBJEMj;=O zPa!JOYn7dx569aOrCSc>kq*73{|=)l@xRvT<`zb?%0YI3)mbBlxZr+02`&Hw~k2=b4{UC@pBD&L^tfLzpbx5PG+zg zGOeLC($O&aL20J!M9RqaRqf}T>5MxA6y=G4i(sV!HuZr0d6^`MkG%g~u7K8-3% z2G@Pf=-C}D#<(_=qW8r2=LrHWsqB_k+=%LTv4V|?Y!L76hvV0>z+&p-!eIv1RrW&L z>|DTSd9R7wJ*M#qY?rMWEvr$MbG@P$U(`o&lv3!qNCrqabU)s-X)nGD#*a~qnoW_4 z^$xi24rL`0q=eE-1Df)goRoRZpKQQD*v+b9i|W8j?f~Em1bsDzV;(tgO#h zVXFva>H%>SE!P>+$k-gBdkT;q(>kP z*6g$-=iS{+GqjU5^7ghA4K{;M!7cj~a*d?Te~jPsvj1*3B&@?| zyl~UQiTFk1w_KA(_@Sw#&g`0829Tv|gs0FNm+5(Fx9-s+JulScEB3c1@i9VKQ$xzH z(QMxwmq*^u2^eYiupOSgHnY($8p(j8!zeH8&;-0WT4j!(#_kHf8@(M(u`!udTYV{~ zXR?}Bx4jbg==0^J&a$p5(_Noi^K+1ZHr&Iz6&aQeGI^@MA7VxFR(uaK;TaO=B=`TI zlcWs{Di|?6#}Rfqp%5mXi8$H=Etej?Zd}pygF&R!&FBvlLe5pWXS~60!F8W~JVVlj zNiDiTQFQF)tOR4s#UHQs)weC`8Xab;?xUh|{;h6oe8Q4R#U*51NVQXca%URb+Pj>q zv(*WEg5A)|mn>M%mQ=mjljDxKcQ&E^Ur`lvK>n}qpF-jIis5xsg3ejv{x{40W@{rq zp`J%*KXB~@ERmLeXN7$_9?_>vq^mySqzhgcgk7zF&3eb&RW--obHN>^eU6VS4VZ1w za1I(zq!AxqRw2pv%WS^l3VrFYS=tDos6Wq2tQb{3bsX-X@(oN{OPAeKcBxm z^+)dz^X@!WRr5n^9wV`!)pIu{Ty-e;$w&4A#;kdzt}{EQmYOEQj@~+yzB`MW zyMkS9HbV?z=@|PwnmB9YS6E^X(N!eew}xKiDyMx(Rg4vaRt^2B#E*vDTwDmKDVb_n&nYFLapx4n75p{_d&MJgv(-#T4xZb0MUxV_F%D8r>X+SYf@o zI>xnr$ynKOd$9wX;mBzSl-d+}lqfq%SV$Z@ruO%KHPR0Ke_85?Q&J zy%G1d=g;vovc~;>RhLH6JW!7zkntNYw|T%``SW=lU)J^LdS|H6wi~{D5%FhC>((Gs z6ICd?@7AeH0Pcje1o`&5B4I~&7jZXCzY~VO`*?hh8Aww5qAQCAf+Y6P!}r$j%P~^j ztw%2(OiGAkPu9D2Y1*2riR z?IKx`kg3zOP_d>jsEMPjUh^wYIx4n9)D1sl$+^$N<7tQ30-~fTEgjt1ClAs?mU?ye zEV)FGc;ZFx@0L(&op8jfGp~WCA>Wsj2K9~cZl&TH9T%j%TiwZUS>}@@;4$rC{;pja z_q!#`x|*)2SiWC>%HU!9Ls5FUF$Ryee;z*je%s;{R&UaF-;lDuZ4L<-lH-6~_q%ke z4U8Jk);FJTUIF#|hoJ9??`tYyaztf;+Dxuo@avIk;~iySCAF+`n}o)sN6i!ukE;i9ev(o$ z%82vKJ-cZp--lslo)B}v!<$}LwDV2e`#^9gtpKTqL^|DCnDn|F2ngSp)B)jO%i3W$ z_d8y0akmAKPdu)jhU9{lMR;ZK)H*o3nDDGrbdqRgtWvl2{q`AX9&kNHk(Tu5fiPP7>wtmCE`VOn z8^Rrb`X{)v_@yOJZ)B`3Tl5}`VtlAMT$A@?y-Cc$_B_{HC-GLvxgmF<+#vWmiB#Sc5gkjsm(9f@zk7|=#+BVzqifRze|CTI zjZH+KL3NBab*0Qv_h;qzcb4cIDIQp{fX{Tafjau(!)ifq z>XNHSN{PWQzW9zi$3NrGyr@14TlCqAu@Fj`^}egbc2WAuiupKQ(CHzI?^*t6@uq6( zcxN(ahSJ_UW4F23<{MJi;6tdlZ21-QeqZDKoKF(vFlEze z$Eg>zHol_cuflHG$OMRu)J8VF63tLNaym3D+@a&OfCUL38~QPqhnBZ?uqas~dtYET z3}-cWC5`&ToS{t~|D&c?SXvP$+#$UBa$#h6XPc2>3?6Bp+QzTXggir_j8X5XXpd$ z9~@1iUjrZ|gi>Bu({FN|wu8JssU8t|iPlA%`BPlUk(P`g#C(J5zDm(YU*K_suSYFB z$b_|}NbO1yg8b$qc!X4(QFIOIHx4oDjEy=`mZ%lz7C*EeE%=`LQiaLzZm~t7gR3z` zZSY;Ky@8r({fv#(VT+9z*+CEt0bRHls?ZaG1cjIO;gWM?g!=&(O|Vc>d1BM$dWr zZ%{{=S+z&5)}%zpqMGJ31#^|WFto>fgIN(-je<_d$xBUs4NPn{jNlzXST(JlIGGr) zRJzv$pZPJONehfo69*m&05-&VaQPCbV z$IFZWpx-x#N@Q8*d2Hodtw|%-tziKE?zWjxSLMXr;Mn&1uH;nXV8B<-f066)tKE2uH5v~`SpHYM25@`LOR{BTE*eTdR;Qppb9` z;V@tOO?dF6eqzU>Eu_lp*Bv7&BieQ~@s zH{K9oMxrG-ub#w~+Sbq4(6k>z?`U8ibtAQn^~INOHeAUZ`XhlNbyupGK)#L%MOIO* zgtN(79@}=zBN5=Nd^*a7drJ6Icwrv5LPA3LS&hLl>1uyDvikfs8QDkqs832?UKD~= zVw2e8AL@tc=+CJO6e)*}YPD&0O1^&7jd3&kqbL~0d{0zYRK*YWkeMgc!7yso^t%&R zqKU3#@<=SqCrYZ4d-oby>%6b$g2Fv-H&mk(C8?TS*iv*^WQ3)w+9seeO5!WqOUiEp z_{tVW_L474Tzq(Op=9ykgvdulK;c)oMMt1si98++(3K~&GuJs^i!qnN{AjJ16ceZ6 z2~|v$es}x>Nc}>De_poSJ)knX3|S@-8QI;g%SEY3_QQ3iVq_?KPTv162dcH!dC61_ zP?sN|o!zNGwWzDg)#XmeEraQ+N$NTy;p1Nw91TV{xCFLp zv&L0N?hf1(2_qPJLyzM~6&>eAe8@d657&VspAro=1Et6{)R8=>y&*Qj(*Nz9| z?nulVB6e$vuyc**5dSl+#!xRb-$=HbM`sE^(Z2-|TPykL4;l4lDz=QB-+7^+DdCcp ze80)9&ecv#w(y&RzLtl!2}geAi z4eS+NmyoP1x9W~y5ap0!*b8v%bS`mvVzvPT^ceH z3Js6fJ-5>(0-9M2uW3<%b%A=T4pShJHp_Wk-R{6-hGs^@rQU?%YxSO=PaZmtlnxMsjh;~%K?T0&%a1jH8%~W}(KQgM*DK5@x+8rm_>H65G$RmDH z&kVHStsm196!<$2zo=gf>0(x0wTp_aIeYkER$Y^l`OA>&^K`hZK!NkRCc_6Vr#b;= z!OW&Wmwax55I#5Tgl3uy^5J`mZ?nBC?#Vt~<)L{z_HEKMcN^yyYG@znvrRfXp3JvV zX(JhaN7d$3Qq@NIG0rWMBZ4L)C3P!{hMDNgTE?_iIAro((Icq$qTRU?SdSyN1|%7H zNvyf0cpSEPzeJ{RPBD_Wn3^FO7+X%WU0tXJKQ(kY4dlYr;DL zebHO_hTPW|S8P;zq;(=JoFT_+so&_B_Zf~!<)7nv#7m*^*}y=?4FxFHZtyCx>0VM6 z{`86`w+dGTl{+r-pu0U&V#;;odLBaJ{*}SIJxH3fMj<}yZGR$JhM4%7#_n^ZiJ;ac zaL+gHpqc8JuC!0xUY@Bgb=#}995hDGY(g4XuGPo!&~Ock`p-Zam7zy1YLJ1Zp}bB+ zn`_g4@mjKhtC1jtw$?3jploK^%@I=?ph&5lOmw;j(Hj;Mpok1}O9WoRsOK?XOZT#Y zFTs+(Xwwtb8^*M-l&X~A3BQ;P%M)_JcqQ0ji_!x!=zI1va zvTZX%s;dL2l}mlFtxKo3X@N(D?U;XBTnd=>3YmmV+`50lOStNfE!q%E% z@o-vu>`C=+VY~P5`34aU4lMsVuZM2T0ac`c5^ zB^`%k2Kv5rz-4hC)kv@p=~T4%F#r9gi}nw9N~->lH@(A-?$86*1`&s@<_)4E@fv*m zy0AU#>5BSl|NeN9n2LUQwhd>Lnys7vbYLP(V%^8a!NHE$yh0}+h@g^iR|2v>Kg35e zj1rfGq*_=o0V46Pb9*w$0<`j zNGYs*xwip0->C^CXnf;Zjq<-0{FRc=Ht%MDjDlSZZ6#9lKSK!^;Itgd)=E*^omhN5 zPa1Hwe3mX7=(Vo?-Ay$$6O-^AjJ4tjJ7R3E1Ox?TZZv8jWBfSCdCgxV0k^~Ts{~?5 zX=mV_T?d-(Ej&w8Jz1WGn!Odkik{>3CaK2il`dhhHw?HLl;86wL)C&d zdpZ~$3->x|%BM(7RI!`M_-#fjrqv;XONsY8?wM85Xl_uJd~_!a)yjUsb1MqU>ZN&E z-}+&9$ha-p2vyt;DdRYbsqZ)46Mp^Af4Gs326tLUPiX`J6`mlN( zz8sq2qQ~7ik%C{2%{Z5zL5Vv+I(jn_uFS4mI5!cV9FclUpl# z=GEhon{X8pc%vtTVU`<;_Z%sZ(>ED|JCw)!fNY=f?#Xh73y;ycXSL69bo4YJQfxH7 zol37Y4?tV}-p37W!mq814$=0)uj*Dubf!TOG!jAjb7hLp_uJVXTRz>n(@~rZW3z7^ zo?gmtVL@!=XbocRpYu9#0lh-q>W7dW|IyF*z>R?RrI6ROkYw2?cDT&1NL+i%2fI|+ zrSZx)I-VJ^=Xhi^7_AZivfS7%)XMWdSRr11@XYXu|K!lU5(o^{qi?R4osRILK%ceI zBc}Rhw=~87brF&Vg)imAf|XkY9}di>wAu{GT-3TG5125pFCUrre#n<+`0eI>w3ZWO zycLY((4SyNkx}^b>Bcp?HT|qe3A+9yU^sQ>w^==xa5(dWCwq)(zO0ZL z|DcGcJ8e0X1>`Hm7K6D?PV^;WAMw^XM+@~i*NU#i~y+SJ~$x&~g%yvfeyjkIA_Kx+V z?|hQBPQaP&)xkT}g>}6B_z#0(Pd_2!lby&(LJ6sB`y7IgEu{x5Wg5de@6;7?Z8>H? zX>vPqCwM+`cl{H+pAm8zyCu}_9#=okjX8oyXGBv~Y#6{YB2UR>^r#8LR& zydQEJ8a{iqBK`403nhJtuYRWQHMCy8^YA4B>T10HOi$03BJCbwds1m3->&~2z3VMyiqPDa#SI1z2W*HgxakN0wQvh8zo> z!p`U!=NslNd&AquQpQ_q6ii)&Af%PcF6qW}jI3DbSr7F%IXSlUfAu{e|7?GEkIVYs t>1y~l(*HZ?`u}^3`~P3x(FyAcYuU)|c40a8C^(l<6lI^t6g)Hx{vRf_)wBQr diff --git a/docs/investigation_ball_contact_orientation_divergence.md b/docs/investigation_ball_contact_orientation_divergence.md deleted file mode 100644 index f05c8898..00000000 --- a/docs/investigation_ball_contact_orientation_divergence.md +++ /dev/null @@ -1,42 +0,0 @@ -# Investigation — a robot pinned against the ball rotates away from contact - -2026-08-31. **Status: mechanism localized, not fixed.** Needs motion-controller work, not a -tactic patch. Full original writeup: -`git log -p -- docs/investigation_ball_contact_orientation_divergence.md`. - -## Finding - -A robot approaching via `go_to_ball` can sit at chassis contact distance -(`ROBOT_RADIUS + BALL_RADIUS` ≈ 0.1115m) for seconds (up to 11s) while its facing error -*grows* instead of converging, so `has_ball` stays `False`. rsim's `isTouchingBall()` -(`vendor/rSim/src/robosim/sslrobot.cpp`) requires the ball inside a narrow box (~3cm forward, -~4cm lateral) at the kicker face in the robot's current heading, not just within chassis -radius. Visually the robot "has the ball" but doesn't. - -Example (`switch_of_play_vs_default.pkl`, friendly robot 1, t=39.0-40.5s): facing error falls -to 4° at 0.19m, then once distance locks at 0.1136m it rises steadily 25° → 48° over 0.8s — -sustained divergence once translation is blocked, not jitter. - -Incidence (runs of ≥20 ticks with distance < 0.20m and no `has_ball`): 17, 28 and 21 windows -in three replays, both teams, several tactics (`LeadAndSupportTactic`, -`PressAndContainTactic`, ...). Systemic to `go_to_ball`'s short-range approach. - -`move()` passes `angular_vel` straight through from the motion controller, so the divergence -originates inside the controller (orientation PID and/or the planner's lookahead carrot) once -translation stalls. - -## Fix candidates (in order) - -1. **Check for a `target_oren` discontinuity first.** `shielded_approach_angle` - (`skills/src/shielding.py`) recomputes the target heading every tick; a flip near contact - would hit the PID with a jump. `MotionController.reset(robot_id)` and the auto-reset on - orientation discontinuity (`91100ff`) exist for exactly that shape, and shielding later - gained commit/release hysteresis (`8059abc`). Trace `target_oren` tick by tick through a - window like the one above before anything else. -2. Otherwise, log the carrot point and orientation-PID setpoint under near-zero translation - (the carrot may flip sides once the robot is closer than the lookahead distance). -3. Once within the final-approach radius, compute `target_oren` directly from robot→ball - geometry, bypassing the carrot. Smaller, but risks masking the controller bug. - -(An adjacent hazard noted at the time — `has_ball()` misreading enemy ids — is now documented -as friendly-only by design in `shared/pass_and_score_geometry.py`.) diff --git a/docs/investigation_default_vs_lowblock_stalemate.md b/docs/investigation_default_vs_lowblock_stalemate.md deleted file mode 100644 index d1f43e1f..00000000 --- a/docs/investigation_default_vs_lowblock_stalemate.md +++ /dev/null @@ -1,41 +0,0 @@ -# Investigation — `default` vs `low_block` stays 0-0 - -2026-08-19. **Status: partly fixed, still 0-0.** Both configs are baselines -(`docs/strategies.md`), so the remainder isn't worth fixing for its own sake. Full original -writeup: `git log -p -- docs/investigation_default_vs_lowblock_stalemate.md`. - -## Finding - -In a 60s headless 6v6 rsim match the two teams' `PassAndShootTactic` passers (robot 1 on each -side) pinned the ball between them near the centre circle for the whole match: both stayed in -`setup` for all 3600 ticks, no kick ever fired (max ball speed ~1 m/s), ball travel was 6.8m, -and there were zero referee events. It is a tactic-level deadlock, not a referee, planner or -rsim-physics problem. - -Root-cause chain: - -1. **Symmetric race.** Mirrored formation spots, both passers 3.43m from the ball, and the sim - started in `FORCE_START` with no kickoff, so both arrived at the same moment. -2. **`go_to_ball` had no concept of an opponent on the ball.** Both drove to the ball's exact - position from opposite sides and wedged against each other at pin distance. -3. **`PassAndShootTactic`'s setup is opponent-blind.** `run_setup_phase` exits only when the - passer reaches a target ~2.5m away *while holding the ball*; the longest possession either - side managed was 0.9s. -4. **The 12s setup timeout (`3a17afc`) only restarts the same dance**: same pair, same pinned - ball, target still unreachable. -5. **`default` commands only 2 of its 5 outfield robots.** `PassAndShootTactic` only commands - `robot_ids[0:2]`, so robots 3-5 never move and nobody can break the 1v1. - -## Fix candidates and status - -1. **Opponent-aware approach in `go_to_ball`** — done 2026-08-20 (approach from the far side of - a contesting enemy). Partial: possession went from a near-total pin to 55%/44% and ball - travel to 8.8m, but the score stays 0-0. -2. **Setup-phase kick-out** (holding the ball with an opponent within ~0.4m for N ticks → push - it into space) — not implemented. See `low_block`'s setup bug in `docs/strategies.md`. -3. **Stop handing 5 robots to a 2-robot tactic in `default`** — not implemented (open bug in - `docs/strategies.md`). -4. **Kickoff ceremony for sim matches** — done: `match.py` starts matches with a real - `PREPARE_KICKOFF_*`. `StrategyRunner` itself still defaults to `FORCE_START` in sim modes. - -Reproduce with `pixi run python tools/debug_match.py --strategy default --opponent low_block --dump-ticks ticks.jsonl` (per-tick dump) and render windows with `utama_core/analysis/render_window.py`. diff --git a/docs/roadmap.md b/docs/roadmap.md index 11de07f8..a9bab6c7 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -30,7 +30,6 @@ entry by its title, not its number. - **trajsample liveness fixes** — escape grace `2e53f3e`; target-jitter tolerance `5183ed1`; brake scales planned velocity; stale intermediate target; restart-scoped priority blocking `9757814`; two-segment candidate instability `4b701ae`; teleport-settle speed + 10s ball-placement timeout `43d41af`; four `COMMITTED_FROZEN` causes `70cb5c6`; `DefenseTactic` carrier clearing; `DirectFreeOursStep`/`BallPlacementOursStep` sticky kicker/placer. - **Sumatra-fidelity audit, top 3 findings** — acceptor leniency, escaping-grace clearance, full-window priority re-check. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). -- **`metric_correlation.py` reads `.npz`**. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). - **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion at the last release (a frozen `.strategy` file) in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded sim noise (the simulated world and robots from `world.json` and `robots.json`). Candidate and reference meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 better, <= 0.2 worse, undecided after 6 rounds (`analysis/ratings.py`); the match results store (`replays/match_results/`) never replays a fixture it already has, and `tools/evaluation/explain.py` draws where the robots stand. Until 2026-11-12 it used `opponents.json` with held-out opponents and a ledger (`replays/eval/ledger.jsonl`). The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. diff --git a/docs/signal_report.md b/docs/signal_report.md deleted file mode 100644 index 38d48abb..00000000 --- a/docs/signal_report.md +++ /dev/null @@ -1,156 +0,0 @@ -# Signal report - -What each strategy does well and badly, from the signals in [`signals.md`](signals.md), drawn -from one round-robin. Standings are in [`strategies.md`](strategies.md); this shows why. - -*Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names -(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). - -**Run:** `tournament_20261017_151052` (sim-realism-20261016 at `423f63a0`, the 12 non-retired -configs, 66 matches, sim noise `v3_seed2`). Regenerate the figures after a new full round-robin, then rewrite the notes: - - pixi run python tools/signal_report.py replays/tournament_ - -Signals explain results; none is a target. A red cell is a place to look, not a thing to tune -away. - -## Why each strategy gets its results - -![Goals, shots and goals per shot, for and against](img/signals/results.png) - -Goals per match are shots per match times goals per shot, so the three panels say whether a -strategy wins on how many shots it gets or on how good they are. Blue is the strategy's own, -orange the opponent's. - -- **`split_shape` wins on both**: 21.9 shots to 9.0 faced, and 27% of its shots score against - 14% of the shots it faces. -- **`clear_press_plus` wins on quality alone**: as many shots as it faces (6.3 and 6.5), but - only 13% of the shots against it score, the fewest of all. -- **`counter_flow` loses on quality**: it outshoots its opponents (8.9 to 7.4) but scores with - 17% of its shots, the worst, and concedes with 26%. -- **`decoy_and_overload` faces the most shots** (11.5 a match) and is outshot by 5. -- **`high_press` plays the most open games**: 32% of its shots score and 29% of those it faces. -- **`score_aware_counter_flow` is last on defense**: 30% of the shots it faces score. - -## The signals behind it - -![Signals per strategy](img/signals/signals.png) - -Each panel is one signal on its own scale; every strategy is a dot, in the same order as above, -and the dashed line is the median. Only the lowest and highest values are printed: all of them -are in the table at the end. - -- `split_shape` is far ahead in attack: 26.5 entries to the attacking third, a shot after 23% of - its regains and 55% of its free kicks, 1.28 m gained per pass from the fewest passes (17). -- `clear_press_plus` and `split_shape` face the least open shots (48–49% of the goal mouth) and - save 86–87%: the defense in front of the keeper blocks the lane. `overload_press` concedes - the least danger (74 s) but faces the most open shots (67%). -- `clear_press_plus`, `overload_press` and `tiki_taka_plus` pass the most (100–118 a match) - for the least ground (0.13–0.20 m a pass). - -## What makes a shot score - -![Goals per shot by distance and open goal](img/signals/shot_quality.png) - -All 1122 shots of the run; cells under 15 shots are grey, with no rate. With three quarters of -the goal open, 90% score inside 1.5 m and 13% past 3 m; with under a quarter open, at most 12% -do. So shot distance and open goal mouth measure chance quality, and a strategy's conversion -follows from where it shoots, not from luck. Every shot here is already on target -(`MatchStats`' detector), which is why the rates are high. - -## How each strategy loses the ball - -![Ball losses by kind](img/signals/ball_losses.png) - -Real ball losses per match (not won back within 1 s). They are measured for config_a only, so -strategies with fewer than 5 matches as config_a are left out; in a round-robin config_a is the -earlier name, which leaves out `split_shape`, `tiki_taka_plus`, `press_and_pass`, -`press_trigger_flow` and `score_aware_counter_flow`. - -- Being tackled (15–19 a match) and kicking the ball out (10–13) are the largest losses for - everyone shown. -- `decoy_and_overload` loses the most to fouls (about 6 a match), the excessive dribbling and - double touches below. - -## Fouls and stalls - -![Fouls by rule](img/signals/fouls.png) - -Fouls per match by the offending strategy, by rule; the ball going out of play is not a foul and -has its own panel. Each stall counts for both teams in the match. - -- `split_shape` commits the most (about 10 a match), half of them stopping play in the defense - area (4.6). -- `decoy_and_overload` dribbles too far most (3.7); it and `overload_press` run - `DecoyOverloadTactic` and double-touch most (1.6 and 1.7): the lure lets the ball go and - touches it again. -- The ball goes out 15–22 times a match for every strategy; most for `clear_press_plus` and - `clear_danger`, the two with a clearance valve. - -## On the pitch - -Drawn by `tools/pitch_maps.py` from the same run (`pixi run python tools/pitch_maps.py replays/tournament_`, -about 3 minutes). Every panel attacks to the right: the strategy's own goal is on the left, and a -team that attacks left is turned 180 degrees, so its left wing is the top of its panel too. -Live play only. "With the ball" means the team's nearest robot is within reach of the ball and the -ball is slow, the same radius `MatchStats` uses for possession. - -![Where the outfield robots stand with the ball](img/signals/positions_attack.png) - -Share of the live samples per cell, one scale for every panel; the five dots are each robot's mean -position (the goalkeeper is left out). - -- `overload_press` is the most forward. 83% of its samples with the ball are in the attacking half, - and only 17% of its samples without it are in its own half. Its robots stack about 2 m into the - attacking half (the dark block in its panel). -- `split_shape` builds from deep: 37% of its samples with the ball are in the attacking half, yet - 72% of its shots are struck from the attacking third (below). - -![Where the outfield robots stand without the ball](img/signals/positions_defence.png) - -The same robots while the opponent has the ball. - -- `split_shape` and `score_aware_counter_flow` sit deepest: 68% and 69% of their samples without the - ball are in their own half, against 17% for `overload_press`. -- In most panels a vertical stripe stands about 2.7 m in front of the strategy's own goal, in both - figures: robots that hold one line in their own half whether or not they have the ball. It is - mostly `BlockShapeTactic`'s fixed-depth screen; the breakdown by tactic is in - [visual_guide.md](visual_guide.md#where-its-robots-stand-the-position-map). - -![Where each strategy shoots from, and where it concedes](img/signals/shots.png) - -Every shot at the spot it was struck from: filled if it scored, hollow if not. Conceded shots are at -the other end, faded. The counts are shots and goals per strategy over the run. - -- `split_shape` takes the most shots (241, 22 a match, 65 goals). Its own shots are spread across the - attacking half, and its conceded shots sit on the left. -- `decoy_and_overload` faces the most shots (127, 11.5 a match) and `clear_press_plus` the fewest (71, - 6.5 a match); the faded conceded shots of `decoy_and_overload` fill the left half of its panel. - -![Where each strategy commits its fouls, by rule](img/signals/fouls_map.png) - -Each foul at the ball's spot. The four most common rules in the run have their own colours and the -rest are "other rules"; ball out of play is not a foul. - -- `score_aware_counter_flow` commits the largest share in its own defensive third (41% of its fouls), - and `clear_press_plus` the smallest (12%); the script prints these shares. -- Excessive dribbling (blue) and crashing (green) are spread across the pitch in most panels. - -## The numbers - -Every value in the figures, one row per strategy, by points per match. - -| strategy | points / match | GF | GA | shots | shots faced | goals / shot | conceded / shot faced | attacking-third entries / match | regains followed by a shot | free kicks followed by a shot | shot distance (m) | goal mouth open, own shots | completed passes / match | metres gained per pass | danger conceded (s / match) | goal mouth open, shots faced | save rate | -|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---| -| `split_shape` | 2.82 | 6.0 | 1.3 | 21.9 | 9.0 | 27% | 14% | 26.5 | 23% | 55% | 3.1 | 52% | 17 | 1.28 | 96 | 49% | 86% | -| `clear_press_plus` | 1.82 | 1.3 | 0.8 | 6.3 | 6.5 | 20% | 13% | 15.5 | 11% | 14% | 3.1 | 56% | 114 | 0.13 | 84 | 48% | 87% | -| `overload_press` | 1.82 | 2.0 | 1.6 | 7.8 | 8.6 | 26% | 19% | 19.8 | 14% | 19% | 2.7 | 57% | 118 | 0.20 | 74 | 67% | 81% | -| `clear_danger` | 1.55 | 1.8 | 2.2 | 8.1 | 8.0 | 22% | 27% | 18.6 | 15% | 14% | 3.1 | 57% | 37 | 0.36 | 93 | 53% | 74% | -| `tiki_taka_plus` | 1.45 | 2.1 | 1.9 | 7.3 | 7.4 | 29% | 26% | 13.5 | 12% | 15% | 3.2 | 58% | 103 | 0.15 | 79 | 53% | 74% | -| `high_press` | 1.36 | 2.2 | 2.5 | 6.8 | 8.4 | 32% | 29% | 16.6 | 16% | 11% | 3.0 | 57% | 73 | 0.23 | 82 | 64% | 72% | -| `press_trigger_flow` | 1.18 | 1.2 | 1.7 | 6.6 | 7.8 | 18% | 22% | 14.2 | 10% | 13% | 3.2 | 49% | 37 | 0.43 | 84 | 57% | 78% | -| `give_and_go_solo` | 1.09 | 1.8 | 2.7 | 7.9 | 9.4 | 23% | 29% | 18.3 | 17% | 15% | 3.1 | 60% | 39 | 0.45 | 82 | 65% | 74% | -| `press_and_pass` | 1.09 | 1.3 | 2.5 | 6.3 | 9.8 | 20% | 26% | 16.2 | 12% | 9% | 3.3 | 61% | 79 | 0.20 | 87 | 60% | 74% | -| `decoy_and_overload` | 1.00 | 1.5 | 2.5 | 6.5 | 11.5 | 23% | 21% | 17.5 | 12% | 12% | 3.2 | 60% | 45 | 0.47 | 93 | 49% | 80% | -| `counter_flow` | 0.91 | 1.5 | 1.9 | 8.9 | 7.4 | 17% | 26% | 15.8 | 14% | 19% | 3.1 | 58% | 40 | 0.40 | 80 | 51% | 74% | -| `score_aware_counter_flow` | 0.64 | 1.5 | 2.5 | 7.6 | 8.3 | 19% | 30% | 13.2 | 13% | 14% | 2.9 | 58% | 38 | 0.52 | 102 | 56% | 70% | diff --git a/docs/signals.md b/docs/signals.md index 68c119c9..94601d3e 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -67,12 +67,9 @@ Every `tools/evaluation/evaluate.py` run prints round 1's sections and writes ea | — | `results[*].stats` | per-match `MatchStats`, everything above per match | | — | `run` | git commit, dirty flag, argv: compare runs only at clean commits | -**Figures:** [`signal_report.md`](signal_report.md) draws the main signals for the latest full -round robin (`tools/signal_report.py ` regenerates them), with notes on what stands out. -**Offline only** (not in `evaluate.py`'s output): `tools/metric_correlation.py ...` -replays a run at 10 Hz for the signals marked *offline* below, and -`python -m utama_core.analysis.goal_sources ` writes the goal sources +**Offline only** (not in `evaluate.py`'s output): `python -m utama_core.analysis.goal_sources ` +writes the goal sources ([Where do goals come from?](#where-do-goals-come-from)). **Sides.** Per-match stats are config_a's view ("friendly"); a strategy's row reads its own @@ -94,10 +91,6 @@ Check these first: a broken strategy's other signals mean nothing. | Restarts not taken | RESTARTS; `restarts.by_kind[*].outcomes` | a kickoff, free kick or penalty `voided`, `timeout`, `stopped_before_kick` instead of `taken` | free kicks: 3414 taken of 3467 | The taker can't reach or kick the ball: restart positioning, a planner clamp, a keep-out circle | | Fouls by rule | FOULS; `fouls` | every foul by rule, then strategy/tactic of the offending robot | per strategy 6.3 (`chameleon`) · 7.9 · 23.3 (`three_slot`); run: out_of_bounds 2938, excessive_dribbling 448, defense_area 310, crashing 307 | One tactic dominating a rule is its bug: dribbling too far, entering the box, driving into robots | | `no_progress` restarts | `results[*].stats.rule_event_counts` | the referee stopped play: nobody moved the ball for 10 s | 296 in the run | Two robots wedged on the ball, or a carrier holding without a pass | -| Near stalls *(offline)* | `near_stall_events` | a side's nearest robot stuck within 0.5 m of the ball for 2 s without gaining it: an early warning before the watchdog | not checked on current code | Wedges, a robot that can't take the ball | -| Kicker thrash *(offline)* | `kicker_identity_thrash` | during a restart, how often a side's nearest-to-ball robot changes | not checked on current code | Restart takers swapping on position noise (a sticky pick missing) | -| Retreat-reapproach *(offline)* | `retreat_reapproach_oscillations` | a side's nearest robot closes on the ball, backs off, closes again (> 0.3 m each way) | not checked on current code | Planner local minimum, congestion, a target that flips | -| Longest carry *(offline)* | `ball_carrier_hold_max_s` | the longest one robot held the ball in a match | not checked on current code | A carrier dragging the ball or holding for a pass that never comes | ## Does it create chances? @@ -111,7 +104,6 @@ Check these first: a broken strategy's other signals mean nothing. | Open goal mouth | CHANCES `open`; `chances.shot_open_goal` | share of the goal mouth no opponent blocked at the shot. Tops out near 75%, the keeper always covers some | 43% · 50% · 68% | Low: shooting into bodies; the attack never opens a lane | | Conversion | CHANCES `conv`; `chances.conversion` | goals per shot. High for everyone, since a shot is already on target | 21% · 35% · 60% | Read with distance and open goal, not alone | | Goals without a shot | `chances.unshot_goals` | goals no detected shot preceded: deflections, slow rolls, scrambles | 73 of 1068 goals | Many: goals by accident, not by design | -| Rebound support *(offline)* | `shot_backed_up_rate` | share of shots with a teammate within 1 m of the ball | not checked on current code | Low: nobody follows up a save | ## Does it keep and move the ball? diff --git a/docs/strategies.md b/docs/strategies.md index 02e84243..12ece412 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -62,7 +62,6 @@ Against the 2026-10-10 run: rsim is our fork with the v3 sim noise (latency, mot friction, kick direction), and restarts, ball placement and the carry limit were fixed, so goals fell from 7.1 a match to 4.0 and the results are not comparable with earlier runs. `pendulum` is still first, unbeaten; `riptide`, second before, is eleventh. -What each strategy does well and badly in this run, in figures: [`signal_report.md`](signal_report.md). | Strategy | W-D-L | GF-GA | Points per match | |---|---|---|---| @@ -85,7 +84,7 @@ Writeups of bugs since fixed were removed from this file; code comments that cit bugs" refer to them — read them with `git log -p -- docs/strategies.md`. Still open: - **`default` commands only 2 of 5 robots** (robots 3-5 idle) and draws 0-0 with - `low_block`; see `docs/investigation_default_vs_lowblock_stalemate.md`. `default` is the + `low_block` (an opponent-aware approach in `go_to_ball` reduced it; still 0-0). `default` is the kernel's smoke-test scaffold and `low_block` is retired, so not worth fixing for its own sake. ## Updating this file diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md deleted file mode 100644 index 9acf8094..00000000 --- a/docs/strategy_tools_plan.md +++ /dev/null @@ -1,90 +0,0 @@ -# Strategy tools: one question, one tool - -Design note, agreed after two review rounds; status updated 2026-11-12. It says which tool answers which question, what -is planned and in what order, and what is still undecided. Items marked **planned** do not -exist yet. The current tools are in [tools.md](tools.md), and the "Which tool?" table there -links back here. - -## The problem - -- **Too many overlapping tools.** Several scripts answer the same question in slightly - different ways. A reader cannot tell which one to run first, or which result to believe. -- **The docs list scripts, not jobs.** `tools.md` says what each script is. It does not say - which question the script answers, so a reader has to work that out. -- **Runner set-up was written five times** (step 5 fixed them all). Each of these built its own strategy runner, - referee and dashboard: `tools/evaluation/match.py`, `tools/debug_match.py`, - `tools/repro_from_replay.py`, `tools/moments.py` and `main.py`. Now they all build their referee and - runner in `tools/sim_setup.py`. - Before step 5 only `match.py` loaded `.strategy` files (`utama_core/bundle/`), so the other four - could not run a `.strategy` file. - -## The question, the tool - -"Today" is a tool that exists. "Planned" is in the steps at the end. - -| Question | Tool | Status | -|---|---|---| -| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with how many matches checked them | Today | -| Is it better? | `tools/evaluation/evaluate.py CANDIDATE`: paired against the champion at the last release. The only verdict | Today | -| Does everything still run, after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches), with stalls and signals. `--all` plays every strategy, occasionally | Today | -| What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py` (`--fouls` for our side's fouls), then the picture tools. find_bugs finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal sources (`utama_core/analysis/goal_sources.py`) | Today | -| Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | -| Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | -| Is the simulator realistic? | Simulator tools: `realism_scorecard.py`, `physics_ranges.py`, `field_physics.py`, `robot_calibration.py`, `convert_ssl_log.py`. Not part of strategy development | Today | - -Notes on the table: - -- One tool plays matches: `evaluate.py`. Each round is a round robin under a new noise seed; the - first answers "is the catalog healthy?" (stalls, signals), and rounds continue until "is this - candidate stronger than the champion at the last release?" is clear. The verdict is goals; nothing else ranks. -- "Look closely" tools explain a result. They never judge one. - -## The screen (dropped) - -The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. - -## Moments - -Regression moments are fixed-state checks of shared-code bugs (restart and placement geometry), -played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: - -- **`moments.py fouls` moved into `tools/find_bugs.py --fouls`** (the code in - `utama_core/analysis/fouls.py`), so there is one place to find what went wrong in a run. -- **`new` (hand-made templates) removed.** Moments come from `capture`, from a replay. -- **`--seeds` kept.** `play --seeds 0-4` is how a moment is checked (it must fail on 4 of 5 - seeds before the fix). -- **`--against` fixed.** Its worktrees sit beside the repo in `-moments-against/`, set once in - `AGAINST_DIR`, no longer in a dated folder from one session. - -## Planned steps, in order - -1. **Fix `main.py`'s import.** Done: it loads strategies through `strategy/catalog.py`. Its runner set-up is still one of the five hand-built ones above. -2. **This note and the docs.** `docs/strategy_tools_plan.md`, the "Which tool?" table in - `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the "from the match results store" counts. -3. **Stalls in the match results.** Done. Stalls are recorded in `replays/match_results/`, and `evaluate.py` - reports them with coverage: how many of the matches it used were checked for stalls. The - stall watchdog covers config_a only, so coverage is partial. A match whose stats were not - collected counts as **unknown, not clean**. -4. **One tool for matches.** Done 2026-11-12: `round_robin.py` merged into `evaluate.py`. Round 1 is - a round robin of the core strategies and the reference (the champion at - the last release, a `.strategy` file); later rounds repeat it under new seeds while a candidate is undecided. No held-out - opponents, no `--vs-champion`, no standings. The strategies were renamed the same day - (`catalog.RENAMED`). -5. **One shared match and runner construction** for every tool. `tools/sim_setup.py` has `load_side` (a - catalog name, a `.strategy` file or `PATH.py:FUNCTION`), `sim_referee` (the referee and its kickoff team) and `sim_runner` (the rsim `StrategyRunner`). `repro_from_replay.py`, `moments.py`, - `debug_match.py`, `main.py` and `tools/evaluation/match.py` all build through them, so every tool plays - `.strategy` files and the referee and runner exist in one place. `main.py` keeps its dashboard: the - referee is built before the dashboard attaches, the runner after. `match.py`'s fingerprint changed with - this (its set-up is now in `sim_setup.py`), so every stored match replays once. The match results store - (`replay/match_results.py`) changed the same fingerprints, so one replay covers both. -6. **The screen.** The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. -7. **Triage takes the foul listing.** Done: `find_bugs.py --fouls`; `moments.py` lost `fouls` and `new`, - and `--against` no longer uses a dated folder. - -Every step that changes shared code follows the rule in `docs/STRATEGY_DEVELOPMENT.md`: batch -such changes, and run one evaluation at the end. - -## Names - -Decided 2026-11-12: `find_bugs.py` (was `triage.py`), goal sources (was the goal ledger), and -`evaluate.py` for the one match tool. diff --git a/docs/tools.md b/docs/tools.md index a2d31d9a..62ddfa06 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -3,11 +3,22 @@ Every script in the repository, by what it is for. Run them from the repository root with `pixi run python `; each script's docstring has its full usage and flags. +## Start with these four + +New to the repo? You need only these ([first_strategy.md](first_strategy.md) walks through them): + +| Command | What it does | +|---|---| +| `pixi run main A B` | Watch strategy A (yellow) play strategy B in the simulator | +| `pixi run test`, `pixi run lint` | Check nothing broke, before every pull request | +| `pixi run python tools/evaluation/evaluate.py NAME` | Is strategy NAME better than the champion? Read the verdict and the mean diff | +| `pixi run python dashboard_server.py` | Browse recorded replays at http://localhost:8080 | + +Everything below is for specialists. + ## Which tool? -Pick the tool by the question you have. Only tools that exist are named in this table. Items marked -*planned* are designed but not built: see [strategy_tools_plan.md](strategy_tools_plan.md), which also -says why the tools are split this way. +Pick the tool by the question you have. For the four jobs that chain several of them, follow a skill in `.claude/skills/`: `change-strategy`, `explain-result`, `debug-incident`, `field-session`. @@ -59,7 +70,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | | `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `tools/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | -| `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | +| `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: recorded replays and run results | ## Evaluating strategies @@ -68,19 +79,10 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/signal_report.py` | Figures of a run's strategy signals (an `evaluate.py` round dir) for [signal_report.md](signal_report.md) | -| `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for [signal_report.md](signal_report.md#on-the-pitch). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | +| `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | | `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | | `tools/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | -### Validation studies - -These check how far cheap metrics agree with match results. They do not judge a strategy: use `evaluate.py`. - -| Script | Purpose | -|---|---| -| `tools/metric_correlation.py` | Which cheap per-match metrics predict results; computes the *offline* signals in [signals.md](signals.md) | - ## Real matches | Script | Purpose | diff --git a/docs/visual_guide.md b/docs/visual_guide.md index ac979ef8..1e7bd27b 100644 --- a/docs/visual_guide.md +++ b/docs/visual_guide.md @@ -82,7 +82,6 @@ Each foul at the ball's spot, coloured by rule (one fixed colour per rule, the s which rules a strategy breaks, and where on the pitch. Draw: `pixi run python tools/pitch_maps.py replays/tournament_` (a full round-robin, about 3 min). -The rest of the strategy report, as numbers: [signal_report.md](signal_report.md). ## 2. A candidate against the champion diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 903ae47d..97b8af92 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -1,80 +1,20 @@ """evaluate.py — how the strategies play, and whether a candidate beats the champion at the last release. Run: - pixi run python tools/evaluation/evaluate.py [CANDIDATE ...] [flags] - -With no candidate it plays one round: a round robin of the players, the health check (stalls, fouls, -every signal). With candidates (strategy names, played from the working tree, or `.strategy` files) -it plays rounds until each candidate is decided. - - --at REF the reference is the champion as it was at git commit REF (default: the latest - release tag), played from a `.strategy` file built once into replays/eval/frozen/ - --all every strategy in the catalog plays, not only the core (occasionally, for a - wider field) - -Matches play in parallel, one fewer than the CPUs (at most 12). To explain a result: find_bugs.py, -goal_sources, pitch_maps.py and explain.py on the run's round folders. - -Players -------- -`reference/players.json` names the champion and the core strategies, which play every round. Every -other strategy in the catalog is reserve: it plays only with `--all`, an occasional run for a wider -field (the verdict needs only fixed opponents, the same for candidate and reference). The reference (the champion -at the last release) plays every round too. It is a frozen file, so a change to shared code moves the -candidates and the working-tree strategies, never the reference. - -Rounds ------- -Round k plays under sim-noise seed k (the reference world and robots, reference/world.json and -robots.json). Every round is the same round robin: every pair of players once, under seed k. Only the -candidates still undecided stay in later rounds. Nothing is played twice: the match results store holds -every match whose code is unchanged, so a run plays only the matches of edited strategies, and of a -seed not played before. In every match the candidate (then the reference) is config_a in odd rounds and -config_b in even ones, so a candidate and the reference meet each opponent with the same colour and -noise. Matches are 1200 s of sim time at most (two 300 s halves of playing time, `MAX_MATCH_SECONDS`). - -How it decides --------------- -One number per opponent and seed: the candidate's goal difference minus the reference's, against the -same opponent with the same seed and colour (a "diff", `paired`). The same opponent cancels its -strength and the same noise cancels part of the luck. Head-to-head matches are reported, not counted: -they answer "does it beat the champion?", the one matchup a search is most tempted to exploit. - -- **Screen**, seeds 1..ROUNDS: from round 2 on, a candidate whose mean diff is <= 0 is **dropped**. - One that survives ROUNDS rounds goes on to confirm; the screen never accepts. -- **Confirm**, fresh seeds 101..100+ROUNDS: the same drop rule, then **better** if the one-sided - paired t-test on these seeds' diffs gives p <= ALPHA, else **undecided** (`ratings.decide`). - -Only fresh seeds can accept, so a candidate picked because it looked good on seeds 1..ROUNDS, or tuned -to them, is not accepted on that luck; dropping early can never make a false "better". "Dropped" means -not promising, not worse: an equal strategy is dropped at the first look about half the time. -`tools/evaluation/verdict_sim.py` plays this rule on simulated results (no matches); its test pins -that an equal strategy is called better at most ALPHA of the time. - -ROUNDS and ALPHA (in `analysis/ratings.py`) are the rule's only settings; both are provisional. The reference's results on each -seed are stored and reused for every candidate, so a confirm stage that many candidates reach shares -the reference's luck on seeds 101..; few do, since most are dropped in the screen. - -The reference is frozen with the shared code (tactics, skills, planner, engine) of the release, so a -"better" can come from shared code changed since. Today's champion plays the same opponents with the -same seeds and colours, so the report adds the candidate against it too, at no extra matches: there -the shared code is the same on both sides. `evaluate.py ` measures the shared code alone. - -Signals and stalls are reported, never judged on: they explain a result (docs/signals.md). The stall -watchdog watches config_a only, so the report says how many matches each strategy was checked in. - -Matches the match results store holds (replays/match_results/, `replay/match_results.py`) are taken from -it, not played: after a change to one strategy only its matches play. Delete that folder to replay all. - -A match that crashes is reported (`failed` in summary.json and report.json), not stored, and missing -from the verdict's pairs; the run goes on, and the next run plays it again. - -Writes replays/eval_/: `report.json` (verdicts, round 1's signals), and per round `round_/` -with each played match's replay, intention log and stats (`_vs_.*`), `summary.json` and -`ball_losses.md` — the layout tools/find_bugs.py, tools/pitch_maps.py and goal_sources read. - -Promoting is a decision, not a side effect: set the champion by hand in reference/players.json. It is -the reference from the next release on: the reference is read from players.json as it was at the release. + pixi run python tools/evaluation/evaluate.py [CANDIDATE ...] [--at REF] [--all] + +No candidate: one round robin of the core strategies (the health check: stalls, fouls, signals). +With candidates (strategy names or `.strategy` files): rounds until each is better, dropped or undecided. + + --at REF the reference is the champion as it was at git commit REF (default: the latest release tag) + --all every strategy in the catalog plays, not only the core + +How it works (players, rounds, the verdict, the match results store, the output folder): +docs/STRATEGY_DEVELOPMENT.md, "Evaluating a strategy". For a beginner: docs/first_strategy.md, step 8. + +Matches play in parallel (CPUs minus one, at most 12). A match the store (replays/match_results/) holds +is never played again. A match that crashes is reported (`failed` in summary.json and report.json) and +left out of the verdict; the next run plays it again. Writes replays/eval_/. """ from __future__ import annotations diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index 700a5061..dc5338e0 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -40,9 +40,9 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) +from tools import figure_style as sr # noqa: E402 from tools import find_bugs # noqa: E402 from tools import pitch_maps as pm # noqa: E402 -from tools import signal_report as sr # noqa: E402 from tools.evaluation.match import _short_name # noqa: E402 from utama_core.analysis.matches import Match, find_matches # noqa: E402 diff --git a/tools/figure_style.py b/tools/figure_style.py new file mode 100644 index 00000000..f259cef4 --- /dev/null +++ b/tools/figure_style.py @@ -0,0 +1,25 @@ +"""The colours and matplotlib style every figure tool shares (pitch_maps, explain, match_timeline), +so the figures read as one set. Importing it sets the style.""" + +import matplotlib.pyplot as plt + +INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" +FOR, AGAINST = "#2a78d6", "#eb6834" # categorical slots 1 and 2 +# Categorical slots in fixed order (validated adjacent-pair for stacks); never cycled. +SLOTS = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6"] + +plt.rcParams.update( + { + "figure.facecolor": SURFACE, + "axes.facecolor": SURFACE, + "axes.edgecolor": INK_3, + "axes.labelcolor": INK_2, + "axes.titlesize": 10, + "axes.titlecolor": INK, + "axes.spines.top": False, + "axes.spines.right": False, + "xtick.color": INK_2, + "ytick.color": INK, + "font.size": 9, + } +) diff --git a/tools/match_timeline.py b/tools/match_timeline.py index 81d20868..847960c9 100644 --- a/tools/match_timeline.py +++ b/tools/match_timeline.py @@ -64,7 +64,7 @@ # Under this much live play a rate is noise (one switch in 10 s reads as 6 per minute): no thrash finding. MIN_LIVE_S = 30.0 -# Styling copied from tools/signal_report.py so the figures read as one set. +# Styling shared with tools/figure_style.py so the figures read as one set. INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" FOR, AGAINST = "#2a78d6", "#eb6834" # categorical slots 1 and 2 SLOTS = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6"] diff --git a/tools/metric_correlation.py b/tools/metric_correlation.py deleted file mode 100644 index 59bb2b1b..00000000 --- a/tools/metric_correlation.py +++ /dev/null @@ -1,1536 +0,0 @@ -#!/usr/bin/env python3 -# ruff: noqa: E402 -"""Offline study: which cheap per-match proxy metrics predict match outcome. - -Run from the repository root, for example: - - pixi run python tools/metric_correlation.py \\ - replays/tournament_20260903_101521 \\ - replays/tournament_20260903_112025 \\ - replays/tournament_20260903_115838 \\ - --out benchmark_results/metric_correlation.md - -Purpose -------- -`docs/strategies.md` and `evaluate.py` already tell us who won each match, but a -full 65s round-robin match is expensive to run inside an agent loop that's iterating -on a single strategy change. If some cheap per-match "proxy" metric (possession, -territory, shots, ...) reliably predicts match outcome, a much shorter scenario -benchmark reporting just that metric could stand in for a full win-rate sweep. This -script is the offline study that answers "which metrics, if any" using replay data we -already have on disk, before spending any effort wiring new metrics into the live -`MatchStats` accumulator (`utama_core/engine/match_stats.py`). - -It does not run the simulator, a tactic, or a strategy — it only reads -`summary.json`/`_vs_.stats.json` (already-computed `MatchStats`) and replays -`_vs_.pkl` frame-by-frame at a 10 Hz sample (`_SAMPLE_HZ`) to compute a second -family of metrics `MatchStats` does not currently report. - -Side convention (see `match.run_match`): `config_a` is always yellow AND -starts on the right (`my_team_is_right=True`), `config_b` is always blue/left; the teams -change ends at half-time, so each frame's own `my_team_is_right` gives its side. Every replay -frame's `friendly_robots`/`ball` are recorded from `config_a`'s perspective -(`ReplayMetadata.my_team_is_yellow=True` in every file checked), so "friendly" in a -frame or in `.stats.json` always means `config_a`. Side is a real effect in -this sim, so every metric below is -reported both as a per-side value and as an a-minus-b differential, and side is kept -as an explicit covariate in the logistic fit (part A) rather than assumed away. - -Frame-derived metric definitions (see also each metric function's own docstring for -the precise threshold/tie-break used — this is the summary): - -1. `shots_on_target` — a ball-speed spike (>= `_SHOT_SPEED_MPS`, matching - `match_stats.py`'s existing shot heuristic for consistency) launched from within - `_SHOT_LAUNCH_RADIUS_M` of an attacking-side robot, moving toward the opponent - goal, whose straight-line velocity ray crosses the opponent goal line inside the - goal mouth. Edge-detected with the same "locked until ball slows" debounce - `match_stats.py` uses, so one continuous fast, on-target ball counts once. This is - a slightly stricter version of `MatchStats.shots` (also requires launch proximity - to a robot, not just "ball already fast in the attacking third") — kept as its own - metric rather than replacing `shots` since the two disagree occasionally (a - deflection re-accelerating the ball with no robot nearby) and that disagreement is - itself informative for part D's "which to instrument" call. -2. `attacking_third_entries` — count of ball crossings from at/behind the midline - into a side's attacking third (`x` beyond +/-1.5 m from centre on that side's - attack axis, matching `match_stats.py`'s zone boundary), hysteresis band - `_ENTRY_HYSTERESIS_M` wide so oscillation on the 1.5 m line doesn't double-count. -3. `completed_passes` / `turnovers` — a "possession" event starts when the ball - enters a robot's `_POSSESSION_RADIUS_M` while moving slower than - `_PASS_RELEASE_MPS ` (i.e. controlled, not a shot flying past) and ends when it - leaves that radius at >= `_PASS_RELEASE_MPS`. A **completed pass** is a - possession-end-by-a-side-A-robot immediately (no intervening possession event by - the opposing side) followed by a possession-start by a *different* side-A robot. A - **turnover** is the same shape but the next possessor is an opposing-side robot. - Ball-out-of-bounds/no-further-possession before the match ends counts as neither. -4. `possession_under_pressure_s` — seconds a side's nearest-robot-to-ball (the same - possession attribution `MatchStats.possession_pct` uses) also has an opponent - robot within `_PRESSURE_RADIUS_M`, at the 10 Hz sample rate. -5. `restart_to_first_entry_s` / `n_restarts` — from the intentions.jsonl referee - trace: each transition *into* a live command (`NORMAL_START`/`FORCE_START`) from a - non-live command starts a restart clock, attributed to whichever side is - possessing the ball (nearest-robot-to-ball) at that live-start frame; it stops - at the first frame afterward where that same side's ball position enters its - attacking third. Restarts with no qualifying entry before the next stoppage or - match end are excluded from the mean (and counted separately, `n_restarts` vs. - `n_restarts_with_entry`) rather than imputing an arbitrary ceiling. Reported - both per-side (`restart_to_first_entry_s_friendly`/`_enemy`, feeding the same - `a-b` differential every other metric uses) and as a single match-level mean - pooling both sides. *Lower is better* for the possessing side (faster tempo - off a restart) -- see `_LOWER_IS_BETTER`. -6. `mean_ball_x_towards_opponent_goal` (territory) and `defensive_third_time_pct` — - mean of `ball.p.x` projected onto each side's attack axis (matching - `match_stats.py`'s `own_goal_sign` convention) across sampled frames, and the - fraction of sampled frames the ball spends in a side's own defensive third. -7. Two more, chosen for a plausible causal link to scoring rather than just - correlation-mining: - - `shot_backed_up_rate` — of `shots_on_target` events, the fraction where a - teammate of the shooting side is within `_SUPPORT_RADIUS_M` of the ball at the - moment of the shot (rebound/follow-up support). Motivated by: an unsupported shot - that's saved or deflected usually just turns over possession, while a backed-up - shot can be converted on the second ball — plausibly causal for *actually* - converting territory into goals, not just reaching the box. - - `defensive_third_time_pct` (see 6) doubles as a plausible direct predictor of - *conceding*: time spent defending your own third is time the opponent could - be shooting, independent of any single shot metric firing. - -All frame-derived metrics are computed once per match from a single pass over -10 Hz-sampled frames (`_iter_sampled_frames`) and cached to -`/frame_metrics//.json` so a re-run (e.g. after a code -tweak to this script) never re-reads a `.pkl`. Per-match rows (frame metrics + -stats.json + summary.json result) are also cached per run to -`/rows/.json`. -""" - -from __future__ import annotations - -import argparse -import json -import math -import multiprocessing as mp -import os -import sys -import tempfile -import time -from dataclasses import dataclass -from pathlib import Path -from typing import Optional - -import numpy as np - -try: - from scipy import stats as scipy_stats - - _HAVE_SCIPY = True -except ImportError: # pragma: no cover - scipy is present in the pixi env - _HAVE_SCIPY = False - -REPO_ROOT = Path(__file__).resolve().parents[1] -if str(REPO_ROOT) not in sys.path: - sys.path.insert(0, str(REPO_ROOT)) - -from utama_core.config.field_params import STANDARD_FIELD_DIMS # noqa: E402 -from utama_core.config.physical_constants import ROBOT_RADIUS # noqa: E402 -from utama_core.replay.columnar_reader import load_columnar_replay # noqa: E402 -from utama_core.replay.entities import ReplayMetadata # noqa: E402 -from utama_core.replay.replay_player import _load_replay # noqa: E402 -from utama_core.strategy.catalog import plain_name - -# --- Sampling --------------------------------------------------------------- -_SAMPLE_HZ = 10.0 -_TICK_HZ = 60.0 # rsim's fixed step rate (match.TICKS_PER_SECOND) -_SAMPLE_STRIDE = max(1, round(_TICK_HZ / _SAMPLE_HZ)) -_DT = _SAMPLE_STRIDE / _TICK_HZ - -# --- Field geometry (matches utama_core/engine/match_stats.py's conventions) --- -_HALF_LENGTH = STANDARD_FIELD_DIMS.full_field_half_length # 4.5 -_HALF_GOAL_WIDTH = STANDARD_FIELD_DIMS.half_goal_width # 0.5 -_ATTACKING_THIRD_M = 1.5 # matches match_stats.py's zone boundary - -# --- Metric thresholds (each used in exactly one metric function below; see the -# module docstring's numbered list for the "why") --- -_SHOT_SPEED_MPS = 3.5 # matches match_stats.py's _SHOT_SPEED_MPS -_SHOT_LAUNCH_RADIUS_M = 0.5 # "from within N m of a robot" per the task's metric 1 -_ENTRY_HYSTERESIS_M = 0.3 # metric 2: band around the 1.5 m third boundary -_POSSESSION_RADIUS_M = 2 * ROBOT_RADIUS + 0.05 # ~0.23 m: robot footprint + dribble slack -_PASS_RELEASE_MPS = 1.0 # matches match_stats.py's _SHOT_LOCK_RELEASE_MPS release speed -_PRESSURE_RADIUS_M = 0.5 # metric 4, per the task spec -_SUPPORT_RADIUS_M = 1.0 # metric 7: "teammate near the ball at shot time" -_RESTART_LIVE_COMMANDS = {"NORMAL_START", "FORCE_START"} - -# --- Metrics 8-12 (2026-09-04 debugging-signal expansion): each mined from a -# real, already-traced bug mechanism in docs/roadmap.md's "trajsample liveness fixes", rather than -# invented speculatively -- the point is a cheap counter that would have -# flagged that exact mechanism automatically instead of needing a human to -# live-trace a match. See each metric's own comment below for which bug it -# targets. -_NEAR_STALL_RADIUS_M = 0.5 # metric 8: same order as match_stats.py's NO_PROGRESS_POSSESSION radius (0.35), a -# little looser here since this is meant to catch pre-watchdog *risk*, not confirmed stalls -_NEAR_STALL_SECONDS = 2.0 # metric 8: much shorter than the live watchdog's 8s -- an early-warning signal, -# not a replacement for it -_THRASH_WINDOW_S = 5.0 # metric 9: matches the ~5-9s windows item 15's kicker-thrash traces were measured over -_OSCILLATION_WINDOW_S = 3.0 # metric 10: window over which a distance-derivative sign-flip run is counted -_OSCILLATION_MIN_AMPLITUDE_M = 0.3 # metric 10: ignore sub-30cm position noise, only count a real retreat/re-approach - - -def _iter_sampled_frames(replay_path: Path): - """Yield every `_SAMPLE_STRIDE`-th `GameFrame` from a replay file, plus the - replay metadata first. A generator, not a list, so a caller that only needs - a running accumulation (the common case here) never holds the sampled frames - in memory at once. - - Dispatches on extension like `replay_player.load_frames_in_range` does: - `.npz` is the columnar format current tournament runs actually write - (`ColumnarReplayWriter`) — `_load_replay` only understands the older - one-pickle-per-frame `.pkl` format, so it can't read current runs at all. - `ColumnarReplay` has no separate `ReplayMetadata` object; `my_team_is_yellow` - is a field on it directly, which is the only piece of metadata this module - reads, so it's wrapped in a `ReplayMetadata` to keep `compute_frame_metrics` - unchanged. - """ - if replay_path.suffix == ".npz": - replay = load_columnar_replay(replay_path) - yield ReplayMetadata( - my_team_is_yellow=replay.my_team_is_yellow, - exp_friendly=len(replay.friendly_ids), - exp_enemy=len(replay.enemy_ids), - ) - for i in range(0, replay.n_ticks, _SAMPLE_STRIDE): - yield replay.frame_at(i) - return - - gen = _load_replay(replay_path) - metadata = next(gen) - yield metadata - for i, frame in enumerate(gen): - if i % _SAMPLE_STRIDE == 0: - yield frame - - -def _attack_sign(my_team_is_right: bool, side: str) -> float: - """+1/-1 multiplier s.t. `x * attack_sign` grows as `side`'s ball/robot moves - toward the *opponent's* goal. Matches `match_stats.py`'s `own_goal_sign` - convention exactly (friendly's own goal sits at `+own_goal_sign * half_length`). - """ - own_goal_sign = 1.0 if my_team_is_right else -1.0 - return -own_goal_sign if side == "friendly" else own_goal_sign - - -def _own_goal_x(my_team_is_right: bool, side: str) -> float: - own_goal_sign = 1.0 if my_team_is_right else -1.0 - ref_sign = own_goal_sign if side == "friendly" else -own_goal_sign - return ref_sign * _HALF_LENGTH - - -@dataclass -class _PossessionState: - side: Optional[str] = None - robot_id: Optional[int] = None - - -def compute_frame_metrics(replay_path: Path, referee_events: list[dict]) -> dict: - """Single pass over 10 Hz-sampled frames computing every frame-derived metric - (see module docstring, items 1-7) for both `friendly` (config_a) and `enemy` - (config_b). Returns a flat dict of `{metric}_{side}` -> value plus a couple of - match-level counts (`n_restarts`, `n_restarts_with_entry`). - """ - frames_iter = _iter_sampled_frames(replay_path) - next(frames_iter) # metadata - - sides = ("friendly", "enemy") - shots_on_target = {s: 0 for s in sides} - shots_backed_up = {s: 0 for s in sides} - shot_lock = {s: False for s in sides} - entries = {s: 0 for s in sides} - in_attacking_third = {s: False for s in sides} # hysteresis state - ball_x_sum = {s: 0.0 for s in sides} - defensive_third_ticks = {s: 0 for s in sides} - pressure_ticks = {s: 0 for s in sides} - n_ticks = 0 - - possession = _PossessionState() # current controlling (side, robot_id) or None - completed_passes = {s: 0 for s in sides} - turnovers = {s: 0 for s in sides} - - # --- metric 8: near-stall risk (pre-watchdog early warning) --- - # Same shape as match_stats.py's NO_PROGRESS_POSSESSION watchdog (a robot - # stuck near the ball without ever gaining possession), but a much shorter - # threshold and a looser radius -- meant to fire well before the live 8s - # watchdog would, so it can serve as a leading risk indicator rather than a - # confirmed-stall count. Tracked per side (whichever side's nearest robot is - # the one stuck). - near_stall_since: dict[str, Optional[float]] = {s: None for s in sides} - near_stall_holder: dict[str, Optional[int]] = {s: None for s in sides} - near_stall_events = {s: 0 for s in sides} - - # --- metric 9: kicker/nearest-robot identity thrash during a restart --- - # Mined directly from item 15's traced DIRECT_FREE bug: the "closest robot - # to the ball" identity flipped ~9x/second on ordinary position noise - # before the Sticky[int] fix (243 switches/27s -> 4). This counts identity - # switches of the nearest-to-ball robot *within a side*, while a restart - # command is in effect -- a regression of that exact bug class would show - # up here even if nothing else changes. - restart_active = False - thrash_prev_id: dict[str, Optional[int]] = {s: None for s in sides} - thrash_switches = {s: 0 for s in sides} - - # --- metric 10: retreat/re-approach oscillation --- - # The "congestion/local-minimum" signature item 15 traced repeatedly: a - # side's nearest-robot-to-ball distance oscillates (approach, retreat, - # re-approach) instead of monotonically closing, for seconds at a time, - # while the planner reports no collision. Counts local direction reversals - # in each side's nearest-to-ball distance time series, ignoring reversals - # smaller than _OSCILLATION_MIN_AMPLITUDE_M (position noise). - osc_last_dist: dict[str, Optional[float]] = {s: None for s in sides} - osc_last_extremum: dict[str, Optional[float]] = {s: None for s in sides} - osc_direction: dict[str, int] = {s: 0 for s in sides} # +1 closing, -1 opening, 0 unknown - osc_reversals = {s: 0 for s in sides} - - # --- metric 11: ball-carrier hold duration (COMMITTED_FROZEN precursor) --- - # Targets the DefenseTactic ball-drag bug class: one robot keeps has_ball - # continuously for an abnormally long stretch. Tracks the longest - # continuous has_ball run per side across the match (p95 needs many - # matches pooled, so this reports the single max per match; part B pools - # across a strategy's matches for a percentile). - carrier_hold_since: dict[str, Optional[float]] = {s: None for s in sides} - carrier_hold_id: dict[str, Optional[int]] = {s: None for s in sides} - carrier_hold_max_s = {s: 0.0 for s in sides} - - # Restart-to-entry bookkeeping, split by which side was possessing at the - # restart (so it folds into the same per-side differential framework every - # other metric uses -- a side reaching the attacking third faster off its - # own restarts is a directly plausible predictor of scoring more). - restarts_resolved: dict[str, list[float]] = {s: [] for s in sides} - n_restarts = 0 - n_restarts_with_entry = 0 - pending_restart: Optional[dict] = None # {"t0": float, "side": Optional[str]} - - # Referee events are timestamped independently (intentions.jsonl); merge by - # sim_time against the sampled frame stream below rather than a second pass. - ref_events = sorted(referee_events, key=lambda e: e["sim_time"]) - ref_idx = 0 - prev_command: Optional[str] = None - - for frame in frames_iter: - my_team_is_right = frame.my_team_is_right # config_a's side; the teams change ends at half-time - ball = frame.ball - if ball is None: - continue - n_ticks += 1 - t = frame.ts - - # Advance the referee-event cursor to the latest event at or before this - # sampled frame, tracking live-command transitions as we pass them. - while ref_idx < len(ref_events) and ref_events[ref_idx]["sim_time"] <= t: - cmd = ref_events[ref_idx]["command"] - if cmd in _RESTART_LIVE_COMMANDS and prev_command not in _RESTART_LIVE_COMMANDS: - # A live-play command just started a restart clock. Whoever is - # nearest the ball *now* (this frame) is "the possessing side" for - # the purpose of measuring how fast they reach the attacking third. - all_robots = [(rid, r, "friendly") for rid, r in frame.friendly_robots.items()] + [ - (rid, r, "enemy") for rid, r in frame.enemy_robots.items() - ] - nearest_side = min(all_robots, key=lambda e: e[1].p.distance_to(ball.p))[2] if all_robots else None - pending_restart = {"t0": t, "side": nearest_side} - n_restarts += 1 - # metric 9: "restart active" = any non-HALT/STOP referee command that - # isn't yet live play (the mass-replan ceremony window item 15's - # kicker-thrash bug was traced during -- PREPARE_*/DIRECT_FREE_*/ - # BALL_PLACEMENT_* etc., not the live-play commands themselves, since - # once play is live the "nearest robot" is expected to change hands - # normally as the ball moves). - restart_active = cmd not in ("HALT", "STOP") and cmd not in _RESTART_LIVE_COMMANDS - prev_command = cmd - ref_idx += 1 - - all_robots = [(rid, r, "friendly") for rid, r in frame.friendly_robots.items()] + [ - (rid, r, "enemy") for rid, r in frame.enemy_robots.items() - ] - - # --- possession (nearest robot to ball; matches match_stats.py) --- - nearest_id, nearest_robot, nearest_side = min(all_robots, key=lambda e: e[1].p.distance_to(ball.p)) - dist_to_nearest = nearest_robot.p.distance_to(ball.p) - - # --- metric 4: possession under pressure --- - opp_prefix = "enemy" if nearest_side == "friendly" else "friendly" - opponents = [r for rid, r, s in all_robots if s == opp_prefix] - if dist_to_nearest <= _POSSESSION_RADIUS_M and opponents: - min_opp_dist = min(r.p.distance_to(ball.p) for r in opponents) - if min_opp_dist <= _PRESSURE_RADIUS_M: - pressure_ticks[nearest_side] += 1 - - # --- metric 8: near-stall risk --- - # A side's nearest robot sits within _NEAR_STALL_RADIUS_M of the ball, - # same identity, for more than _NEAR_STALL_SECONDS, without possession - # ever latching to it (possession.side/robot_id != this holder) -- an - # early-warning version of match_stats.py's NO_PROGRESS_POSSESSION - # watchdog (which uses a tighter radius and an 8s threshold). One event - # is logged per qualifying stretch (not re-logged every tick it - # continues), mirroring that watchdog's own "log once per stretch" shape. - for side in sides: - side_robots = [(rid, r) for rid, r, s in all_robots if s == side] - if not side_robots: - near_stall_since[side] = None - near_stall_holder[side] = None - continue - s_id, s_robot = min(side_robots, key=lambda e: e[1].p.distance_to(ball.p)) - s_dist = s_robot.p.distance_to(ball.p) - has_control = possession.side == side and possession.robot_id == s_id - if s_dist <= _NEAR_STALL_RADIUS_M and not has_control: - if near_stall_holder[side] != s_id: - near_stall_since[side] = t - near_stall_holder[side] = s_id - elif near_stall_since[side] is not None and (t - near_stall_since[side]) > _NEAR_STALL_SECONDS: - near_stall_events[side] += 1 - near_stall_since[side] = None # reset so a longer stretch doesn't multi-count - else: - near_stall_since[side] = None - near_stall_holder[side] = None - - # --- metric 9: nearest-robot identity thrash during a restart ceremony --- - if restart_active: - for side in sides: - side_robots = [(rid, r) for rid, r, s in all_robots if s == side] - if not side_robots: - continue - s_id, _ = min(side_robots, key=lambda e: e[1].p.distance_to(ball.p)) - if thrash_prev_id[side] is not None and thrash_prev_id[side] != s_id: - thrash_switches[side] += 1 - thrash_prev_id[side] = s_id - else: - thrash_prev_id = {s: None for s in sides} - - # --- metric 10: retreat/re-approach oscillation --- - # A local direction reversal in a side's nearest-to-ball distance, - # ignoring reversals smaller than _OSCILLATION_MIN_AMPLITUDE_M so - # ordinary position noise (and a robot legitimately arriving and - # settling) doesn't count. This is a running peak/trough detector, not - # a windowed FFT -- cheap and matches how the bug was actually spotted - # in live traces (distance visibly sawtoothing instead of monotonically - # closing). - for side in sides: - side_robots = [(rid, r) for rid, r, s in all_robots if s == side] - if not side_robots: - continue - s_dist = min(r.p.distance_to(ball.p) for _, r in side_robots) - if osc_last_dist[side] is None: - osc_last_dist[side] = s_dist - osc_last_extremum[side] = s_dist - else: - delta = s_dist - osc_last_dist[side] - new_direction = 1 if delta > 0 else (-1 if delta < 0 else osc_direction[side]) - if ( - osc_direction[side] != 0 - and new_direction != osc_direction[side] - and osc_last_extremum[side] is not None - and abs(s_dist - osc_last_extremum[side]) >= _OSCILLATION_MIN_AMPLITUDE_M - ): - osc_reversals[side] += 1 - osc_last_extremum[side] = s_dist - elif osc_last_extremum[side] is None or ( - new_direction == osc_direction[side] - and ( - (new_direction > 0 and s_dist > osc_last_extremum[side]) - or (new_direction < 0 and s_dist < osc_last_extremum[side]) - ) - ): - osc_last_extremum[side] = s_dist - osc_direction[side] = new_direction - osc_last_dist[side] = s_dist - - # --- metric 11: ball-carrier hold duration (COMMITTED_FROZEN precursor) --- - for side in sides: - side_robots = [(rid, r) for rid, r, s in all_robots if s == side] - holder = next((rid for rid, r in side_robots if r.has_ball), None) - if holder is not None and carrier_hold_id[side] == holder: - held_for = t - carrier_hold_since[side] - if held_for > carrier_hold_max_s[side]: - carrier_hold_max_s[side] = held_for - elif holder is not None: - carrier_hold_id[side] = holder - carrier_hold_since[side] = t - else: - carrier_hold_id[side] = None - carrier_hold_since[side] = None - - # --- metric 3: completed passes / turnovers (possession-radius state machine) --- - ball_speed = math.hypot(ball.v.x, ball.v.y) - controlled = dist_to_nearest <= _POSSESSION_RADIUS_M and ball_speed < _PASS_RELEASE_MPS - if controlled: - new_holder = (nearest_side, nearest_id) - if possession.side is None: - possession = _PossessionState(*new_holder) - elif (possession.side, possession.robot_id) != new_holder: - # Possession changed hands without an intervening "released at - # speed" event (e.g. a slow dribble handoff/tackle) -- attribute - # as a same-side completed pass or a turnover exactly like a - # released pass would be, then adopt the new holder. - if possession.side == nearest_side: - completed_passes[possession.side] += 1 - else: - turnovers[possession.side] += 1 - possession = _PossessionState(*new_holder) - elif possession.side is not None and ball_speed >= _PASS_RELEASE_MPS and dist_to_nearest > _POSSESSION_RADIUS_M: - # Ball just left a controlled possession at speed: released. The - # eventual outcome (pass vs turnover vs neither) is resolved the next - # time the ball is controlled again, or never if it isn't. Mark as - # "released" by clearing robot_id but remembering the releasing side. - if possession.robot_id is not None: - possession = _PossessionState(side=possession.side, robot_id=None) - - # --- metric 1: shots on target --- - for side in sides: - attack_sign = _attack_sign(my_team_is_right, side) - if ball_speed < 1.0: - shot_lock[side] = False - if shot_lock[side]: - continue - toward_goal = ball.v.x * attack_sign > 0.0 - own_goal_x = _own_goal_x(my_team_is_right, side) - progress_from_own_goal = (ball.p.x - own_goal_x) * attack_sign - if not ( - ball_speed >= _SHOT_SPEED_MPS - and toward_goal - and progress_from_own_goal > _HALF_LENGTH + _ATTACKING_THIRD_M - ): - continue - launcher_side_robots = [r for rid, r, s in all_robots if s == side] - if not launcher_side_robots: - continue - near_launcher = min(r.p.distance_to(ball.p) for r in launcher_side_robots) <= _SHOT_LAUNCH_RADIUS_M - if not near_launcher: - continue - attacking_goal_x = attack_sign * _HALF_LENGTH - if ball.v.x == 0: - continue - ticks_to_goal_line = (attacking_goal_x - ball.p.x) / ball.v.x - predicted_y = ball.p.y + ball.v.y * ticks_to_goal_line - if abs(predicted_y) <= _HALF_GOAL_WIDTH: - shots_on_target[side] += 1 - shot_lock[side] = True - # metric 7a: is a teammate (excluding the shooter itself, hence - # the `0 <` lower bound) backing up the shot within support range? - teammates = [r for rid, r, s in all_robots if s == side] - if any(0 < r.p.distance_to(ball.p) <= _SUPPORT_RADIUS_M for r in teammates): - shots_backed_up[side] += 1 - - # --- metric 2: attacking-third entries (hysteresis) --- - for side in sides: - attack_sign = _attack_sign(my_team_is_right, side) - own_goal_x = _own_goal_x(my_team_is_right, side) - progress = (ball.p.x - own_goal_x) * attack_sign - enter_th = _HALF_LENGTH + _ATTACKING_THIRD_M - exit_th = enter_th - _ENTRY_HYSTERESIS_M - if not in_attacking_third[side] and progress > enter_th: - in_attacking_third[side] = True - entries[side] += 1 - elif in_attacking_third[side] and progress < exit_th: - in_attacking_third[side] = False - - # --- metric 6: territory / defensive-third time --- - # `progress` here is the ball's position measured from `side`'s own goal - # along its attack axis: large positive = deep in the opponent's end - # (territory), small/negative = deep in `side`'s own end. The same - # `< _ATTACKING_THIRD_M` cut `match_stats.py` uses for "defensive zone" - # (mirrored: that file measures from each *robot's* own goal too) gives - # the fraction of time the ball spends in `side`'s own defensive third. - for side in sides: - attack_sign = _attack_sign(my_team_is_right, side) - own_goal_x = _own_goal_x(my_team_is_right, side) - progress = (ball.p.x - own_goal_x) * attack_sign - ball_x_sum[side] += progress - if progress < _ATTACKING_THIRD_M: - defensive_third_ticks[side] += 1 - - # --- restart-to-entry resolution --- - if pending_restart is not None: - side = pending_restart["side"] - if side is not None and in_attacking_third[side]: - restarts_resolved[side].append(t - pending_restart["t0"]) - n_restarts_with_entry += 1 - pending_restart = None - - n_ticks = max(n_ticks, 1) - all_resolved = restarts_resolved["friendly"] + restarts_resolved["enemy"] - out = { - "n_sampled_ticks": n_ticks, - "n_restarts": n_restarts, - "n_restarts_with_entry": n_restarts_with_entry, - "restart_to_first_entry_s_mean": (float(np.mean(all_resolved)) if all_resolved else None), - } - for side in sides: - out[f"shots_on_target_{side}"] = shots_on_target[side] - out[f"restart_to_first_entry_s_{side}"] = ( - float(np.mean(restarts_resolved[side])) if restarts_resolved[side] else None - ) - out[f"shot_backed_up_rate_{side}"] = ( - shots_backed_up[side] / shots_on_target[side] if shots_on_target[side] > 0 else None - ) - out[f"attacking_third_entries_{side}"] = entries[side] - out[f"completed_passes_{side}"] = completed_passes[side] - out[f"turnovers_{side}"] = turnovers[side] - out[f"possession_under_pressure_s_{side}"] = pressure_ticks[side] * _DT - out[f"mean_ball_x_towards_opponent_goal_{side}"] = ball_x_sum[side] / n_ticks - out[f"defensive_third_time_pct_{side}"] = defensive_third_ticks[side] / n_ticks - out[f"near_stall_events_{side}"] = near_stall_events[side] - out[f"kicker_identity_thrash_{side}"] = thrash_switches[side] - out[f"retreat_reapproach_oscillations_{side}"] = osc_reversals[side] - out[f"ball_carrier_hold_max_s_{side}"] = carrier_hold_max_s[side] - return out - - -def _match_tag(config_a: str, config_b: str) -> str: - def short(name: str) -> str: - return plain_name(name) - - return f"{short(config_a)}_vs_{short(config_b)}" - - -def _load_referee_events(intentions_path: Path) -> list[dict]: - events = [] - if not intentions_path.exists(): - return events - with open(intentions_path) as f: - for line in f: - line = line.strip() - if not line: - continue - d = json.loads(line) - if d.get("event") == "referee": - events.append({"sim_time": d["sim_time"], "command": d["command"]}) - return events - - -def _cache_path(scratch_dir: Path, run_name: str, match_tag: str) -> Path: - d = scratch_dir / "frame_metrics" / run_name - d.mkdir(parents=True, exist_ok=True) - return d / f"{match_tag}.json" - - -def _worker(args: tuple) -> tuple[str, dict]: - run_dir_str, match_tag, scratch_dir_str = args - run_dir = Path(run_dir_str) - scratch_dir = Path(scratch_dir_str) - cache_path = _cache_path(scratch_dir, run_dir.name, match_tag) - if cache_path.exists(): - with open(cache_path) as f: - return match_tag, json.load(f) - # Current tournament runs write `.npz` (ColumnarReplayWriter); older run - # directories on disk still have `.pkl` (see `_iter_sampled_frames`'s - # dispatch on extension) — prefer `.npz`, fall back for old runs. - npz_path = run_dir / f"{match_tag}.npz" - replay_path = npz_path if npz_path.exists() else run_dir / f"{match_tag}.pkl" - intentions_path = run_dir / f"{match_tag}.intentions.jsonl" - ref_events = _load_referee_events(intentions_path) - try: - metrics = compute_frame_metrics(replay_path, ref_events) - except Exception as exc: # pragma: no cover - defensive: one bad match shouldn't kill the run - metrics = {"_error": str(exc)} - with open(cache_path, "w") as f: - json.dump(metrics, f) - return match_tag, metrics - - -def build_rows(run_dir: Path, scratch_dir: Path, n_workers: int) -> list[dict]: - """One row per match in `run_dir`: summary.json result + stats.json + frame - metrics, cached whole to `/rows/.json`. - """ - rows_cache = scratch_dir / "rows" / f"{run_dir.name}.json" - rows_cache.parent.mkdir(parents=True, exist_ok=True) - if rows_cache.exists(): - with open(rows_cache) as f: - return json.load(f) - - with open(run_dir / "summary.json") as f: - summary = json.load(f) - - tasks = [] - for r in summary["results"]: - match_tag = _match_tag(r["config_a"], r["config_b"]) - tasks.append((str(run_dir), match_tag, str(scratch_dir))) - - frame_results: dict[str, dict] = {} - if n_workers > 1: - with mp.Pool(n_workers) as pool: - for match_tag, metrics in pool.imap_unordered(_worker, tasks, chunksize=1): - frame_results[match_tag] = metrics - else: - for t in tasks: - match_tag, metrics = _worker(t) - frame_results[match_tag] = metrics - - rows = [] - for r in summary["results"]: - match_tag = _match_tag(r["config_a"], r["config_b"]) - stats = r.get("stats") or {} - frame_metrics = frame_results.get(match_tag, {}) - row = { - "run": run_dir.name, - "match_tag": match_tag, - "config_a": r["config_a"], - "config_b": r["config_b"], - "score_a": r["score_a"], - "score_b": r["score_b"], - "winner": r["winner"], - "stats": stats, - "frame_metrics": frame_metrics, - } - rows.append(row) - - with open(rows_cache, "w") as f: - json.dump(rows, f) - return rows - - -# --- Metric differential extraction ----------------------------------------- - -# (metric_name, stats.json path template or frame_metrics key template). -# "stats:" prefix -> read from row["stats"], "frame:" prefix -> row["frame_metrics"]. -# -# `ball_travel_m` (from stats.json) is deliberately NOT in this list: `MatchStats` -# records it as one match-level total, not split by side, so it has no `a-b` -# differential to compute -- see `part_a`/report generation below for how it's -# reported instead (against |goal diff|, not signed goal diff). -# -# `shot_backed_up_rate` is also excluded from `ALL_METRICS`'s per-match -# differential framework (part A): it's only defined for a side that took >=1 -# shot on target in that match, and with only ~13 shots_on_target events across -# 231 matches in a run, both sides taking a shot in the *same* match essentially -# never happens -- the per-match differential would be `None` almost everywhere. -# It's still analysed in parts B/C, pooled per-strategy (total backed-up shots / -# total shots across all of a strategy's matches, not a mean of per-match -# differences) -- see `_shot_backed_up_pooled_rate`. -_STATS_METRICS = [ - "possession_pct", - "shots", - "zone_time_pct_attacking", - "robot_motion_pct", -] -_FRAME_METRICS = [ - "shots_on_target", - "attacking_third_entries", - "completed_passes", - "turnovers", - "possession_under_pressure_s", - "mean_ball_x_towards_opponent_goal", - "defensive_third_time_pct", - "restart_to_first_entry_s", - # Metrics 8-11 (2026-09-04 debugging-signal expansion, see compute_frame_metrics): - # each is a cheap proxy mined from a real, already-traced bug mechanism, tested - # here for whether it *also* carries any outcome signal, not just bug-detection value. - "near_stall_events", - "kicker_identity_thrash", - "retreat_reapproach_oscillations", - "ball_carrier_hold_max_s", -] -# Metrics where a *lower* value is better for that side -- `turnovers`, -# `defensive_third_time_pct`, and `restart_to_first_entry_s` (faster = better -# attacking tempo off a restart). Their differentials are still computed the -# same `own - opponent` way as every other metric; a *negative* correlation -# with points/goal-diff is the expected "good" sign for these, same as -# `defensive_third_time_pct` already reads in part B's table. The 4 new -# debugging-signal metrics are all "lower is better" too -- each one counts an -# occurrence of a known-bad mechanism (near-stall risk, identity thrash, -# retreat/re-approach oscillation, an abnormally long ball hold). -_LOWER_IS_BETTER = frozenset( - { - "turnovers", - "defensive_third_time_pct", - "restart_to_first_entry_s", - "near_stall_events", - "kicker_identity_thrash", - "retreat_reapproach_oscillations", - "ball_carrier_hold_max_s", - } -) - -ALL_METRICS = _STATS_METRICS + _FRAME_METRICS - - -def _team_zone_attacking_mean(zone_time_pct: dict, side: str) -> Optional[float]: - vals = [v["attacking"] for k, v in zone_time_pct.items() if k.startswith(f"{side}_") and "attacking" in v] - return float(np.mean(vals)) if vals else None - - -def _team_robot_motion_mean(robot_motion_pct: dict, side: str) -> Optional[float]: - vals = [v for k, v in robot_motion_pct.items() if k.startswith(f"{side}_")] - return float(np.mean(vals)) if vals else None - - -def extract_side_value(row: dict, metric: str, side: str) -> Optional[float]: - """`side` is "friendly" (=config_a) or "enemy" (=config_b) — matches the - replay/stats.json convention throughout this file. - """ - stats = row["stats"] - fm = row["frame_metrics"] - if metric == "possession_pct": - return stats.get("possession_pct", {}).get(side) - if metric == "shots": - return stats.get("shots", {}).get(side) - if metric == "zone_time_pct_attacking": - return _team_zone_attacking_mean(stats.get("zone_time_pct", {}), side) - if metric == "robot_motion_pct": - return _team_robot_motion_mean(stats.get("robot_motion_pct", {}), side) - if metric in _FRAME_METRICS: - return fm.get(f"{metric}_{side}") - raise ValueError(metric) - - -def compute_differential(row: dict, metric: str) -> Optional[float]: - """a (friendly/config_a) minus b (enemy/config_b), None if either side's value - is missing (e.g. shot_backed_up_rate when a side took zero shots on target). - """ - a = extract_side_value(row, metric, "friendly") - b = extract_side_value(row, metric, "enemy") - if a is None or b is None: - return None - return a - b - - -def goal_diff(row: dict) -> int: - return row["score_a"] - row["score_b"] - - -def winner_label(row: dict) -> Optional[int]: - """1 if config_a won, 0 if config_b won, None if draw (decisive-only metrics).""" - if row["winner"] == "draw": - return None - return 1 if row["winner"] == row["config_a"] else 0 - - -# --- Statistics --------------------------------------------------------------- - - -def spearman(x: np.ndarray, y: np.ndarray) -> tuple[float, float, int]: - mask = ~(np.isnan(x) | np.isnan(y)) - x, y = x[mask], y[mask] - n = len(x) - if n < 3: - return float("nan"), float("nan"), n - if _HAVE_SCIPY: - rho, p = scipy_stats.spearmanr(x, y) - return float(rho), float(p), n - # Fallback: rank + Pearson. - rx = _rankdata(x) - ry = _rankdata(y) - rho = _pearson(rx, ry) - return rho, float("nan"), n - - -def _rankdata(a: np.ndarray) -> np.ndarray: - order = np.argsort(a, kind="mergesort") - ranks = np.empty(len(a), dtype=float) - sorted_a = a[order] - i = 0 - while i < len(a): - j = i - while j + 1 < len(a) and sorted_a[j + 1] == sorted_a[i]: - j += 1 - avg_rank = (i + j) / 2.0 + 1 - ranks[order[i : j + 1]] = avg_rank - i = j + 1 - return ranks - - -def _pearson(x: np.ndarray, y: np.ndarray) -> float: - xm, ym = x - x.mean(), y - y.mean() - denom = math.sqrt(float(np.sum(xm**2)) * float(np.sum(ym**2))) - if denom == 0: - return float("nan") - return float(np.sum(xm * ym) / denom) - - -def auc_score(values: np.ndarray, labels: np.ndarray) -> tuple[float, int]: - """AUC of `values` predicting `labels==1`, via Mann-Whitney U (ties split).""" - mask = ~np.isnan(values) - values, labels = values[mask], labels[mask] - pos = values[labels == 1] - neg = values[labels == 0] - n = len(pos) + len(neg) - if len(pos) == 0 or len(neg) == 0: - return float("nan"), n - if _HAVE_SCIPY: - u, _ = scipy_stats.mannwhitneyu(pos, neg, alternative="two-sided") - auc = u / (len(pos) * len(neg)) - return float(auc), n - # Fallback: direct rank-sum AUC. - combined = np.concatenate([pos, neg]) - ranks = _rankdata(combined) - r_pos = ranks[: len(pos)].sum() - auc = (r_pos - len(pos) * (len(pos) + 1) / 2.0) / (len(pos) * len(neg)) - return float(auc), n - - -def fit_logistic_with_side(x: np.ndarray, side_is_a_right: np.ndarray, y: np.ndarray) -> Optional[dict]: - """Logistic regression of `y` (1=config_a win) on [intercept, x, side_covariate]. - - In this dataset config_a is *always* right (see module docstring), so a - literal "which physical side" covariate would be a constant column and - useless. What genuinely varies match-to-match is a fixed all-True/False - only across the whole corpus, so instead we use, as the requested "side - intercept", a coin-flip-free proxy that is still a real per-match binary - covariate: none exists in this dataset since config_a=yellow=right on - every single match (see match.run_match's hardcoded - my_team_is_yellow=True/my_team_is_right=True). We therefore fit x alone - (intercept + slope) and report that the side covariate is degenerate - (constant) rather than silently fitting a coefficient to an all-ones - column, which statsmodels/sklearn would either drop or blow up on. - """ - mask = ~np.isnan(x) - x, y = x[mask], y[mask] - if len(np.unique(y)) < 2 or len(x) < 5: - return None - # Standardize x for numerically stable IRLS. - mu, sigma = x.mean(), x.std() - if sigma == 0: - return None - xs = (x - mu) / sigma - X = np.column_stack([np.ones_like(xs), xs]) - beta = np.zeros(2) - for _ in range(100): - z = X @ beta - p = 1.0 / (1.0 + np.exp(-z)) - w = p * (1 - p) - w = np.clip(w, 1e-6, None) - W = np.diag(w) - try: - hessian = X.T @ W @ X - grad = X.T @ (y - p) - delta = np.linalg.solve(hessian, grad) - except np.linalg.LinAlgError: - return None - beta = beta + delta - if np.max(np.abs(delta)) < 1e-8: - break - slope_per_unit = beta[1] / sigma - return { - "intercept": float(beta[0]), - "slope_std": float(beta[1]), - "slope_per_unit": float(slope_per_unit), - "n": int(len(x)), - "side_covariate": "degenerate (config_a is right on every match in this dataset)", - } - - -def fit_weighted_proxy(metric_names: list[str], X: np.ndarray, y_goal_diff: np.ndarray) -> Optional[dict]: - """OLS: goal_diff ~ intercept + sum(w_i * standardized_metric_i), reported - back in original (per-metric-unit) goals-per-match terms. Used only for - part D's proposed weighted proxy score, over per-strategy aggregates. - """ - mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_goal_diff) - X, y = X[mask], y_goal_diff[mask] - n = len(y) - if n < len(metric_names) + 2: - return None - mu = X.mean(axis=0) - sigma = X.std(axis=0) - sigma[sigma == 0] = 1.0 - Xs = (X - mu) / sigma - design = np.column_stack([np.ones(n), Xs]) - beta, *_ = np.linalg.lstsq(design, y, rcond=None) - weights_per_unit = beta[1:] / sigma - residuals = y - design @ beta - r2 = 1 - np.sum(residuals**2) / np.sum((y - y.mean()) ** 2) if np.sum((y - y.mean()) ** 2) > 0 else float("nan") - return { - "intercept": float(beta[0]), - "weights_per_unit": {name: float(w) for name, w in zip(metric_names, weights_per_unit)}, - "weights_standardized": {name: float(w) for name, w in zip(metric_names, beta[1:])}, - "n": n, - "r2": float(r2), - } - - -# --- Per-strategy aggregation -------------------------------------------------- - - -def per_strategy_aggregates(all_rows: list[dict], metrics: list[str]) -> dict[str, dict]: - """For each strategy, mean differential (as that strategy's side minus - opponent, regardless of whether it played a or b) per metric across every - match it played, plus points-per-match and goal-diff-per-match. - """ - strategies: dict[str, dict] = {} - for row in all_rows: - for role, config, opp_config in ( - ("a", row["config_a"], row["config_b"]), - ("b", row["config_b"], row["config_a"]), - ): - s = strategies.setdefault( - config, - {"matches": 0, "points": 0.0, "goal_diff_sum": 0, "metric_sums": {m: [] for m in metrics}}, - ) - s["matches"] += 1 - if row["winner"] == "draw": - s["points"] += 1.0 - elif row["winner"] == config: - s["points"] += 3.0 - gd = (row["score_a"] - row["score_b"]) if role == "a" else (row["score_b"] - row["score_a"]) - s["goal_diff_sum"] += gd - own_side = "friendly" if role == "a" else "enemy" - opp_side = "enemy" if role == "a" else "friendly" - for m in metrics: - own_val = extract_side_value(row, m, own_side) - opp_val = extract_side_value(row, m, opp_side) - if own_val is not None and opp_val is not None: - s["metric_sums"][m].append(own_val - opp_val) - - out = {} - for name, s in strategies.items(): - entry = { - "matches": s["matches"], - "points_per_match": s["points"] / s["matches"] if s["matches"] else float("nan"), - "goal_diff_per_match": s["goal_diff_sum"] / s["matches"] if s["matches"] else float("nan"), - } - for m in metrics: - vals = s["metric_sums"][m] - entry[f"mean_diff_{m}"] = float(np.mean(vals)) if vals else float("nan") - out[name] = entry - return out - - -def pooled_shot_backed_up_rate_diff(all_rows: list[dict]) -> dict[str, float]: - """Per-strategy `own_pooled_rate - opp_pooled_rate` for `shot_backed_up_rate`, - where each pooled rate is `sum(backed-up shots) / sum(shots on target)` across - every match the strategy played -- NOT a mean of per-match differentials (see - `ALL_METRICS`'s docstring note on why the per-match differential is too sparse - to use directly here: ~13 shots_on_target events across 231 matches). - """ - own_backed: dict[str, int] = {} - own_shots: dict[str, int] = {} - opp_backed: dict[str, int] = {} - opp_shots: dict[str, int] = {} - for row in all_rows: - fm = row["frame_metrics"] - for role, config, opp_config in ( - ("a", row["config_a"], row["config_b"]), - ("b", row["config_b"], row["config_a"]), - ): - own_side = "friendly" if role == "a" else "enemy" - opp_side = "enemy" if role == "a" else "friendly" - shots_n = fm.get(f"shots_on_target_{own_side}", 0) or 0 - rate = fm.get(f"shot_backed_up_rate_{own_side}") - own_shots[config] = own_shots.get(config, 0) + shots_n - if rate is not None: - own_backed[config] = own_backed.get(config, 0) + round(rate * shots_n) - opp_shots_n = fm.get(f"shots_on_target_{opp_side}", 0) or 0 - opp_rate = fm.get(f"shot_backed_up_rate_{opp_side}") - opp_shots[config] = opp_shots.get(config, 0) + opp_shots_n - if opp_rate is not None: - opp_backed[config] = opp_backed.get(config, 0) + round(opp_rate * opp_shots_n) - - out = {} - for config in own_shots: - own_rate = own_backed.get(config, 0) / own_shots[config] if own_shots.get(config, 0) > 0 else float("nan") - opp_rate = opp_backed.get(config, 0) / opp_shots[config] if opp_shots.get(config, 0) > 0 else float("nan") - out[config] = own_rate - opp_rate - return out - - -# --- Report generation ---------------------------------------------------- - - -def _fmt(v, nd=3) -> str: - if v is None or (isinstance(v, float) and math.isnan(v)): - return "n/a" - if isinstance(v, float): - return f"{v:.{nd}f}" - return str(v) - - -def _mlabel(name: str) -> str: - """Metric name for table display, flagged with `†` when a *lower* raw - `a-b` differential is the "good" direction for side a (see `_LOWER_IS_BETTER`) - -- otherwise a reader sees e.g. `restart_to_first_entry_s`'s negative - correlation with winning and might misread it as "this metric doesn't matter" - rather than "lower is better and the sign is exactly as expected". - """ - base = name.split(" ")[0] - return f"{name} †" if base in _LOWER_IS_BETTER else name - - -def main() -> None: - parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("run_dirs", nargs="+", type=Path, help="tournament run directories") - parser.add_argument("--out", type=Path, required=True, help="output markdown report path") - parser.add_argument( - "--reliability-runs", - nargs=2, - default=["tournament_20260903_101521", "tournament_20260903_115838"], - help="two run names (by dir basename) to correlate per-strategy metrics across, for part C", - ) - parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) - 1)) - parser.add_argument( - "--scratch-dir", - type=Path, - default=Path( - os.environ.get( - "METRIC_CORRELATION_SCRATCH", - str(Path(tempfile.gettempdir()) / "metric_correlation_scratch"), - ) - ), - ) - args = parser.parse_args() - - t_start = time.time() - args.scratch_dir.mkdir(parents=True, exist_ok=True) - - all_rows: list[dict] = [] - for run_dir in args.run_dirs: - rows = build_rows(run_dir, args.scratch_dir, args.workers) - all_rows.extend(rows) - - print(f"Loaded {len(all_rows)} match rows across {len(args.run_dirs)} runs in {time.time() - t_start:.1f}s") - - report_lines: list[str] = [] - report_lines.append("# Metric-correlation study: proxy metrics vs. match outcome") - report_lines.append("") - report_lines.append( - f"Generated {time.strftime('%Y-%m-%d %H:%M UTC', time.gmtime())} by `tools/metric_correlation.py`." - ) - report_lines.append("") - report_lines.append( - "Runs analysed: " + ", ".join(r.name for r in args.run_dirs) + f" ({len(all_rows)} matches total)." - ) - report_lines.append("") - report_lines.append( - "Side convention: `config_a` is always yellow and starts on the right " - "(`match.run_match` hardcodes `my_team_is_yellow=True, my_team_is_right=True`; " - "in runs with halves the teams change ends at half-time); " - "`friendly` in stats/frame metrics always means `config_a`. All metrics below are reported " - "as `a - b` differentials. Because config_a is right on literally every match in this corpus, " - "side cannot be fit as a genuine covariate (it is a constant column) -- see part A." - ) - report_lines.append("") - - # ---- Part A: per-match ---- - report_lines.append("## A. Per-match: Spearman correlation with goal diff, AUC for decisive matches") - report_lines.append("") - report_lines.append( - "Spearman correlates each metric's `a-b` differential with `score_a - score_b` over ALL matches " - "(including draws, since goal diff is still informative at 0-0 for many metrics). AUC is computed only " - "over the 22-26 decisive matches per run (config_a win=1 vs config_b win=0), predicting winner from the " - "raw differential's rank. A logistic fit (intercept + standardized slope) is also reported per metric; " - "a genuine side covariate could not be added (see note above), so this is intercept+slope only, not the " - "originally intended 3-parameter model." - ) - report_lines.append("") - report_lines.append("| metric | n (corr) | spearman rho | p | n (AUC) | AUC | logistic slope/unit |") - report_lines.append("|---|---:|---:|---:|---:|---:|---:|") - - gd = np.array([goal_diff(r) for r in all_rows], dtype=float) - win_labels = np.array([w if w is not None else np.nan for w in (winner_label(r) for r in all_rows)]) - - part_a_results = {} - for m in ALL_METRICS: - diffs = np.array( - [compute_differential(r, m) if compute_differential(r, m) is not None else np.nan for r in all_rows] - ) - rho, p, n_corr = spearman(diffs, gd) - auc, n_auc = auc_score(diffs, win_labels) - dec_mask = ~np.isnan(win_labels) - logit = fit_logistic_with_side(diffs[dec_mask], None, win_labels[dec_mask]) - slope = logit["slope_per_unit"] if logit else None - part_a_results[m] = {"rho": rho, "p": p, "n_corr": n_corr, "auc": auc, "n_auc": n_auc, "slope": slope} - report_lines.append( - f"| {_mlabel(m)} | {n_corr} | {_fmt(rho)} | {_fmt(p)} | {n_auc} | {_fmt(auc)} | {_fmt(slope, 4)} |" - ) - report_lines.append("") - report_lines.append( - "`ball_travel_m` (from `stats.json`) and `shot_backed_up_rate` are not in the table above: " - "`MatchStats` records `ball_travel_m` as one match-level total with no side split, so it has no " - "`a-b` differential -- see below for a match-level check against `|goal diff|` instead. " - "`shot_backed_up_rate` requires a side to have taken >=1 shot on target, and with only a handful of " - "`shots_on_target` events per run, both sides rarely take one in the *same* match -- its per-match " - "differential is `None` almost everywhere, so it's analysed only in parts B/C as a pooled per-strategy " - "rate instead (`pooled_shot_backed_up_rate_diff`)." - ) - report_lines.append("") - - ball_travel = np.array( - [r["stats"].get("ball_travel_m", float("nan")) if r["stats"] else float("nan") for r in all_rows] - ) - abs_gd = np.abs(gd) - rho_bt, p_bt, n_bt = spearman(ball_travel, abs_gd) - part_a_results["ball_travel_m (match-level, vs |goal diff|)"] = {"rho": rho_bt, "p": p_bt, "n_corr": n_bt} - report_lines.append( - f"`ball_travel_m` (match total) vs. `|goal diff|`: spearman rho={_fmt(rho_bt)}, p={_fmt(p_bt)}, n={n_bt}. " - "A more-decisive match plausibly involves more end-to-end ball movement (attacks that go somewhere) " - "rather than a stalemate, hence testing against |goal diff| rather than the signed value." - ) - report_lines.append("") - - # Metric 12 (2026-09-04 expansion) plus a follow-up split (2026-09-04, - # same day): total fouls per match, and its two largest components - # broken out individually, from `rule_event_counts` (already computed by - # MatchStats, previously unused by this study). No side split in - # stats.json (same limitation as ball_travel_m), so all three are tested - # match-level against |goal diff| rather than as an a-b differential. - # Two plausible, opposite-sign hypotheses for total_fouls: more fouls - # could mean a more contested, competitive match (positive with - # |goal diff| is NOT expected -- closer contests are lower |goal diff|), - # or could mean more congestion/crashing typical of a stalling match - # (which would show low |goal diff| too). Reported without a strong - # prior on sign; the data decides. - # - # crashing_rate and out_of_bounds_rate are broken out individually - # because they dominate total_fouls by a wide margin (roughly 60% and - # 20% of it respectively in a same-day 462-match spot check) and are - # architecturally distinct: crashing_rule.py fires on §8.4.2's own - # closing-speed fault thresholds with a built-in 2s retrigger cooldown - # (so this is a genuine per-collision-event count, not tick-spam), while - # out_of_bounds is a pure ball-position check with no cooldown of its - # own (each firing ends the active-play window until the next restart, - # so it also can't tick-spam in practice). A user-observed spot check - # (2026-09-04) found out_of_bounds heavily right-skewed rather than - # uniform: 46% of matches in that check had zero out_of_bounds events, - # but a few pathological matches hit 40-58 in a single 65s window, and - # the per-strategy rate spanned an 8-10x range (switch_of_play/ - # counter_press/high_line_zone/breakwater far above tiki_taka/ - # three_slot/decoy_and_overload) -- worth its own metric to track - # whether that skew is a specific strategy's aim/geometry issue (e.g. a - # cross-field switch-of-play pass overshooting the sideline) rather than - # a uniform baseline, which a single pooled total_fouls number would - # hide entirely. - total_fouls = np.array( - [sum(r["stats"].get("rule_event_counts", {}).values()) if r["stats"] else float("nan") for r in all_rows] - ) - crashing_rate = np.array( - [r["stats"].get("rule_event_counts", {}).get("crashing", 0) if r["stats"] else float("nan") for r in all_rows] - ) - out_of_bounds_rate = np.array( - [ - r["stats"].get("rule_event_counts", {}).get("out_of_bounds", 0) if r["stats"] else float("nan") - for r in all_rows - ] - ) - for name, values in ( - ("total_fouls", total_fouls), - ("crashing_rate", crashing_rate), - ("out_of_bounds_rate", out_of_bounds_rate), - ): - rho_v, p_v, n_v = spearman(values, abs_gd) - part_a_results[f"{name} (match-level, vs |goal diff|)"] = {"rho": rho_v, "p": p_v, "n_corr": n_v} - report_lines.append( - f"`{name}` (match total) vs. `|goal diff|`: spearman rho={_fmt(rho_v)}, p={_fmt(p_v)}, n={n_v}. " - f"Mean {float(np.nanmean(values)):.2f}/match, max {int(np.nanmax(values))}, " - f"{int(np.sum(values == 0))} matches ({np.sum(values == 0) / len(values) * 100:.1f}%) with zero." - ) - report_lines.append("") - - # ---- Part B: per-strategy ---- - report_lines.append("## B. Per-strategy: mean differential vs. points/goal-diff per match") - report_lines.append("") - report_lines.append( - "Each strategy's mean `own - opponent` differential per metric, aggregated across every match it played " - "in the three 101521/112025/115838 runs (63 matches per strategy, 21 per run x 3 runs), correlated " - "(Spearman) against that strategy's points-per-match (3/1/0) and goal-diff-per-match across the 22 strategies." - ) - report_lines.append("") - - main_run_names = {r.name for r in args.run_dirs if "20260902" not in r.name} - main_rows = [r for r in all_rows if r["run"] in main_run_names] - agg = per_strategy_aggregates(main_rows, ALL_METRICS) - strategy_names = sorted(agg.keys()) - points = np.array([agg[s]["points_per_match"] for s in strategy_names]) - gd_per_match = np.array([agg[s]["goal_diff_per_match"] for s in strategy_names]) - - part_b_results = {} - for m in ALL_METRICS: - vals = np.array([agg[s][f"mean_diff_{m}"] for s in strategy_names]) - rho_pts, p_pts, n_pts = spearman(vals, points) - rho_gd, p_gd, n_gd = spearman(vals, gd_per_match) - part_b_results[m] = {"rho_points": rho_pts, "p_points": p_pts, "rho_gd": rho_gd, "p_gd": p_gd, "n": n_pts} - - # shot_backed_up_rate: pooled per-strategy rate (see - # pooled_shot_backed_up_rate_diff's docstring for why this can't use the - # mean-of-per-match-differentials framework the other metrics use above). - sbr_diff = pooled_shot_backed_up_rate_diff(main_rows) - sbr_vals = np.array([sbr_diff.get(s, float("nan")) for s in strategy_names]) - rho_pts, p_pts, n_pts = spearman(sbr_vals, points) - rho_gd, p_gd, n_gd = spearman(sbr_vals, gd_per_match) - part_b_results["shot_backed_up_rate (pooled)"] = { - "rho_points": rho_pts, - "p_points": p_pts, - "rho_gd": rho_gd, - "p_gd": p_gd, - "n": n_pts, - } - - ranked = sorted( - part_b_results.items(), key=lambda kv: -abs(kv[1]["rho_points"]) if not math.isnan(kv[1]["rho_points"]) else 0 - ) - - report_lines.append("Full ranking (by |rho vs points-per-match|):") - report_lines.append("") - report_lines.append("| metric | n strategies | rho vs points/match | p | rho vs goal-diff/match | p |") - report_lines.append("|---|---:|---:|---:|---:|---:|") - for m, res in ranked: - report_lines.append( - f"| {_mlabel(m)} | {res['n']} | {_fmt(res['rho_points'])} | {_fmt(res['p_points'])} | " - f"{_fmt(res['rho_gd'])} | {_fmt(res['p_gd'])} |" - ) - report_lines.append("") - - report_lines.append("### Top five metrics by |rho vs points-per-match|") - report_lines.append("") - report_lines.append("| rank | metric | rho vs points/match | p | rho vs goal-diff/match | p |") - report_lines.append("|---:|---|---:|---:|---:|---:|") - top5 = ranked[:5] - for i, (m, res) in enumerate(top5, 1): - report_lines.append( - f"| {i} | {m} | {_fmt(res['rho_points'])} | {_fmt(res['p_points'])} | " - f"{_fmt(res['rho_gd'])} | {_fmt(res['p_gd'])} |" - ) - report_lines.append("") - - # ---- Part B.5: per-strategy crashing_rate / out_of_bounds_rate ---- - # Not folded into per_strategy_aggregates()'s differential framework - # (crashing_rate/out_of_bounds_rate have no side split -- see the Part A - # comment above), so computed directly here: for each strategy, its own - # rate summed across every match it played (either side), same "own + - # opponent, summed over role" shape a-differential metrics don't need but - # a match-level total does, since a match-level count isn't attributable - # to one side. - report_lines.append("### B.5 Per-strategy crashing_rate / out_of_bounds_rate") - report_lines.append("") - report_lines.append( - "Match-level counts (no side split available) summed across every match a strategy played, either side, " - "then divided by matches played. Sorted by `out_of_bounds_rate` descending -- flagged for investigation " - "2026-09-04 after a user spot check found a 8-10x spread across strategies (not a uniform baseline) with " - "some individual matches hitting 40-58 events in 65s." - ) - report_lines.append("") - strategy_foul_totals: dict[str, dict] = {} - for row in all_rows: - rec = row["stats"].get("rule_event_counts", {}) if row["stats"] else {} - crashing_n = rec.get("crashing", 0) - oob_n = rec.get("out_of_bounds", 0) - for config in (row["config_a"], row["config_b"]): - s = strategy_foul_totals.setdefault(config, {"matches": 0, "crashing": 0, "out_of_bounds": 0}) - s["matches"] += 1 - s["crashing"] += crashing_n - s["out_of_bounds"] += oob_n - ranked_fouls = sorted( - strategy_foul_totals.items(), - key=lambda kv: -(kv[1]["out_of_bounds"] / kv[1]["matches"] if kv[1]["matches"] else 0), - ) - report_lines.append("| strategy | matches | crashing/match | out_of_bounds/match |") - report_lines.append("|---|---:|---:|---:|") - for name, s in ranked_fouls: - report_lines.append( - f"| {name} | {s['matches']} | {_fmt(s['crashing'] / s['matches'])} | {_fmt(s['out_of_bounds'] / s['matches'])} |" - ) - report_lines.append("") - - strat_points = {name: agg["points_per_match"] for name, agg in per_strategy_aggregates(all_rows, []).items()} - oob_rates = np.array([s["out_of_bounds"] / s["matches"] for _, s in ranked_fouls]) - points_arr = np.array([strat_points.get(name, float("nan")) for name, _ in ranked_fouls]) - rho_oob_pts, p_oob_pts, n_oob_pts = spearman(oob_rates, points_arr) - report_lines.append( - f"`out_of_bounds_rate` vs. points-per-match across the {len(ranked_fouls)} strategies: " - f"spearman rho={_fmt(rho_oob_pts)}, p={_fmt(p_oob_pts)}, n={n_oob_pts} -- does going out of bounds more " - "actually predict worse results for that strategy, or is it orthogonal to winning (e.g. a deliberate " - "relief-clearance pattern that costs nothing)." - ) - report_lines.append("") - - # ---- Part C: reliability ---- - report_lines.append("## C. Reliability: per-strategy metric value, run 101521 vs run 115838") - report_lines.append("") - report_lines.append( - "**Caveat: code changed between these runs** (stall/deadlock fixes landed on this branch between " - "101521, 112025, and 115838 -- see the git log). Any reliability number below is therefore a *lower " - "bound* on true metric reliability: some run-to-run disagreement here is genuine strategy-vs-strategy " - "noise, but some is the runner behaving differently, not the metric being noisy." - ) - report_lines.append("") - - run_a_name, run_b_name = args.reliability_runs - rows_a = [r for r in all_rows if r["run"] == run_a_name] - rows_b = [r for r in all_rows if r["run"] == run_b_name] - reliability = {} - if rows_a and rows_b: - agg_a = per_strategy_aggregates(rows_a, ALL_METRICS) - agg_b = per_strategy_aggregates(rows_b, ALL_METRICS) - common = sorted(set(agg_a) & set(agg_b)) - report_lines.append(f"Comparing {len(common)} strategies present in both `{run_a_name}` and `{run_b_name}`.") - report_lines.append("") - report_lines.append("| metric | n strategies | spearman rho (run-to-run) | p |") - report_lines.append("|---|---:|---:|---:|") - for m in ALL_METRICS: - va = np.array([agg_a[s][f"mean_diff_{m}"] for s in common]) - vb = np.array([agg_b[s][f"mean_diff_{m}"] for s in common]) - rho, p, n = spearman(va, vb) - reliability[m] = {"rho": rho, "p": p, "n": n} - report_lines.append(f"| {_mlabel(m)} | {n} | {_fmt(rho)} | {_fmt(p)} |") - - sbr_a = pooled_shot_backed_up_rate_diff(rows_a) - sbr_b = pooled_shot_backed_up_rate_diff(rows_b) - va = np.array([sbr_a.get(s, float("nan")) for s in common]) - vb = np.array([sbr_b.get(s, float("nan")) for s in common]) - rho, p, n = spearman(va, vb) - reliability["shot_backed_up_rate (pooled)"] = {"rho": rho, "p": p, "n": n} - report_lines.append(f"| shot_backed_up_rate (pooled) | {n} | {_fmt(rho)} | {_fmt(p)} |") - report_lines.append("") - - report_lines.append("### Reliability of the top-five B metrics") - report_lines.append("") - report_lines.append("| metric | validity rho (points/match) | reliability rho (run-to-run) | verdict |") - report_lines.append("|---|---:|---:|---|") - for m, res in top5: - rel = reliability.get(m, {"rho": float("nan")}) - v_rho = res["rho_points"] - r_rho = rel["rho"] - if not math.isnan(v_rho) and not math.isnan(r_rho): - if abs(v_rho) >= 0.3 and abs(r_rho) >= 0.5: - verdict = "valid & reliable -- good instrumentation candidate" - elif abs(v_rho) >= 0.3 and abs(r_rho) < 0.5: - verdict = "valid but unreliable -- likely noise, deprioritize" - elif abs(v_rho) < 0.3 and abs(r_rho) >= 0.5: - verdict = "reliable but not valid -- measures something other than winning" - else: - verdict = "neither valid nor reliable" - else: - verdict = "insufficient data" - report_lines.append(f"| {_mlabel(m)} | {_fmt(v_rho)} | {_fmt(r_rho)} | {verdict} |") - report_lines.append("") - else: - report_lines.append("*(one or both reliability runs not present in the provided `run_dirs`; skipped.)*") - report_lines.append("") - - old_draw_runs = [r for r in args.run_dirs if "20260902_2209" in r.name or "20260902_2223" in r.name] - if old_draw_runs: - report_lines.append( - "Two older 36-match, 9-strategy runs (`tournament_20260902_220936`, `tournament_20260902_222351`) " - "were all draws and cover fewer than half the strategy catalog -- not used quantitatively above " - "(too few decisive matches and too small a strategy set for a meaningful correlation), consistent " - "with the task's guidance to use them only for reliability spot-checks." - ) - report_lines.append("") - - # ---- Part D: recommendation ---- - report_lines.append("## D. Recommendation") - report_lines.append("") - - # Combined validity-x-reliability ranking, computed here (ahead of the "which - # metrics to instrument" subsection below) so the weighted proxy score and the - # instrument/drop lists are built from the same selection instead of two - # different top-N cuts. - combined = [] - for m, res in part_b_results.items(): - rel = reliability.get(m, {"rho": float("nan")}) - v_rho, r_rho = res["rho_points"], rel["rho"] - score = abs(v_rho) * abs(r_rho) if not (math.isnan(v_rho) or math.isnan(r_rho)) else float("-inf") - combined.append((m, v_rho, r_rho, score)) - combined.sort(key=lambda t: t[3], reverse=True) - n_strong = sum(1 for *_, s in combined if s >= 0.3) - n_keep = min(6, max(4, n_strong)) if n_strong >= 4 else min(6, len(combined)) - top_n = combined[:n_keep] - recommend_keep = [m for m, _v, _r, s in top_n if s != float("-inf")] - recommend_drop = [m for m, _v, _r, _s in combined if m not in recommend_keep] - - # shot_backed_up_rate (pooled) has no per-match `mean_diff_` entry in `agg` - # (it's computed separately -- see pooled_shot_backed_up_rate_diff), so the - # weighted-proxy fit below only includes metrics with a real `agg` column. - candidate_metrics = [m for m in recommend_keep if f"mean_diff_{m}" in next(iter(agg.values()), {})] - X_cols = [] - valid_metric_names = [] - for m in candidate_metrics: - vals = np.array([agg[s][f"mean_diff_{m}"] for s in strategy_names]) - if not np.all(np.isnan(vals)): - X_cols.append(vals) - valid_metric_names.append(m) - weighted = None - if X_cols: - X = np.column_stack(X_cols) - weighted = fit_weighted_proxy(valid_metric_names, X, gd_per_match) - - n_decisive = int(np.sum(~np.isnan(win_labels))) - report_lines.append( - f"**Honesty check first:** matches are 65 s and only {n_decisive}/{len(all_rows)} " - f"({100*n_decisive/max(1,len(all_rows)):.0f}%) are decisive across the analysed runs. Per-match AUCs in " - "part A are computed on ~22-26 matches per run; per-strategy correlations in part B have n=22 (one point " - "per strategy) and n=9 for the tiny reliability spot-check runs. None of these sample sizes support " - 'strong causal claims -- treat every number here as "consistent with" rather than "proves". The ' - "cleanest signal is the per-strategy aggregate (63 matches/strategy pools out a lot of single-match " - "noise), which is why part D's weights are fit there, not on individual matches." - ) - report_lines.append("") - - if weighted: - report_lines.append( - f"Weighted proxy score (OLS, goal-diff-per-match ~ intercept + weighted metrics; " - f"n={weighted['n']} strategies, R^2={_fmt(weighted['r2'])}):" - ) - report_lines.append("") - report_lines.append(f"`proxy_score = {_fmt(weighted['intercept'])}`") - for name, w in weighted["weights_per_unit"].items(): - report_lines.append(f" `+ ({_fmt(w, 5)}) * mean_diff_{name}`") - report_lines.append("") - report_lines.append( - "Units: `proxy_score` is in goals per match; each weight is per one raw unit of that metric's " - "`a-b` differential (e.g. per 1.0 of possession_pct differential, or per 1 extra shot_on_target). " - f"R^2={_fmt(weighted['r2'])} on n={weighted['n']} strategies -- with this few points, treat the " - "specific weight values as directionally suggestive, not a tuned production model." - ) - report_lines.append("") - - report_lines.append("### Which metrics to instrument live in MatchStats") - report_lines.append("") - report_lines.append( - "Combined score = `|validity rho (B, vs points/match)| x |reliability rho (C, run-to-run)|`, over every " - "metric analysed in B (including the pooled `shot_backed_up_rate`) -- rewards metrics that are both " - "predictive of winning and stable run-to-run, rather than gating on a hard top-five-only cutoff:" - ) - report_lines.append("") - report_lines.append("| metric | validity rho | reliability rho | combined score |") - report_lines.append("|---|---:|---:|---:|") - for m, v_rho, r_rho, score in combined: - report_lines.append( - f"| {_mlabel(m)} | {_fmt(v_rho)} | {_fmt(r_rho)} | {_fmt(score) if score != float('-inf') else 'n/a'} |" - ) - report_lines.append("") - report_lines.append(f"**Instrument these {len(recommend_keep)} live in `MatchStats`:**") - report_lines.append("") - for m in recommend_keep: - report_lines.append(f"- `{m}`") - report_lines.append("") - report_lines.append("**Drop or deprioritize:**") - report_lines.append("") - for m in recommend_drop: - report_lines.append(f"- `{m}`") - report_lines.append("") - report_lines.append( - "Note `possession_pct`, `robot_motion_pct`, and `possession_under_pressure_s` land in the drop list " - "despite `possession_pct`/`robot_motion_pct` already being free (already computed by `MatchStats` today) " - '-- "drop" here means "don\'t treat as a proxy for winning / don\'t weight in the proxy score", not ' - '"remove from `MatchStats`"; they may still be useful for other diagnostic purposes.' - ) - report_lines.append("") - report_lines.append(f"**Runtime:** full analysis over {len(all_rows)} matches took {time.time() - t_start:.1f}s.") - report_lines.append("") - - args.out.parent.mkdir(parents=True, exist_ok=True) - with open(args.out, "w") as f: - f.write("\n".join(report_lines)) - - json_out = args.out.with_suffix(".json") - with open(json_out, "w") as f: - json.dump( - { - "part_a": part_a_results, - "part_b": {m: res for m, res in part_b_results.items()}, - "part_b_top5": [m for m, _ in top5], - "reliability": reliability, - "weighted_proxy": weighted, - "n_matches": len(all_rows), - "n_decisive": n_decisive, - "runtime_s": time.time() - t_start, - }, - f, - indent=2, - ) - - print(f"Wrote {args.out} and {json_out} in {time.time() - t_start:.1f}s total") - - -if __name__ == "__main__": - main() diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index 5ceb96c1..f6837da8 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -1198,7 +1198,7 @@ def markdown_report(payload: dict) -> str: # --- Figures (`--figures DIR`) ------------------------------------------------------------- -# Style copied from tools/signal_report.py. matplotlib is imported only when figures are written, +# Style copied from tools/figure_style.py. matplotlib is imported only when figures are written, # so a default run neither loads it nor changes its output. INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" # Categorical slots in fixed order. A scheme keeps the same slot in every figure; slots are never cycled. diff --git a/tools/pitch_maps.py b/tools/pitch_maps.py index dcb57b80..aff46537 100644 --- a/tools/pitch_maps.py +++ b/tools/pitch_maps.py @@ -2,7 +2,7 @@ pixi run python tools/pitch_maps.py replays/eval_/round_1 [--out docs/img/signals] -Every strategy gets one panel per figure, in `signal_report`'s order (points per match). All +Every strategy gets one panel per figure, in name order (never a ranking). All panels use one frame: the strategy attacks toward +x, its own goal is on the left (-x), and the pitch is rotated 180 degrees for a team that attacks toward -x, so its left wing is +y in every panel. Writes: @@ -45,7 +45,7 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import signal_report as sr # noqa: E402 +from tools import figure_style as sr # noqa: E402 from utama_core.analysis import turnover_breakdown # noqa: E402 from utama_core.analysis.findings import Finding, write_jsonl # noqa: E402 from utama_core.config.field_params import STANDARD_FIELD_DIMS as F # noqa: E402 @@ -58,6 +58,7 @@ ColumnarReplay, load_columnar_replay, ) +from utama_core.strategy.catalog import plain_name # noqa: E402 L, W = F.full_field_half_length, F.full_field_half_width BOX_D, BOX_W = 2 * F.half_defense_area_depth, F.half_defense_area_width # the 2 m x 1 m box, from the goal line @@ -416,7 +417,7 @@ def zone_findings(views: list[MatchView], order: list[str], images: Optional[dic threshold=None, unit="share of samples", message=( - f"{sr.short(name)} had {share:.0%} of its {label} samples in the {zone} " + f"{plain_name(name)} had {share:.0%} of its {label} samples in the {zone} " f"({xs.size} samples)." ), image=(images or {}).get(label), @@ -438,7 +439,7 @@ def summary_rows(views: list[MatchView], order: list[str]) -> list[dict]: fouls = [f for v in views if v.strategy == name for f in v.fouls] rows.append( { - "strategy": sr.short(name), + "strategy": plain_name(name), "in_possession_attacking_half": float(np.mean(x[inp] > 0)) if inp.any() else None, "in_possession_mean_abs_y": float(np.mean(np.abs(y[inp]))) if inp.any() else None, "out_possession_own_half": float(np.mean(x[~inp] < 0)) if (~inp).any() else None, @@ -470,7 +471,7 @@ def run_views(run_dir: Path, workers: int) -> list[MatchView]: summary = json.loads((run_dir / "summary.json").read_text()) jobs = [] for r in summary["results"]: - stem = f"{sr.short(r['config_a'])}_vs_{sr.short(r['config_b'])}" + stem = f"{plain_name(r['config_a'])}_vs_{plain_name(r['config_b'])}" npz = run_dir / f"{stem}.npz" if npz.exists(): jobs.append((str(npz), r["config_a"], r["config_b"], (r.get("stats") or {}).get("fouls") or [])) @@ -487,8 +488,8 @@ def main() -> None: ) args = parser.parse_args() summary = json.loads((args.run_dir / "summary.json").read_text()) - order = sr._order(summary["strategies"]) - labels = {n: f"{sr.short(n)} {sr.points(summary['strategies'][n]):.2f}" for n in order} + order = sorted(summary["strategies"], key=plain_name) + labels = {n: plain_name(n) for n in order} views = run_views(args.run_dir, args.workers) args.out.mkdir(parents=True, exist_ok=True) attack_png = args.out / "positions_attack.png" diff --git a/tools/signal_report.py b/tools/signal_report.py deleted file mode 100644 index 8b7bc1fe..00000000 --- a/tools/signal_report.py +++ /dev/null @@ -1,413 +0,0 @@ -"""Figures of a round-robin's strategy signals (`docs/signals.md`) for `docs/signal_report.md`. - - pixi run python tools/signal_report.py replays/eval_/round_1 [--out docs/img/signals] - -Replays the run's saved matches through `turnover_breakdown.analyse_match` (which carries -`chances`), so it works on runs recorded before chances were measured; it covers the matches -whose replay is in the run directory. Every figure lists the strategies in one order, by points -per match, top first. Writes: - -- `results.png`: goals, shots and goals per shot, each for and against: goals per match is shots - times goals per shot, so it shows whether a strategy wins on volume or on quality; -- `signals.png`: one panel per main signal, every strategy a dot on the signal's own scale, the - median dashed; -- `shot_quality.png`: goals per shot by distance and open goal mouth, over the whole run; -- `fouls.png`: fouls per match by rule (the ball going out is not a foul: its own panel), with - the stalled matches; -- `ball_losses.png`: real ball losses per match by kind, for strategies with at least - `MIN_LOSS_MATCHES` matches as config_a (losses are measured for config_a only). - -It also prints the figures' numbers as a markdown table, for the report and for reading without -the images. -""" - -from __future__ import annotations - -import argparse -import json -import sys -from pathlib import Path -from typing import Callable, Optional - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.pyplot as plt # noqa: E402 -import numpy as np # noqa: E402 - -REPO_ROOT = Path(__file__).resolve().parents[1] -if str(REPO_ROOT) not in sys.path: - sys.path.insert(0, str(REPO_ROOT)) - -from utama_core.analysis import turnover_breakdown # noqa: E402 -from utama_core.analysis.strategy_table import strategy_table # noqa: E402 -from utama_core.strategy.catalog import plain_name - -INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" -FOR, AGAINST = "#2a78d6", "#eb6834" # categorical slots 1 and 2 -# Categorical slots in fixed order (validated adjacent-pair for stacks); never cycled. -SLOTS = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6"] -MIN_LOSS_MATCHES = 5 - -plt.rcParams.update( - { - "figure.facecolor": SURFACE, - "axes.facecolor": SURFACE, - "axes.edgecolor": INK_3, - "axes.labelcolor": INK_2, - "axes.titlesize": 10, - "axes.titlecolor": INK, - "axes.spines.top": False, - "axes.spines.right": False, - "xtick.color": INK_2, - "ytick.color": INK, - "font.size": 9, - } -) - - -def short(name: str) -> str: - return plain_name(name) - - -def points(row: dict) -> float: - return (3 * row["wins"] + row["draws"]) / max(1, row["matches"]) - - -def _order(table: dict) -> list[str]: - return sorted(table, key=lambda n: -points(table[n])) - - -def _per_match(key: str) -> Callable[[dict], Optional[float]]: - return lambda r: r[key] / r["matches"] if r["matches"] else None - - -def _chance(key: str) -> Callable[[dict], Optional[float]]: - return lambda r: r["chances"].get(key) - - -def _ratio(num: str, den: str) -> Callable[[dict], Optional[float]]: - return lambda r: r[num] / r[den] if r[den] else None - - -# (label, value, which way usually helps: "higher" / "lower" / "", format) -SIGNALS = [ - ("attacking-third entries / match", _per_match("attacking_third_entries"), "higher", "{:.1f}"), - ("regains followed by a shot", _chance("regain_to_shot"), "higher", "{:.0%}"), - ("free kicks followed by a shot", _chance("free_kick_to_shot"), "higher", "{:.0%}"), - ("shot distance (m)", _chance("shot_distance_m"), "lower", "{:.1f}"), - ("goal mouth open, own shots", _chance("shot_open_goal"), "higher", "{:.0%}"), - ("completed passes / match", _per_match("completed_passes"), "", "{:.0f}"), - ("metres gained per pass", lambda r: r["pass_progress_m"], "higher", "{:.2f}"), - ("danger conceded (s / match)", _chance("danger_s_per_match"), "lower", "{:.0f}"), - ("goal mouth open, shots faced", _chance("faced_open_goal"), "lower", "{:.0%}"), - ("save rate", _chance("save_rate"), "higher", "{:.0%}"), -] - - -def _ylabels(ax, names: list[str], table: dict, show: bool = True) -> None: - ax.set_yticks(range(len(names))) - if show: # shared y: clearing one panel's labels would clear them all, so hide them instead - ax.set_yticklabels([f"{short(n)} {points(table[n]):.2f}" for n in names]) - ax.set_ylim(len(names) - 0.5, -0.5) - ax.tick_params(axis="y", length=0, labelleft=show) - ax.spines["left"].set_visible(False) - ax.grid(axis="x", color=GRID, lw=0.8) - ax.set_axisbelow(True) - - -def _dumbbell(ax, names, table, value_for, value_against, fmt) -> None: - for i, n in enumerate(names): - a, b = value_for(table[n]), value_against(table[n]) - if a is None or b is None: - continue - ax.plot([a, b], [i, i], color=INK_3, lw=2, solid_capstyle="round", zorder=1) - ax.scatter([b], [i], s=64, color=AGAINST, edgecolors=SURFACE, linewidths=2, zorder=2) - ax.scatter([a], [i], s=64, color=FOR, edgecolors=SURFACE, linewidths=2, zorder=3) - ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _: fmt.format(v))) - - -def results(table: dict, path: Path) -> None: - names = _order(table) - fig, axes = plt.subplots(1, 3, figsize=(13, 0.36 * len(names) + 1.9), sharey=True) - panels = [ - ("goals per match", _per_match("goals_for"), _per_match("goals_against"), "{:.0f}"), - ("shots per match", _per_match("shots"), _per_match("shots_faced"), "{:.0f}"), - ("goals per shot", _ratio("goals_for", "shots"), _ratio("goals_against", "shots_faced"), "{:.0%}"), - ] - for k, (ax, (title, f, a, fmt)) in enumerate(zip(axes, panels)): - _dumbbell(ax, names, table, f, a, fmt) - _ylabels(ax, names, table, show=k == 0) - ax.set_title(title, loc="left") - axes[0].set_xlim(left=0) - axes[1].set_xlim(left=0) - axes[2].set_xlim(left=0) - handles = [ - plt.Line2D([], [], marker="o", ls="", color=FOR, markersize=8, label="for (scored, shots made)"), - plt.Line2D([], [], marker="o", ls="", color=AGAINST, markersize=8, label="against (conceded, shots faced)"), - ] - fig.legend(handles=handles, loc="upper left", ncol=2, frameon=False, bbox_to_anchor=(0.0, 1.0)) - fig.suptitle( - "Why each strategy gets its results: goals per match = shots x goals per shot " - "(strategies by points per match, the number after the name)", - x=0.0, - ha="left", - y=1.07, - fontsize=10, - color=INK, - ) - fig.tight_layout() - fig.savefig(path, dpi=130, bbox_inches="tight") - plt.close(fig) - - -def signals(table: dict, path: Path, cols: int = 5) -> None: - names = _order(table) - rows = -(-len(SIGNALS) // cols) - fig, axes = plt.subplots(rows, cols, figsize=(3.0 * cols + 2.2, (0.3 * len(names) + 1.1) * rows), sharey=True) - for k, (ax, (label, value, helps, fmt)) in enumerate(zip(axes.flat, SIGNALS)): - vals = [value(table[n]) for n in names] - present = [(i, v) for i, v in enumerate(vals) if v is not None] - ax.scatter( - [v for _, v in present], [i for i, _ in present], s=56, color=FOR, edgecolors=SURFACE, lw=2, zorder=3 - ) - if present: - ax.axvline(float(np.median([v for _, v in present])), color=INK_3, lw=1, ls="--", zorder=1) - lo = min(present, key=lambda p: p[1]) - hi = max(present, key=lambda p: p[1]) - for i, v in (lo, hi): # label only the extremes; the table has every value - ax.annotate( - fmt.format(v), - (v, i), - xytext=(0, 7), - textcoords="offset points", - ha="center", - fontsize=8, - color=INK_2, - ) - ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda v, _, f=fmt: f.format(v))) - ax.xaxis.set_major_locator(plt.MaxNLocator(4)) - _ylabels(ax, names, table, show=k % cols == 0) - ax.set_title(label + (f" ({helps} helps)" if helps else ""), loc="left", fontsize=9) - for ax in list(axes.flat)[len(SIGNALS) :]: - ax.set_visible(False) - fig.suptitle( - "Signals per strategy, each on its own scale (dashed: median of the 12; labels: lowest and highest)", - x=0.0, - ha="left", - fontsize=10, - color=INK, - ) - fig.tight_layout() - fig.savefig(path, dpi=130, bbox_inches="tight") - plt.close(fig) - - -DIST_BINS = [0.0, 1.5, 2.0, 2.5, 3.0, 3.5, 10.0] -OPEN_BINS = [0.0, 0.25, 0.5, 0.75, 1.01] -MIN_CELL_SHOTS = 15 - - -def shot_quality(shots: list[dict], path: Path) -> None: - goals = np.zeros((len(OPEN_BINS) - 1, len(DIST_BINS) - 1)) - count = np.zeros_like(goals) - for s in shots: - i = np.searchsorted(OPEN_BINS, s["open_goal"], side="right") - 1 - j = np.searchsorted(DIST_BINS, s["distance_m"], side="right") - 1 - count[i, j] += 1 - goals[i, j] += s["scored"] - rate = np.divide(goals, count, out=np.full_like(goals, np.nan), where=count >= MIN_CELL_SHOTS) - fig, ax = plt.subplots(figsize=(8, 4.2)) - cmap = matplotlib.colors.LinearSegmentedColormap.from_list("blue", ["#cde2fb", "#6da7ec", "#256abf", "#0d366b"]) - cmap.set_bad(GRID) - im = ax.imshow(np.ma.masked_invalid(rate), cmap=cmap, vmin=0, vmax=1, origin="lower", aspect="auto") - for i in range(rate.shape[0]): - for j in range(rate.shape[1]): - n = int(count[i, j]) - if n >= MIN_CELL_SHOTS: - ax.text( - j, - i, - f"{rate[i, j]:.0%}\n{n} shots", - ha="center", - va="center", - fontsize=8, - color=SURFACE if rate[i, j] > 0.45 else INK, - ) - elif n: - ax.text(j, i, f"{n} shots", ha="center", va="center", fontsize=7, color=INK_2) - ax.set_xticks(range(len(DIST_BINS) - 1)) - ax.set_xticklabels([f"{a:g}-{b:g}" if b < 10 else f">{a:g}" for a, b in zip(DIST_BINS, DIST_BINS[1:])]) - ax.set_yticks(range(len(OPEN_BINS) - 1)) - ax.set_yticklabels([f"{a:.0%}-{min(b, 1):.0%}" for a, b in zip(OPEN_BINS, OPEN_BINS[1:])]) - ax.set_xlabel("shot distance to goal centre (m)") - ax.set_ylabel("goal mouth open at the shot") - ax.tick_params(length=0) - for sp in ax.spines.values(): - sp.set_visible(False) - ax.set_title( - f"Goals per shot, all {len(shots)} shots of the run (grey: under {MIN_CELL_SHOTS} shots, no rate)", loc="left" - ) - fig.colorbar(im, ax=ax, label="goals per shot", format=plt.FuncFormatter(lambda v, _: f"{v:.0%}")) - fig.tight_layout() - fig.savefig(path, dpi=130) - plt.close(fig) - - -def _stacked(ax, names, parts: list[tuple[str, list[float]]]) -> None: - left = np.zeros(len(names)) - for k, (label, vals) in enumerate(parts): - v = np.array(vals, dtype=float) - ax.barh( - range(len(names)), v, left=left, height=0.62, color=SLOTS[k], label=label, edgecolor=SURFACE, linewidth=2 - ) - left += v - - -LOSS_KINDS = [ - "tackled", - "ball_out_after_kick", - "shot_saved_or_blocked", - "pass_intercepted", - "loose_ball_lost", - "foul", - "ball_out_other", -] - - -def ball_losses(table: dict, path: Path) -> None: - names = [n for n in _order(table) if table[n]["matches_as_a"] >= MIN_LOSS_MATCHES] - fig, ax = plt.subplots(figsize=(10, 0.36 * len(names) + 1.8)) - parts = [ - ( - kind.replace("_", " "), - [table[n]["real_loss_kinds_as_a"].get(kind, 0) / table[n]["matches_as_a"] for n in names], - ) - for kind in LOSS_KINDS - ] - _stacked(ax, names, parts) - ax.set_yticks(range(len(names))) - ax.set_yticklabels([f"{short(n)} ({table[n]['matches_as_a']} matches)" for n in names]) - ax.set_ylim(len(names) - 0.5, -0.5) - ax.tick_params(axis="y", length=0) - ax.spines["left"].set_visible(False) - ax.grid(axis="x", color=GRID, lw=0.8) - ax.set_axisbelow(True) - ax.set_xlabel("real ball losses per match (not won back within 1 s)") - ax.set_title( - f"How each strategy loses the ball (as config_a only; strategies with {MIN_LOSS_MATCHES}+ such matches)", - loc="left", - ) - ax.legend(ncol=4, frameon=False, loc="upper left", bbox_to_anchor=(0, -0.12 - 0.3 / max(1, len(names)))) - fig.tight_layout() - fig.savefig(path, dpi=130, bbox_inches="tight") - plt.close(fig) - - -BALL_OUT = "out_of_bounds" - - -def _fouls_per_match(summary: dict, table: dict) -> dict[str, dict[str, float]]: - out: dict[str, dict[str, float]] = {n: {} for n in table} - for rule, info in summary["fouls"].items(): - for key, count in info["by_tactic"].items(): - strategy = key.split("/")[0] - if strategy in table: - out[strategy][rule] = out[strategy].get(rule, 0.0) + count / table[strategy]["matches"] - return out - - -def fouls(summary: dict, table: dict, path: Path, top: int = 5) -> None: - names = _order(table) - per = _fouls_per_match(summary, table) - rules = [r for r in summary["fouls"] if r != BALL_OUT] - shown = sorted(rules, key=lambda r: -summary["fouls"][r]["total"])[:top] - parts = [(r.replace("_", " "), [per[n].get(r, 0.0) for n in names]) for r in shown] - parts.append(("other", [sum(v for r, v in per[n].items() if r not in shown and r != BALL_OUT) for n in names])) - fig, (a, b) = plt.subplots( - 1, 2, figsize=(13, 0.36 * len(names) + 2.0), sharey=True, gridspec_kw={"width_ratios": [3, 1]} - ) - _stacked(a, names, parts) - for i, n in enumerate(names): - total = sum(v for _, vals in parts for v in [vals[i]]) - stalled = table[n]["stalled"] - if stalled: - a.text(total + 0.1, i, f"{stalled} stalled", va="center", fontsize=8, color=INK_2) - _ylabels(a, names, table) - a.set_title("fouls per match, by rule", loc="left") - a.legend(ncol=6, frameon=False, loc="upper left", bbox_to_anchor=(0, -0.08 - 0.3 / len(names))) - b.barh(range(len(names)), [per[n].get(BALL_OUT, 0.0) for n in names], height=0.62, color=INK_3) - _ylabels(b, names, table, show=False) - b.set_title("ball out of play per match (not a foul)", loc="left") - fig.suptitle( - "Fouls by the offending strategy, and the matches it stalled in (each stall counts for both teams)", - x=0.0, - ha="left", - fontsize=10, - color=INK, - ) - fig.tight_layout() - fig.savefig(path, dpi=130, bbox_inches="tight") - plt.close(fig) - - -def markdown(table: dict) -> str: - """The figures' numbers, one row per strategy in the figures' order.""" - cols = [ - ("points / match", points, "{:.2f}"), - ("GF", _per_match("goals_for"), "{:.1f}"), - ("GA", _per_match("goals_against"), "{:.1f}"), - ("shots", _per_match("shots"), "{:.1f}"), - ("shots faced", _per_match("shots_faced"), "{:.1f}"), - ("goals / shot", _ratio("goals_for", "shots"), "{:.0%}"), - ("conceded / shot faced", _ratio("goals_against", "shots_faced"), "{:.0%}"), - ] + [(label, value, fmt) for label, value, _, fmt in SIGNALS] - lines = ["| strategy | " + " | ".join(c[0] for c in cols) + " |", "|---" * (len(cols) + 1) + "|"] - for n in _order(table): - cells = [] - for _, value, fmt in cols: - v = value(table[n]) - cells.append("-" if v is None else fmt.format(v)) - lines.append(f"| `{short(n)}` | " + " | ".join(cells) + " |") - return "\n".join(lines) - - -def build(summary: dict, losses: list[dict], out: Path) -> dict: - """Write every figure for `summary` (a round-robin's summary.json) and its replays' - `turnover_breakdown.analyse_match` records. Returns the strategy table plotted, each row - with `shots_faced` added.""" - out.mkdir(parents=True, exist_ok=True) - real = {r["match"]: turnover_breakdown.real_loss_kinds(r) for r in losses} - chances_by_match = {r["match"]: r["chances"] for r in losses if "chances" in r} - table = strategy_table(summary["results"], real, chances_by_match) - for row in table.values(): - row["shots_faced"] = 0 - for r in summary["results"]: - shots = (r.get("stats") or {}).get("shots") or {} - for name, theirs in ((r["config_a"], "enemy"), (r["config_b"], "friendly")): - if name in table: - table[name]["shots_faced"] += shots.get(theirs, 0) - shots = [s for c in chances_by_match.values() for s in c["shots"]] - results(table, out / "results.png") - signals(table, out / "signals.png") - shot_quality(shots, out / "shot_quality.png") - ball_losses(table, out / "ball_losses.png") - fouls(summary, table, out / "fouls.png") - return table - - -def main() -> None: - parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) - parser.add_argument("run_dir", type=Path) - parser.add_argument("--out", type=Path, default=REPO_ROOT / "docs" / "img" / "signals") - parser.add_argument("--workers", type=int, default=8) - args = parser.parse_args() - summary = json.loads((args.run_dir / "summary.json").read_text()) - losses = turnover_breakdown.analyse_run(args.run_dir, args.workers) - table = build(summary, losses, args.out) - print(f"{len(losses)} of {len(summary['results'])} matches had a replay; figures in {args.out}\n") - print(markdown(table)) - - -if __name__ == "__main__": - main() diff --git a/utama_core/analysis/plan_snapshot.py b/utama_core/analysis/plan_snapshot.py index 3ff5f323..973b5145 100644 --- a/utama_core/analysis/plan_snapshot.py +++ b/utama_core/analysis/plan_snapshot.py @@ -40,7 +40,7 @@ from utama_core.replay.scenario import Scenario, scenario_from_replay from utama_core.strategy.catalog import plain_name -# Same ink and palette as tools/signal_report.py (FOR = friendly, AGAINST = enemy). +# Same ink and palette as tools/figure_style.py (FOR = friendly, AGAINST = enemy). INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" FOR, AGAINST = "#2a78d6", "#eb6834" CARROT = "#1baf7a" # categorical slot 3: the planner's output, distinct from the team colours diff --git a/utama_core/analysis/plan_trace.py b/utama_core/analysis/plan_trace.py index dfb2a669..fb014b09 100644 --- a/utama_core/analysis/plan_trace.py +++ b/utama_core/analysis/plan_trace.py @@ -60,7 +60,7 @@ # Single-hue ramp (light to dark FOR blue) for time; the carrot dots keep the carrot colour. TIME_CMAP = mcolors.LinearSegmentedColormap.from_list("time", ["#d6e6fa", FOR, "#0f3d7a"]) -# Referee bands: categorical slots from tools/signal_report.py, STOP grey, BALL_PLACEMENT ink. +# Referee bands: categorical slots from tools/figure_style.py, STOP grey, BALL_PLACEMENT ink. REFEREE_COLOURS = { "HALT": "#e4e3df", "STOP": "#e4e3df", diff --git a/utama_core/tests/analysis/test_signal_report.py b/utama_core/tests/analysis/test_signal_report.py deleted file mode 100644 index 266781c2..00000000 --- a/utama_core/tests/analysis/test_signal_report.py +++ /dev/null @@ -1,52 +0,0 @@ -from tools.signal_report import build, markdown - - -def _result(a: str, b: str, score_a: int, score_b: int) -> dict: - return { - "config_a": a, - "config_b": b, - "score_a": score_a, - "score_b": score_b, - "stats": {"shots": {"friendly": 2, "enemy": 1}, "pass_progress_m": [1.5], "enemy_pass_progress_m": [0.2]}, - } - - -def test_build_writes_every_figure(tmp_path): - shot = {"side": "friendly", "distance_m": 2.2, "angle_deg": 10.0, "open_goal": 0.6, "scored": True} - chances = { - "shots": [shot, {**shot, "side": "enemy", "scored": False}], - "unshot_goals": {"friendly": 0, "enemy": 0}, - "regains": [{"side": "friendly", "t": 1.0, "shot_after_s": 2.0}], - "danger": {"friendly": {"s": 5.0, "spells": 1}, "enemy": {"s": 9.0, "spells": 2}}, - "free_kicks": [{"side": "enemy", "t": 3.0, "attacking_third": False, "shot_after_s": None}], - } - losses = [ - { - "match": "x_vs_y", - "turnovers": [ - {"kind": "tackled", "t": 0.0, "tactic": "T", "just_restarted": False, "regained_after_s": None} - ], - "restarts": [], - "chances": chances, - } - ] - summary = { - "results": [_result("x", "y", 1, 0)], - "fouls": {"crashing": {"total": 1, "inferred": 0, "by_tactic": {"x/T": 1}}}, - } - - table = build(summary, losses, tmp_path) - - assert sorted(p.name for p in tmp_path.iterdir()) == [ - "ball_losses.png", - "fouls.png", - "results.png", - "shot_quality.png", - "signals.png", - ] - assert table["x"]["chances"]["regain_to_shot"] == 1.0 - # Shots faced are the other side's shots: x (config_a, friendly) faced the enemy's 1, y faced 2. - assert table["x"]["shots_faced"] == 1 - assert table["y"]["shots_faced"] == 2 - rows = markdown(table).splitlines() - assert rows[2].startswith("| `x` | 3.00 | 1.0 | 0.0 | 2.0 | 1.0 | 50% | 0% |") diff --git a/utama_core/tests/strategy/test_first_strategy_doc.py b/utama_core/tests/strategy/test_first_strategy_doc.py new file mode 100644 index 00000000..ec8e1886 --- /dev/null +++ b/utama_core/tests/strategy/test_first_strategy_doc.py @@ -0,0 +1,17 @@ +"""The tutorial's strategy (docs/first_strategy.md) still builds, so a new member's first paste works.""" + +import re +from pathlib import Path +from unittest.mock import MagicMock + +from utama_core.engine.strategy import Strategy + +DOC = Path(__file__).resolve().parents[3] / "docs" / "first_strategy.md" + + +def test_the_tutorial_strategy_builds(): + blocks = re.findall(r"```python\n(.*?)```", DOC.read_text(), re.S) + (code,) = [b for b in blocks if b.startswith("# utama_core/strategy/rookie.py")] + module: dict = {} + exec(compile(code, "rookie.py", "exec"), module) + assert isinstance(module["build"]((1, 2, 3, 4, 5), MagicMock()), Strategy) From f0312b2988181aa6abb331a72caa6e21efe3a7e6 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:17:25 +0000 Subject: [PATCH 35/59] structure: drop the src/ layer in skills, motion_planning, team_controller, rsoccer_simulator Moved everything under each src/ up one level and deleted the empty src/: - utama_core/skills/src/* -> utama_core/skills/ - utama_core/motion_planning/src/* -> utama_core/motion_planning/ - utama_core/team_controller/src/* -> utama_core/team_controller/ - utama_core/rsoccer_simulator/src/* -> utama_core/rsoccer_simulator/ The empty src/__init__.py in team_controller was dropped; team_controller/__init__.py already existed (both empty). Compiled robosim/fastpathplanner extensions (gitignored) moved with their directories. Dotted and slash references updated across the repo. Co-Authored-By: Claude Haiku --- .claude/skills/field-session/SKILL.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 6 +-- docs/architecture.md | 6 +-- docs/first_strategy.md | 8 ++-- .../motion_planning/make_control_schemes.py | 14 +++---- docs/img/pipeline/make_one_tick.py | 4 +- docs/img/sim_realism/make_rsim_tick.py | 12 +++--- docs/img/strategy/make_tactic_kernel.py | 4 +- .../team_controller/make_real_robot_path.py | 4 +- docs/roadmap.md | 6 +-- docs/sim_realism.md | 2 +- docs/tools.md | 4 +- examples/ball_trials.py | 2 +- examples/calibrate_robot.py | 4 +- examples/demo_custom_referee.py | 8 ++-- examples/demo_dribbler_test.py | 2 +- examples/pass_receive.py | 7 +--- examples/planner_ab.py | 2 +- examples/save_and_counter.py | 4 +- examples/shooting_drill.py | 8 ++-- pixi.toml | 6 +-- tools/evaluation/evaluate.py | 2 +- tools/evaluation/match.py | 6 +-- tools/evaluation/sim_settings.py | 2 +- tools/field_check.py | 2 +- tools/moments.py | 6 +-- tools/motion_planning_benchmark.py | 6 +-- tools/repro_from_replay.py | 2 +- tools/setup_worktree.sh | 4 +- tools/sim_setup.py | 2 +- tools/trim_idle_log.py | 2 +- tools/vision_check.py | 2 +- utama_core/analysis/close_calls.py | 4 +- utama_core/analysis/plan_snapshot.py | 2 +- utama_core/analysis/plan_trace.py | 2 +- utama_core/analysis/render_window.py | 2 +- utama_core/analysis/robot_calibration.py | 2 +- utama_core/bundle/host.py | 2 +- utama_core/custom_referee/actions.py | 9 +---- .../receivers/referee_receiver.py | 6 +-- .../receivers/vision_receiver.py | 4 +- utama_core/engine/abstract_strategy.py | 10 ++--- utama_core/engine/ball_release.py | 2 +- utama_core/engine/ball_roles.py | 2 +- utama_core/engine/context.py | 2 +- utama_core/engine/referee_override.py | 2 +- .../{src => }/common/acceleration_limiter.py | 0 .../{src => }/common/control_schemes.py | 4 +- .../{src => }/common/motion_controller.py | 4 +- .../{src => }/common/pose_ahead.py | 0 .../motion_planning/controllers/__init__.py | 8 ++++ .../{src => }/controllers/dwa_controller.py | 10 ++--- .../{src => }/controllers/fastpathplanning.py | 8 ++-- .../{src => }/controllers/pid_controller.py | 6 +-- .../{src => }/controllers/trajsampling.py | 14 +++---- .../motion_planning/{src => }/dwa/config.py | 0 .../motion_planning/{src => }/dwa/planner.py | 11 ++---- .../{src => }/dwa/translation_controller.py | 8 ++-- .../{src => }/fastpathplanning/config.py | 0 .../fastpathplanning/cpp/CMakeLists.txt | 0 .../fastpathplanning/cpp/planner.cpp | 0 .../fastpathplanning/numba_kernels.py | 0 .../{src => }/fastpathplanning/planner.py | 8 ++-- utama_core/motion_planning/pid/__init__.py | 1 + .../motion_planning/{src => }/pid/configs.py | 0 .../motion_planning/{src => }/pid/pid.py | 4 +- .../{src => }/pid/pid_abstract.py | 6 +-- .../{src => }/planning/geometry.py | 0 .../{src => }/planning/obstacles.py | 2 +- .../src/controllers/__init__.py | 8 ---- .../motion_planning/src/pid/__init__.py | 1 - .../{src => }/trajsampling/__init__.py | 0 .../{src => }/trajsampling/bang_bang.py | 0 .../{src => }/trajsampling/collision_numba.py | 0 .../{src => }/trajsampling/config.py | 0 .../{src => }/trajsampling/obstacles.py | 2 +- .../{src => }/trajsampling/planner.py | 10 ++--- utama_core/replay/fingerprint.py | 6 +-- utama_core/replay/game_log_writer.py | 4 +- utama_core/replay/replay_player.py | 10 ++--- utama_core/replay/scenario.py | 2 +- utama_core/replay/ssl_log.py | 8 ++-- utama_core/rsoccer_simulator/.gitignore | 2 +- .../{src => }/Entities/Ball.py | 2 +- .../{src => }/Entities/Field.py | 0 .../{src => }/Entities/Frame.py | 4 +- .../{src => }/Entities/Robot.py | 0 .../rsoccer_simulator/Entities/__init__.py | 4 ++ utama_core/rsoccer_simulator/README.md | 2 +- .../rsoccer_simulator/Render/__init__.py | 13 +++++++ .../{src => }/Render/ball.py | 2 +- .../{src => }/Render/field.py | 2 +- .../{src => }/Render/overlay.py | 2 +- .../{src => }/Render/robot.py | 2 +- .../{src => }/Render/utils.py | 0 .../{src => }/Simulators/__init__.py | 0 .../Simulators/robosim/robosim_subprocess.py | 0 .../Simulators/robosim/robosim_wrapper.py | 0 .../{src => }/Simulators/rsim.py | 4 +- .../rsoccer_simulator/Utils/__init__.py | 1 + .../{src => }/Utils/gaussian_noise.py | 0 .../{src => }/Utils/kdtree.py | 0 .../{src => }/Utils/sim_noise.py | 2 +- .../src/Entities/__init__.py | 4 -- .../rsoccer_simulator/src/Render/__init__.py | 13 ------- .../rsoccer_simulator/src/Utils/__init__.py | 1 - .../src/ssl/envs/__init__.py | 1 - .../{src => }/ssl/__init__.py | 0 .../rsoccer_simulator/ssl/envs/__init__.py | 1 + .../{src => }/ssl/envs/standard_ssl.py | 10 ++--- .../{src => }/ssl/ssl_gym_base.py | 8 ++-- utama_core/run/game_gater.py | 2 +- utama_core/run/side_runtime.py | 2 +- utama_core/run/strategy_runner.py | 18 ++++----- utama_core/run/vision_stream.py | 4 +- utama_core/shared/pass_and_score_geometry.py | 8 ++-- utama_core/skills/{src => }/block.py | 4 +- .../skills/{src => }/defend_parameter.py | 6 +-- utama_core/skills/{src => }/go_to_ball.py | 14 +++---- utama_core/skills/{src => }/go_to_point.py | 4 +- utama_core/skills/{src => }/goalkeep.py | 10 ++--- utama_core/skills/{src => }/kick_upfield.py | 4 +- utama_core/skills/{src => }/man_mark.py | 4 +- utama_core/skills/{src => }/score_goal.py | 0 utama_core/skills/{src => }/shielding.py | 0 .../skills/{src => }/utils/defense_utils.py | 0 .../skills/{src => }/utils/move_utils.py | 2 +- utama_core/strategy/avalanche.py | 2 +- utama_core/strategy/breakwater.py | 2 +- utama_core/strategy/chameleon.py | 2 +- utama_core/strategy/default.py | 2 +- utama_core/strategy/firebreak.py | 2 +- utama_core/strategy/mirage.py | 2 +- utama_core/strategy/pendulum.py | 2 +- utama_core/strategy/ricochet.py | 2 +- utama_core/strategy/riptide.py | 2 +- utama_core/strategy/terrier.py | 2 +- utama_core/strategy/tripwire.py | 2 +- utama_core/strategy/weaver.py | 2 +- utama_core/strategy/wolfpack.py | 2 +- utama_core/tactics/_pass_and_score.py | 9 +---- utama_core/tactics/block_shape.py | 4 +- utama_core/tactics/clear_ball.py | 6 +-- utama_core/tactics/decoy_and_overload.py | 4 +- utama_core/tactics/defense.py | 10 ++--- utama_core/tactics/dribble.py | 4 +- utama_core/tactics/give_and_go.py | 6 +-- utama_core/tactics/goalkeeper.py | 6 +-- utama_core/tactics/lead_and_support.py | 6 +-- utama_core/tactics/press_and_contain.py | 10 ++--- utama_core/tactics/shadow_and_mark.py | 10 ++--- utama_core/tactics/switch_of_play.py | 8 ++-- .../team_controller/controllers/__init__.py | 18 +++++++++ .../common/robot_controller_abstract.py | 0 .../controllers/common/robot_profile.py | 2 +- .../common/sim_controller_abstract.py | 0 .../{src => }/controllers/real/find_robots.py | 6 +-- .../controllers/real/kicker_charge.py | 0 .../controllers/real/real_robot_controller.py | 4 +- .../controllers/sim/grsim_controller.py | 11 ++---- .../controllers/sim/grsim_robot_controller.py | 8 ++-- .../controllers/sim/rsim_controller.py | 4 +- .../controllers/sim/rsim_robot_controller.py | 4 +- .../{src => }/debug_utils/telop_gui.py | 2 +- .../generated_code/ssl_gc_common_pb2.py | 0 .../generated_code/ssl_gc_game_event_pb2.py | 0 .../generated_code/ssl_gc_geometry_pb2.py | 0 .../ssl_gc_referee_message_pb2.py | 0 .../generated_code/ssl_gc_state_pb2.py | 0 .../ssl_simulation_config_pb2.py | 0 .../ssl_simulation_control_pb2.py | 0 .../ssl_simulation_error_pb2.py | 0 .../ssl_simulation_robot_control_pb2.py | 0 .../ssl_simulation_robot_feedback_pb2.py | 0 .../ssl_simulation_synchronous_pb2.py | 0 .../ssl_vision_detection_pb2.py | 0 .../ssl_vision_detection_tracked_pb2.py | 0 .../generated_code/ssl_vision_geometry_pb2.py | 0 .../generated_code/ssl_vision_wrapper_pb2.py | 0 .../ssl_vision_wrapper_tracked_pb2.py | 0 utama_core/team_controller/src/__init__.py | 0 .../src/controllers/__init__.py | 22 ----------- .../{src => }/utils/network_manager.py | 2 +- .../{src => }/utils/network_utils.py | 0 .../tests/analysis/test_robot_calibration.py | 8 ++-- utama_core/tests/bundle/test_strategy_file.py | 6 +-- .../tests/common/abstract_test_manager.py | 2 +- .../tests/controller/test_dribbler_limiter.py | 4 +- .../tests/controller/test_find_robots.py | 4 +- .../tests/controller/test_kicker_charge.py | 2 +- .../tests/controller/test_robot_profile.py | 2 +- .../tests/controller/test_sim_controller.py | 2 +- utama_core/tests/engine/test_ball_roles.py | 2 +- .../tests/engine/test_block_shape_tactic.py | 4 +- .../engine/test_decoy_and_overload_tactic.py | 2 +- utama_core/tests/engine/test_evaluate.py | 4 +- .../tests/engine/test_give_and_go_tactic.py | 2 +- .../engine/test_lead_and_support_tactic.py | 2 +- .../engine/test_pass_and_shoot_tactic.py | 2 +- .../engine/test_press_and_contain_tactic.py | 2 +- .../engine/test_shadow_and_mark_tactic.py | 4 +- .../engine/test_switch_of_play_tactic.py | 2 +- .../tests/examples/test_calibrate_robot.py | 2 +- .../tests/examples/test_save_and_counter.py | 2 +- .../tests/examples/test_shooting_drill.py | 2 +- utama_core/tests/fixtures/exact_math.py | 4 +- .../_kernel_test_strategies.py | 4 +- .../contract/controller_contract_test.py | 4 +- .../defense_area_avoidance_test.py | 2 +- .../fastpathplanner_corner_test.py | 2 +- .../fastpathplanner_equivalence_test.py | 6 +-- .../fastpathplanner_fast_math_test.py | 2 +- .../fastpathplanner_subgoal_test.py | 2 +- .../bang_bang_edge_cases_test.py | 7 +--- .../trajsampling_controller_test.py | 6 +-- .../trajsampling_correctness_test.py | 37 +++++++++---------- .../trajsampling_sideways_test.py | 8 ++-- .../motion_planning/multiple_robots_test.py | 2 +- .../single_robot_moving_obstacle_test.py | 2 +- .../single_robot_static_obstacle_test.py | 2 +- .../motion_planning/standardized/harness.py | 2 +- .../test_fastpathplanner_cpp.py | 8 ++-- .../motion_planning/test_fpp_ball_keep_out.py | 2 +- .../test_fpp_inside_ball_keep_out.py | 2 +- .../test_fpp_pressed_against_robot.py | 2 +- .../test_fpp_wall_near_robot.py | 2 +- .../motion_planning/test_pid_approach.py | 4 +- .../test_placement_near_enemy_box.py | 6 +-- .../tests/motion_planning/test_pose_ahead.py | 9 ++--- .../tests/receivers/referee_receiver_test.py | 4 +- .../receivers/vision_receiver_unit_test.py | 2 +- utama_core/tests/referee/test_referee_unit.py | 4 +- .../tests/referee/wandering_strategy.py | 4 +- utama_core/tests/replay/test_fingerprint.py | 22 +++++------ utama_core/tests/replay/test_repro_summary.py | 4 +- utama_core/tests/replay/test_scenario.py | 2 +- utama_core/tests/replay/test_ssl_log.py | 8 ++-- .../tests/replay/test_ssl_log_extras.py | 10 ++--- .../test_dribble_with_friction.py | 4 +- .../rsoccer_simulator/test_render_overlay.py | 2 +- .../rsoccer_simulator/test_robosim_wrapper.py | 10 ++--- .../tests/rsoccer_simulator/test_sim_noise.py | 6 +-- .../test_sim_physics_knobs.py | 6 +-- .../shared/test_defense_area_rules_off.py | 6 +-- .../shared/test_pass_and_score_geometry.py | 4 +- .../tests/skills/test_defend_parameter.py | 2 +- utama_core/tests/skills/test_defense_utils.py | 2 +- .../tests/skills/test_find_best_shot.py | 12 +++--- utama_core/tests/skills/test_go_to_ball.py | 8 ++-- utama_core/tests/skills/test_goalkeep.py | 6 +-- utama_core/tests/skills/test_man_mark.py | 2 +- utama_core/tests/skills/test_move_utils.py | 8 ++-- utama_core/tests/skills/test_shielding.py | 4 +- .../teleport_position_accuracy_test.py | 2 +- .../test_ball_placement_rsim.py | 2 +- .../tests/strategy_runner/test_exp_ball.py | 2 +- .../tests/strategy_runner/test_field_fence.py | 2 +- .../strategy_runner/test_kick_bend_wiring.py | 4 +- .../strategy_runner/test_match_state_reset.py | 2 +- .../strategy_runner/test_referee_rsim.py | 8 ++-- .../strategy_runner/test_scenario_hooks.py | 2 +- .../strategy_runner/test_sim_pose_ahead.py | 4 +- .../test_strategy_control_scheme.py | 2 +- .../tests/tools/test_field_check_tool.py | 2 +- utama_core/tests/tools/test_trim_idle_log.py | 4 +- utama_core/tests/tools/test_vision_check.py | 2 +- 266 files changed, 497 insertions(+), 573 deletions(-) rename utama_core/motion_planning/{src => }/common/acceleration_limiter.py (100%) rename utama_core/motion_planning/{src => }/common/control_schemes.py (85%) rename utama_core/motion_planning/{src => }/common/motion_controller.py (95%) rename utama_core/motion_planning/{src => }/common/pose_ahead.py (100%) create mode 100644 utama_core/motion_planning/controllers/__init__.py rename utama_core/motion_planning/{src => }/controllers/dwa_controller.py (77%) rename utama_core/motion_planning/{src => }/controllers/fastpathplanning.py (84%) rename utama_core/motion_planning/{src => }/controllers/pid_controller.py (83%) rename utama_core/motion_planning/{src => }/controllers/trajsampling.py (95%) rename utama_core/motion_planning/{src => }/dwa/config.py (100%) rename utama_core/motion_planning/{src => }/dwa/planner.py (96%) rename utama_core/motion_planning/{src => }/dwa/translation_controller.py (91%) rename utama_core/motion_planning/{src => }/fastpathplanning/config.py (100%) rename utama_core/motion_planning/{src => }/fastpathplanning/cpp/CMakeLists.txt (100%) rename utama_core/motion_planning/{src => }/fastpathplanning/cpp/planner.cpp (100%) rename utama_core/motion_planning/{src => }/fastpathplanning/numba_kernels.py (100%) rename utama_core/motion_planning/{src => }/fastpathplanning/planner.py (99%) create mode 100644 utama_core/motion_planning/pid/__init__.py rename utama_core/motion_planning/{src => }/pid/configs.py (100%) rename utama_core/motion_planning/{src => }/pid/pid.py (99%) rename utama_core/motion_planning/{src => }/pid/pid_abstract.py (94%) rename utama_core/motion_planning/{src => }/planning/geometry.py (100%) rename utama_core/motion_planning/{src => }/planning/obstacles.py (93%) delete mode 100644 utama_core/motion_planning/src/controllers/__init__.py delete mode 100644 utama_core/motion_planning/src/pid/__init__.py rename utama_core/motion_planning/{src => }/trajsampling/__init__.py (100%) rename utama_core/motion_planning/{src => }/trajsampling/bang_bang.py (100%) rename utama_core/motion_planning/{src => }/trajsampling/collision_numba.py (100%) rename utama_core/motion_planning/{src => }/trajsampling/config.py (100%) rename utama_core/motion_planning/{src => }/trajsampling/obstacles.py (98%) rename utama_core/motion_planning/{src => }/trajsampling/planner.py (99%) rename utama_core/rsoccer_simulator/{src => }/Entities/Ball.py (72%) rename utama_core/rsoccer_simulator/{src => }/Entities/Field.py (100%) rename utama_core/rsoccer_simulator/{src => }/Entities/Frame.py (96%) rename utama_core/rsoccer_simulator/{src => }/Entities/Robot.py (100%) create mode 100644 utama_core/rsoccer_simulator/Entities/__init__.py create mode 100644 utama_core/rsoccer_simulator/Render/__init__.py rename utama_core/rsoccer_simulator/{src => }/Render/ball.py (87%) rename utama_core/rsoccer_simulator/{src => }/Render/field.py (99%) rename utama_core/rsoccer_simulator/{src => }/Render/overlay.py (95%) rename utama_core/rsoccer_simulator/{src => }/Render/robot.py (98%) rename utama_core/rsoccer_simulator/{src => }/Render/utils.py (100%) rename utama_core/rsoccer_simulator/{src => }/Simulators/__init__.py (100%) rename utama_core/rsoccer_simulator/{src => }/Simulators/robosim/robosim_subprocess.py (100%) rename utama_core/rsoccer_simulator/{src => }/Simulators/robosim/robosim_wrapper.py (100%) rename utama_core/rsoccer_simulator/{src => }/Simulators/rsim.py (97%) create mode 100644 utama_core/rsoccer_simulator/Utils/__init__.py rename utama_core/rsoccer_simulator/{src => }/Utils/gaussian_noise.py (100%) rename utama_core/rsoccer_simulator/{src => }/Utils/kdtree.py (100%) rename utama_core/rsoccer_simulator/{src => }/Utils/sim_noise.py (99%) delete mode 100644 utama_core/rsoccer_simulator/src/Entities/__init__.py delete mode 100644 utama_core/rsoccer_simulator/src/Render/__init__.py delete mode 100644 utama_core/rsoccer_simulator/src/Utils/__init__.py delete mode 100644 utama_core/rsoccer_simulator/src/ssl/envs/__init__.py rename utama_core/rsoccer_simulator/{src => }/ssl/__init__.py (100%) create mode 100644 utama_core/rsoccer_simulator/ssl/envs/__init__.py rename utama_core/rsoccer_simulator/{src => }/ssl/envs/standard_ssl.py (98%) rename utama_core/rsoccer_simulator/{src => }/ssl/ssl_gym_base.py (97%) rename utama_core/skills/{src => }/block.py (96%) rename utama_core/skills/{src => }/defend_parameter.py (97%) rename utama_core/skills/{src => }/go_to_ball.py (94%) rename utama_core/skills/{src => }/go_to_point.py (90%) rename utama_core/skills/{src => }/goalkeep.py (97%) rename utama_core/skills/{src => }/kick_upfield.py (91%) rename utama_core/skills/{src => }/man_mark.py (95%) rename utama_core/skills/{src => }/score_goal.py (100%) rename utama_core/skills/{src => }/shielding.py (100%) rename utama_core/skills/{src => }/utils/defense_utils.py (100%) rename utama_core/skills/{src => }/utils/move_utils.py (99%) create mode 100644 utama_core/team_controller/controllers/__init__.py rename utama_core/team_controller/{src => }/controllers/common/robot_controller_abstract.py (100%) rename utama_core/team_controller/{src => }/controllers/common/robot_profile.py (98%) rename utama_core/team_controller/{src => }/controllers/common/sim_controller_abstract.py (100%) rename utama_core/team_controller/{src => }/controllers/real/find_robots.py (98%) rename utama_core/team_controller/{src => }/controllers/real/kicker_charge.py (100%) rename utama_core/team_controller/{src => }/controllers/real/real_robot_controller.py (99%) rename utama_core/team_controller/{src => }/controllers/sim/grsim_controller.py (93%) rename utama_core/team_controller/{src => }/controllers/sim/grsim_robot_controller.py (94%) rename utama_core/team_controller/{src => }/controllers/sim/rsim_controller.py (93%) rename utama_core/team_controller/{src => }/controllers/sim/rsim_robot_controller.py (97%) rename utama_core/team_controller/{src => }/debug_utils/telop_gui.py (99%) rename utama_core/team_controller/{src => }/generated_code/ssl_gc_common_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_gc_game_event_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_gc_geometry_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_gc_referee_message_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_gc_state_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_config_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_control_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_error_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_robot_control_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_robot_feedback_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_simulation_synchronous_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_vision_detection_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_vision_detection_tracked_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_vision_geometry_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_vision_wrapper_pb2.py (100%) rename utama_core/team_controller/{src => }/generated_code/ssl_vision_wrapper_tracked_pb2.py (100%) delete mode 100644 utama_core/team_controller/src/__init__.py delete mode 100644 utama_core/team_controller/src/controllers/__init__.py rename utama_core/team_controller/{src => }/utils/network_manager.py (97%) rename utama_core/team_controller/{src => }/utils/network_utils.py (100%) diff --git a/.claude/skills/field-session/SKILL.md b/.claude/skills/field-session/SKILL.md index b2a3535a..9ceba380 100644 --- a/.claude/skills/field-session/SKILL.md +++ b/.claude/skills/field-session/SKILL.md @@ -35,7 +35,7 @@ caps are 0.3 m/s and 0.6 rad/s on real robots (balls are lost turning faster). ## Things not to chase on the day - Kick strength varies (battery, charge, many causes). The kicker is fixed power and holds its - charge ~30 s; `team_controller/src/controllers/real/kicker_charge.py` keeps it up in play. + charge ~30 s; `team_controller/controllers/real/kicker_charge.py` keeps it up in play. - Kick bend comes from the ball's offset on the dribbler (fitted per radio). - The sim does not model a robot's shortfalls: robot capability is assumed league-level in sim, and real robots' gaps are compensated in the control layer, not in sim settings. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 240c00e6..50ae7629 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -58,7 +58,7 @@ sequenceDiagram participant RO as RefereeOverride
engine/referee_override.py participant P as Partitioner
e.g. strategy/pendulum.py participant T as Tactic
tactics/*.py - participant SK as Skills
skills/src/ + participant SK as Skills
skills/ participant RC as robot controller SR->>AS: step() (side.strategy, after the frame is refined) @@ -388,7 +388,7 @@ whoever runs it. - **`MatchLog`** (`engine/match_log.py`) — one JSONL per match. `Strategy` records an intention row per slot-assignment *change*; call `ctx.match_log.trace(tick, sim_time, key, value)` yourself from a `Tactic` or skill (guard with `if ctx.match_log is not None:`; it's - `None` on tournament/CI runs, so traces can stay in). Examples: `skills/src/go_to_ball.py`, + `None` on tournament/CI runs, so traces can stay in). Examples: `skills/go_to_ball.py`, `tactics/give_and_go.py`. Enable with `match_log_path=` or `match.run_match(..., run_dir=...)`; read back with `load_jsonl(path)`. A run with a dashboard or a game log keeps one in memory too: a plain value traced under a key naming a robot (`ctx.trace(game, f"shoot[{rid}]", @@ -428,7 +428,7 @@ whoever runs it. `diagnosis` (ball in goal / past a line, taker not closing on the ball, taker at the ball but not kicking). The tournament prints a STALLS section, and writes it to `summary.json`; a possession-pinned backstop flags what the watchdog misses. -- **Sim noise** (`rsoccer_simulator/src/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded +- **Sim noise** (`rsoccer_simulator/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded command latency per robot, kick speed and direction noise (a per-robot offset plus kick-to-kick spread), two-phase ball friction (slide after a kick, then roll), per-robot speed and braking limits applied to the commands the sim acts on (hardware caps, the 4 m/s^2 command cap, no per-match acceleration draw, diff --git a/docs/architecture.md b/docs/architecture.md index e1d9006e..7e1f8ecd 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -30,15 +30,15 @@ flowchart TD ovr["RefereeOverride.tick
engine/referee_override.py
custom_referee/actions.py"] part["Partitioner (robots per tactic)
engine/strategy.py, strategy/*.py"] tac["Tactic.tick
tactics/*.py"] - skill["Skills
skills/src/*.py"] + skill["Skills
skills/*.py"] end subgraph motion["Motion (motion_planning/)"] - mc["MotionController.calculate
motion_planning/src/controllers/
fpp, dwa, trajsample"] + mc["MotionController.calculate
motion_planning/controllers/
fpp, dwa, trajsample"] end subgraph output["Output (team_controller/)"] - ctrl["RobotController.send_robot_commands
team_controller/src/controllers/"] + ctrl["RobotController.send_robot_commands
team_controller/controllers/"] rsim["rsim
rsoccer_simulator/ (sim/rsim_robot_controller.py)"] grsim["grSim over UDP
sim/grsim_robot_controller.py"] real["Real robots over radio
real/real_robot_controller.py"] diff --git a/docs/first_strategy.md b/docs/first_strategy.md index 340b0454..846a3fbf 100644 --- a/docs/first_strategy.md +++ b/docs/first_strategy.md @@ -54,9 +54,9 @@ from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy from utama_core.engine.tactic import BaseTactic, TacticTag from utama_core.entities.data.vector import Vector2D -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.kick_upfield import kick_upfield +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.kick_upfield import kick_upfield LANES = [-2.0, -0.7, 0.7, 2.0] # where the helpers stand across the pitch (y, metres) @@ -185,4 +185,4 @@ You decide what to keep. - [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): how strategies and tactics really work. Read it when you want to write a proper tactic. - `utama_core/tactics/`: real tactics to copy from. -- `utama_core/skills/src/`: every skill a robot can use. +- `utama_core/skills/`: every skill a robot can use. diff --git a/docs/img/motion_planning/make_control_schemes.py b/docs/img/motion_planning/make_control_schemes.py index 57593355..7c326654 100644 --- a/docs/img/motion_planning/make_control_schemes.py +++ b/docs/img/motion_planning/make_control_schemes.py @@ -27,12 +27,12 @@ "_path_to", "RobotCommand", "StrategyRunner", - "utama_core/skills/src/utils/move_utils.py", - "utama_core/motion_planning/src/common/control_schemes.py", - "utama_core/motion_planning/src/controllers/fastpathplanning.py", - "utama_core/motion_planning/src/controllers/dwa_controller.py", - "utama_core/motion_planning/src/controllers/trajsampling.py", - "utama_core/motion_planning/src/pid/pid.py", + "utama_core/skills/utils/move_utils.py", + "utama_core/motion_planning/common/control_schemes.py", + "utama_core/motion_planning/controllers/fastpathplanning.py", + "utama_core/motion_planning/controllers/dwa_controller.py", + "utama_core/motion_planning/controllers/trajsampling.py", + "utama_core/motion_planning/pid/pid.py", ] d = Diagram( @@ -51,7 +51,7 @@ 34, 28, "move()", - "skills/src/utils/move_utils.py\ncalls calculate(game, robot_id,\ntarget, orientation) once,\nthen rotates the velocity\ninto the robot frame", + "skills/utils/move_utils.py\ncalls calculate(game, robot_id,\ntarget, orientation) once,\nthen rotates the velocity\ninto the robot frame", kind="decision", ) d.box( diff --git a/docs/img/pipeline/make_one_tick.py b/docs/img/pipeline/make_one_tick.py index 5ad5486a..e513774c 100644 --- a/docs/img/pipeline/make_one_tick.py +++ b/docs/img/pipeline/make_one_tick.py @@ -38,7 +38,7 @@ "utama_core/entities/game", "utama_core/engine/strategy.py", "utama_core/motion_planning", - "utama_core/team_controller/src/controllers", + "utama_core/team_controller/controllers", ] d = Diagram( @@ -128,7 +128,7 @@ d.note(52.5, 27.6, "targets", style="italic", ha="center", va="top") # --- output -------------------------------------------------------------------------------------- -d.box(34, 13, 28, 8, "RobotController", "team_controller/src/controllers/", kind="output", size=10) +d.box(34, 13, 28, 8, "RobotController", "team_controller/controllers/", kind="output", size=10) d.arrow((34, 21.8), (34, 17.2), "RobotCommand per robot", lx=1.2) for x, w, name in ((12, 13, "rsim"), (27, 13, "grSim"), (54, 16, "Real robots")): d.box(x, 3.5, w, 4.5, name, kind="output", size=9.5) diff --git a/docs/img/sim_realism/make_rsim_tick.py b/docs/img/sim_realism/make_rsim_tick.py index 81824232..deb8d386 100644 --- a/docs/img/sim_realism/make_rsim_tick.py +++ b/docs/img/sim_realism/make_rsim_tick.py @@ -29,12 +29,12 @@ "vision_rng", "utama_core/run/strategy_runner.py", "utama_core/custom_referee/custom_referee.py", - "utama_core/team_controller/src/controllers/sim/rsim_controller.py", - "utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py", - "utama_core/rsoccer_simulator/src/Utils/sim_noise.py", - "utama_core/rsoccer_simulator/src/Simulators/rsim.py", - "utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_wrapper.py", - "utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py", + "utama_core/team_controller/controllers/sim/rsim_controller.py", + "utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py", + "utama_core/rsoccer_simulator/Utils/sim_noise.py", + "utama_core/rsoccer_simulator/Simulators/rsim.py", + "utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py", + "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py", "vendor/rSim/src/robosim", ] diff --git a/docs/img/strategy/make_tactic_kernel.py b/docs/img/strategy/make_tactic_kernel.py index 90cbf6d1..834fb62e 100644 --- a/docs/img/strategy/make_tactic_kernel.py +++ b/docs/img/strategy/make_tactic_kernel.py @@ -34,7 +34,7 @@ "utama_core/engine/match_log.py", "utama_core/strategy/pendulum.py", "utama_core/tactics", - "utama_core/skills/src", + "utama_core/skills", ] d = Diagram( @@ -140,7 +140,7 @@ 10, 46, 12, - "Skills (skills/src/)", + "Skills (skills/)", "go_to_ball, go_to_point, ... each\nreturns a RobotCommand", kind="motion", ) diff --git a/docs/img/team_controller/make_real_robot_path.py b/docs/img/team_controller/make_real_robot_path.py index 3cd4f6ed..85c90547 100644 --- a/docs/img/team_controller/make_real_robot_path.py +++ b/docs/img/team_controller/make_real_robot_path.py @@ -40,7 +40,7 @@ "utama_core/entities/game/game_frame.py", "utama_core/engine/strategy.py", "utama_core/motion_planning", - "utama_core/team_controller/src/controllers/real/real_robot_controller.py", + "utama_core/team_controller/controllers/real/real_robot_controller.py", ] d = Diagram( @@ -110,7 +110,7 @@ 40, 12, "RealRobotController", - "team_controller/src/controllers/real/\nserial radio on settings.PORT, 115200 baud", + "team_controller/controllers/real/\nserial radio on settings.PORT, 115200 baud", kind="output", size=10, ) diff --git a/docs/roadmap.md b/docs/roadmap.md index a9bab6c7..f98b391a 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -32,7 +32,7 @@ entry by its title, not its number. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). - **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion at the last release (a frozen `.strategy` file) in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded sim noise (the simulated world and robots from `world.json` and `robots.json`). Candidate and reference meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 better, <= 0.2 worse, undecided after 6 rounds (`analysis/ratings.py`); the match results store (`replays/match_results/`) never replays a fixture it already has, and `tools/evaluation/explain.py` draws where the robots stand. Until 2026-11-12 it used `opponents.json` with held-out opponents and a ledger (`replays/eval/ledger.jsonl`). The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. -- **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. +- **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. - **Shared hysteresis helper** — `Sticky` in `shared/tolerance.py` (`fd87c7f6`), now used by `PassAndShootTactic`'s passer choice, `ClearBallTactic`'s target choice and `PressAndContainTactic`'s presser choice instead of per-site margins — `0ce4e2a2`. (`pickers.friendly_closer_to_ball` keeps its own tick-count hysteresis.) @@ -115,7 +115,7 @@ entry by its title, not its number. carry) vs a short kinematic rollout that proves release before the carry limit and the keeper hold time. Leaning single-tick first; rollout only if something slips past. - *What counts as a valid response per tactic:* pass vs clear vs carry, and who decides - (the tactic, or a shared default like `skills/src/kick_upfield.py`). + (the tactic, or a shared default like `skills/kick_upfield.py`). - *Where the guarantee lives:* per-tactic branches (current approach), or an engine-level safety net that takes over a robot holding the ball too long — the latter is a new kernel concept, so it needs a concrete case the per-tactic approach can't handle. @@ -207,7 +207,7 @@ entry by its title, not its number. (their placer running to the ball, ours clearing away from it along the same line) and touched; each planner saw the other, but 79 ms late and braking sideways at ~1.8 m/s². *Delay prediction done 2026-10-28:* `move()` plans from our robots' pose - `RobotParams.CONTROL_LATENCY_S` (real: 0.079 s) ahead (`motion_planning/src/common/pose_ahead.py`). + `RobotParams.CONTROL_LATENCY_S` (real: 0.079 s) ahead (`motion_planning/common/pose_ahead.py`). Checked in rsim given the calibrated robot (delay, gains and per-axis acceleration applied in the sim by a scratch harness): driving while turning, off-line drift 30 → 7 cm; motion benchmark collisions with the delay alone 7 → 3 (24 → 26 of 29 pass). With the diff --git a/docs/sim_realism.md b/docs/sim_realism.md index a61bc9e0..a2e6c94e 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -467,7 +467,7 @@ Removed 2026-11-09: simulation models the measured world and assumes robots work A robot's calibrated profile now drives its kick in rsim when a run gives the profile (the examples do): ball speed `kick_speed` (yellow 0 2.19 m/s, blue 0 1.31, the medians of 2026-10-28's kicks), direction bias + bend × ball offset + normal scatter of `kick_spread_deg` -(`utama_core/rsoccer_simulator/src/Utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than +(`utama_core/rsoccer_simulator/Utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than the kick speed commanded, at 1 to 5 m/s, so the command adds that back. The strategy evaluation passes no profiles, so its matches are unchanged: whether evaluation should use our kick is the Phase 4 / roadmap 2a decision, not this one. Latency is not in this kick profile: rsim's latency is `SimNoise`'s (`reference/world.json`), and real robots predict their diff --git a/docs/tools.md b/docs/tools.md index 62ddfa06..d85d6df8 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -44,12 +44,12 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `lint` | the whole pre-commit stack (black, ruff, isort) on every file | | `precommit-install` / `precommit-uninstall` | install or remove the pre-commit hook | | `main` | `main.py`: watch one match between two strategies in rsim (below) | -| `build-planner` | build the C++ fast-path planner (`utama_core/motion_planning/src/fastpathplanning/cpp`) into `build/fpp` with cmake | +| `build-planner` | build the C++ fast-path planner (`utama_core/motion_planning/fastpathplanning/cpp`) into `build/fpp` with cmake | | `replay [-n NAME] [-p]` | play a legacy pickle replay `replays/NAME.pkl` in the rSoccer viewer (newest if no name; `-p` step by step). Today's `.npz` replays open in the dashboard instead | | `runs` | list the tournament runs in `replays/`: start time, commit, matches, stalls, arguments | | `debug-robots` | keyboard/click teleoperation GUI for real robots over the serial radio (robots chosen by radio ID; [real_robot_setup.md](real_robot_setup.md)) | | `field-check` | the start of a test day in one command (`tools/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([real_robot_setup.md](real_robot_setup.md#each-test-day)) | -| `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.src.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | +| `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | | `demos` | every dashboard demo from one command (`examples/demos.py`, `--mode rsim` to rehearse, `--demo` the first): one dashboard stays up and the Live tab's Demo panel switches demo while halted (robots stopped, log saved, radio and vision released, the page reloads by itself), sets the first robot, camera half and rules for the next run, runs the field check, and offers teleop by keyboard ([real_robot_setup.md](real_robot_setup.md#running-the-demos)) | | `calibrate` | measure one real robot from the terminal and write its profile (`examples/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | diff --git a/examples/ball_trials.py b/examples/ball_trials.py index fc33a8f7..259f1a16 100644 --- a/examples/ball_trials.py +++ b/examples/ball_trials.py @@ -41,7 +41,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import FieldBounds, Game from utama_core.shared.pass_and_score_geometry import kick_bend -from utama_core.skills.src.utils.move_utils import turn_on_spot +from utama_core.skills.utils.move_utils import turn_on_spot CARRY_M = 0.5 # how far a carry goes TURN_RAD = math.pi # how far a turn goes diff --git a/examples/calibrate_robot.py b/examples/calibrate_robot.py index 86d9e452..f604fa8c 100644 --- a/examples/calibrate_robot.py +++ b/examples/calibrate_robot.py @@ -80,13 +80,13 @@ Move, ScriptedMovesTactic, ) -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( RobotProfile, load_profile, profile_path, save_profile, ) -from utama_core.team_controller.src.controllers.real import find_robots +from utama_core.team_controller.controllers.real import find_robots _START = ( "Robot near the middle of the camera's view facing +x, 0.8 m clear ahead and 0.6 m to its left, " diff --git a/examples/demo_custom_referee.py b/examples/demo_custom_referee.py index 3ad63337..f894f2b0 100644 --- a/examples/demo_custom_referee.py +++ b/examples/demo_custom_referee.py @@ -46,14 +46,14 @@ from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.rsoccer_simulator.src.Render import COLORS, SSLRenderField -from utama_core.rsoccer_simulator.src.Render.ball import RenderBall -from utama_core.rsoccer_simulator.src.Render.overlay import ( +from utama_core.rsoccer_simulator.Render import COLORS, SSLRenderField +from utama_core.rsoccer_simulator.Render.ball import RenderBall +from utama_core.rsoccer_simulator.Render.overlay import ( OverlayObject, OverlayType, RenderOverlay, ) -from utama_core.rsoccer_simulator.src.Render.robot import RenderSSLRobot +from utama_core.rsoccer_simulator.Render.robot import RenderSSLRobot # --------------------------------------------------------------------------- # Scene definition diff --git a/examples/demo_dribbler_test.py b/examples/demo_dribbler_test.py index e0b428be..12ed39a1 100644 --- a/examples/demo_dribbler_test.py +++ b/examples/demo_dribbler_test.py @@ -21,7 +21,7 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.run import StrategyRunner from utama_core.tactics.dribble import DribbleTactic diff --git a/examples/pass_receive.py b/examples/pass_receive.py index 6fb1b71d..0e8b6dca 100644 --- a/examples/pass_receive.py +++ b/examples/pass_receive.py @@ -92,12 +92,7 @@ kick_bend, oriented_towards, ) -from utama_core.skills.src.utils.move_utils import ( - empty_command, - kick, - move, - turn_on_spot, -) +from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot from utama_core.tactics.scripted_moves import ScriptedMovesTactic # --------------------------------------------------------------------------- diff --git a/examples/planner_ab.py b/examples/planner_ab.py index 37cd1a6c..c7ba3d7e 100644 --- a/examples/planner_ab.py +++ b/examples/planner_ab.py @@ -54,7 +54,7 @@ from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner -from utama_core.skills.src.utils.move_utils import move +from utama_core.skills.utils.move_utils import move # (robot A's spot, robot B's spot) per leg, in turn; the first is where they start. START = (Vector2D(-0.8, 0.0), Vector2D(0.8, 0.0)) diff --git a/examples/save_and_counter.py b/examples/save_and_counter.py index 6aba9acf..eedea79d 100644 --- a/examples/save_and_counter.py +++ b/examples/save_and_counter.py @@ -69,8 +69,8 @@ has_ball, oriented_towards, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.utils.move_utils import empty_command, move, turn_on_spot +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.utils.move_utils import empty_command, move, turn_on_spot from utama_core.tactics._pass_and_score import FACE_GOAL_RAD from utama_core.tactics.goalkeeper import GoalkeeperTactic from utama_core.tactics.lead_and_support import LeadAndSupportTactic diff --git a/examples/shooting_drill.py b/examples/shooting_drill.py index 8d396994..4ec2dff9 100644 --- a/examples/shooting_drill.py +++ b/examples/shooting_drill.py @@ -84,18 +84,18 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run import StrategyRunner from utama_core.shared.pass_and_score_geometry import has_ball, oriented_towards -from utama_core.skills.src.utils.move_utils import kick, turn_on_spot +from utama_core.skills.utils.move_utils import kick, turn_on_spot from utama_core.tactics.defense import DefenseTactic from utama_core.tactics.give_and_go import GiveAndGoTactic from utama_core.tactics.goalkeeper import GoalkeeperTactic from utama_core.tactics.lead_and_support import LeadAndSupportTactic from utama_core.tactics.press_and_contain import PressAndContainTactic from utama_core.tactics.scripted_moves import ScriptedMovesTactic -from utama_core.team_controller.src.controllers.common.robot_profile import RobotProfile -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import RobotProfile +from utama_core.team_controller.controllers.common.robot_profile import ( load_profile as robot_profile, ) -from utama_core.team_controller.src.controllers.real.find_robots import ( +from utama_core.team_controller.controllers.real.find_robots import ( confirm as confirm_lids, ) diff --git a/pixi.toml b/pixi.toml index 94d07ab5..8561e4ba 100644 --- a/pixi.toml +++ b/pixi.toml @@ -55,13 +55,13 @@ numpy = "<=2.0.2" [tasks] lint = "pre-commit run --all-files" test = "pytest utama_core/tests/" -build-planner = "cmake -B build/fpp utama_core/motion_planning/src/fastpathplanning/cpp && cmake --build build/fpp -j" +build-planner = "cmake -B build/fpp utama_core/motion_planning/fastpathplanning/cpp && cmake --build build/fpp -j" main = "python -m main" replay = "python -m utama_core.replay.replay_player" runs = "python -m utama_core.analysis.list_runs" -debug-robots = "python -m utama_core.team_controller.src.debug_utils.telop_gui" +debug-robots = "python -m utama_core.team_controller.debug_utils.telop_gui" calibrate = "python examples/calibrate_robot.py" -find-robots = "python -m utama_core.team_controller.src.controllers.real.find_robots" +find-robots = "python -m utama_core.team_controller.controllers.real.find_robots" field-check = "python tools/field_check.py" demos = "python examples/demos.py" package-results = "python tools/package_logs.py tournament" diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 97b8af92..5f035f70 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -57,7 +57,7 @@ from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 from utama_core.replay import match_results # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise # noqa: E402 +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise # noqa: E402 from utama_core.strategy import catalog # noqa: E402 CONFIRM_SEED = 101 # the confirm stage's first seed: never one the screen plays diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index c8ad1bfd..15aecbbb 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -36,10 +36,10 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.replay.columnar_writer import ColumnarReplayWriterConfig -from utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper import ( +from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( enable_sim_reuse, ) -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.strategy import catalog from utama_core.strategy.catalog import plain_name @@ -165,7 +165,7 @@ def run_match( Both sides use the fpp planner (`tools/motion_planning_benchmark.py` compares planners). `sim_noise`, if set, plays the match with seeded latency, kick speed noise and vision noise - (`utama_core/rsoccer_simulator/src/Utils/sim_noise.py`, `docs/sim_realism.md`). The draws + (`utama_core/rsoccer_simulator/Utils/sim_noise.py`, `docs/sim_realism.md`). The draws depend on the seed, team colour and robot id only, so the same `sim_noise` gives every pairing the same physics. """ diff --git a/tools/evaluation/sim_settings.py b/tools/evaluation/sim_settings.py index 3b6b5561..44f02bed 100644 --- a/tools/evaluation/sim_settings.py +++ b/tools/evaluation/sim_settings.py @@ -11,7 +11,7 @@ import json from pathlib import Path -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise REFERENCE_DIR = Path(__file__).with_name("reference") DEFAULT_PLAYERS = REFERENCE_DIR / "players.json" diff --git a/tools/field_check.py b/tools/field_check.py index 84cc043a..714b5335 100644 --- a/tools/field_check.py +++ b/tools/field_check.py @@ -29,7 +29,7 @@ from vision_check import _socket, listen from utama_core.config.settings import MULTICAST_GROUP, PORT, VISION_PORT -from utama_core.team_controller.src.controllers.real import find_robots +from utama_core.team_controller.controllers.real import find_robots VISION_S = 2.0 MIN_CAMERA_HZ = 30 # a camera sending fewer packets per second than this is struggling diff --git a/tools/moments.py b/tools/moments.py index 5c380669..bd5a3e78 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -108,8 +108,8 @@ # Python and results differ). AGAINST_DIR = REPO_ROOT.parent / f"{REPO_ROOT.name}-moments-against" BUILD_ARTIFACTS = ( - "utama_core/motion_planning/src/fastpathplanning/_fastpathplanner.cpython-*.so", - "utama_core/rsoccer_simulator/src/Simulators/robosim/_robosim.cpython-*.so", + "utama_core/motion_planning/fastpathplanning/_fastpathplanner.cpython-*.so", + "utama_core/rsoccer_simulator/Simulators/robosim/_robosim.cpython-*.so", ) @@ -525,7 +525,7 @@ def label(name: str) -> str: def play(m: Moment, strategy: str) -> list[Tick]: """Play `m` with `strategy` on our side (yellow) for `m.seconds`.""" from utama_core.replay.scenario import apply_scenario - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise def side(name: str): try: diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index f6837da8..760b70fb 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -47,10 +47,10 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.global_utils.git_utils import git_revision -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.run import StrategyRunner -from utama_core.skills.src.utils.move_utils import move -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.skills.utils.move_utils import move +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/tools/repro_from_replay.py b/tools/repro_from_replay.py index 41bcdabd..c21e234b 100644 --- a/tools/repro_from_replay.py +++ b/tools/repro_from_replay.py @@ -98,7 +98,7 @@ class name (e.g. "DecoyOverloadTactic"), on a release why, else null. Written wh from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.columnar_reader import load_sim_noise from utama_core.replay.scenario import Scenario, apply_scenario, scenario_from_replay -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.strategy import catalog _STILL_STALLED_WINDOW_S = 10.0 diff --git a/tools/setup_worktree.sh b/tools/setup_worktree.sh index 3f086783..2641b0b4 100755 --- a/tools/setup_worktree.sh +++ b/tools/setup_worktree.sh @@ -31,8 +31,8 @@ else fi for rel in \ - utama_core/motion_planning/src/fastpathplanning \ - utama_core/rsoccer_simulator/src/Simulators/robosim; do + utama_core/motion_planning/fastpathplanning \ + utama_core/rsoccer_simulator/Simulators/robosim; do for src in "$main_root/$rel"/_*.cpython-*.so; do [ -e "$src" ] || continue name="$(basename "$src")" diff --git a/tools/sim_setup.py b/tools/sim_setup.py index 00696001..27a65db4 100644 --- a/tools/sim_setup.py +++ b/tools/sim_setup.py @@ -25,7 +25,7 @@ from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner from utama_core.strategy import catalog diff --git a/tools/trim_idle_log.py b/tools/trim_idle_log.py index 2f1e9a4d..e49bfe8f 100644 --- a/tools/trim_idle_log.py +++ b/tools/trim_idle_log.py @@ -36,7 +36,7 @@ VISION_2014, ) from utama_core.replay.ssl_log import read_records # noqa: E402 -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( # noqa: E402 +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import ( # noqa: E402 Referee, ) diff --git a/tools/vision_check.py b/tools/vision_check.py index cfd942f4..cf5a7405 100644 --- a/tools/vision_check.py +++ b/tools/vision_check.py @@ -33,7 +33,7 @@ sys.path.insert(0, str(REPO_ROOT)) from utama_core.config.settings import MULTICAST_GROUP, VISION_PORT -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) diff --git a/utama_core/analysis/close_calls.py b/utama_core/analysis/close_calls.py index f273abf6..91fef62c 100644 --- a/utama_core/analysis/close_calls.py +++ b/utama_core/analysis/close_calls.py @@ -32,9 +32,7 @@ from utama_core.analysis.robot_calibration import FieldLog, _main_camera, tag_offsets from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.replay.ssl_log import REFEREE, read_records -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee CLOSE_M = 0.25 CONTACT_M = 2 * ROBOT_RADIUS diff --git a/utama_core/analysis/plan_snapshot.py b/utama_core/analysis/plan_snapshot.py index 973b5145..b989c601 100644 --- a/utama_core/analysis/plan_snapshot.py +++ b/utama_core/analysis/plan_snapshot.py @@ -33,7 +33,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.motion_planning.src.fastpathplanning.planner import ( +from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _keeps_off_ball, ) diff --git a/utama_core/analysis/plan_trace.py b/utama_core/analysis/plan_trace.py index fb014b09..c1ef3b0d 100644 --- a/utama_core/analysis/plan_trace.py +++ b/utama_core/analysis/plan_trace.py @@ -51,7 +51,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS, FieldDimensions from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE from utama_core.entities.game import Game -from utama_core.motion_planning.src.fastpathplanning.planner import ( +from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _keeps_off_ball, ) diff --git a/utama_core/analysis/render_window.py b/utama_core/analysis/render_window.py index 9045c0f4..aeb86f2f 100644 --- a/utama_core/analysis/render_window.py +++ b/utama_core/analysis/render_window.py @@ -32,7 +32,7 @@ from utama_core.engine.match_log import load_jsonl from utama_core.entities.game import GameFrame from utama_core.replay.replay_player import load_frames_in_range -from utama_core.rsoccer_simulator.src.Render.utils import COLORS +from utama_core.rsoccer_simulator.Render.utils import COLORS _FRIENDLY_COLOR = tuple(c / 255 for c in COLORS["YELLOW"]) _ENEMY_COLOR = tuple(c / 255 for c in COLORS["BLUE"]) diff --git a/utama_core/analysis/robot_calibration.py b/utama_core/analysis/robot_calibration.py index 41f568b9..1c733114 100644 --- a/utama_core/analysis/robot_calibration.py +++ b/utama_core/analysis/robot_calibration.py @@ -42,7 +42,7 @@ from utama_core.replay.game_log_writer import RADIO_IN, RADIO_OUT, RUN_INFO from utama_core.replay.ssl_log import VISION_2014, read_records -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) diff --git a/utama_core/bundle/host.py b/utama_core/bundle/host.py index 11761501..865a966f 100644 --- a/utama_core/bundle/host.py +++ b/utama_core/bundle/host.py @@ -24,7 +24,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.motion_planning.src.common.control_schemes import CONTROL_SCHEME_MAP +from utama_core.motion_planning.common.control_schemes import CONTROL_SCHEME_MAP class _CommandRecorder: diff --git a/utama_core/custom_referee/actions.py b/utama_core/custom_referee/actions.py index d9893f67..4f44c935 100644 --- a/utama_core/custom_referee/actions.py +++ b/utama_core/custom_referee/actions.py @@ -40,13 +40,8 @@ restart_support, ) from utama_core.shared.tolerance import Sticky -from utama_core.skills.src.man_mark import mark_target -from utama_core.skills.src.utils.move_utils import ( - empty_command, - kick, - move, - turn_on_spot, -) +from utama_core.skills.man_mark import mark_target +from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot _WALL_FROM_BALL_M = BALL_KEEP_OUT_DISTANCE + 0.15 _STOP_FORMATION_SPEED_MPS = 1.2 # under RobotStopSpeedRule's limit diff --git a/utama_core/data_processing/receivers/referee_receiver.py b/utama_core/data_processing/receivers/referee_receiver.py index 5783187d..ba729e82 100644 --- a/utama_core/data_processing/receivers/referee_receiver.py +++ b/utama_core/data_processing/receivers/referee_receiver.py @@ -7,10 +7,8 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) -from utama_core.team_controller.src.utils import network_manager +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee +from utama_core.team_controller.utils import network_manager logger = logging.getLogger(__name__) diff --git a/utama_core/data_processing/receivers/vision_receiver.py b/utama_core/data_processing/receivers/vision_receiver.py index 7d6cc84b..90d8bda2 100644 --- a/utama_core/data_processing/receivers/vision_receiver.py +++ b/utama_core/data_processing/receivers/vision_receiver.py @@ -4,10 +4,10 @@ from utama_core.config.settings import MULTICAST_GROUP, VISION_PORT from utama_core.entities.data.raw_vision import RawBallData, RawRobotData, RawVisionData -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) -from utama_core.team_controller.src.utils import network_manager +from utama_core.team_controller.utils import network_manager logger = logging.getLogger(__name__) diff --git a/utama_core/engine/abstract_strategy.py b/utama_core/engine/abstract_strategy.py index bf1e3d43..5bd3f1e1 100644 --- a/utama_core/engine/abstract_strategy.py +++ b/utama_core/engine/abstract_strategy.py @@ -30,13 +30,13 @@ assert_contains, assert_valid_bounding_box, ) -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv -from utama_core.skills.src.utils.move_utils import empty_command -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.skills.utils.move_utils import empty_command +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) -from utama_core.team_controller.src.controllers.real.kicker_charge import KickerCharge +from utama_core.team_controller.controllers.real.kicker_charge import KickerCharge @dataclass(slots=True, frozen=True) diff --git a/utama_core/engine/ball_release.py b/utama_core/engine/ball_release.py index 40966928..31c2bdc5 100644 --- a/utama_core/engine/ball_release.py +++ b/utama_core/engine/ball_release.py @@ -23,7 +23,7 @@ reaches_own_goal, release_heading, ) -from utama_core.skills.src.utils.move_utils import turn_on_spot +from utama_core.skills.utils.move_utils import turn_on_spot if TYPE_CHECKING: from utama_core.engine.context import TickContext diff --git a/utama_core/engine/ball_roles.py b/utama_core/engine/ball_roles.py index 702cf88f..882113ec 100644 --- a/utama_core/engine/ball_roles.py +++ b/utama_core/engine/ball_roles.py @@ -27,7 +27,7 @@ receiver_of_rolling_ball, still_receiving, ) -from utama_core.skills.src.utils.move_utils import move, turn_on_spot +from utama_core.skills.utils.move_utils import move, turn_on_spot if TYPE_CHECKING: from utama_core.engine.context import TickContext diff --git a/utama_core/engine/context.py b/utama_core/engine/context.py index b0038360..d66ceea8 100644 --- a/utama_core/engine/context.py +++ b/utama_core/engine/context.py @@ -15,7 +15,7 @@ from dataclasses import dataclass, field from typing import TYPE_CHECKING, Any, Optional -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController if TYPE_CHECKING: from utama_core.engine.match_log import MatchLog diff --git a/utama_core/engine/referee_override.py b/utama_core/engine/referee_override.py index d4127b58..872517af 100644 --- a/utama_core/engine/referee_override.py +++ b/utama_core/engine/referee_override.py @@ -70,7 +70,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController # Commands requiring a legal-position override: every stoppage/restart except # HALT, which `Strategy.tick()`'s `is_paused` check already handles by issuing diff --git a/utama_core/motion_planning/src/common/acceleration_limiter.py b/utama_core/motion_planning/common/acceleration_limiter.py similarity index 100% rename from utama_core/motion_planning/src/common/acceleration_limiter.py rename to utama_core/motion_planning/common/acceleration_limiter.py diff --git a/utama_core/motion_planning/src/common/control_schemes.py b/utama_core/motion_planning/common/control_schemes.py similarity index 85% rename from utama_core/motion_planning/src/common/control_schemes.py rename to utama_core/motion_planning/common/control_schemes.py index 2b4b1a05..14918dff 100644 --- a/utama_core/motion_planning/src/common/control_schemes.py +++ b/utama_core/motion_planning/common/control_schemes.py @@ -1,7 +1,7 @@ from typing import Type -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.controllers import ( +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.controllers import ( DWAController, FastPathPlanningController, PIDController, diff --git a/utama_core/motion_planning/src/common/motion_controller.py b/utama_core/motion_planning/common/motion_controller.py similarity index 95% rename from utama_core/motion_planning/src/common/motion_controller.py rename to utama_core/motion_planning/common/motion_controller.py index 413e8acf..4b062780 100644 --- a/utama_core/motion_planning/src/common/motion_controller.py +++ b/utama_core/motion_planning/common/motion_controller.py @@ -3,12 +3,12 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.pose_ahead import ( +from utama_core.motion_planning.common.pose_ahead import ( _PARAMS_BY_MODE, PoseAhead, control_latency_s, ) -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv class MotionController(ABC): diff --git a/utama_core/motion_planning/src/common/pose_ahead.py b/utama_core/motion_planning/common/pose_ahead.py similarity index 100% rename from utama_core/motion_planning/src/common/pose_ahead.py rename to utama_core/motion_planning/common/pose_ahead.py diff --git a/utama_core/motion_planning/controllers/__init__.py b/utama_core/motion_planning/controllers/__init__.py new file mode 100644 index 00000000..e24f0243 --- /dev/null +++ b/utama_core/motion_planning/controllers/__init__.py @@ -0,0 +1,8 @@ +from utama_core.motion_planning.controllers.dwa_controller import DWAController +from utama_core.motion_planning.controllers.fastpathplanning import ( + FastPathPlanningController, +) +from utama_core.motion_planning.controllers.pid_controller import PIDController +from utama_core.motion_planning.controllers.trajsampling import ( + TrajectorySamplingController, +) diff --git a/utama_core/motion_planning/src/controllers/dwa_controller.py b/utama_core/motion_planning/controllers/dwa_controller.py similarity index 77% rename from utama_core/motion_planning/src/controllers/dwa_controller.py rename to utama_core/motion_planning/controllers/dwa_controller.py index 2e70a2f7..5e1b46f5 100644 --- a/utama_core/motion_planning/src/controllers/dwa_controller.py +++ b/utama_core/motion_planning/controllers/dwa_controller.py @@ -1,13 +1,13 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.dwa.config import get_dwa_config -from utama_core.motion_planning.src.dwa.translation_controller import ( +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.dwa.config import get_dwa_config +from utama_core.motion_planning.dwa.translation_controller import ( DWATranslationController, ) -from utama_core.motion_planning.src.pid import PID, get_pids -from utama_core.rsoccer_simulator.src.ssl.envs.standard_ssl import SSLStandardEnv +from utama_core.motion_planning.pid import PID, get_pids +from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv class DWAController(MotionController): diff --git a/utama_core/motion_planning/src/controllers/fastpathplanning.py b/utama_core/motion_planning/controllers/fastpathplanning.py similarity index 84% rename from utama_core/motion_planning/src/controllers/fastpathplanning.py rename to utama_core/motion_planning/controllers/fastpathplanning.py index 35787d9c..9917ce64 100644 --- a/utama_core/motion_planning/src/controllers/fastpathplanning.py +++ b/utama_core/motion_planning/controllers/fastpathplanning.py @@ -1,10 +1,10 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner -from utama_core.motion_planning.src.pid.pid import get_pids -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.pid.pid import get_pids +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv class FastPathPlanningController(MotionController): diff --git a/utama_core/motion_planning/src/controllers/pid_controller.py b/utama_core/motion_planning/controllers/pid_controller.py similarity index 83% rename from utama_core/motion_planning/src/controllers/pid_controller.py rename to utama_core/motion_planning/controllers/pid_controller.py index 1bcb9157..ee5970c1 100644 --- a/utama_core/motion_planning/src/controllers/pid_controller.py +++ b/utama_core/motion_planning/controllers/pid_controller.py @@ -3,9 +3,9 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.pid.pid import get_pids -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.pid.pid import get_pids +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv class PIDController(MotionController): diff --git a/utama_core/motion_planning/src/controllers/trajsampling.py b/utama_core/motion_planning/controllers/trajsampling.py similarity index 95% rename from utama_core/motion_planning/src/controllers/trajsampling.py rename to utama_core/motion_planning/controllers/trajsampling.py index 0cf02a69..a89c48dc 100644 --- a/utama_core/motion_planning/src/controllers/trajsampling.py +++ b/utama_core/motion_planning/controllers/trajsampling.py @@ -39,15 +39,11 @@ class of bug `TwoDPID.set_final_target` works around for FPP's carrot. from utama_core.config.settings import CONTROL_FREQUENCY from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.pid.pid import get_pids -from utama_core.motion_planning.src.trajsampling.config import ( - trajsamplingconfig as config, -) -from utama_core.motion_planning.src.trajsampling.planner import ( - TrajectorySamplingPlanner, -) -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.pid.pid import get_pids +from utama_core.motion_planning.trajsampling.config import trajsamplingconfig as config +from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv _PARAMS_BY_MODE = {Mode.RSIM: RSIM_PARAMS, Mode.GRSIM: GRSIM_PARAMS, Mode.REAL: REAL_PARAMS} diff --git a/utama_core/motion_planning/src/dwa/config.py b/utama_core/motion_planning/dwa/config.py similarity index 100% rename from utama_core/motion_planning/src/dwa/config.py rename to utama_core/motion_planning/dwa/config.py diff --git a/utama_core/motion_planning/src/dwa/planner.py b/utama_core/motion_planning/dwa/planner.py similarity index 96% rename from utama_core/motion_planning/src/dwa/planner.py rename to utama_core/motion_planning/dwa/planner.py index 788d0547..a338465f 100644 --- a/utama_core/motion_planning/src/dwa/planner.py +++ b/utama_core/motion_planning/dwa/planner.py @@ -8,16 +8,13 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game, Robot from utama_core.global_utils.math_utils import normalise_heading -from utama_core.motion_planning.src.dwa.config import DynamicWindowConfig -from utama_core.motion_planning.src.planning.geometry import ( +from utama_core.motion_planning.dwa.config import DynamicWindowConfig +from utama_core.motion_planning.planning.geometry import ( AxisAlignedRectangle, point_segment_distance, ) -from utama_core.motion_planning.src.planning.obstacles import ( - ObstacleRegion, - to_rectangles, -) -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.motion_planning.planning.obstacles import ObstacleRegion, to_rectangles +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv class DynamicWindowPlanner: diff --git a/utama_core/motion_planning/src/dwa/translation_controller.py b/utama_core/motion_planning/dwa/translation_controller.py similarity index 91% rename from utama_core/motion_planning/src/dwa/translation_controller.py rename to utama_core/motion_planning/dwa/translation_controller.py index c6bfa731..07cd0c89 100644 --- a/utama_core/motion_planning/src/dwa/translation_controller.py +++ b/utama_core/motion_planning/dwa/translation_controller.py @@ -3,11 +3,9 @@ from utama_core.config.settings import TIMESTEP from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.acceleration_limiter import ( - AccelerationLimiter, -) -from utama_core.motion_planning.src.dwa.config import DynamicWindowConfig -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.motion_planning.common.acceleration_limiter import AccelerationLimiter +from utama_core.motion_planning.dwa.config import DynamicWindowConfig +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv from .planner import DynamicWindowPlanner diff --git a/utama_core/motion_planning/src/fastpathplanning/config.py b/utama_core/motion_planning/fastpathplanning/config.py similarity index 100% rename from utama_core/motion_planning/src/fastpathplanning/config.py rename to utama_core/motion_planning/fastpathplanning/config.py diff --git a/utama_core/motion_planning/src/fastpathplanning/cpp/CMakeLists.txt b/utama_core/motion_planning/fastpathplanning/cpp/CMakeLists.txt similarity index 100% rename from utama_core/motion_planning/src/fastpathplanning/cpp/CMakeLists.txt rename to utama_core/motion_planning/fastpathplanning/cpp/CMakeLists.txt diff --git a/utama_core/motion_planning/src/fastpathplanning/cpp/planner.cpp b/utama_core/motion_planning/fastpathplanning/cpp/planner.cpp similarity index 100% rename from utama_core/motion_planning/src/fastpathplanning/cpp/planner.cpp rename to utama_core/motion_planning/fastpathplanning/cpp/planner.cpp diff --git a/utama_core/motion_planning/src/fastpathplanning/numba_kernels.py b/utama_core/motion_planning/fastpathplanning/numba_kernels.py similarity index 100% rename from utama_core/motion_planning/src/fastpathplanning/numba_kernels.py rename to utama_core/motion_planning/fastpathplanning/numba_kernels.py diff --git a/utama_core/motion_planning/src/fastpathplanning/planner.py b/utama_core/motion_planning/fastpathplanning/planner.py similarity index 99% rename from utama_core/motion_planning/src/fastpathplanning/planner.py rename to utama_core/motion_planning/fastpathplanning/planner.py index 94637658..70fae825 100644 --- a/utama_core/motion_planning/src/fastpathplanning/planner.py +++ b/utama_core/motion_planning/fastpathplanning/planner.py @@ -20,10 +20,10 @@ distance_point_to_segment, find_intersection, ) -from utama_core.motion_planning.src.fastpathplanning.config import ( +from utama_core.motion_planning.fastpathplanning.config import ( fastpathplanningconfig as config, ) -from utama_core.motion_planning.src.fastpathplanning.numba_kernels import ( +from utama_core.motion_planning.fastpathplanning.numba_kernels import ( clamp_to_obstacle_clearance_nb, collides_nb, find_segment_nb, @@ -33,10 +33,10 @@ scan_collides_nb, scan_find_subgoal_nb, ) -from utama_core.rsoccer_simulator.src.ssl.envs.standard_ssl import SSLStandardEnv +from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv try: - from utama_core.motion_planning.src.fastpathplanning import _fastpathplanner + from utama_core.motion_planning.fastpathplanning import _fastpathplanner HAS_CPP = True except ImportError: diff --git a/utama_core/motion_planning/pid/__init__.py b/utama_core/motion_planning/pid/__init__.py new file mode 100644 index 00000000..bf13217d --- /dev/null +++ b/utama_core/motion_planning/pid/__init__.py @@ -0,0 +1 @@ +from utama_core.motion_planning.pid.pid import PID, TwoDPID, get_pids diff --git a/utama_core/motion_planning/src/pid/configs.py b/utama_core/motion_planning/pid/configs.py similarity index 100% rename from utama_core/motion_planning/src/pid/configs.py rename to utama_core/motion_planning/pid/configs.py diff --git a/utama_core/motion_planning/src/pid/pid.py b/utama_core/motion_planning/pid/pid.py similarity index 99% rename from utama_core/motion_planning/src/pid/pid.py rename to utama_core/motion_planning/pid/pid.py index d18f0d08..eb8a7493 100644 --- a/utama_core/motion_planning/src/pid/pid.py +++ b/utama_core/motion_planning/pid/pid.py @@ -4,12 +4,12 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D from utama_core.global_utils.math_utils import normalise_heading -from utama_core.motion_planning.src.pid.configs import ( +from utama_core.motion_planning.pid.configs import ( OrientationPIDConfigs, TranslationPIDConfigs, get_pid_configs, ) -from utama_core.motion_planning.src.pid.pid_abstract import AbstractPID +from utama_core.motion_planning.pid.pid_abstract import AbstractPID # A phase hand-off / reassignment re-aiming a robot swings the target by a # large angle in one tick (observed 100+ degrees in `switch_of_play`'s diff --git a/utama_core/motion_planning/src/pid/pid_abstract.py b/utama_core/motion_planning/pid/pid_abstract.py similarity index 94% rename from utama_core/motion_planning/src/pid/pid_abstract.py rename to utama_core/motion_planning/pid/pid_abstract.py index 69578e1d..7548f888 100644 --- a/utama_core/motion_planning/src/pid/pid_abstract.py +++ b/utama_core/motion_planning/pid/pid_abstract.py @@ -2,10 +2,8 @@ from typing import Generic, Optional, TypeVar from utama_core.config.settings import SENDING_DELAY -from utama_core.motion_planning.src.common.acceleration_limiter import ( - AccelerationLimiter, -) -from utama_core.motion_planning.src.pid.configs import ( +from utama_core.motion_planning.common.acceleration_limiter import AccelerationLimiter +from utama_core.motion_planning.pid.configs import ( OrientationPIDConfigs, TranslationPIDConfigs, ) diff --git a/utama_core/motion_planning/src/planning/geometry.py b/utama_core/motion_planning/planning/geometry.py similarity index 100% rename from utama_core/motion_planning/src/planning/geometry.py rename to utama_core/motion_planning/planning/geometry.py diff --git a/utama_core/motion_planning/src/planning/obstacles.py b/utama_core/motion_planning/planning/obstacles.py similarity index 93% rename from utama_core/motion_planning/src/planning/obstacles.py rename to utama_core/motion_planning/planning/obstacles.py index 00106f48..278b84e1 100644 --- a/utama_core/motion_planning/src/planning/obstacles.py +++ b/utama_core/motion_planning/planning/obstacles.py @@ -7,7 +7,7 @@ import numpy as np -from utama_core.motion_planning.src.planning.geometry import AxisAlignedRectangle +from utama_core.motion_planning.planning.geometry import AxisAlignedRectangle @dataclass(frozen=True) diff --git a/utama_core/motion_planning/src/controllers/__init__.py b/utama_core/motion_planning/src/controllers/__init__.py deleted file mode 100644 index b97d23b2..00000000 --- a/utama_core/motion_planning/src/controllers/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -from utama_core.motion_planning.src.controllers.dwa_controller import DWAController -from utama_core.motion_planning.src.controllers.fastpathplanning import ( - FastPathPlanningController, -) -from utama_core.motion_planning.src.controllers.pid_controller import PIDController -from utama_core.motion_planning.src.controllers.trajsampling import ( - TrajectorySamplingController, -) diff --git a/utama_core/motion_planning/src/pid/__init__.py b/utama_core/motion_planning/src/pid/__init__.py deleted file mode 100644 index 0963d98d..00000000 --- a/utama_core/motion_planning/src/pid/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from utama_core.motion_planning.src.pid.pid import PID, TwoDPID, get_pids diff --git a/utama_core/motion_planning/src/trajsampling/__init__.py b/utama_core/motion_planning/trajsampling/__init__.py similarity index 100% rename from utama_core/motion_planning/src/trajsampling/__init__.py rename to utama_core/motion_planning/trajsampling/__init__.py diff --git a/utama_core/motion_planning/src/trajsampling/bang_bang.py b/utama_core/motion_planning/trajsampling/bang_bang.py similarity index 100% rename from utama_core/motion_planning/src/trajsampling/bang_bang.py rename to utama_core/motion_planning/trajsampling/bang_bang.py diff --git a/utama_core/motion_planning/src/trajsampling/collision_numba.py b/utama_core/motion_planning/trajsampling/collision_numba.py similarity index 100% rename from utama_core/motion_planning/src/trajsampling/collision_numba.py rename to utama_core/motion_planning/trajsampling/collision_numba.py diff --git a/utama_core/motion_planning/src/trajsampling/config.py b/utama_core/motion_planning/trajsampling/config.py similarity index 100% rename from utama_core/motion_planning/src/trajsampling/config.py rename to utama_core/motion_planning/trajsampling/config.py diff --git a/utama_core/motion_planning/src/trajsampling/obstacles.py b/utama_core/motion_planning/trajsampling/obstacles.py similarity index 98% rename from utama_core/motion_planning/src/trajsampling/obstacles.py rename to utama_core/motion_planning/trajsampling/obstacles.py index 144071cc..de468326 100644 --- a/utama_core/motion_planning/src/trajsampling/obstacles.py +++ b/utama_core/motion_planning/trajsampling/obstacles.py @@ -24,7 +24,7 @@ import numpy as np -from utama_core.motion_planning.src.trajsampling.bang_bang import BangBang1D +from utama_core.motion_planning.trajsampling.bang_bang import BangBang1D class TimedObstacle(Protocol): diff --git a/utama_core/motion_planning/src/trajsampling/planner.py b/utama_core/motion_planning/trajsampling/planner.py similarity index 99% rename from utama_core/motion_planning/src/trajsampling/planner.py rename to utama_core/motion_planning/trajsampling/planner.py index e67d1a8f..d04cd098 100644 --- a/utama_core/motion_planning/src/trajsampling/planner.py +++ b/utama_core/motion_planning/trajsampling/planner.py @@ -49,12 +49,10 @@ from utama_core.entities.game import Game from utama_core.entities.game.field import FieldBounds from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.trajsampling import collision_numba as _cn -from utama_core.motion_planning.src.trajsampling.bang_bang import Trajectory2D -from utama_core.motion_planning.src.trajsampling.config import ( - trajsamplingconfig as config, -) -from utama_core.motion_planning.src.trajsampling.obstacles import ( +from utama_core.motion_planning.trajsampling import collision_numba as _cn +from utama_core.motion_planning.trajsampling.bang_bang import Trajectory2D +from utama_core.motion_planning.trajsampling.config import trajsamplingconfig as config +from utama_core.motion_planning.trajsampling.obstacles import ( ConstantVelocityObstacle, EnemyRobotObstacle, OwnRobotObstacle, diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index c6f53ce4..9b5ae92c 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -66,11 +66,11 @@ "utama_core.engine.tactic", ) # Part of every player though no strategy imports it: where a side's motion controller comes from. -PLAYER_ROOTS = ("utama_core.motion_planning.src.common.control_schemes",) +PLAYER_ROOTS = ("utama_core.motion_planning.common.control_schemes",) # Code that runs but is not imported: `robosim_wrapper.py` starts it as a script in the # `robosim` pixi environment. -SUBPROCESS_SCRIPTS = ("utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_subprocess",) +SUBPROCESS_SCRIPTS = ("utama_core.rsoccer_simulator.Simulators.robosim.robosim_subprocess",) # Environment variables that change play: UTAMA_EXACT_MATH (`config/settings.py`) and the # thread/JIT knobs of numba and the BLAS numpy links against. @@ -169,7 +169,7 @@ def _load(self, name: str) -> Optional[_Module]: mod = _Module(name, base.with_suffix(".py"), is_package=False) elif (base / "__init__.py").is_file(): mod = _Module(name, base / "__init__.py", is_package=True) - elif base.is_dir() and "." in name: # namespace package, e.g. utama_core/skills/src + elif base.is_dir() and "." in name: # namespace package, e.g. utama_core/skills return _Module(name, None, is_package=True) else: return None diff --git a/utama_core/replay/game_log_writer.py b/utama_core/replay/game_log_writer.py index 3d4cd96a..59b4e96e 100644 --- a/utama_core/replay/game_log_writer.py +++ b/utama_core/replay/game_log_writer.py @@ -37,9 +37,7 @@ from typing import Optional from utama_core.entities.data.referee import RefereeData -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee # The league's format, as `ssl_log` reads it (not imported from there: the runner would pull # in the whole reader). diff --git a/utama_core/replay/replay_player.py b/utama_core/replay/replay_player.py index 5e0f11fa..ba97966f 100644 --- a/utama_core/replay/replay_player.py +++ b/utama_core/replay/replay_player.py @@ -15,11 +15,11 @@ from utama_core.global_utils.mapping_utils import map_friendly_enemy_to_colors from utama_core.global_utils.math_utils import rad_to_deg from utama_core.replay.entities import ReplayMetadata -from utama_core.rsoccer_simulator.src.Entities import Ball as RSoccerBall -from utama_core.rsoccer_simulator.src.Entities import Frame as RSoccerFrame -from utama_core.rsoccer_simulator.src.Entities import FrameSSL -from utama_core.rsoccer_simulator.src.Entities import Robot as RSoccerRobot -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.Entities import Ball as RSoccerBall +from utama_core.rsoccer_simulator.Entities import Frame as RSoccerFrame +from utama_core.rsoccer_simulator.Entities import FrameSSL +from utama_core.rsoccer_simulator.Entities import Robot as RSoccerRobot +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv logger = logging.getLogger(__name__) diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 04cd524c..38e9d53a 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -14,7 +14,7 @@ Coordinate frame: `GameFrame.friendly_robots`/`enemy_robots`/`ball` store positions in plain pitch-frame metres — the same frame `AbstractSimController.teleport_ball`/`teleport_robot` take directly (see -`utama_core/rsoccer_simulator/src/ssl/ssl_gym_base.py`'s `teleport_ball`/ +`utama_core/rsoccer_simulator/ssl/ssl_gym_base.py`'s `teleport_ball`/ `teleport_robot`, which do the y-flip into rsim's internal frame themselves; callers, including the teleport accuracy test in `utama_core/tests/strategy_runner/teleport_position_accuracy_test.py`, pass diff --git a/utama_core/replay/ssl_log.py b/utama_core/replay/ssl_log.py index 1ebfcc29..19954051 100644 --- a/utama_core/replay/ssl_log.py +++ b/utama_core/replay/ssl_log.py @@ -102,13 +102,11 @@ ColumnarReplayWriter, ColumnarReplayWriterConfig, ) -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_tracked_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_tracked_pb2 import ( TrackerWrapperPacket, ) diff --git a/utama_core/rsoccer_simulator/.gitignore b/utama_core/rsoccer_simulator/.gitignore index e214c5c3..2373779b 100644 --- a/utama_core/rsoccer_simulator/.gitignore +++ b/utama_core/rsoccer_simulator/.gitignore @@ -1,6 +1,6 @@ .DS_Store *.pyc -rsoccer_simulator.src.egg-info/ +rsoccer_simulator.egg-info/ .vscode/* __pycache__ .idea/ diff --git a/utama_core/rsoccer_simulator/src/Entities/Ball.py b/utama_core/rsoccer_simulator/Entities/Ball.py similarity index 72% rename from utama_core/rsoccer_simulator/src/Entities/Ball.py rename to utama_core/rsoccer_simulator/Entities/Ball.py index 42d6d2cb..f1db504a 100644 --- a/utama_core/rsoccer_simulator/src/Entities/Ball.py +++ b/utama_core/rsoccer_simulator/Entities/Ball.py @@ -2,7 +2,7 @@ from numpy.random import normal -from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise @dataclass() diff --git a/utama_core/rsoccer_simulator/src/Entities/Field.py b/utama_core/rsoccer_simulator/Entities/Field.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Entities/Field.py rename to utama_core/rsoccer_simulator/Entities/Field.py diff --git a/utama_core/rsoccer_simulator/src/Entities/Frame.py b/utama_core/rsoccer_simulator/Entities/Frame.py similarity index 96% rename from utama_core/rsoccer_simulator/src/Entities/Frame.py rename to utama_core/rsoccer_simulator/Entities/Frame.py index ea86510e..ef29e261 100644 --- a/utama_core/rsoccer_simulator/src/Entities/Frame.py +++ b/utama_core/rsoccer_simulator/Entities/Frame.py @@ -1,7 +1,7 @@ from typing import Dict -from utama_core.rsoccer_simulator.src.Entities.Ball import Ball -from utama_core.rsoccer_simulator.src.Entities.Robot import Robot +from utama_core.rsoccer_simulator.Entities.Ball import Ball +from utama_core.rsoccer_simulator.Entities.Robot import Robot class Frame: diff --git a/utama_core/rsoccer_simulator/src/Entities/Robot.py b/utama_core/rsoccer_simulator/Entities/Robot.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Entities/Robot.py rename to utama_core/rsoccer_simulator/Entities/Robot.py diff --git a/utama_core/rsoccer_simulator/Entities/__init__.py b/utama_core/rsoccer_simulator/Entities/__init__.py new file mode 100644 index 00000000..7fea65bd --- /dev/null +++ b/utama_core/rsoccer_simulator/Entities/__init__.py @@ -0,0 +1,4 @@ +from utama_core.rsoccer_simulator.Entities.Ball import Ball +from utama_core.rsoccer_simulator.Entities.Field import Field +from utama_core.rsoccer_simulator.Entities.Frame import Frame, FrameSSL, FrameVSS +from utama_core.rsoccer_simulator.Entities.Robot import Robot diff --git a/utama_core/rsoccer_simulator/README.md b/utama_core/rsoccer_simulator/README.md index a121e719..744a8d3c 100644 --- a/utama_core/rsoccer_simulator/README.md +++ b/utama_core/rsoccer_simulator/README.md @@ -87,7 +87,7 @@ def teleport_robot( Functions used to draw points/lines/polygons of interest. Used for visualisation and debugging. Note that these are also sent together with robot commands ONLY at the end of the frame. -For the list of available colours, see `rsoccer_simulator/src/Render/utils.py`. +For the list of available colours, see `rsoccer_simulator/Render/utils.py`. #### Draw Point diff --git a/utama_core/rsoccer_simulator/Render/__init__.py b/utama_core/rsoccer_simulator/Render/__init__.py new file mode 100644 index 00000000..95376852 --- /dev/null +++ b/utama_core/rsoccer_simulator/Render/__init__.py @@ -0,0 +1,13 @@ +from utama_core.rsoccer_simulator.Render.ball import RenderBall +from utama_core.rsoccer_simulator.Render.field import ( + Sim2DRenderField, + SSLRenderField, + VSSRenderField, +) +from utama_core.rsoccer_simulator.Render.overlay import RenderOverlay +from utama_core.rsoccer_simulator.Render.robot import ( + RenderSim2DRobot, + RenderSSLRobot, + RenderVSSRobot, +) +from utama_core.rsoccer_simulator.Render.utils import COLORS diff --git a/utama_core/rsoccer_simulator/src/Render/ball.py b/utama_core/rsoccer_simulator/Render/ball.py similarity index 87% rename from utama_core/rsoccer_simulator/src/Render/ball.py rename to utama_core/rsoccer_simulator/Render/ball.py index 6a7c4e04..7cbc3f42 100644 --- a/utama_core/rsoccer_simulator/src/Render/ball.py +++ b/utama_core/rsoccer_simulator/Render/ball.py @@ -1,6 +1,6 @@ import pygame -from utama_core.rsoccer_simulator.src.Render.utils import COLORS +from utama_core.rsoccer_simulator.Render.utils import COLORS class RenderBall: diff --git a/utama_core/rsoccer_simulator/src/Render/field.py b/utama_core/rsoccer_simulator/Render/field.py similarity index 99% rename from utama_core/rsoccer_simulator/src/Render/field.py rename to utama_core/rsoccer_simulator/Render/field.py index 25febcbb..5a5dbf5a 100644 --- a/utama_core/rsoccer_simulator/src/Render/field.py +++ b/utama_core/rsoccer_simulator/Render/field.py @@ -1,6 +1,6 @@ import pygame -from utama_core.rsoccer_simulator.src.Render.utils import COLORS +from utama_core.rsoccer_simulator.Render.utils import COLORS class RenderField: diff --git a/utama_core/rsoccer_simulator/src/Render/overlay.py b/utama_core/rsoccer_simulator/Render/overlay.py similarity index 95% rename from utama_core/rsoccer_simulator/src/Render/overlay.py rename to utama_core/rsoccer_simulator/Render/overlay.py index 09eba248..d20982a2 100644 --- a/utama_core/rsoccer_simulator/src/Render/overlay.py +++ b/utama_core/rsoccer_simulator/Render/overlay.py @@ -3,7 +3,7 @@ import pygame -from utama_core.rsoccer_simulator.src.Render.utils import COLORS +from utama_core.rsoccer_simulator.Render.utils import COLORS class OverlayType(Enum): diff --git a/utama_core/rsoccer_simulator/src/Render/robot.py b/utama_core/rsoccer_simulator/Render/robot.py similarity index 98% rename from utama_core/rsoccer_simulator/src/Render/robot.py rename to utama_core/rsoccer_simulator/Render/robot.py index a025bfbe..91c6bd9d 100644 --- a/utama_core/rsoccer_simulator/src/Render/robot.py +++ b/utama_core/rsoccer_simulator/Render/robot.py @@ -1,7 +1,7 @@ import numpy as np import pygame -from utama_core.rsoccer_simulator.src.Render.utils import COLORS, TAG_ID_COLORS +from utama_core.rsoccer_simulator.Render.utils import COLORS, TAG_ID_COLORS class RenderRobot: diff --git a/utama_core/rsoccer_simulator/src/Render/utils.py b/utama_core/rsoccer_simulator/Render/utils.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Render/utils.py rename to utama_core/rsoccer_simulator/Render/utils.py diff --git a/utama_core/rsoccer_simulator/src/Simulators/__init__.py b/utama_core/rsoccer_simulator/Simulators/__init__.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Simulators/__init__.py rename to utama_core/rsoccer_simulator/Simulators/__init__.py diff --git a/utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py b/utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py rename to utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py diff --git a/utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_wrapper.py b/utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_wrapper.py rename to utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py diff --git a/utama_core/rsoccer_simulator/src/Simulators/rsim.py b/utama_core/rsoccer_simulator/Simulators/rsim.py similarity index 97% rename from utama_core/rsoccer_simulator/src/Simulators/rsim.py rename to utama_core/rsoccer_simulator/Simulators/rsim.py index 0ef37b92..07d1a0d1 100644 --- a/utama_core/rsoccer_simulator/src/Simulators/rsim.py +++ b/utama_core/rsoccer_simulator/Simulators/rsim.py @@ -2,8 +2,8 @@ import numpy as np -from utama_core.rsoccer_simulator.src.Entities import Field, Frame, FrameSSL -from utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper import ( +from utama_core.rsoccer_simulator.Entities import Field, Frame, FrameSSL +from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( RSimSubprocessWrapper, acquire_simulator, ) diff --git a/utama_core/rsoccer_simulator/Utils/__init__.py b/utama_core/rsoccer_simulator/Utils/__init__.py new file mode 100644 index 00000000..bd0b51c1 --- /dev/null +++ b/utama_core/rsoccer_simulator/Utils/__init__.py @@ -0,0 +1 @@ +from utama_core.rsoccer_simulator.Utils.kdtree import KDTree diff --git a/utama_core/rsoccer_simulator/src/Utils/gaussian_noise.py b/utama_core/rsoccer_simulator/Utils/gaussian_noise.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Utils/gaussian_noise.py rename to utama_core/rsoccer_simulator/Utils/gaussian_noise.py diff --git a/utama_core/rsoccer_simulator/src/Utils/kdtree.py b/utama_core/rsoccer_simulator/Utils/kdtree.py similarity index 100% rename from utama_core/rsoccer_simulator/src/Utils/kdtree.py rename to utama_core/rsoccer_simulator/Utils/kdtree.py diff --git a/utama_core/rsoccer_simulator/src/Utils/sim_noise.py b/utama_core/rsoccer_simulator/Utils/sim_noise.py similarity index 99% rename from utama_core/rsoccer_simulator/src/Utils/sim_noise.py rename to utama_core/rsoccer_simulator/Utils/sim_noise.py index 8dcbb17c..1a94d59c 100644 --- a/utama_core/rsoccer_simulator/src/Utils/sim_noise.py +++ b/utama_core/rsoccer_simulator/Utils/sim_noise.py @@ -26,7 +26,7 @@ import numpy as np -from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise COLOURS = ("team_blue", "team_yellow") diff --git a/utama_core/rsoccer_simulator/src/Entities/__init__.py b/utama_core/rsoccer_simulator/src/Entities/__init__.py deleted file mode 100644 index 1d07343f..00000000 --- a/utama_core/rsoccer_simulator/src/Entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from utama_core.rsoccer_simulator.src.Entities.Ball import Ball -from utama_core.rsoccer_simulator.src.Entities.Field import Field -from utama_core.rsoccer_simulator.src.Entities.Frame import Frame, FrameSSL, FrameVSS -from utama_core.rsoccer_simulator.src.Entities.Robot import Robot diff --git a/utama_core/rsoccer_simulator/src/Render/__init__.py b/utama_core/rsoccer_simulator/src/Render/__init__.py deleted file mode 100644 index 2d43723f..00000000 --- a/utama_core/rsoccer_simulator/src/Render/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -from utama_core.rsoccer_simulator.src.Render.ball import RenderBall -from utama_core.rsoccer_simulator.src.Render.field import ( - Sim2DRenderField, - SSLRenderField, - VSSRenderField, -) -from utama_core.rsoccer_simulator.src.Render.overlay import RenderOverlay -from utama_core.rsoccer_simulator.src.Render.robot import ( - RenderSim2DRobot, - RenderSSLRobot, - RenderVSSRobot, -) -from utama_core.rsoccer_simulator.src.Render.utils import COLORS diff --git a/utama_core/rsoccer_simulator/src/Utils/__init__.py b/utama_core/rsoccer_simulator/src/Utils/__init__.py deleted file mode 100644 index 2a1b32c2..00000000 --- a/utama_core/rsoccer_simulator/src/Utils/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from utama_core.rsoccer_simulator.src.Utils.kdtree import KDTree diff --git a/utama_core/rsoccer_simulator/src/ssl/envs/__init__.py b/utama_core/rsoccer_simulator/src/ssl/envs/__init__.py deleted file mode 100644 index 1423630d..00000000 --- a/utama_core/rsoccer_simulator/src/ssl/envs/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from utama_core.rsoccer_simulator.src.ssl.envs.standard_ssl import SSLStandardEnv diff --git a/utama_core/rsoccer_simulator/src/ssl/__init__.py b/utama_core/rsoccer_simulator/ssl/__init__.py similarity index 100% rename from utama_core/rsoccer_simulator/src/ssl/__init__.py rename to utama_core/rsoccer_simulator/ssl/__init__.py diff --git a/utama_core/rsoccer_simulator/ssl/envs/__init__.py b/utama_core/rsoccer_simulator/ssl/envs/__init__.py new file mode 100644 index 00000000..0770ac16 --- /dev/null +++ b/utama_core/rsoccer_simulator/ssl/envs/__init__.py @@ -0,0 +1 @@ +from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv diff --git a/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py b/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py similarity index 98% rename from utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py rename to utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py index 6088faaa..d0e580c0 100644 --- a/utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py +++ b/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py @@ -21,11 +21,11 @@ normalise_heading_deg, rad_to_deg, ) -from utama_core.rsoccer_simulator.src.Entities import Ball, Frame, Robot -from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv -from utama_core.rsoccer_simulator.src.Utils import KDTree -from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.src.Utils.sim_noise import ( +from utama_core.rsoccer_simulator.Entities import Ball, Frame, Robot +from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.rsoccer_simulator.Utils import KDTree +from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import ( CommandDelay, KickAngleNoise, KickSpeedNoise, diff --git a/utama_core/rsoccer_simulator/src/ssl/ssl_gym_base.py b/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py similarity index 97% rename from utama_core/rsoccer_simulator/src/ssl/ssl_gym_base.py rename to utama_core/rsoccer_simulator/ssl/ssl_gym_base.py index d80355ea..b28cd618 100644 --- a/utama_core/rsoccer_simulator/src/ssl/ssl_gym_base.py +++ b/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py @@ -11,19 +11,19 @@ import pygame from utama_core.global_utils.math_utils import rad_to_deg -from utama_core.rsoccer_simulator.src.Entities import Ball, Field, Frame, Robot -from utama_core.rsoccer_simulator.src.Render import ( +from utama_core.rsoccer_simulator.Entities import Ball, Field, Frame, Robot +from utama_core.rsoccer_simulator.Render import ( COLORS, RenderBall, RenderSSLRobot, SSLRenderField, ) -from utama_core.rsoccer_simulator.src.Render.overlay import ( +from utama_core.rsoccer_simulator.Render.overlay import ( OverlayObject, OverlayType, RenderOverlay, ) -from utama_core.rsoccer_simulator.src.Simulators.rsim import RSimSSL +from utama_core.rsoccer_simulator.Simulators.rsim import RSimSSL class SSLBaseEnv: diff --git a/utama_core/run/game_gater.py b/utama_core/run/game_gater.py index 2b77c3f9..7441c77b 100644 --- a/utama_core/run/game_gater.py +++ b/utama_core/run/game_gater.py @@ -4,7 +4,7 @@ from utama_core.data_processing.refiners import PositionRefiner from utama_core.entities.data.raw_vision import RawVisionData from utama_core.entities.game.game_frame import GameFrame -from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv class GameGater: diff --git a/utama_core/run/side_runtime.py b/utama_core/run/side_runtime.py index e768ca7b..5ff4fdfa 100644 --- a/utama_core/run/side_runtime.py +++ b/utama_core/run/side_runtime.py @@ -15,7 +15,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game, GameFrame, GameHistory, Robot from utama_core.entities.game.field import FieldBounds -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController def _turned(robot: Robot, bounds: FieldBounds) -> Robot: diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 83f62b47..2ce21eeb 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -48,17 +48,17 @@ map_left_right_to_colors, ) from utama_core.global_utils.math_utils import assert_valid_bounding_box -from utama_core.motion_planning.src.common.control_schemes import get_control_scheme -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.control_schemes import get_control_scheme +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.replay.columnar_writer import ( ColumnarReplayWriter, ColumnarReplayWriterConfig, ) from utama_core.replay.game_log_writer import GameLogWriter, code_version from utama_core.replay.replay_writer import ReplayWriter, ReplayWriterConfig -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run import GameGater from utama_core.run.field_check import LOOP_STALL_S, FieldCheck from utama_core.run.field_fence import FencedRobotController, inner_edges @@ -75,9 +75,9 @@ from utama_core.run.vision_stream import GameFrameRenderer, RSimVisionStreamServer from utama_core.run.vision_stream_status import VisionStreamStatusMixin from utama_core.shared.pass_and_score_geometry import reset_possession_state -from utama_core.skills.src.shielding import reset_shield_state +from utama_core.skills.shielding import reset_shield_state from utama_core.strategy.pickers import reset_closer_to_ball_state -from utama_core.team_controller.src.controllers import ( +from utama_core.team_controller.controllers import ( AbstractSimController, GRSimController, GRSimRobotController, @@ -86,7 +86,7 @@ RSimPVPManager, RSimRobotController, ) -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( ProfiledRobotController, RobotProfile, ) @@ -281,7 +281,7 @@ class StrategyRunner(SimRecoveryMixin, VisionStreamStatusMixin, LiveStatusMixin) Defaults to 0. sim_noise (SimNoise, optional): When running in rsim, seeded latency, kick and ball physics, motion limits and vision noise - (`utama_core/rsoccer_simulator/src/Utils/sim_noise.py`); replaces `rsim_noise` and `rsim_vanishing`. + (`utama_core/rsoccer_simulator/Utils/sim_noise.py`); replaces `rsim_noise` and `rsim_vanishing`. Recorded in a columnar replay. Defaults to None (off). filtering (bool, optional): Turn on Kalman smoothing and vanished-robot imputation. Defaults to True. referee (RefereeSource, optional): Referee source. Pass a ``CustomReferee`` diff --git a/utama_core/run/vision_stream.py b/utama_core/run/vision_stream.py index 292bb8c5..c61f36d6 100644 --- a/utama_core/run/vision_stream.py +++ b/utama_core/run/vision_stream.py @@ -36,7 +36,7 @@ class GameFrameRenderer: def __init__(self, field_dims, scale: float = 100.0) -> None: import pygame - from utama_core.rsoccer_simulator.src.Render import SSLRenderField + from utama_core.rsoccer_simulator.Render import SSLRenderField self._pygame = pygame self._field_renderer = SSLRenderField( @@ -61,7 +61,7 @@ def __init__(self, field_dims, scale: float = 100.0) -> None: def render(self, game_frame, friendly_color=None, enemy_color=None) -> np.ndarray: """Render a `GameFrame` into an RGB numpy array.""" - from utama_core.rsoccer_simulator.src.Render import ( + from utama_core.rsoccer_simulator.Render import ( COLORS, RenderBall, RenderSSLRobot, diff --git a/utama_core/shared/pass_and_score_geometry.py b/utama_core/shared/pass_and_score_geometry.py index 30cce8ec..703f237a 100644 --- a/utama_core/shared/pass_and_score_geometry.py +++ b/utama_core/shared/pass_and_score_geometry.py @@ -22,10 +22,8 @@ from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.fastpathplanning.config import ( - fastpathplanningconfig, -) -from utama_core.skills.src.score_goal import ( # noqa: F401 (re-exported) +from utama_core.motion_planning.fastpathplanning.config import fastpathplanningconfig +from utama_core.skills.score_goal import ( # noqa: F401 (re-exported) _find_best_shot, is_goal_blocked, ) @@ -794,7 +792,7 @@ def find_best_shot( """Thin passthrough to Core's own shadow/ray-casting shot finder. `prev_best_shot_y`/`switch_margin`: optional hysteresis, forwarded - unchanged — see `_find_best_shot`'s docstring in `skills/src/score_goal.py`. + unchanged — see `_find_best_shot`'s docstring in `skills/score_goal.py`. Both default to no-hysteresis (today's exact behaviour); a caller opts in by passing its own previously-chosen shot y (typically from its `mem`). """ diff --git a/utama_core/skills/src/block.py b/utama_core/skills/block.py similarity index 96% rename from utama_core/skills/src/block.py rename to utama_core/skills/block.py index dfcf2019..73238feb 100644 --- a/utama_core/skills/src/block.py +++ b/utama_core/skills/block.py @@ -15,8 +15,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.utils.move_utils import move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.utils.move_utils import move _STEAL_RANGE = 0.5 # metres — inside this, contest the ball directly instead of only shadowing the shot line diff --git a/utama_core/skills/src/defend_parameter.py b/utama_core/skills/defend_parameter.py similarity index 97% rename from utama_core/skills/src/defend_parameter.py rename to utama_core/skills/defend_parameter.py index b5309344..ee1996c2 100644 --- a/utama_core/skills/src/defend_parameter.py +++ b/utama_core/skills/defend_parameter.py @@ -18,9 +18,9 @@ from utama_core.data_processing.predictors.position import predict_ball_pos_at_x from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.defense_utils import ( +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.defense_utils import ( clamp_y, intersection_with_x_line, single_defender_stop_y, diff --git a/utama_core/skills/src/go_to_ball.py b/utama_core/skills/go_to_ball.py similarity index 94% rename from utama_core/skills/src/go_to_ball.py rename to utama_core/skills/go_to_ball.py index fcf1b83d..50e00aa6 100644 --- a/utama_core/skills/src/go_to_ball.py +++ b/utama_core/skills/go_to_ball.py @@ -3,7 +3,7 @@ The lowest-level "get the ball" primitive; every attacking tactic that needs a robot to reach a loose or contested ball calls this rather than computing an approach itself. By default the approach angle is opponent-aware (see -`utama_core.skills.src.shielding`) so a robot converging on a ball an enemy +`utama_core.skills.shielding`) so a robot converging on a ball an enemy is also converging on ends up shielding it from that enemy's side instead of wedging to a stop short of the ball entirely — the exact mechanism behind the `default_vs_lowblock` stalemate investigation @@ -22,7 +22,7 @@ held the ball in its own box). Handled here, not per-tactic, since every `go_to_ball` caller hits the same planner clamp the same way. -See `utama_core.skills.src.shielding`'s module docstring for why the +See `utama_core.skills.shielding`'s module docstring for why the shielding logic was pulled out of this file rather than kept as private helpers here (in short: it was reach-driven — "many tactics call `go_to_ball`, so fixing it here fixes them all" — not a considered fit for a @@ -42,16 +42,16 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import ( ball_in_enemy_defense_area, ball_intercept_point, clamp_outside_own_defense_area, enemy_defense_area_hold_point, ) -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.shielding import shielded_approach_angle -from utama_core.skills.src.utils.move_utils import move +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.shielding import shielded_approach_angle +from utama_core.skills.utils.move_utils import move # Overshoot past ball center so the DWA keeps driving until the robot makes # contact. The dribbler-on approach can push further; the dribbler-off approach @@ -104,7 +104,7 @@ def go_to_ball( which approach branch ("shield" vs "direct") was taken this call. Omit for callers outside a `Tactic.tick()` that don't have a `ctx`. shield: if True (default), approach from the far side of any - contesting enemy (see `utama_core.skills.src.shielding`) instead + contesting enemy (see `utama_core.skills.shielding`) instead of a straight line from the robot's own position. Pass False to always approach directly — e.g. a fast-break tactic racing for a clearly-winnable loose ball, where the shield detour only costs diff --git a/utama_core/skills/src/go_to_point.py b/utama_core/skills/go_to_point.py similarity index 90% rename from utama_core/skills/src/go_to_point.py rename to utama_core/skills/go_to_point.py index 11798f34..7e6a1588 100644 --- a/utama_core/skills/src/go_to_point.py +++ b/utama_core/skills/go_to_point.py @@ -16,8 +16,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.utils.move_utils import face_ball, move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.utils.move_utils import face_ball, move def go_to_point( diff --git a/utama_core/skills/src/goalkeep.py b/utama_core/skills/goalkeep.py similarity index 97% rename from utama_core/skills/src/goalkeep.py rename to utama_core/skills/goalkeep.py index a4251140..4a680db7 100644 --- a/utama_core/skills/src/goalkeep.py +++ b/utama_core/skills/goalkeep.py @@ -27,7 +27,7 @@ from utama_core.data_processing.predictors.position import predict_ball_pos_at_x from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import ( ANNOUNCE_PASS_RAD, ball_in_own_defense_area, @@ -35,14 +35,14 @@ open_teammate, oriented_towards, ) -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.kick_upfield import kick_upfield -from utama_core.skills.src.utils.defense_utils import ( +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.kick_upfield import kick_upfield +from utama_core.skills.utils.defense_utils import ( clamp_y, intersection_with_x_line, single_defender_stop_y, ) -from utama_core.skills.src.utils.move_utils import kick, turn_on_spot +from utama_core.skills.utils.move_utils import kick, turn_on_spot if TYPE_CHECKING: from utama_core.engine.context import TickContext diff --git a/utama_core/skills/src/kick_upfield.py b/utama_core/skills/kick_upfield.py similarity index 91% rename from utama_core/skills/src/kick_upfield.py rename to utama_core/skills/kick_upfield.py index 64904fb2..967af83f 100644 --- a/utama_core/skills/src/kick_upfield.py +++ b/utama_core/skills/kick_upfield.py @@ -8,9 +8,9 @@ """ from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import oriented_towards, upfield_heading -from utama_core.skills.src.utils.move_utils import kick, turn_on_spot +from utama_core.skills.utils.move_utils import kick, turn_on_spot # A clearance only has to go upfield, not along a line: kick within ~11 degrees of it. With the # 0.05 rad shot/pass tolerance the real keeper never kicked (2026-10-27 field runs): 0.07 rad diff --git a/utama_core/skills/src/man_mark.py b/utama_core/skills/man_mark.py similarity index 95% rename from utama_core/skills/src/man_mark.py rename to utama_core/skills/man_mark.py index 36eeef8c..b08c9289 100644 --- a/utama_core/skills/src/man_mark.py +++ b/utama_core/skills/man_mark.py @@ -15,8 +15,8 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.utils.move_utils import face_ball, move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.utils.move_utils import face_ball, move MARK_STANDOFF = 0.6 # metres — mark from this distance on the goal side of the opponent, not on top of them _ON_BALL_M = 0.13 # robot centre to ball with both touching diff --git a/utama_core/skills/src/score_goal.py b/utama_core/skills/score_goal.py similarity index 100% rename from utama_core/skills/src/score_goal.py rename to utama_core/skills/score_goal.py diff --git a/utama_core/skills/src/shielding.py b/utama_core/skills/shielding.py similarity index 100% rename from utama_core/skills/src/shielding.py rename to utama_core/skills/shielding.py diff --git a/utama_core/skills/src/utils/defense_utils.py b/utama_core/skills/utils/defense_utils.py similarity index 100% rename from utama_core/skills/src/utils/defense_utils.py rename to utama_core/skills/utils/defense_utils.py diff --git a/utama_core/skills/src/utils/move_utils.py b/utama_core/skills/utils/move_utils.py similarity index 99% rename from utama_core/skills/src/utils/move_utils.py rename to utama_core/skills/utils/move_utils.py index 4c76c661..5db3e54f 100644 --- a/utama_core/skills/src/utils/move_utils.py +++ b/utama_core/skills/utils/move_utils.py @@ -8,7 +8,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.global_utils.math_utils import normalise_heading, rotate_vector -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController # Off its target orientation by more than this, a robot turns at least `MotionController.min_turn`. _MIN_TURN_FROM_RAD = 0.01 diff --git a/utama_core/strategy/avalanche.py b/utama_core/strategy/avalanche.py index 5b16db69..47fb2919 100644 --- a/utama_core/strategy/avalanche.py +++ b/utama_core/strategy/avalanche.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, carrier_first, diff --git a/utama_core/strategy/breakwater.py b/utama_core/strategy/breakwater.py index 83d79e98..d8405123 100644 --- a/utama_core/strategy/breakwater.py +++ b/utama_core/strategy/breakwater.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, ball_zone, diff --git a/utama_core/strategy/chameleon.py b/utama_core/strategy/chameleon.py index 7a187f57..e68d28ac 100644 --- a/utama_core/strategy/chameleon.py +++ b/utama_core/strategy/chameleon.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, carrier_first, diff --git a/utama_core/strategy/default.py b/utama_core/strategy/default.py index b67495b3..7bd01b68 100644 --- a/utama_core/strategy/default.py +++ b/utama_core/strategy/default.py @@ -4,7 +4,7 @@ from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.pass_and_shoot import PassAndShootTactic diff --git a/utama_core/strategy/firebreak.py b/utama_core/strategy/firebreak.py index fd70f901..c5278e9b 100644 --- a/utama_core/strategy/firebreak.py +++ b/utama_core/strategy/firebreak.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, carrier_first, diff --git a/utama_core/strategy/mirage.py b/utama_core/strategy/mirage.py index 0580a1aa..7272b53b 100644 --- a/utama_core/strategy/mirage.py +++ b/utama_core/strategy/mirage.py @@ -4,7 +4,7 @@ from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import fixed_ratio_picker from utama_core.tactics.decoy_and_overload import DecoyOverloadTactic from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic diff --git a/utama_core/strategy/pendulum.py b/utama_core/strategy/pendulum.py index b4ca43f7..675954cd 100644 --- a/utama_core/strategy/pendulum.py +++ b/utama_core/strategy/pendulum.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import carrier_first, friendly_closer_to_ball from utama_core.tactics.lead_and_support import LeadAndSupportTactic from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic diff --git a/utama_core/strategy/ricochet.py b/utama_core/strategy/ricochet.py index a2fb361a..354f1146 100644 --- a/utama_core/strategy/ricochet.py +++ b/utama_core/strategy/ricochet.py @@ -4,7 +4,7 @@ from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.give_and_go import GiveAndGoTactic diff --git a/utama_core/strategy/riptide.py b/utama_core/strategy/riptide.py index bbe54f7a..70a098f0 100644 --- a/utama_core/strategy/riptide.py +++ b/utama_core/strategy/riptide.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, carrier_first, diff --git a/utama_core/strategy/terrier.py b/utama_core/strategy/terrier.py index aba6188c..294894d2 100644 --- a/utama_core/strategy/terrier.py +++ b/utama_core/strategy/terrier.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import carrier_first, friendly_closer_to_ball from utama_core.tactics.give_and_go import GiveAndGoTactic from utama_core.tactics.press_and_contain import PressAndContainTactic diff --git a/utama_core/strategy/tripwire.py b/utama_core/strategy/tripwire.py index c5c2608a..3cee5643 100644 --- a/utama_core/strategy/tripwire.py +++ b/utama_core/strategy/tripwire.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, ball_zone, diff --git a/utama_core/strategy/weaver.py b/utama_core/strategy/weaver.py index 141fe4aa..11f16810 100644 --- a/utama_core/strategy/weaver.py +++ b/utama_core/strategy/weaver.py @@ -8,7 +8,7 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import RobotId from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import ( allocate_ordered, ball_zone, diff --git a/utama_core/strategy/wolfpack.py b/utama_core/strategy/wolfpack.py index 2ef2929b..d5ac46f0 100644 --- a/utama_core/strategy/wolfpack.py +++ b/utama_core/strategy/wolfpack.py @@ -4,7 +4,7 @@ from utama_core.engine.context import TickContext from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.strategy.pickers import fixed_ratio_picker from utama_core.tactics.give_and_go import GiveAndGoTactic from utama_core.tactics.press_and_contain import PressAndContainTactic diff --git a/utama_core/tactics/_pass_and_score.py b/utama_core/tactics/_pass_and_score.py index 12df2437..bf1fc0fb 100644 --- a/utama_core/tactics/_pass_and_score.py +++ b/utama_core/tactics/_pass_and_score.py @@ -46,13 +46,8 @@ segment_blocked, shot_heading_reachable, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.utils.move_utils import ( - empty_command, - kick, - move, - turn_on_spot, -) +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot _MIN_SETUP_CLEARANCE = 0.35 # metres — must be > FPP's SAFE_OBSTACLES_RADIUS (0.26 m) _SETUP_SAMPLE_COUNT = 48 diff --git a/utama_core/tactics/block_shape.py b/utama_core/tactics/block_shape.py index 9846c293..819b846a 100644 --- a/utama_core/tactics/block_shape.py +++ b/utama_core/tactics/block_shape.py @@ -50,8 +50,8 @@ ball_in_own_defense_area, ball_is_loose, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point # Depth of our own defense area (standard SSL penalty box front edge). _DEFENSE_AREA_DEPTH = 1.3 diff --git a/utama_core/tactics/clear_ball.py b/utama_core/tactics/clear_ball.py index 012d2e74..779dab4f 100644 --- a/utama_core/tactics/clear_ball.py +++ b/utama_core/tactics/clear_ball.py @@ -56,9 +56,9 @@ segment_clearance, ) from utama_core.shared.tolerance import Sticky -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.move_utils import kick, turn_on_spot +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.move_utils import kick, turn_on_spot # Ball deeper than this (distance from our own goal line) counts as "danger # zone" for applicability. Slightly tighter than the whole own third diff --git a/utama_core/tactics/decoy_and_overload.py b/utama_core/tactics/decoy_and_overload.py index 54c84373..e786ef36 100644 --- a/utama_core/tactics/decoy_and_overload.py +++ b/utama_core/tactics/decoy_and_overload.py @@ -71,8 +71,8 @@ has_ball, segment_blocked, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point from utama_core.tactics._pass_and_score import _pass_exec, _score_goal _LURE_DRAG_THRESHOLD = 0.8 # metres — marker must be pulled at least this far off the central shot lane's y diff --git a/utama_core/tactics/defense.py b/utama_core/tactics/defense.py index e651808b..d1ee13f0 100644 --- a/utama_core/tactics/defense.py +++ b/utama_core/tactics/defense.py @@ -4,7 +4,7 @@ BT strategy was almost entirely role-assignment plumbing (`SetRoles` pinning robot 4 as goalkeeper, `execute_default_action` dispatching by `Role`) around a single already-self-contained skill function, -`utama_core.skills.src.defend_parameter.defend_parameter` — the actual +`utama_core.skills.defend_parameter.defend_parameter` — the actual positioning logic (choosing which post to cover, shadowing the shot line, picking sides dynamically for a 2-defender team) already lives in Core and needed no porting itself. This tactic is that same dispatch, expressed as a @@ -58,10 +58,10 @@ own_defense_area_exit_point, upfield_heading, ) -from utama_core.skills.src.defend_parameter import defend_parameter -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.move_utils import kick, turn_on_spot +from utama_core.skills.defend_parameter import defend_parameter +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.move_utils import kick, turn_on_spot _LOOSE_BALL_CLAIM_RANGE = 1.5 # metres — matches ball_is_loose's own contest range diff --git a/utama_core/tactics/dribble.py b/utama_core/tactics/dribble.py index c58cafc6..6d63439a 100644 --- a/utama_core/tactics/dribble.py +++ b/utama_core/tactics/dribble.py @@ -22,8 +22,8 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.shared.pass_and_score_geometry import at_target, has_ball -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.utils.move_utils import empty_command, move +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.utils.move_utils import empty_command, move # Rectangle corners as fractions of field half-dimensions, in traversal order. _RECT_X_FRAC = 0.55 diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index fa7a3f76..e10e8494 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -70,9 +70,9 @@ segment_blocked, shot_heading_reachable, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.move_utils import kick, move, turn_on_spot +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.move_utils import kick, move, turn_on_spot from utama_core.tactics._pass_and_score import _pass_exec, move_for_a_shot _MAX_HOPS_PER_POSSESSION = 6 # safety valve — force a shot attempt rather than passing forever diff --git a/utama_core/tactics/goalkeeper.py b/utama_core/tactics/goalkeeper.py index 68c76f25..7eef0f5b 100644 --- a/utama_core/tactics/goalkeeper.py +++ b/utama_core/tactics/goalkeeper.py @@ -23,9 +23,9 @@ from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag from utama_core.entities.data.command import RobotCommand from utama_core.entities.game import Game -from utama_core.motion_planning.src.controllers.pid_controller import PIDController -from utama_core.skills.src.goalkeep import goalkeep -from utama_core.skills.src.utils.move_utils import empty_command +from utama_core.motion_planning.controllers.pid_controller import PIDController +from utama_core.skills.goalkeep import goalkeep +from utama_core.skills.utils.move_utils import empty_command @dataclass diff --git a/utama_core/tactics/lead_and_support.py b/utama_core/tactics/lead_and_support.py index 3adf4dad..5aaba85b 100644 --- a/utama_core/tactics/lead_and_support.py +++ b/utama_core/tactics/lead_and_support.py @@ -47,9 +47,9 @@ segment_blocked, shot_heading_reachable, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.move_utils import kick, move, turn_on_spot +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.move_utils import kick, move, turn_on_spot from utama_core.tactics._pass_and_score import move_for_a_shot _MIN_SUPPORT_SEPARATION = 0.9 # metres — supports must not crowd each other or the leader diff --git a/utama_core/tactics/press_and_contain.py b/utama_core/tactics/press_and_contain.py index ab5c7550..abc93dce 100644 --- a/utama_core/tactics/press_and_contain.py +++ b/utama_core/tactics/press_and_contain.py @@ -37,11 +37,11 @@ own_defense_area_exit_point, ) from utama_core.shared.tolerance import Sticky -from utama_core.skills.src.block import block_attacker -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.kick_upfield import kick_upfield -from utama_core.skills.src.man_mark import man_mark +from utama_core.skills.block import block_attacker +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.kick_upfield import kick_upfield +from utama_core.skills.man_mark import man_mark _PRESS_ENTER_RANGE = 1.4 # metres — ball must be within this of an enemy to start pressing _PRESS_EXIT_RANGE = 1.7 # metres — enemy must clear past this to release pressing diff --git a/utama_core/tactics/shadow_and_mark.py b/utama_core/tactics/shadow_and_mark.py index e228940c..bbb2544c 100644 --- a/utama_core/tactics/shadow_and_mark.py +++ b/utama_core/tactics/shadow_and_mark.py @@ -46,11 +46,11 @@ has_ball, own_defense_area_exit_point, ) -from utama_core.skills.src.defend_parameter import defend_parameter -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.kick_upfield import kick_upfield -from utama_core.skills.src.man_mark import mark_target +from utama_core.skills.defend_parameter import defend_parameter +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.kick_upfield import kick_upfield +from utama_core.skills.man_mark import mark_target _LOOSE_BALL_CLAIM_RANGE = 1.5 # metres — matches ball_is_loose's own contest range diff --git a/utama_core/tactics/switch_of_play.py b/utama_core/tactics/switch_of_play.py index e00243b2..ebdcdbfb 100644 --- a/utama_core/tactics/switch_of_play.py +++ b/utama_core/tactics/switch_of_play.py @@ -73,9 +73,9 @@ has_ball, segment_blocked, ) -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.go_to_point import go_to_point -from utama_core.skills.src.utils.move_utils import move +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.go_to_point import go_to_point +from utama_core.skills.utils.move_utils import move from utama_core.tactics._pass_and_score import _pass_exec, _score_goal # Guidance point 3: a naive "count enemies on each half of the field" read @@ -140,7 +140,7 @@ # Widening `_ARRIVAL_SPEED_THRESHOLD` (above) was not sufficient on its own: # a robot converged on a static target still never truly settles under this # codebase's PID translation controller (`TwoDPID._calculate` in -# `motion_planning/src/pid/pid.py` — proportional-only near the target, no +# `motion_planning/pid/pid.py` — proportional-only near the target, no # terminal deadband above its 3mm snap-to-zero), so speed keeps oscillating # in a small band straddling the threshold indefinitely rather than # converging below it. Live-traced on `shadow_switch_vs_zone_fluid` diff --git a/utama_core/team_controller/controllers/__init__.py b/utama_core/team_controller/controllers/__init__.py new file mode 100644 index 00000000..b7dff8b0 --- /dev/null +++ b/utama_core/team_controller/controllers/__init__.py @@ -0,0 +1,18 @@ +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( + AbstractRobotController, +) +from utama_core.team_controller.controllers.common.sim_controller_abstract import ( + AbstractSimController, +) +from utama_core.team_controller.controllers.real.real_robot_controller import ( + RealRobotController, +) +from utama_core.team_controller.controllers.sim.grsim_controller import GRSimController +from utama_core.team_controller.controllers.sim.grsim_robot_controller import ( + GRSimRobotController, +) +from utama_core.team_controller.controllers.sim.rsim_controller import RSimController +from utama_core.team_controller.controllers.sim.rsim_robot_controller import ( + RSimPVPManager, + RSimRobotController, +) diff --git a/utama_core/team_controller/src/controllers/common/robot_controller_abstract.py b/utama_core/team_controller/controllers/common/robot_controller_abstract.py similarity index 100% rename from utama_core/team_controller/src/controllers/common/robot_controller_abstract.py rename to utama_core/team_controller/controllers/common/robot_controller_abstract.py diff --git a/utama_core/team_controller/src/controllers/common/robot_profile.py b/utama_core/team_controller/controllers/common/robot_profile.py similarity index 98% rename from utama_core/team_controller/src/controllers/common/robot_profile.py rename to utama_core/team_controller/controllers/common/robot_profile.py index a6cfd870..279e3183 100644 --- a/utama_core/team_controller/src/controllers/common/robot_profile.py +++ b/utama_core/team_controller/controllers/common/robot_profile.py @@ -27,7 +27,7 @@ from utama_core.config.settings import CONTROL_FREQUENCY from utama_core.entities.data.command import RobotCommand -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) diff --git a/utama_core/team_controller/src/controllers/common/sim_controller_abstract.py b/utama_core/team_controller/controllers/common/sim_controller_abstract.py similarity index 100% rename from utama_core/team_controller/src/controllers/common/sim_controller_abstract.py rename to utama_core/team_controller/controllers/common/sim_controller_abstract.py diff --git a/utama_core/team_controller/src/controllers/real/find_robots.py b/utama_core/team_controller/controllers/real/find_robots.py similarity index 98% rename from utama_core/team_controller/src/controllers/real/find_robots.py rename to utama_core/team_controller/controllers/real/find_robots.py index e4546b60..d3988648 100644 --- a/utama_core/team_controller/src/controllers/real/find_robots.py +++ b/utama_core/team_controller/controllers/real/find_robots.py @@ -30,11 +30,11 @@ from utama_core.config.settings import MULTICAST_GROUP, VISION_PORT from utama_core.entities.data.command import RobotCommand -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( PROFILE_DIR, profile_path, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) @@ -145,7 +145,7 @@ def radio(self, radio: int) -> dict: def find(radios=RADIOS, controller=None, sock=None, clock=time.monotonic, sleep=time.sleep) -> dict: """Probes each of `radios`; the lids seen, and per radio whether it answered and its lid.""" if controller is None: - from utama_core.team_controller.src.controllers.real.real_robot_controller import ( + from utama_core.team_controller.controllers.real.real_robot_controller import ( RealRobotController, ) diff --git a/utama_core/team_controller/src/controllers/real/kicker_charge.py b/utama_core/team_controller/controllers/real/kicker_charge.py similarity index 100% rename from utama_core/team_controller/src/controllers/real/kicker_charge.py rename to utama_core/team_controller/controllers/real/kicker_charge.py diff --git a/utama_core/team_controller/src/controllers/real/real_robot_controller.py b/utama_core/team_controller/controllers/real/real_robot_controller.py similarity index 99% rename from utama_core/team_controller/src/controllers/real/real_robot_controller.py rename to utama_core/team_controller/controllers/real/real_robot_controller.py index 82e0d008..e095d096 100644 --- a/utama_core/team_controller/src/controllers/real/real_robot_controller.py +++ b/utama_core/team_controller/controllers/real/real_robot_controller.py @@ -25,8 +25,8 @@ DRIBBLER_DRAIN_RATE: float = 2.0 # bucket seconds drained per real second DRIBBLER_RESUME_SECONDS: float = 10.0 from utama_core.entities.data.command import RobotCommand, RobotResponse -from utama_core.skills.src.utils.move_utils import empty_command -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( +from utama_core.skills.utils.move_utils import empty_command +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) diff --git a/utama_core/team_controller/src/controllers/sim/grsim_controller.py b/utama_core/team_controller/controllers/sim/grsim_controller.py similarity index 93% rename from utama_core/team_controller/src/controllers/sim/grsim_controller.py rename to utama_core/team_controller/controllers/sim/grsim_controller.py index 87879c51..b67e950a 100644 --- a/utama_core/team_controller/src/controllers/sim/grsim_controller.py +++ b/utama_core/team_controller/controllers/sim/grsim_controller.py @@ -9,20 +9,17 @@ TELEPORT_X_COORDS, ) from utama_core.entities.game.field import FieldBounds -from utama_core.team_controller.src.controllers.common.sim_controller_abstract import ( +from utama_core.team_controller.controllers.common.sim_controller_abstract import ( AbstractSimController, ) -from utama_core.team_controller.src.generated_code.ssl_gc_common_pb2 import ( - RobotId, - Team, -) -from utama_core.team_controller.src.generated_code.ssl_simulation_control_pb2 import ( +from utama_core.team_controller.generated_code.ssl_gc_common_pb2 import RobotId, Team +from utama_core.team_controller.generated_code.ssl_simulation_control_pb2 import ( SimulatorCommand, SimulatorControl, TeleportBall, TeleportRobot, ) -from utama_core.team_controller.src.utils import network_manager +from utama_core.team_controller.utils import network_manager class GRSimController(AbstractSimController): diff --git a/utama_core/team_controller/src/controllers/sim/grsim_robot_controller.py b/utama_core/team_controller/controllers/sim/grsim_robot_controller.py similarity index 94% rename from utama_core/team_controller/src/controllers/sim/grsim_robot_controller.py rename to utama_core/team_controller/controllers/sim/grsim_robot_controller.py index c81954ba..7c47cf46 100644 --- a/utama_core/team_controller/src/controllers/sim/grsim_robot_controller.py +++ b/utama_core/team_controller/controllers/sim/grsim_robot_controller.py @@ -14,16 +14,16 @@ RobotResponse, RobotVelCommand, ) -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) -from utama_core.team_controller.src.generated_code.ssl_simulation_robot_control_pb2 import ( +from utama_core.team_controller.generated_code.ssl_simulation_robot_control_pb2 import ( RobotControl, ) -from utama_core.team_controller.src.generated_code.ssl_simulation_robot_feedback_pb2 import ( +from utama_core.team_controller.generated_code.ssl_simulation_robot_feedback_pb2 import ( RobotControlResponse, ) -from utama_core.team_controller.src.utils import network_manager +from utama_core.team_controller.utils import network_manager logger = logging.getLogger(__name__) diff --git a/utama_core/team_controller/src/controllers/sim/rsim_controller.py b/utama_core/team_controller/controllers/sim/rsim_controller.py similarity index 93% rename from utama_core/team_controller/src/controllers/sim/rsim_controller.py rename to utama_core/team_controller/controllers/sim/rsim_controller.py index 8879cdec..ded588c9 100644 --- a/utama_core/team_controller/src/controllers/sim/rsim_controller.py +++ b/utama_core/team_controller/controllers/sim/rsim_controller.py @@ -2,8 +2,8 @@ from utama_core.config.settings import ADD_Y_COORD, REMOVAL_Y_COORD, TELEPORT_X_COORDS from utama_core.entities.game.field import FieldBounds -from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv -from utama_core.team_controller.src.controllers.common.sim_controller_abstract import ( +from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.team_controller.controllers.common.sim_controller_abstract import ( AbstractSimController, ) diff --git a/utama_core/team_controller/src/controllers/sim/rsim_robot_controller.py b/utama_core/team_controller/controllers/sim/rsim_robot_controller.py similarity index 97% rename from utama_core/team_controller/src/controllers/sim/rsim_robot_controller.py rename to utama_core/team_controller/controllers/sim/rsim_robot_controller.py index fb2f75fd..2c09d39a 100644 --- a/utama_core/team_controller/src/controllers/sim/rsim_robot_controller.py +++ b/utama_core/team_controller/controllers/sim/rsim_robot_controller.py @@ -5,8 +5,8 @@ from numpy.typing import NDArray from utama_core.entities.data.command import RobotCommand, RobotResponse -from utama_core.rsoccer_simulator.src.ssl.ssl_gym_base import SSLBaseEnv -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( +from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) diff --git a/utama_core/team_controller/src/debug_utils/telop_gui.py b/utama_core/team_controller/debug_utils/telop_gui.py similarity index 99% rename from utama_core/team_controller/src/debug_utils/telop_gui.py rename to utama_core/team_controller/debug_utils/telop_gui.py index fc779193..27df6975 100644 --- a/utama_core/team_controller/src/debug_utils/telop_gui.py +++ b/utama_core/team_controller/debug_utils/telop_gui.py @@ -26,7 +26,7 @@ if not USE_DUMMY_CONTROLLER: - from utama_core.team_controller.src.controllers.real.real_robot_controller import ( + from utama_core.team_controller.controllers.real.real_robot_controller import ( RealRobotController, RobotCommand, empty_command, diff --git a/utama_core/team_controller/src/generated_code/ssl_gc_common_pb2.py b/utama_core/team_controller/generated_code/ssl_gc_common_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_gc_common_pb2.py rename to utama_core/team_controller/generated_code/ssl_gc_common_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_gc_game_event_pb2.py b/utama_core/team_controller/generated_code/ssl_gc_game_event_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_gc_game_event_pb2.py rename to utama_core/team_controller/generated_code/ssl_gc_game_event_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_gc_geometry_pb2.py b/utama_core/team_controller/generated_code/ssl_gc_geometry_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_gc_geometry_pb2.py rename to utama_core/team_controller/generated_code/ssl_gc_geometry_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_gc_referee_message_pb2.py b/utama_core/team_controller/generated_code/ssl_gc_referee_message_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_gc_referee_message_pb2.py rename to utama_core/team_controller/generated_code/ssl_gc_referee_message_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_gc_state_pb2.py b/utama_core/team_controller/generated_code/ssl_gc_state_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_gc_state_pb2.py rename to utama_core/team_controller/generated_code/ssl_gc_state_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_config_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_config_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_config_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_config_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_control_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_control_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_control_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_control_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_error_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_error_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_error_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_error_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_robot_control_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_robot_control_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_robot_control_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_robot_control_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_robot_feedback_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_robot_feedback_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_robot_feedback_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_robot_feedback_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_simulation_synchronous_pb2.py b/utama_core/team_controller/generated_code/ssl_simulation_synchronous_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_simulation_synchronous_pb2.py rename to utama_core/team_controller/generated_code/ssl_simulation_synchronous_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_vision_detection_pb2.py b/utama_core/team_controller/generated_code/ssl_vision_detection_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_vision_detection_pb2.py rename to utama_core/team_controller/generated_code/ssl_vision_detection_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_vision_detection_tracked_pb2.py b/utama_core/team_controller/generated_code/ssl_vision_detection_tracked_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_vision_detection_tracked_pb2.py rename to utama_core/team_controller/generated_code/ssl_vision_detection_tracked_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_vision_geometry_pb2.py b/utama_core/team_controller/generated_code/ssl_vision_geometry_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_vision_geometry_pb2.py rename to utama_core/team_controller/generated_code/ssl_vision_geometry_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_vision_wrapper_pb2.py b/utama_core/team_controller/generated_code/ssl_vision_wrapper_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_vision_wrapper_pb2.py rename to utama_core/team_controller/generated_code/ssl_vision_wrapper_pb2.py diff --git a/utama_core/team_controller/src/generated_code/ssl_vision_wrapper_tracked_pb2.py b/utama_core/team_controller/generated_code/ssl_vision_wrapper_tracked_pb2.py similarity index 100% rename from utama_core/team_controller/src/generated_code/ssl_vision_wrapper_tracked_pb2.py rename to utama_core/team_controller/generated_code/ssl_vision_wrapper_tracked_pb2.py diff --git a/utama_core/team_controller/src/__init__.py b/utama_core/team_controller/src/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/utama_core/team_controller/src/controllers/__init__.py b/utama_core/team_controller/src/controllers/__init__.py deleted file mode 100644 index e8ce33d9..00000000 --- a/utama_core/team_controller/src/controllers/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -from utama_core.team_controller.src.controllers.common.robot_controller_abstract import ( - AbstractRobotController, -) -from utama_core.team_controller.src.controllers.common.sim_controller_abstract import ( - AbstractSimController, -) -from utama_core.team_controller.src.controllers.real.real_robot_controller import ( - RealRobotController, -) -from utama_core.team_controller.src.controllers.sim.grsim_controller import ( - GRSimController, -) -from utama_core.team_controller.src.controllers.sim.grsim_robot_controller import ( - GRSimRobotController, -) -from utama_core.team_controller.src.controllers.sim.rsim_controller import ( - RSimController, -) -from utama_core.team_controller.src.controllers.sim.rsim_robot_controller import ( - RSimPVPManager, - RSimRobotController, -) diff --git a/utama_core/team_controller/src/utils/network_manager.py b/utama_core/team_controller/utils/network_manager.py similarity index 97% rename from utama_core/team_controller/src/utils/network_manager.py rename to utama_core/team_controller/utils/network_manager.py index 52c242eb..9f0f1614 100644 --- a/utama_core/team_controller/src/utils/network_manager.py +++ b/utama_core/team_controller/utils/network_manager.py @@ -2,7 +2,7 @@ import socket from typing import Optional, Tuple -from utama_core.team_controller.src.utils import network_utils +from utama_core.team_controller.utils import network_utils logger = logging.getLogger(__name__) diff --git a/utama_core/team_controller/src/utils/network_utils.py b/utama_core/team_controller/utils/network_utils.py similarity index 100% rename from utama_core/team_controller/src/utils/network_utils.py rename to utama_core/team_controller/utils/network_utils.py diff --git a/utama_core/tests/analysis/test_robot_calibration.py b/utama_core/tests/analysis/test_robot_calibration.py index 6691ea29..6ba01e08 100644 --- a/utama_core/tests/analysis/test_robot_calibration.py +++ b/utama_core/tests/analysis/test_robot_calibration.py @@ -25,13 +25,11 @@ from utama_core.entities.referee.stage import Stage from utama_core.replay.game_log_writer import RADIO_OUT, GameLogWriter from utama_core.replay.ssl_log import REFEREE, read_records, referee_data -from utama_core.team_controller.src.controllers.real.real_robot_controller import ( +from utama_core.team_controller.controllers.real.real_robot_controller import ( RealRobotController, ) -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) diff --git a/utama_core/tests/bundle/test_strategy_file.py b/utama_core/tests/bundle/test_strategy_file.py index 959e98d8..a1c75ec9 100644 --- a/utama_core/tests/bundle/test_strategy_file.py +++ b/utama_core/tests/bundle/test_strategy_file.py @@ -18,7 +18,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.motion_planning.src.common.control_schemes import get_control_scheme +from utama_core.motion_planning.common.control_schemes import get_control_scheme from utama_core.replay.fingerprint import CodeGraph from utama_core.strategy import catalog @@ -169,8 +169,8 @@ def test_what_a_file_adds_around_the_code_is_not_part_of_the_player(tmp_path, mo "member", [ "utama_core/strategy/pendulum.py", - "utama_core/skills/src/go_to_ball.py", - "utama_core/motion_planning/src/common/control_schemes.py", + "utama_core/skills/go_to_ball.py", + "utama_core/motion_planning/common/control_schemes.py", ], ) def test_a_file_of_different_code_is_a_different_player(tmp_path, monkeypatch, member): diff --git a/utama_core/tests/common/abstract_test_manager.py b/utama_core/tests/common/abstract_test_manager.py index f219b1da..43c9fda5 100644 --- a/utama_core/tests/common/abstract_test_manager.py +++ b/utama_core/tests/common/abstract_test_manager.py @@ -3,7 +3,7 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.game import Game -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController class TestingStatus(Enum): diff --git a/utama_core/tests/controller/test_dribbler_limiter.py b/utama_core/tests/controller/test_dribbler_limiter.py index 38ea62b2..1f1055d5 100644 --- a/utama_core/tests/controller/test_dribbler_limiter.py +++ b/utama_core/tests/controller/test_dribbler_limiter.py @@ -4,14 +4,14 @@ import pytest -from utama_core.team_controller.src.controllers.real.real_robot_controller import ( +from utama_core.team_controller.controllers.real.real_robot_controller import ( DRIBBLER_DRAIN_RATE, DRIBBLER_MAX_ON_SECONDS, DRIBBLER_RESUME_SECONDS, RealRobotController, ) -_MONOTONIC = "utama_core.team_controller.src.controllers.real.real_robot_controller.time.monotonic" +_MONOTONIC = "utama_core.team_controller.controllers.real.real_robot_controller.time.monotonic" @pytest.fixture diff --git a/utama_core/tests/controller/test_find_robots.py b/utama_core/tests/controller/test_find_robots.py index 41422c74..6fdf91e7 100644 --- a/utama_core/tests/controller/test_find_robots.py +++ b/utama_core/tests/controller/test_find_robots.py @@ -9,11 +9,11 @@ import pytest from utama_core.entities.data.command import RobotResponse -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( RobotProfile, save_profile, ) -from utama_core.team_controller.src.controllers.real import find_robots as fr +from utama_core.team_controller.controllers.real import find_robots as fr class _Field: diff --git a/utama_core/tests/controller/test_kicker_charge.py b/utama_core/tests/controller/test_kicker_charge.py index 15d37262..caf76e9a 100644 --- a/utama_core/tests/controller/test_kicker_charge.py +++ b/utama_core/tests/controller/test_kicker_charge.py @@ -8,7 +8,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.team_controller.src.controllers.real.kicker_charge import ( +from utama_core.team_controller.controllers.real.kicker_charge import ( CLEAR_M, KEEP_S, KickerCharge, diff --git a/utama_core/tests/controller/test_robot_profile.py b/utama_core/tests/controller/test_robot_profile.py index 8d6f74f9..cdd9e395 100644 --- a/utama_core/tests/controller/test_robot_profile.py +++ b/utama_core/tests/controller/test_robot_profile.py @@ -10,7 +10,7 @@ from utama_core.config.enums import Mode from utama_core.entities.data.command import RobotCommand from utama_core.run.strategy_runner import StrategyRunner -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( _PUSH_TICKS, CARRY_SPEED, CARRY_TURN, diff --git a/utama_core/tests/controller/test_sim_controller.py b/utama_core/tests/controller/test_sim_controller.py index b0bd48b6..79fd6e17 100644 --- a/utama_core/tests/controller/test_sim_controller.py +++ b/utama_core/tests/controller/test_sim_controller.py @@ -4,7 +4,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS, FieldBounds from utama_core.config.settings import OFF_PITCH_OFFSET -from utama_core.team_controller.src.controllers.common.sim_controller_abstract import ( +from utama_core.team_controller.controllers.common.sim_controller_abstract import ( AbstractSimController, ) diff --git a/utama_core/tests/engine/test_ball_roles.py b/utama_core/tests/engine/test_ball_roles.py index 1e3d4bfa..a782b35a 100644 --- a/utama_core/tests/engine/test_ball_roles.py +++ b/utama_core/tests/engine/test_ball_roles.py @@ -27,7 +27,7 @@ receiver_of_rolling_ball, segment_blocked, ) -from utama_core.skills.src.man_mark import MARK_STANDOFF, mark_target +from utama_core.skills.man_mark import MARK_STANDOFF, mark_target from utama_core.tactics.give_and_go import _relocate_target _ORIGINAL = RobotCommand(local_forward_vel=1, local_left_vel=0, angular_vel=0, kick=0, chip=0, dribble=0) diff --git a/utama_core/tests/engine/test_block_shape_tactic.py b/utama_core/tests/engine/test_block_shape_tactic.py index 260b74d4..afbb59b4 100644 --- a/utama_core/tests/engine/test_block_shape_tactic.py +++ b/utama_core/tests/engine/test_block_shape_tactic.py @@ -5,7 +5,7 @@ match"): `go_to_point()`'s signature declares `target_coords: Vector2D`, and `move()` forwards that value straight through to `motion_controller.calculate(..., target_pos=target_coords, ...)` -unconverted (`utama_core/skills/src/utils/move_utils.py`). FPP/DWA happened +unconverted (`utama_core/skills/utils/move_utils.py`). FPP/DWA happened to tolerate a raw tuple silently; trajsampling's stricter `target_pos.x`/`.y` attribute access crashed outright — the actual reason a full trajsample tournament scored 0-0 everywhere. Both of `BlockShapeTactic.tick()`'s @@ -30,7 +30,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.block_shape import BlockShapeTactic diff --git a/utama_core/tests/engine/test_decoy_and_overload_tactic.py b/utama_core/tests/engine/test_decoy_and_overload_tactic.py index 33802b18..2d59636d 100644 --- a/utama_core/tests/engine/test_decoy_and_overload_tactic.py +++ b/utama_core/tests/engine/test_decoy_and_overload_tactic.py @@ -36,7 +36,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.decoy_and_overload import ( _ENEMY_BALL_RELEASE_TICKS, _FINISH_TIMEOUT_TICKS, diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 71f743eb..013ff3bd 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -83,7 +83,7 @@ def test_the_players_load_and_the_core_is_in_the_catalog(): def test_the_reference_world_and_robots_make_one_valid_sim_noise(): from tools.evaluation.sim_settings import reference_noise - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise noise = SimNoise.from_dict(reference_noise(seed=3)) assert noise.seed == 3 @@ -103,7 +103,7 @@ def test_every_reference_setting_names_its_source(): def test_the_reference_sim_does_not_draw_robot_motor_limits(): """Acceleration is the command cap; a per-match draw would be a robot capability as noise.""" from tools.evaluation.sim_settings import reference_noise - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise assert not SimNoise.from_dict(reference_noise()).motion_limits diff --git a/utama_core/tests/engine/test_give_and_go_tactic.py b/utama_core/tests/engine/test_give_and_go_tactic.py index 67926b44..bb9f1806 100644 --- a/utama_core/tests/engine/test_give_and_go_tactic.py +++ b/utama_core/tests/engine/test_give_and_go_tactic.py @@ -35,7 +35,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import ( MIN_OPEN_TEAMMATE_M, find_best_shot, diff --git a/utama_core/tests/engine/test_lead_and_support_tactic.py b/utama_core/tests/engine/test_lead_and_support_tactic.py index a68e7c00..bfa4772c 100644 --- a/utama_core/tests/engine/test_lead_and_support_tactic.py +++ b/utama_core/tests/engine/test_lead_and_support_tactic.py @@ -20,7 +20,7 @@ from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.src.common.pose_ahead import PoseAhead +from utama_core.motion_planning.common.pose_ahead import PoseAhead from utama_core.shared.pass_and_score_geometry import enemy_defense_area_hold_point from utama_core.tactics.lead_and_support import LeadAndSupportTactic diff --git a/utama_core/tests/engine/test_pass_and_shoot_tactic.py b/utama_core/tests/engine/test_pass_and_shoot_tactic.py index 91c14076..1a0092e7 100644 --- a/utama_core/tests/engine/test_pass_and_shoot_tactic.py +++ b/utama_core/tests/engine/test_pass_and_shoot_tactic.py @@ -22,7 +22,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics._pass_and_score import PassAndScoreMem, run_setup_phase from utama_core.tactics.pass_and_shoot import ( _LANE_BLOCKED_ABANDON_TICKS, diff --git a/utama_core/tests/engine/test_press_and_contain_tactic.py b/utama_core/tests/engine/test_press_and_contain_tactic.py index 1d5b7012..02eb5aac 100644 --- a/utama_core/tests/engine/test_press_and_contain_tactic.py +++ b/utama_core/tests/engine/test_press_and_contain_tactic.py @@ -18,7 +18,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.press_and_contain import ( PressAndContainMem, PressAndContainTactic, diff --git a/utama_core/tests/engine/test_shadow_and_mark_tactic.py b/utama_core/tests/engine/test_shadow_and_mark_tactic.py index cbf80cff..bc724fc0 100644 --- a/utama_core/tests/engine/test_shadow_and_mark_tactic.py +++ b/utama_core/tests/engine/test_shadow_and_mark_tactic.py @@ -20,8 +20,8 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.man_mark import MARK_STANDOFF, mark_target +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.man_mark import MARK_STANDOFF, mark_target from utama_core.tactics.shadow_and_mark import ShadowAndMarkTactic diff --git a/utama_core/tests/engine/test_switch_of_play_tactic.py b/utama_core/tests/engine/test_switch_of_play_tactic.py index 9ca17cdf..8625dfd7 100644 --- a/utama_core/tests/engine/test_switch_of_play_tactic.py +++ b/utama_core/tests/engine/test_switch_of_play_tactic.py @@ -40,7 +40,7 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tactics.switch_of_play import ( _SETTLE_DEBOUNCE_TICKS, diff --git a/utama_core/tests/examples/test_calibrate_robot.py b/utama_core/tests/examples/test_calibrate_robot.py index 2d0681d8..8a21c979 100644 --- a/utama_core/tests/examples/test_calibrate_robot.py +++ b/utama_core/tests/examples/test_calibrate_robot.py @@ -8,7 +8,7 @@ import pytest -from utama_core.team_controller.src.controllers.common.robot_profile import ( +from utama_core.team_controller.controllers.common.robot_profile import ( RobotProfile, load_profile, save_profile, diff --git a/utama_core/tests/examples/test_save_and_counter.py b/utama_core/tests/examples/test_save_and_counter.py index 7dbd6e46..53896cf3 100644 --- a/utama_core/tests/examples/test_save_and_counter.py +++ b/utama_core/tests/examples/test_save_and_counter.py @@ -12,7 +12,7 @@ from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D -from utama_core.motion_planning.src.common.pose_ahead import PoseAhead +from utama_core.motion_planning.common.pose_ahead import PoseAhead from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot diff --git a/utama_core/tests/examples/test_shooting_drill.py b/utama_core/tests/examples/test_shooting_drill.py index 93caea71..03294075 100644 --- a/utama_core/tests/examples/test_shooting_drill.py +++ b/utama_core/tests/examples/test_shooting_drill.py @@ -12,7 +12,7 @@ from utama_core.config.enums import Mode from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot diff --git a/utama_core/tests/fixtures/exact_math.py b/utama_core/tests/fixtures/exact_math.py index 4d6c8f23..b1789945 100644 --- a/utama_core/tests/fixtures/exact_math.py +++ b/utama_core/tests/fixtures/exact_math.py @@ -9,8 +9,8 @@ from utama_core.data_processing.refiners.filters import kalman from utama_core.global_utils import math_utils -from utama_core.motion_planning.src.fastpathplanning import planner -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning import planner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner SWITCHES = [ (math_utils, "distance", math_utils._distance_numpy, math_utils._distance_fast), diff --git a/utama_core/tests/motion_planning/_kernel_test_strategies.py b/utama_core/tests/motion_planning/_kernel_test_strategies.py index 0df6c86f..f1665cbd 100644 --- a/utama_core/tests/motion_planning/_kernel_test_strategies.py +++ b/utama_core/tests/motion_planning/_kernel_test_strategies.py @@ -22,8 +22,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.utils.move_utils import move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.utils.move_utils import move @dataclass diff --git a/utama_core/tests/motion_planning/contract/controller_contract_test.py b/utama_core/tests/motion_planning/contract/controller_contract_test.py index c2ad22f5..c124f24d 100644 --- a/utama_core/tests/motion_planning/contract/controller_contract_test.py +++ b/utama_core/tests/motion_planning/contract/controller_contract_test.py @@ -5,11 +5,11 @@ import pytest from utama_core.config.enums import Mode -from utama_core.motion_planning.src.common.control_schemes import ( +from utama_core.motion_planning.common.control_schemes import ( CONTROL_SCHEME_MAP, get_control_scheme, ) -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController EXPECTED_CALCULATE_PARAMETERS = ( "self", diff --git a/utama_core/tests/motion_planning/defense_area_avoidance_test.py b/utama_core/tests/motion_planning/defense_area_avoidance_test.py index ed6b2323..b2ed02c3 100644 --- a/utama_core/tests/motion_planning/defense_area_avoidance_test.py +++ b/utama_core/tests/motion_planning/defense_area_avoidance_test.py @@ -14,7 +14,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.game import Game from utama_core.run import StrategyRunner -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/motion_planning/fastpathplanner_corner_test.py b/utama_core/tests/motion_planning/fastpathplanner_corner_test.py index bb32a2f8..d378f089 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_corner_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_corner_test.py @@ -29,7 +29,7 @@ import numpy as np import pytest -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot _STEP_M = 3.0 / 60 diff --git a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py b/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py index 601e2636..044fc0dd 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py @@ -28,11 +28,11 @@ find_intersection, rotate_vector, ) -from utama_core.motion_planning.src.fastpathplanning.numba_kernels import ( +from utama_core.motion_planning.fastpathplanning.numba_kernels import ( scan_collides_nb, scan_find_subgoal_nb, ) -from utama_core.motion_planning.src.fastpathplanning.planner import ( +from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _same_segment, _segment_key, @@ -428,7 +428,7 @@ class DummyGame: assert len(planner._obstacle_arrays_cache) == 1 cached_obs, cached_arrs = planner._obstacle_arrays_cache[0] assert cached_obs is obstacles - from utama_core.motion_planning.src.fastpathplanning.numba_kernels import ( + from utama_core.motion_planning.fastpathplanning.numba_kernels import ( flatten_obstacles, ) diff --git a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py b/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py index 4513e169..fc852c14 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py @@ -11,7 +11,7 @@ from utama_core.data_processing.refiners.filters import kalman from utama_core.global_utils import math_utils -from utama_core.motion_planning.src.fastpathplanning.planner import ( +from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _same_segment, _segment_key, diff --git a/utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py b/utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py index 95cd43b2..f480e97e 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py @@ -25,7 +25,7 @@ import numpy as np from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner def _planner() -> FastPathPlanner: diff --git a/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py b/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py index c7995707..0565c4e8 100644 --- a/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py +++ b/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py @@ -1,5 +1,5 @@ """Boundary-condition and randomized-invariant sweep over `BangBang1D`/ -`Trajectory2D` (`utama_core/motion_planning/src/trajsampling/bang_bang.py`). +`Trajectory2D` (`utama_core/motion_planning/trajsampling/bang_bang.py`). `trajsampling_correctness_test.py` (read before writing this file) already covers: rejecting non-positive `v_max`/`a_max`; endpoint/kinematic invariants @@ -57,10 +57,7 @@ import pytest -from utama_core.motion_planning.src.trajsampling.bang_bang import ( - BangBang1D, - Trajectory2D, -) +from utama_core.motion_planning.trajsampling.bang_bang import BangBang1D, Trajectory2D _N_SEEDS = 200 _END_TOL = 1e-6 diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py b/utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py index d09d47a2..fcf91cb4 100644 --- a/utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py +++ b/utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py @@ -9,11 +9,11 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.src.controllers.trajsampling import ( +from utama_core.motion_planning.controllers.trajsampling import ( TrajectorySamplingController, ) -from utama_core.motion_planning.src.trajsampling.bang_bang import Trajectory2D -from utama_core.motion_planning.src.trajsampling.planner import PlanResult +from utama_core.motion_planning.trajsampling.bang_bang import Trajectory2D +from utama_core.motion_planning.trajsampling.planner import PlanResult def _game_with_robot(p_xy, v_xy) -> Game: diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py b/utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py index 0eba11b6..a966abc3 100644 --- a/utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py +++ b/utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py @@ -9,18 +9,15 @@ from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.trajsampling import collision_numba as collision -from utama_core.motion_planning.src.trajsampling.bang_bang import ( - BangBang1D, - Trajectory2D, -) -from utama_core.motion_planning.src.trajsampling.obstacles import ( +from utama_core.motion_planning.trajsampling import collision_numba as collision +from utama_core.motion_planning.trajsampling.bang_bang import BangBang1D, Trajectory2D +from utama_core.motion_planning.trajsampling.obstacles import ( ConstantVelocityObstacle, EnemyRobotObstacle, OwnRobotObstacle, StaticSegmentObstacle, ) -from utama_core.motion_planning.src.trajsampling.planner import ( +from utama_core.motion_planning.trajsampling.planner import ( PlanResult, TrajectorySamplingPlanner, _bangbang_to_row, @@ -341,7 +338,7 @@ def test_first_collision_numba_grants_escape_grace_when_starting_inside_obstacle the robot's own starting position was "the collision" -- so a trajectory heading directly AWAY from the obstacle was still rejected at t=0. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -475,7 +472,7 @@ def test_try_reuse_notices_a_priority_obstacle_only_encroaching_later_in_the_tra i.e. collision-free by the harder threshold, but priority-blocked by the softer one. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -528,7 +525,7 @@ def test_try_reuse_does_not_invalidate_on_a_priority_conflict_beyond_the_recheck `MAX_LOOKAHEAD_TIME`-capped scan remains the backstop for anything genuinely dangerous further out. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -593,7 +590,7 @@ def test_try_reuse_ignores_priority_conflict_when_priority_blocking_disabled(): would still reject the reuse) -- but passes `priority_enabled=False` and asserts the reuse now survives instead. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -774,7 +771,7 @@ def test_intermediate_targets_drops_a_stale_backward_pointing_last_target(): candidates = planner._intermediate_targets(robot_id=0, p0=p0, final_target=final_target) - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -823,7 +820,7 @@ def test_intermediate_targets_keeps_a_last_target_that_is_still_a_reasonable_det candidates = planner._intermediate_targets(robot_id=0, p0=p0, final_target=final_target) - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -857,10 +854,10 @@ def test_intermediate_targets_inserts_same_side_jitter_around_a_kept_last_target candidates = planner._intermediate_targets(robot_id=0, p0=p0, final_target=final_target) - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) - from utama_core.motion_planning.src.trajsampling.planner import ( + from utama_core.motion_planning.trajsampling.planner import ( _N_NEAR_LAST_JITTER, _NEAR_LAST_JITTER_STEP_RAD, ) @@ -896,7 +893,7 @@ def test_collision_leniency_accepts_a_far_collision_when_priority_blocking_disab unchanged -- a fast collision with real braking distance left is still rejected even with priority disabled. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -1041,7 +1038,7 @@ def test_with_current_clearance_excludes_an_obstacle_the_robot_is_still_escaping penetrated obstacle must NOT be reported as nearest -- the clear one must win instead. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -1069,7 +1066,7 @@ def test_with_current_clearance_still_reports_a_genuinely_approaching_obstacle() only ever exclude an obstacle the robot is already inside, never a genuinely approaching one that the emergency brake still needs to see. """ - from utama_core.motion_planning.src.trajsampling.config import ( + from utama_core.motion_planning.trajsampling.config import ( trajsamplingconfig as config, ) @@ -1132,7 +1129,7 @@ def test_enemy_obstacle_lateral_clearance_is_tube_not_inflated_sphere(): robot radius, not an inflated circle of radius (radius + r_dyn). A query point located laterally at y=0.35m from an opponent traveling along y=0 must have clearance equal to 0.35 - radius, without being encroached upon by r_dyn.""" - from utama_core.motion_planning.src.trajsampling.obstacles import EnemyRobotObstacle + from utama_core.motion_planning.trajsampling.obstacles import EnemyRobotObstacle obs = EnemyRobotObstacle( p0=(0.0, 0.0), @@ -1156,7 +1153,7 @@ def test_has_priority_role_aware_ball_carrier_and_fallback(): When neither has the ball, or game is None, falls back to ID-based tie breaking.""" from dataclasses import replace - from utama_core.motion_planning.src.trajsampling.planner import _has_priority + from utama_core.motion_planning.trajsampling.planner import _has_priority # Standalone (no game): higher ID wins assert _has_priority(2, 1, game=None) is True diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py b/utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py index 9ca743d5..cdfac6e1 100644 --- a/utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py +++ b/utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py @@ -7,13 +7,11 @@ from utama_core.config.enums import Mode from utama_core.config.robot_params import REAL_PARAMS, RSIM_PARAMS -from utama_core.motion_planning.src.controllers.trajsampling import ( +from utama_core.motion_planning.controllers.trajsampling import ( TrajectorySamplingController, ) -from utama_core.motion_planning.src.trajsampling.bang_bang import Trajectory2D -from utama_core.motion_planning.src.trajsampling.planner import ( - TrajectorySamplingPlanner, -) +from utama_core.motion_planning.trajsampling.bang_bang import Trajectory2D +from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot A_MAX, A_SIDEWAYS = 4.0, 1.8 diff --git a/utama_core/tests/motion_planning/multiple_robots_test.py b/utama_core/tests/motion_planning/multiple_robots_test.py index bd3b6261..50024a87 100644 --- a/utama_core/tests/motion_planning/multiple_robots_test.py +++ b/utama_core/tests/motion_planning/multiple_robots_test.py @@ -9,7 +9,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.run import StrategyRunner -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py b/utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py index 69637ce6..ea9d0217 100644 --- a/utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py +++ b/utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py @@ -6,7 +6,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.run import StrategyRunner -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/motion_planning/single_robot_static_obstacle_test.py b/utama_core/tests/motion_planning/single_robot_static_obstacle_test.py index 332ddd2a..4ff26d55 100644 --- a/utama_core/tests/motion_planning/single_robot_static_obstacle_test.py +++ b/utama_core/tests/motion_planning/single_robot_static_obstacle_test.py @@ -6,7 +6,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.run import StrategyRunner -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/motion_planning/standardized/harness.py b/utama_core/tests/motion_planning/standardized/harness.py index ff9569e5..24735d6f 100644 --- a/utama_core/tests/motion_planning/standardized/harness.py +++ b/utama_core/tests/motion_planning/standardized/harness.py @@ -17,7 +17,7 @@ from utama_core.entities.game import Game from utama_core.entities.game.robot import Robot from utama_core.run import StrategyRunner -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/motion_planning/test_fastpathplanner_cpp.py b/utama_core/tests/motion_planning/test_fastpathplanner_cpp.py index 5e10553f..83ac3bf1 100644 --- a/utama_core/tests/motion_planning/test_fastpathplanner_cpp.py +++ b/utama_core/tests/motion_planning/test_fastpathplanner_cpp.py @@ -16,10 +16,10 @@ import numpy as np import pytest -_fastpathplanner = pytest.importorskip("utama_core.motion_planning.src.fastpathplanning._fastpathplanner") +_fastpathplanner = pytest.importorskip("utama_core.motion_planning.fastpathplanning._fastpathplanner") -from utama_core.motion_planning.src.fastpathplanning import numba_kernels # noqa: E402 -from utama_core.motion_planning.src.fastpathplanning.planner import ( # noqa: E402 +from utama_core.motion_planning.fastpathplanning import numba_kernels # noqa: E402 +from utama_core.motion_planning.fastpathplanning.planner import ( # noqa: E402 HAS_CPP, FastPathPlanner, ) @@ -135,7 +135,7 @@ class DummyBounds: ) # Reference Python (with HAS_CPP=False) - import utama_core.motion_planning.src.fastpathplanning.planner as planner_mod + import utama_core.motion_planning.fastpathplanning.planner as planner_mod planner_mod.HAS_CPP = False try: diff --git a/utama_core/tests/motion_planning/test_fpp_ball_keep_out.py b/utama_core/tests/motion_planning/test_fpp_ball_keep_out.py index 414c4309..88347c41 100644 --- a/utama_core/tests/motion_planning/test_fpp_ball_keep_out.py +++ b/utama_core/tests/motion_planning/test_fpp_ball_keep_out.py @@ -23,7 +23,7 @@ from utama_core.entities.game.game_history import GameHistory from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner _BALL = (2.25, 0.0) diff --git a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py index 3079ec10..ed67ad36 100644 --- a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py +++ b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py @@ -18,7 +18,7 @@ from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.global_utils.math_utils import distance_point_to_segment -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot _BALL = (-3.747805, -2.497416) diff --git a/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py b/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py index cc7885db..798076a1 100644 --- a/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py +++ b/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py @@ -12,7 +12,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.global_utils.math_utils import distance_point_to_segment -from utama_core.motion_planning.src.fastpathplanning.planner import ( +from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _leaving, ) diff --git a/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py b/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py index ce3c0274..c6f089d8 100644 --- a/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py +++ b/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py @@ -13,7 +13,7 @@ from utama_core.config.field_params import FieldDimensions from utama_core.entities.data.vector import Vector2D -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot # The lab field: 3 m x 2.25 m (`examples/shooting_drill.py`'s FIELD). diff --git a/utama_core/tests/motion_planning/test_pid_approach.py b/utama_core/tests/motion_planning/test_pid_approach.py index 028e91a0..553f3809 100644 --- a/utama_core/tests/motion_planning/test_pid_approach.py +++ b/utama_core/tests/motion_planning/test_pid_approach.py @@ -3,8 +3,8 @@ import pytest from utama_core.entities.data.vector import Vector2D -from utama_core.motion_planning.src.pid.configs import TranslationPIDConfigs -from utama_core.motion_planning.src.pid.pid import TwoDPID +from utama_core.motion_planning.pid.configs import TranslationPIDConfigs +from utama_core.motion_planning.pid.pid import TwoDPID _ORIGIN = Vector2D(0.0, 0.0) _KP = 1.8 diff --git a/utama_core/tests/motion_planning/test_placement_near_enemy_box.py b/utama_core/tests/motion_planning/test_placement_near_enemy_box.py index 3887349c..17b989c5 100644 --- a/utama_core/tests/motion_planning/test_placement_near_enemy_box.py +++ b/utama_core/tests/motion_planning/test_placement_near_enemy_box.py @@ -19,10 +19,8 @@ from utama_core.entities.game.game_history import GameHistory from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner -from utama_core.motion_planning.src.trajsampling.planner import ( - TrajectorySamplingPlanner, -) +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner def _game(command: RefereeCommand, ball_gap_m: float) -> Game: diff --git a/utama_core/tests/motion_planning/test_pose_ahead.py b/utama_core/tests/motion_planning/test_pose_ahead.py index e9970ff9..0757093a 100644 --- a/utama_core/tests/motion_planning/test_pose_ahead.py +++ b/utama_core/tests/motion_planning/test_pose_ahead.py @@ -5,12 +5,9 @@ import pytest from utama_core.entities.data.vector import Vector2D -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.motion_planning.src.common.pose_ahead import ( - PoseAhead, - control_latency_s, -) -from utama_core.skills.src.utils.move_utils import move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.motion_planning.common.pose_ahead import PoseAhead, control_latency_s +from utama_core.skills.utils.move_utils import move from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot LATENCY = 0.08 diff --git a/utama_core/tests/receivers/referee_receiver_test.py b/utama_core/tests/receivers/referee_receiver_test.py index 7c92cbb7..50e29b71 100644 --- a/utama_core/tests/receivers/referee_receiver_test.py +++ b/utama_core/tests/receivers/referee_receiver_test.py @@ -4,9 +4,7 @@ from utama_core.data_processing.receivers import referee_receiver from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee def _packet() -> bytes: diff --git a/utama_core/tests/receivers/vision_receiver_unit_test.py b/utama_core/tests/receivers/vision_receiver_unit_test.py index ecdb5e10..4b99dab1 100644 --- a/utama_core/tests/receivers/vision_receiver_unit_test.py +++ b/utama_core/tests/receivers/vision_receiver_unit_test.py @@ -8,7 +8,7 @@ RawRobotData, VisionReceiver, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) diff --git a/utama_core/tests/referee/test_referee_unit.py b/utama_core/tests/referee/test_referee_unit.py index 8f471aee..6c143f4f 100644 --- a/utama_core/tests/referee/test_referee_unit.py +++ b/utama_core/tests/referee/test_referee_unit.py @@ -33,8 +33,8 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.motion_planning.src.common.pose_ahead import PoseAhead -from utama_core.skills.src.utils.move_utils import empty_command +from utama_core.motion_planning.common.pose_ahead import PoseAhead +from utama_core.skills.utils.move_utils import empty_command # --------------------------------------------------------------------------- # Helpers diff --git a/utama_core/tests/referee/wandering_strategy.py b/utama_core/tests/referee/wandering_strategy.py index 3bfe1668..a76ae3ab 100644 --- a/utama_core/tests/referee/wandering_strategy.py +++ b/utama_core/tests/referee/wandering_strategy.py @@ -18,8 +18,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.src.common.motion_controller import MotionController -from utama_core.skills.src.utils.move_utils import move +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.skills.utils.move_utils import move # Waypoints defined as fractions of the standard field half-dimensions # (half_length=4.5, half_width=3.0) so they scale correctly to any field. diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index dadd9d7d..d743e7e5 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -93,7 +93,7 @@ def c(ids): "utama_core/skills/aim.py": "def aim():\n return 0\n", "utama_core/tactics/defend.py": "class DefendTactic:\n pass\n", "utama_core/tactics/unused.py": 'class UnusedTactic:\n pass\n\n\nif __name__ == "__main__":\n print(1)\n', - "utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py": "import json\n", + "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py": "import json\n", } CONFIGS = ["a", "b", "c"] @@ -104,7 +104,7 @@ def repo(tmp_path: Path) -> Path: path = tmp_path / rel path.parent.mkdir(parents=True, exist_ok=True) path.write_text(text) - for pkg in ("utama_core/rsoccer_simulator", "utama_core/rsoccer_simulator/src"): + for pkg in ("utama_core/rsoccer_simulator", "utama_core/rsoccer_simulator"): (tmp_path / pkg / "__init__.py").write_text("") return tmp_path @@ -238,7 +238,7 @@ def test_a_compiled_planner_counts_for_the_players_that_load_it_and_not_the_base def test_the_rsim_subprocess_script_and_data_files_are_in_the_base(repo): - rel = "utama_core/rsoccer_simulator/src/Simulators/robosim/robosim_subprocess.py" + rel = "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py" assert _changed_after(repo, rel, "import json", "import json, struct") == {"base"} assert _changed_after(repo, "utama_core/profiles/sim.yaml", "speed: 1", "speed: 2") == {"base"} @@ -328,7 +328,7 @@ def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): # them isn't affected by them, and the one that does has them in its own closure. _RUNNER_ONLY_RESETS = { "utama_core.shared.pass_and_score_geometry", - "utama_core.skills.src.shielding", + "utama_core.skills.shielding", "utama_core.strategy.pickers", } @@ -356,7 +356,7 @@ def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): "utama_core.skills", # reset "utama_core.strategy", # reset }, - "utama_core.team_controller.src.controllers.real.real_robot_controller": {"utama_core.skills"}, # real only + "utama_core.team_controller.controllers.real.real_robot_controller": {"utama_core.skills"}, # real only "utama_core.tests.common.abstract_test_manager": {"utama_core.engine"}, # a type } @@ -412,14 +412,14 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "utama_core.bundle.archive", "utama_core.bundle.strategy_file", "utama_core.config.settings", - "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", + "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", ], "dynamic import": ["utama_core.strategy.catalog"], "module-level state": [ - "utama_core.motion_planning.src.fastpathplanning.planner", - "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", + "utama_core.motion_planning.fastpathplanning.planner", + "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", "utama_core.shared.pass_and_score_geometry", - "utama_core.skills.src.shielding", + "utama_core.skills.shielding", "utama_core.strategy.pickers", ], "opens files": [ @@ -433,12 +433,12 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "utama_core.replay.game_log_writer", "utama_core.replay.replay_writer", "utama_core.strategy.catalog", - "utama_core.team_controller.src.controllers.common.robot_profile", + "utama_core.team_controller.controllers.common.robot_profile", ], "subprocess": [ "utama_core.bundle.strategy_file", "utama_core.replay.game_log_writer", - "utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper", + "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", ], } diff --git a/utama_core/tests/replay/test_repro_summary.py b/utama_core/tests/replay/test_repro_summary.py index 08d4d69e..cbe69bc0 100644 --- a/utama_core/tests/replay/test_repro_summary.py +++ b/utama_core/tests/replay/test_repro_summary.py @@ -79,7 +79,7 @@ def test_format_caps_the_lines_and_counts_the_rest(): def test_resolve_sim_noise_uses_the_replays_own_settings_by_default(): - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise settings = SimNoise(seed=2, latency_s=(0.03, 0.15), kick_speed_sd=0.45).to_dict() noise, line = repro.resolve_sim_noise(None, {"settings": settings, "draw": {}}) @@ -109,7 +109,7 @@ def test_the_replays_stored_settings_redraw_the_same_robots(): """The repro's draw is `SimNoise.draw` on the stored settings, so with the same robot counts and time step it is the match's own draw: latency ticks and kick offsets per robot, exactly.""" from utama_core.config.settings import TIMESTEP - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise + from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise noise = SimNoise(seed=2, latency_s=(0.03, 0.15), kick_speed_offset_sd=0.2, max_accel=(1.5, 3.5)) counts = {"team_blue": 6, "team_yellow": 6} diff --git a/utama_core/tests/replay/test_scenario.py b/utama_core/tests/replay/test_scenario.py index 61a5877e..157d543f 100644 --- a/utama_core/tests/replay/test_scenario.py +++ b/utama_core/tests/replay/test_scenario.py @@ -19,7 +19,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.scenario import RobotState, Scenario, apply_scenario from utama_core.strategy.catalog import builder -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/replay/test_ssl_log.py b/utama_core/tests/replay/test_ssl_log.py index d26873aa..3d713e85 100644 --- a/utama_core/tests/replay/test_ssl_log.py +++ b/utama_core/tests/replay/test_ssl_log.py @@ -28,13 +28,11 @@ log_stem, read_records, ) -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_tracked_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_tracked_pb2 import ( TrackerWrapperPacket, ) diff --git a/utama_core/tests/replay/test_ssl_log_extras.py b/utama_core/tests/replay/test_ssl_log_extras.py index 284313ba..21d3f22f 100644 --- a/utama_core/tests/replay/test_ssl_log_extras.py +++ b/utama_core/tests/replay/test_ssl_log_extras.py @@ -24,16 +24,14 @@ _VisionRows, convert_log, ) -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) -from utama_core.team_controller.src.generated_code.ssl_vision_detection_tracked_pb2 import ( +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee +from utama_core.team_controller.generated_code.ssl_vision_detection_tracked_pb2 import ( KickedBall, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_tracked_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_tracked_pb2 import ( TrackerWrapperPacket, ) diff --git a/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py b/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py index b3f4d64f..9e08a5d3 100644 --- a/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py +++ b/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py @@ -14,8 +14,8 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise TICK = 1 / 60 FRONT = 0.1 # the ball's centre, this far in front of the robot's centre, is in the kicker diff --git a/utama_core/tests/rsoccer_simulator/test_render_overlay.py b/utama_core/tests/rsoccer_simulator/test_render_overlay.py index a4f32c5e..52faceaf 100644 --- a/utama_core/tests/rsoccer_simulator/test_render_overlay.py +++ b/utama_core/tests/rsoccer_simulator/test_render_overlay.py @@ -1,6 +1,6 @@ from unittest.mock import patch -from utama_core.rsoccer_simulator.src.Render.overlay import ( +from utama_core.rsoccer_simulator.Render.overlay import ( OverlayObject, OverlayType, RenderOverlay, diff --git a/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py b/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py index 9214f49e..889f604b 100644 --- a/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py +++ b/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.src.Simulators.robosim.robosim_wrapper import ( +from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( RSimSubprocessWrapper, ) @@ -131,9 +131,7 @@ def test_reused_sim_plays_exactly_as_a_fresh_one(monkeypatch): """With reuse on, closing a sim parks its subprocess and the next `acquire` hands it back with a new native world: a play after a different, messy play (ball kicked away, robots fast and turned, dribblers spinning) must be bit-identical to the same play in a fresh subprocess.""" - from utama_core.rsoccer_simulator.src.Simulators.robosim import ( - robosim_wrapper as rw, - ) + from utama_core.rsoccer_simulator.Simulators.robosim import robosim_wrapper as rw monkeypatch.setattr(rw, "_reuse_sims", True) monkeypatch.setattr(rw, "_idle_sims", {}) @@ -162,9 +160,7 @@ def test_reused_sim_plays_exactly_as_a_fresh_one(monkeypatch): def test_sim_whose_request_failed_is_not_parked_for_reuse(monkeypatch): """A request that failed part-way may have left the pipe out of step, so that sim is terminated.""" - from utama_core.rsoccer_simulator.src.Simulators.robosim import ( - robosim_wrapper as rw, - ) + from utama_core.rsoccer_simulator.Simulators.robosim import robosim_wrapper as rw monkeypatch.setattr(rw, "_reuse_sims", True) monkeypatch.setattr(rw, "_idle_sims", {}) diff --git a/utama_core/tests/rsoccer_simulator/test_sim_noise.py b/utama_core/tests/rsoccer_simulator/test_sim_noise.py index d7c765f2..4ab5b41b 100644 --- a/utama_core/tests/rsoccer_simulator/test_sim_noise.py +++ b/utama_core/tests/rsoccer_simulator/test_sim_noise.py @@ -3,9 +3,9 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.src.Utils.sim_noise import ( +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import ( CommandDelay, KickSpeedNoise, SimNoise, diff --git a/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py b/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py index 66566961..16eb75a5 100644 --- a/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py +++ b/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py @@ -11,9 +11,9 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.src.Entities import Robot -from utama_core.rsoccer_simulator.src.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.src.Utils.sim_noise import ( +from utama_core.rsoccer_simulator.Entities import Robot +from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.rsoccer_simulator.Utils.sim_noise import ( KickAngleNoise, MotionLimits, SimDraw, diff --git a/utama_core/tests/shared/test_defense_area_rules_off.py b/utama_core/tests/shared/test_defense_area_rules_off.py index 821f8339..c0e87ded 100644 --- a/utama_core/tests/shared/test_defense_area_rules_off.py +++ b/utama_core/tests/shared/test_defense_area_rules_off.py @@ -16,10 +16,8 @@ from utama_core.entities.game.game_history import GameHistory from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.fastpathplanning.planner import FastPathPlanner -from utama_core.motion_planning.src.trajsampling.planner import ( - TrajectorySamplingPlanner, -) +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner from utama_core.shared.pass_and_score_geometry import ( ball_in_enemy_defense_area, ball_in_own_defense_area, diff --git a/utama_core/tests/shared/test_pass_and_score_geometry.py b/utama_core/tests/shared/test_pass_and_score_geometry.py index 0b86a968..c3f4d2bf 100644 --- a/utama_core/tests/shared/test_pass_and_score_geometry.py +++ b/utama_core/tests/shared/test_pass_and_score_geometry.py @@ -17,9 +17,7 @@ from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.src.fastpathplanning.config import ( - fastpathplanningconfig, -) +from utama_core.motion_planning.fastpathplanning.config import fastpathplanningconfig from utama_core.shared.pass_and_score_geometry import ( _ACQUIRE_LATERAL_MAX, _DEFENSE_AREA_CLAMP_MARGIN, diff --git a/utama_core/tests/skills/test_defend_parameter.py b/utama_core/tests/skills/test_defend_parameter.py index 4b0e1a81..1e6dcbb8 100644 --- a/utama_core/tests/skills/test_defend_parameter.py +++ b/utama_core/tests/skills/test_defend_parameter.py @@ -3,7 +3,7 @@ import numpy as np import pytest -import utama_core.skills.src.defend_parameter as dp +import utama_core.skills.defend_parameter as dp from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.config.referee_constants import OWN_DEFENSE_AREA_STANDOFF_DISTANCE from utama_core.entities.data.vector import Vector2D, Vector3D diff --git a/utama_core/tests/skills/test_defense_utils.py b/utama_core/tests/skills/test_defense_utils.py index 77d207bc..2fe954c1 100644 --- a/utama_core/tests/skills/test_defense_utils.py +++ b/utama_core/tests/skills/test_defense_utils.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from utama_core.skills.src.utils.defense_utils import ( +from utama_core.skills.utils.defense_utils import ( DefenseGeometry, _defense_geometry, calculate_defense_area, diff --git a/utama_core/tests/skills/test_find_best_shot.py b/utama_core/tests/skills/test_find_best_shot.py index 1e72cca3..983265fa 100644 --- a/utama_core/tests/skills/test_find_best_shot.py +++ b/utama_core/tests/skills/test_find_best_shot.py @@ -6,15 +6,15 @@ from utama_core.entities.data.vector import Vector2D # Stub out heavy simulator dependency before importing the module under test -module = types.ModuleType("rsoccer_simulator.src.ssl.envs.standard_ssl") +module = types.ModuleType("rsoccer_simulator.ssl.envs.standard_ssl") module.SSLStandardEnv = object sys.modules.setdefault("rsoccer_simulator", types.ModuleType("rsoccer_simulator")) -sys.modules.setdefault("rsoccer_simulator.src", types.ModuleType("rsoccer_simulator.src")) -sys.modules.setdefault("rsoccer_simulator.src.ssl", types.ModuleType("rsoccer_simulator.src.ssl")) -sys.modules.setdefault("rsoccer_simulator.src.ssl.envs", types.ModuleType("rsoccer_simulator.src.ssl.envs")) -sys.modules["rsoccer_simulator.src.ssl.envs.standard_ssl"] = module +sys.modules.setdefault("rsoccer_simulator", types.ModuleType("rsoccer_simulator")) +sys.modules.setdefault("rsoccer_simulator.ssl", types.ModuleType("rsoccer_simulator.ssl")) +sys.modules.setdefault("rsoccer_simulator.ssl.envs", types.ModuleType("rsoccer_simulator.ssl.envs")) +sys.modules["rsoccer_simulator.ssl.envs.standard_ssl"] = module -import utama_core.skills.src.score_goal as sg # noqa: E402 +import utama_core.skills.score_goal as sg # noqa: E402 def test_candidate_stays_within_boundary_gap(monkeypatch): diff --git a/utama_core/tests/skills/test_go_to_ball.py b/utama_core/tests/skills/test_go_to_ball.py index 274fa8af..7c01c9da 100644 --- a/utama_core/tests/skills/test_go_to_ball.py +++ b/utama_core/tests/skills/test_go_to_ball.py @@ -8,9 +8,9 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.src.common.pose_ahead import PoseAhead +from utama_core.motion_planning.common.pose_ahead import PoseAhead from utama_core.shared.pass_and_score_geometry import enemy_defense_area_hold_point -from utama_core.skills.src.go_to_ball import ( +from utama_core.skills.go_to_ball import ( _APPROACH_OVERSHOOT_M, _DRIBBLE_OVERSHOOT_M, _RACE_ENEMY_RANGE_M, @@ -127,7 +127,7 @@ def test_chases_ball_directly_when_ball_is_not_in_enemy_defense_area(): @pytest.mark.parametrize("robot_xy", [(0.0, 0.0), (2.0, 1.0), (1.0, -1.5)]) def test_approaches_facing_the_ball(monkeypatch, robot_xy): """The kicker and dribbler are on the front: the robot faces the ball on its way in.""" - from utama_core.skills.src import go_to_ball as module + from utama_core.skills import go_to_ball as module captured = {} monkeypatch.setattr(module, "move", lambda **kwargs: captured.update(kwargs)) @@ -139,7 +139,7 @@ def test_approaches_facing_the_ball(monkeypatch, robot_xy): def _race_sprints(robot_x: float, enemy_x: float, monkeypatch, mode=Mode.RSIM, enemy_has_ball=False) -> bool: - from utama_core.skills.src import go_to_ball as module + from utama_core.skills import go_to_ball as module enemy = _robot(0, enemy_x, 0.0, False) enemy = dataclasses.replace(enemy, has_ball=enemy_has_ball) diff --git a/utama_core/tests/skills/test_goalkeep.py b/utama_core/tests/skills/test_goalkeep.py index 1ea6377e..25fd1f58 100644 --- a/utama_core/tests/skills/test_goalkeep.py +++ b/utama_core/tests/skills/test_goalkeep.py @@ -4,11 +4,11 @@ import numpy as np import pytest -import utama_core.skills.src.goalkeep as gk -import utama_core.skills.src.kick_upfield as ku +import utama_core.skills.goalkeep as gk +import utama_core.skills.kick_upfield as ku from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.entities.data.vector import Vector2D, Vector3D -from utama_core.skills.src.utils.defense_utils import ( +from utama_core.skills.utils.defense_utils import ( intersection_with_x_line, single_defender_stop_y, ) diff --git a/utama_core/tests/skills/test_man_mark.py b/utama_core/tests/skills/test_man_mark.py index 8703569a..a70ce459 100644 --- a/utama_core/tests/skills/test_man_mark.py +++ b/utama_core/tests/skills/test_man_mark.py @@ -2,7 +2,7 @@ import pytest -import utama_core.skills.src.man_mark as mm +import utama_core.skills.man_mark as mm from utama_core.entities.data.vector import Vector2D, Vector3D diff --git a/utama_core/tests/skills/test_move_utils.py b/utama_core/tests/skills/test_move_utils.py index bcfab63e..aba4acea 100644 --- a/utama_core/tests/skills/test_move_utils.py +++ b/utama_core/tests/skills/test_move_utils.py @@ -7,8 +7,8 @@ from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.src.common.pose_ahead import PoseAhead -from utama_core.skills.src.utils.move_utils import _sprint_velocity, move, turn_on_spot +from utama_core.motion_planning.common.pose_ahead import PoseAhead +from utama_core.skills.utils.move_utils import _sprint_velocity, move, turn_on_spot PIVOT_RADIUS = ROBOT_RADIUS + BALL_RADIUS @@ -221,10 +221,10 @@ def test_a_robot_that_loses_the_ball_ramps_from_the_carry_speed_it_was_sent(cont 0.3 m/s sent: ramping from the 1 m/s never sent lurched the real robot 0.9 m/s sideways (dribble_and_shoot, 2026-10-28).""" from utama_core.config.enums import Mode - from utama_core.motion_planning.src.controllers.fastpathplanning import ( + from utama_core.motion_planning.controllers.fastpathplanning import ( FastPathPlanningController, ) - from utama_core.motion_planning.src.controllers.pid_controller import PIDController + from utama_core.motion_planning.controllers.pid_controller import PIDController mc = {"fpp": FastPathPlanningController, "pid": PIDController}[controller](Mode.REAL) mc.pose_ahead = PoseAhead(0.0) diff --git a/utama_core/tests/skills/test_shielding.py b/utama_core/tests/skills/test_shielding.py index ce99dd54..6367c50f 100644 --- a/utama_core/tests/skills/test_shielding.py +++ b/utama_core/tests/skills/test_shielding.py @@ -1,11 +1,11 @@ -"""Tests for `utama_core.skills.src.shielding`, extracted out of `go_to_ball.py`.""" +"""Tests for `utama_core.skills.shielding`, extracted out of `go_to_ball.py`.""" import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.skills.src.shielding import ( +from utama_core.skills.shielding import ( _RELEASE_RANGE, COMMIT_RANGE, CONTEST_RANGE, diff --git a/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py b/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py index a3b065d9..2f2f8720 100644 --- a/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py +++ b/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py @@ -11,7 +11,7 @@ from utama_core.entities.game.field import FieldBounds from utama_core.run import StrategyRunner from utama_core.strategy.catalog import builder -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py b/utama_core/tests/strategy_runner/test_ball_placement_rsim.py index 556c5d22..1f8f1342 100644 --- a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py +++ b/utama_core/tests/strategy_runner/test_ball_placement_rsim.py @@ -59,7 +59,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.run.strategy_runner import StrategyRunner from utama_core.strategy.catalog import builder -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/strategy_runner/test_exp_ball.py b/utama_core/tests/strategy_runner/test_exp_ball.py index 3732fbfb..a4981919 100644 --- a/utama_core/tests/strategy_runner/test_exp_ball.py +++ b/utama_core/tests/strategy_runner/test_exp_ball.py @@ -16,7 +16,7 @@ from utama_core.entities.game.field import FieldBounds from utama_core.run.strategy_runner import StrategyRunner from utama_core.strategy.catalog import builder -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/strategy_runner/test_field_fence.py b/utama_core/tests/strategy_runner/test_field_fence.py index 58853c12..17e7b8e4 100644 --- a/utama_core/tests/strategy_runner/test_field_fence.py +++ b/utama_core/tests/strategy_runner/test_field_fence.py @@ -23,7 +23,7 @@ inner_edges, ) from utama_core.run.strategy_runner import StrategyRunner -from utama_core.team_controller.src.controllers.common.robot_profile import RobotProfile +from utama_core.team_controller.controllers.common.robot_profile import RobotProfile LEFT_HALF = FieldBounds(top_left=(-2.0, 1.5), bottom_right=(0.0, -1.5)) diff --git a/utama_core/tests/strategy_runner/test_kick_bend_wiring.py b/utama_core/tests/strategy_runner/test_kick_bend_wiring.py index c0d989a0..1eef2c3e 100644 --- a/utama_core/tests/strategy_runner/test_kick_bend_wiring.py +++ b/utama_core/tests/strategy_runner/test_kick_bend_wiring.py @@ -9,11 +9,11 @@ import pytest from utama_core.config.enums import Mode -from utama_core.motion_planning.src.controllers.fastpathplanning import ( +from utama_core.motion_planning.controllers.fastpathplanning import ( FastPathPlanningController, ) from utama_core.run.strategy_runner import StrategyRunner -from utama_core.team_controller.src.controllers.common.robot_profile import RobotProfile +from utama_core.team_controller.controllers.common.robot_profile import RobotProfile _PROFILES = {1: RobotProfile(kick_bend_deg_per_cm=4.7), 2: RobotProfile(), 3: RobotProfile(kick_bias_deg=2.3)} diff --git a/utama_core/tests/strategy_runner/test_match_state_reset.py b/utama_core/tests/strategy_runner/test_match_state_reset.py index b3674c32..363e5645 100644 --- a/utama_core/tests/strategy_runner/test_match_state_reset.py +++ b/utama_core/tests/strategy_runner/test_match_state_reset.py @@ -4,7 +4,7 @@ from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.run.strategy_runner import StrategyRunner from utama_core.shared import pass_and_score_geometry -from utama_core.skills.src import shielding +from utama_core.skills import shielding from utama_core.strategy.catalog import builder from utama_core.tests.shared.test_pass_and_score_geometry import _visual_game from utama_core.tests.skills.test_shielding import _shielding diff --git a/utama_core/tests/strategy_runner/test_referee_rsim.py b/utama_core/tests/strategy_runner/test_referee_rsim.py index 889e9507..e1be987b 100644 --- a/utama_core/tests/strategy_runner/test_referee_rsim.py +++ b/utama_core/tests/strategy_runner/test_referee_rsim.py @@ -52,12 +52,12 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.src.common.motion_controller import MotionController +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.run.strategy_runner import StrategyRunner -from utama_core.skills.src.go_to_ball import go_to_ball -from utama_core.skills.src.utils.move_utils import empty_command +from utama_core.skills.go_to_ball import go_to_ball +from utama_core.skills.utils.move_utils import empty_command from utama_core.strategy.catalog import builder -from utama_core.team_controller.src.controllers import AbstractSimController +from utama_core.team_controller.controllers import AbstractSimController from utama_core.tests.common.abstract_test_manager import ( AbstractTestManager, TestingStatus, diff --git a/utama_core/tests/strategy_runner/test_scenario_hooks.py b/utama_core/tests/strategy_runner/test_scenario_hooks.py index 8cf35255..a77658ed 100644 --- a/utama_core/tests/strategy_runner/test_scenario_hooks.py +++ b/utama_core/tests/strategy_runner/test_scenario_hooks.py @@ -3,7 +3,7 @@ from utama_core.custom_referee import CustomReferee from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.rsoccer_simulator.src.ssl import ssl_gym_base +from utama_core.rsoccer_simulator.ssl import ssl_gym_base from utama_core.run.strategy_runner import StrategyRunner diff --git a/utama_core/tests/strategy_runner/test_sim_pose_ahead.py b/utama_core/tests/strategy_runner/test_sim_pose_ahead.py index 18a4b3c6..8199899d 100644 --- a/utama_core/tests/strategy_runner/test_sim_pose_ahead.py +++ b/utama_core/tests/strategy_runner/test_sim_pose_ahead.py @@ -6,10 +6,10 @@ from utama_core.config.enums import Mode from utama_core.config.robot_params import REAL_PARAMS -from utama_core.motion_planning.src.controllers.fastpathplanning import ( +from utama_core.motion_planning.controllers.fastpathplanning import ( FastPathPlanningController, ) -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise +from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run.strategy_runner import StrategyRunner TEAM = SimpleNamespace(motion_controller=FastPathPlanningController) diff --git a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py b/utama_core/tests/strategy_runner/test_strategy_control_scheme.py index 9a730947..83a97d57 100644 --- a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py +++ b/utama_core/tests/strategy_runner/test_strategy_control_scheme.py @@ -5,7 +5,7 @@ import pytest from utama_core.engine.abstract_strategy import AbstractStrategy -from utama_core.motion_planning.src.controllers import ( +from utama_core.motion_planning.controllers import ( DWAController, FastPathPlanningController, PIDController, diff --git a/utama_core/tests/tools/test_field_check_tool.py b/utama_core/tests/tools/test_field_check_tool.py index 6581bdfa..089e1566 100644 --- a/utama_core/tests/tools/test_field_check_tool.py +++ b/utama_core/tests/tools/test_field_check_tool.py @@ -5,7 +5,7 @@ import importlib.util from pathlib import Path -from utama_core.team_controller.src.controllers.real import find_robots as fr +from utama_core.team_controller.controllers.real import find_robots as fr spec = importlib.util.spec_from_file_location( "field_check", Path(__file__).resolve().parents[3] / "tools" / "field_check.py" diff --git a/utama_core/tests/tools/test_trim_idle_log.py b/utama_core/tests/tools/test_trim_idle_log.py index bd363b8b..f6a68951 100644 --- a/utama_core/tests/tools/test_trim_idle_log.py +++ b/utama_core/tests/tools/test_trim_idle_log.py @@ -6,9 +6,7 @@ from tools.trim_idle_log import find_active_intervals, trim_log from utama_core.replay.game_log_writer import LOG_HEADER, REFEREE, RUN_INFO -from utama_core.team_controller.src.generated_code.ssl_gc_referee_message_pb2 import ( - Referee, -) +from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee def _write_synthetic_records(path: Path, records: list[tuple[int, int, bytes]]) -> None: diff --git a/utama_core/tests/tools/test_vision_check.py b/utama_core/tests/tools/test_vision_check.py index 20466e41..8dfae104 100644 --- a/utama_core/tests/tools/test_vision_check.py +++ b/utama_core/tests/tools/test_vision_check.py @@ -6,7 +6,7 @@ import time from pathlib import Path -from utama_core.team_controller.src.generated_code.ssl_vision_wrapper_pb2 import ( +from utama_core.team_controller.generated_code.ssl_vision_wrapper_pb2 import ( SSL_WrapperPacket, ) From 5fda00379b08bbb80e1b342316b6c9004cba60b8 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:19:25 +0000 Subject: [PATCH 36/59] structure: shared/ and global_utils/ become geometry/ Geometry helpers move into utama_core/geometry/ (the old shared/ package, __init__ included): - shared/pass_and_score_geometry.py, tolerance.py, field_scaling.py -> geometry/ - global_utils/math_utils.py -> geometry/math_utils.py Other global_utils modules go next to their users, not into geometry/: - global_utils/git_utils.py -> replay/git_utils.py (revision stamp, used by tools/) - global_utils/mapping_utils.py -> entities/game/mapping_utils.py (friendly/enemy to yellow/blue mapping; used by run/, replay/ and data_processing/, and entities/ is the one layer all of them already import, so it adds no import cycle) shared/ and global_utils/ are deleted. Tests: tests/shared/ and tests/global_utils/ move into tests/geometry/ (test_mapping_utils.py too, as one folder). Dotted and slash references updated across code, tools, examples, docs and agent skills, including the fingerprint PLAYER_SIDE entry for pass_and_score_geometry. docs/architecture.md graph nodes were renamed by hand; its edge counts are stale until tools/package_graph.py is rerun. Co-Authored-By: Claude Haiku --- AGENTS.md | 2 +- README.md | 4 +- docs/STRATEGY_DEVELOPMENT.md | 2 +- docs/architecture.md | 40 +++++++++---------- docs/roadmap.md | 4 +- examples/ball_trials.py | 2 +- examples/pass_receive.py | 6 +-- examples/passing_rally.py | 2 +- examples/save_and_counter.py | 4 +- examples/shooting_drill.py | 2 +- tools/motion_planning_benchmark.py | 2 +- utama_core/config/formations.py | 2 +- utama_core/custom_referee/actions.py | 6 +-- .../rules/ball_placement_interference_rule.py | 2 +- .../refiners/filters/kalman.py | 2 +- .../data_processing/refiners/position.py | 2 +- utama_core/engine/abstract_strategy.py | 5 +-- utama_core/engine/ball_release.py | 2 +- utama_core/engine/ball_roles.py | 2 +- .../game}/mapping_utils.py | 0 utama_core/{shared => geometry}/__init__.py | 0 .../{shared => geometry}/field_scaling.py | 0 .../{global_utils => geometry}/math_utils.py | 0 .../pass_and_score_geometry.py | 0 utama_core/{shared => geometry}/tolerance.py | 0 utama_core/global_utils/__init__.py | 1 - utama_core/motion_planning/dwa/planner.py | 2 +- .../fastpathplanning/planner.py | 2 +- utama_core/motion_planning/pid/pid.py | 2 +- utama_core/replay/fingerprint.py | 4 +- .../{global_utils => replay}/git_utils.py | 0 utama_core/replay/replay_player.py | 4 +- .../ssl/envs/standard_ssl.py | 6 +-- .../rsoccer_simulator/ssl/ssl_gym_base.py | 2 +- utama_core/run/strategy_runner.py | 8 ++-- utama_core/skills/go_to_ball.py | 4 +- utama_core/skills/goalkeep.py | 4 +- utama_core/skills/kick_upfield.py | 5 ++- utama_core/skills/score_goal.py | 4 +- utama_core/skills/utils/move_utils.py | 2 +- utama_core/tactics/_pass_and_score.py | 4 +- utama_core/tactics/block_shape.py | 2 +- utama_core/tactics/clear_ball.py | 8 ++-- utama_core/tactics/decoy_and_overload.py | 4 +- utama_core/tactics/defense.py | 2 +- utama_core/tactics/dribble.py | 2 +- utama_core/tactics/give_and_go.py | 2 +- utama_core/tactics/lead_and_support.py | 4 +- utama_core/tactics/pass_and_shoot.py | 8 ++-- utama_core/tactics/press_and_contain.py | 4 +- utama_core/tactics/shadow_and_mark.py | 2 +- utama_core/tactics/switch_of_play.py | 4 +- .../common/sim_controller_abstract.py | 2 +- .../tests/controller/test_sim_controller.py | 2 +- utama_core/tests/engine/test_ball_release.py | 2 +- utama_core/tests/engine/test_ball_roles.py | 2 +- .../tests/engine/test_give_and_go_tactic.py | 4 +- .../engine/test_lead_and_support_tactic.py | 2 +- .../engine/test_switch_of_play_tactic.py | 2 +- .../tests/examples/test_pass_receive.py | 2 +- .../tests/examples/test_passing_rally.py | 2 +- .../tests/examples/test_save_and_counter.py | 2 +- .../tests/examples/test_shooting_drill.py | 2 +- utama_core/tests/fixtures/exact_math.py | 2 +- .../tests/{shared => geometry}/__init__.py | 0 .../test_defense_area_rules_off.py | 6 +-- .../test_geometry_edge_cases.py | 4 +- .../test_mapping_utils.py | 2 +- .../test_math_utils.py | 4 +- .../test_pass_and_score_geometry.py | 10 ++--- .../{shared => geometry}/test_tolerance.py | 4 +- .../fastpathplanner_equivalence_test.py | 6 +-- .../fastpathplanner_fast_math_test.py | 2 +- .../test_fpp_inside_ball_keep_out.py | 2 +- .../test_fpp_pressed_against_robot.py | 2 +- utama_core/tests/referee/test_referee_unit.py | 8 ++-- utama_core/tests/replay/test_fingerprint.py | 6 +-- utama_core/tests/skills/test_go_to_ball.py | 2 +- .../strategy_runner/test_change_of_ends.py | 2 +- .../strategy_runner/test_grsim_sim_setup.py | 2 +- .../strategy_runner/test_match_state_reset.py | 4 +- .../strategy_runner/test_rsim_formations.py | 2 +- 82 files changed, 138 insertions(+), 145 deletions(-) rename utama_core/{global_utils => entities/game}/mapping_utils.py (100%) rename utama_core/{shared => geometry}/__init__.py (100%) rename utama_core/{shared => geometry}/field_scaling.py (100%) rename utama_core/{global_utils => geometry}/math_utils.py (100%) rename utama_core/{shared => geometry}/pass_and_score_geometry.py (100%) rename utama_core/{shared => geometry}/tolerance.py (100%) delete mode 100644 utama_core/global_utils/__init__.py rename utama_core/{global_utils => replay}/git_utils.py (100%) rename utama_core/tests/{shared => geometry}/__init__.py (100%) rename utama_core/tests/{shared => geometry}/test_defense_area_rules_off.py (98%) rename utama_core/tests/{shared => geometry}/test_geometry_edge_cases.py (99%) rename utama_core/tests/{global_utils => geometry}/test_mapping_utils.py (97%) rename utama_core/tests/{global_utils => geometry}/test_math_utils.py (98%) rename utama_core/tests/{shared => geometry}/test_pass_and_score_geometry.py (99%) rename utama_core/tests/{shared => geometry}/test_tolerance.py (98%) diff --git a/AGENTS.md b/AGENTS.md index a013fb81..ff4338f4 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -103,7 +103,7 @@ One term per thing; reuse these instead of coining new ones. `restart_outcomes`, `stuck_detector`, `render_window`, `render_clip`, `list_runs`). Imports `replay/`; `replay/` never imports it. - Everything else (`motion_planning/`, `rsoccer_simulator/`, `team_controller/`, - `data_processing/`, `entities/`, `global_utils/`) is infrastructure the strategy layer + `data_processing/`, `entities/`, `geometry/`) is infrastructure the strategy layer sits on top of. Writing a strategy rarely needs to change it, but it is the main work area for planner, simulator, vision and hardware work: see the Work areas table above. diff --git a/README.md b/README.md index 675ca347..8e3bbfa8 100644 --- a/README.md +++ b/README.md @@ -43,7 +43,7 @@ Coding agents: read [AGENTS.md](AGENTS.md) first (`CLAUDE.md` is a symlink to it Everything lives under `utama_core/`: - `strategy/`: the strategies (one module each, named after the strategy) -- `tactics/`, `skills/`, `shared/`: reusable tactics, per-robot skills, and geometry they share +- `tactics/`, `skills/`, `geometry/`: reusable tactics, per-robot skills, and the geometry they share - `engine/`: the tactic-kernel infrastructure (`Strategy`, `Tactic`, `TickContext`, `MatchLog`, referee overrides) - `custom_referee/`: the in-process referee (rules, state machine, restart positioning, profiles) - `motion_planning/`: path planning and motion control @@ -53,7 +53,7 @@ Everything lives under `utama_core/`: - `rsoccer_simulator/`: the Python simulator environment over the rSim physics fork in `vendor/rSim/` - `team_controller/`, `data_processing/`: vision, robot radio and referee input - `dashboard/`: the browser dashboard -- `entities/`, `config/`, `global_utils/`: data classes, settings and constants, utilities +- `entities/`, `config/`, `geometry/`: data classes, settings and constants, geometry helpers - `tests/`: all tests Scripts live in `tools/` (tournaments in `tools/evaluation/`) and `examples/`; see diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 50ae7629..8317da91 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -159,7 +159,7 @@ Lessons from bugs that recurred (mostly `SwitchOfPlayTactic`, `tactics/switch_of - **`go_to_point()` always faces the ball.** If orientation matters while stationary (facing a pass target), use `move()` with `target_oren`. Check every `go_to_point(` call site — fixing one doesn't fix the pattern. -- **`intercept_point()` (`shared/pass_and_score_geometry.py`) projects along the passer's +- **`intercept_point()` (`geometry/pass_and_score_geometry.py`) projects along the passer's current orientation,** not toward the receiver. A mis-facing passer sends the receiver to a nonsense point; it fails quietly and looks like a vague stall. - **Every path that sets `is_committed()` True needs a path back to False** — success, failure diff --git a/docs/architecture.md b/docs/architecture.md index 7e1f8ecd..61f69c82 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -95,11 +95,11 @@ flowchart LR p_analysis["analysis"] -->|11| p_entities["entities"] p_analysis["analysis"] -->|8| p_replay["replay"] p_analysis["analysis"] -->|1| p_rsoccer_simulator["rsoccer_simulator"] - p_config["config"] -->|1| p_global_utils["global_utils"] + p_config["config"] -->|1| p_geometry["geometry"] p_custom_referee["custom_referee"] -->|20| p_config["config"] p_custom_referee["custom_referee"] -->|48| p_entities["entities"] - p_custom_referee["custom_referee"] -->|2| p_global_utils["global_utils"] - p_custom_referee["custom_referee"] -->|1| p_shared["shared"] + p_custom_referee["custom_referee"] -->|2| p_geometry["geometry"] + p_custom_referee["custom_referee"] -->|1| p_geometry["geometry"] p_custom_referee["custom_referee"] -->|1| p_skills["skills"] p_dashboard["dashboard"] -->|1| p_analysis["analysis"] p_dashboard["dashboard"] -->|3| p_config["config"] @@ -109,58 +109,58 @@ flowchart LR p_dashboard["dashboard"] -->|2| p_replay["replay"] p_data_processing["data_processing"] -->|6| p_config["config"] p_data_processing["data_processing"] -->|26| p_entities["entities"] - p_data_processing["data_processing"] -->|2| p_global_utils["global_utils"] + p_data_processing["data_processing"] -->|2| p_geometry["geometry"] p_data_processing["data_processing"] -->|4| p_team_controller["team_controller"] p_engine["engine"] -->|3| p_config["config"] p_engine["engine"] -->|2| p_custom_referee["custom_referee"] p_engine["engine"] -->|17| p_entities["entities"] - p_engine["engine"] -->|1| p_global_utils["global_utils"] + p_engine["engine"] -->|1| p_geometry["geometry"] p_engine["engine"] -->|3| p_motion_planning["motion_planning"] p_engine["engine"] -->|1| p_rsoccer_simulator["rsoccer_simulator"] p_engine["engine"] -->|1| p_skills["skills"] p_engine["engine"] -->|1| p_tactics["tactics"] p_engine["engine"] -->|1| p_team_controller["team_controller"] p_entities["entities"] -->|1| p_config["config"] - p_global_utils["global_utils"] -->|1| p_config["config"] - p_global_utils["global_utils"] -->|2| p_entities["entities"] + p_geometry["geometry"] -->|1| p_config["config"] + p_geometry["geometry"] -->|2| p_entities["entities"] p_motion_planning["motion_planning"] -->|23| p_config["config"] p_motion_planning["motion_planning"] -->|23| p_entities["entities"] - p_motion_planning["motion_planning"] -->|3| p_global_utils["global_utils"] + p_motion_planning["motion_planning"] -->|3| p_geometry["geometry"] p_motion_planning["motion_planning"] -->|8| p_rsoccer_simulator["rsoccer_simulator"] p_replay["replay"] -->|6| p_config["config"] p_replay["replay"] -->|1| p_custom_referee["custom_referee"] p_replay["replay"] -->|1| p_data_processing["data_processing"] p_replay["replay"] -->|20| p_entities["entities"] - p_replay["replay"] -->|2| p_global_utils["global_utils"] + p_replay["replay"] -->|2| p_geometry["geometry"] p_replay["replay"] -->|5| p_rsoccer_simulator["rsoccer_simulator"] p_replay["replay"] -->|3| p_team_controller["team_controller"] p_rsoccer_simulator["rsoccer_simulator"] -->|4| p_config["config"] p_rsoccer_simulator["rsoccer_simulator"] -->|3| p_entities["entities"] - p_rsoccer_simulator["rsoccer_simulator"] -->|2| p_global_utils["global_utils"] + p_rsoccer_simulator["rsoccer_simulator"] -->|2| p_geometry["geometry"] p_run["run"] -->|8| p_config["config"] p_run["run"] -->|4| p_custom_referee["custom_referee"] p_run["run"] -->|4| p_data_processing["data_processing"] p_run["run"] -->|4| p_engine["engine"] p_run["run"] -->|12| p_entities["entities"] - p_run["run"] -->|2| p_global_utils["global_utils"] + p_run["run"] -->|2| p_geometry["geometry"] p_run["run"] -->|2| p_motion_planning["motion_planning"] p_run["run"] -->|2| p_replay["replay"] p_run["run"] -->|6| p_rsoccer_simulator["rsoccer_simulator"] - p_run["run"] -->|1| p_shared["shared"] + p_run["run"] -->|1| p_geometry["geometry"] p_run["run"] -->|1| p_skills["skills"] p_run["run"] -->|1| p_team_controller["team_controller"] p_run["run"] -->|1| p_tests["tests"] - p_shared["shared"] -->|3| p_config["config"] - p_shared["shared"] -->|4| p_entities["entities"] - p_shared["shared"] -->|1| p_motion_planning["motion_planning"] - p_shared["shared"] -->|1| p_skills["skills"] + p_geometry["geometry"] -->|3| p_config["config"] + p_geometry["geometry"] -->|4| p_entities["entities"] + p_geometry["geometry"] -->|1| p_motion_planning["motion_planning"] + p_geometry["geometry"] -->|1| p_skills["skills"] p_skills["skills"] -->|6| p_config["config"] p_skills["skills"] -->|2| p_data_processing["data_processing"] p_skills["skills"] -->|1| p_engine["engine"] p_skills["skills"] -->|26| p_entities["entities"] - p_skills["skills"] -->|2| p_global_utils["global_utils"] + p_skills["skills"] -->|2| p_geometry["geometry"] p_skills["skills"] -->|8| p_motion_planning["motion_planning"] - p_skills["skills"] -->|3| p_shared["shared"] + p_skills["skills"] -->|3| p_geometry["geometry"] p_strategy["strategy"] -->|65| p_engine["engine"] p_strategy["strategy"] -->|22| p_entities["entities"] p_strategy["strategy"] -->|23| p_motion_planning["motion_planning"] @@ -169,11 +169,11 @@ flowchart LR p_tactics["tactics"] -->|25| p_engine["engine"] p_tactics["tactics"] -->|40| p_entities["entities"] p_tactics["tactics"] -->|1| p_motion_planning["motion_planning"] - p_tactics["tactics"] -->|15| p_shared["shared"] + p_tactics["tactics"] -->|15| p_geometry["geometry"] p_tactics["tactics"] -->|36| p_skills["skills"] p_team_controller["team_controller"] -->|10| p_config["config"] p_team_controller["team_controller"] -->|7| p_entities["entities"] - p_team_controller["team_controller"] -->|1| p_global_utils["global_utils"] + p_team_controller["team_controller"] -->|1| p_geometry["geometry"] p_team_controller["team_controller"] -->|2| p_rsoccer_simulator["rsoccer_simulator"] p_team_controller["team_controller"] -->|1| p_skills["skills"] ``` diff --git a/docs/roadmap.md b/docs/roadmap.md index f98b391a..f2877b60 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -35,7 +35,7 @@ entry by its title, not its number. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. -- **Shared hysteresis helper** — `Sticky` in `shared/tolerance.py` (`fd87c7f6`), now used by `PassAndShootTactic`'s passer choice, `ClearBallTactic`'s target choice and `PressAndContainTactic`'s presser choice instead of per-site margins — `0ce4e2a2`. (`pickers.friendly_closer_to_ball` keeps its own tick-count hysteresis.) +- **Shared hysteresis helper** — `Sticky` in `geometry/tolerance.py` (`fd87c7f6`), now used by `PassAndShootTactic`'s passer choice, `ClearBallTactic`'s target choice and `PressAndContainTactic`'s presser choice instead of per-site margins — `0ce4e2a2`. (`pickers.friendly_closer_to_ball` keeps its own tick-count hysteresis.) ## Open @@ -122,7 +122,7 @@ entry by its title, not its number. - *Setup for role-based tactics* (passer/receiver, committed slots): which robot gets the ball, and in which phase. - *Rule constants:* tactics still copy limits (`CARRY_LIMIT_M` in - `shared/pass_and_score_geometry.py`) instead of importing them from the referee rules; + `geometry/pass_and_score_geometry.py`) instead of importing them from the referee rules; decide whether to share one source. Expect each failing tactic to be a real fix with its own regression test. diff --git a/examples/ball_trials.py b/examples/ball_trials.py index 259f1a16..c9c55c19 100644 --- a/examples/ball_trials.py +++ b/examples/ball_trials.py @@ -40,7 +40,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import FieldBounds, Game -from utama_core.shared.pass_and_score_geometry import kick_bend +from utama_core.geometry.pass_and_score_geometry import kick_bend from utama_core.skills.utils.move_utils import turn_on_spot CARRY_M = 0.5 # how far a carry goes diff --git a/examples/pass_receive.py b/examples/pass_receive.py index 0e8b6dca..b56aff28 100644 --- a/examples/pass_receive.py +++ b/examples/pass_receive.py @@ -80,9 +80,8 @@ from utama_core.entities.game import Game from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import detour_around_circle -from utama_core.run import StrategyRunner -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.math_utils import detour_around_circle +from utama_core.geometry.pass_and_score_geometry import ( ORIENTATION_TOLERANCE_RAD, ball_line_receive_point, clamp_outside_enemy_defense_area, @@ -92,6 +91,7 @@ kick_bend, oriented_towards, ) +from utama_core.run import StrategyRunner from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot from utama_core.tactics.scripted_moves import ScriptedMovesTactic diff --git a/examples/passing_rally.py b/examples/passing_rally.py index 12de1695..66f6c05c 100644 --- a/examples/passing_rally.py +++ b/examples/passing_rally.py @@ -49,8 +49,8 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.entities.game.robot import Robot +from utama_core.geometry.pass_and_score_geometry import clamp_to_field from utama_core.run import StrategyRunner -from utama_core.shared.pass_and_score_geometry import clamp_to_field # --------------------------------------------------------------------------- # Test-day configuration (the robots and the pass distance are pass_receive.py's) diff --git a/examples/save_and_counter.py b/examples/save_and_counter.py index eedea79d..3c53cbd5 100644 --- a/examples/save_and_counter.py +++ b/examples/save_and_counter.py @@ -63,12 +63,12 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.run import StrategyRunner -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( enemy_goal_line, has_ball, oriented_towards, ) +from utama_core.run import StrategyRunner from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.utils.move_utils import empty_command, move, turn_on_spot from utama_core.tactics._pass_and_score import FACE_GOAL_RAD diff --git a/examples/shooting_drill.py b/examples/shooting_drill.py index 4ec2dff9..7c44cc8e 100644 --- a/examples/shooting_drill.py +++ b/examples/shooting_drill.py @@ -82,8 +82,8 @@ from utama_core.engine.strategy import Strategy as KernelSchedulerStrategy from utama_core.engine.tactic import BaseTactic, TacticTag from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.geometry.pass_and_score_geometry import has_ball, oriented_towards from utama_core.run import StrategyRunner -from utama_core.shared.pass_and_score_geometry import has_ball, oriented_towards from utama_core.skills.utils.move_utils import kick, turn_on_spot from utama_core.tactics.defense import DefenseTactic from utama_core.tactics.give_and_go import GiveAndGoTactic diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index 760b70fb..2ae462b9 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -46,8 +46,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.global_utils.git_utils import git_revision from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.replay.git_utils import git_revision from utama_core.run import StrategyRunner from utama_core.skills.utils.move_utils import move from utama_core.team_controller.controllers import AbstractSimController diff --git a/utama_core/config/formations.py b/utama_core/config/formations.py index a53855b2..a8fbdf1f 100644 --- a/utama_core/config/formations.py +++ b/utama_core/config/formations.py @@ -6,7 +6,7 @@ from utama_core.config.field_params import FieldBounds from utama_core.config.physical_constants import MAX_ROBOTS, ROBOT_RADIUS -from utama_core.global_utils.math_utils import normalise_heading +from utama_core.geometry.math_utils import normalise_heading class FormationEntry(NamedTuple): diff --git a/utama_core/custom_referee/actions.py b/utama_core/custom_referee/actions.py index 4f44c935..043c68f4 100644 --- a/utama_core/custom_referee/actions.py +++ b/utama_core/custom_referee/actions.py @@ -27,11 +27,11 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import ( +from utama_core.geometry.math_utils import ( detour_around_circle, distance_point_to_segment, ) -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( enemy_goal_line, has_ball, kick_bend, @@ -39,7 +39,7 @@ oriented_towards, restart_support, ) -from utama_core.shared.tolerance import Sticky +from utama_core.geometry.tolerance import Sticky from utama_core.skills.man_mark import mark_target from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot diff --git a/utama_core/custom_referee/rules/ball_placement_interference_rule.py b/utama_core/custom_referee/rules/ball_placement_interference_rule.py index 01aa7b79..5ac9a1f2 100644 --- a/utama_core/custom_referee/rules/ball_placement_interference_rule.py +++ b/utama_core/custom_referee/rules/ball_placement_interference_rule.py @@ -30,7 +30,7 @@ from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import distance_point_to_segment +from utama_core.geometry.math_utils import distance_point_to_segment _BALL_PLACEMENT_COMMANDS = { RefereeCommand.BALL_PLACEMENT_YELLOW, diff --git a/utama_core/data_processing/refiners/filters/kalman.py b/utama_core/data_processing/refiners/filters/kalman.py index 431cdda8..6b9c266f 100644 --- a/utama_core/data_processing/refiners/filters/kalman.py +++ b/utama_core/data_processing/refiners/filters/kalman.py @@ -7,7 +7,7 @@ from utama_core.entities.data.vector import Vector3D from utama_core.entities.data.vision import VisionRobotData from utama_core.entities.game import Ball, Robot -from utama_core.global_utils.math_utils import deg_to_rad, normalise_heading +from utama_core.geometry.math_utils import deg_to_rad, normalise_heading # An unseen robot is carried on its velocity this long, then held where it is: one seen a few # times a second on the 2026-10-27 field test, carried on, ran off to 10^7 m at 7 m/s. diff --git a/utama_core/data_processing/refiners/position.py b/utama_core/data_processing/refiners/position.py index 164c2a51..e4c8a6d5 100644 --- a/utama_core/data_processing/refiners/position.py +++ b/utama_core/data_processing/refiners/position.py @@ -24,7 +24,7 @@ from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.data.vision import VisionBallData, VisionData, VisionRobotData from utama_core.entities.game import Ball, FieldBounds, GameFrame, Robot -from utama_core.global_utils.mapping_utils import map_friendly_enemy_to_colors +from utama_core.entities.game.mapping_utils import map_friendly_enemy_to_colors def _in_field_or_goal(x: float, y: float, dimensions: FieldDimensions) -> bool: diff --git a/utama_core/engine/abstract_strategy.py b/utama_core/engine/abstract_strategy.py index 5bd3f1e1..58fd003f 100644 --- a/utama_core/engine/abstract_strategy.py +++ b/utama_core/engine/abstract_strategy.py @@ -26,10 +26,7 @@ from utama_core.entities.game import Game from utama_core.entities.game.field import FieldBounds from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import ( - assert_contains, - assert_valid_bounding_box, -) +from utama_core.geometry.math_utils import assert_contains, assert_valid_bounding_box from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv from utama_core.skills.utils.move_utils import empty_command diff --git a/utama_core/engine/ball_release.py b/utama_core/engine/ball_release.py index 31c2bdc5..6cc36b2d 100644 --- a/utama_core/engine/ball_release.py +++ b/utama_core/engine/ball_release.py @@ -15,7 +15,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ANNOUNCE_PASS_RAD, RELEASE_LANE_CLEARANCE, open_teammate, diff --git a/utama_core/engine/ball_roles.py b/utama_core/engine/ball_roles.py index 882113ec..27eb0ee0 100644 --- a/utama_core/engine/ball_roles.py +++ b/utama_core/engine/ball_roles.py @@ -19,7 +19,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_line_receive_point, clamp_outside_enemy_defense_area, clamp_outside_own_defense_area, diff --git a/utama_core/global_utils/mapping_utils.py b/utama_core/entities/game/mapping_utils.py similarity index 100% rename from utama_core/global_utils/mapping_utils.py rename to utama_core/entities/game/mapping_utils.py diff --git a/utama_core/shared/__init__.py b/utama_core/geometry/__init__.py similarity index 100% rename from utama_core/shared/__init__.py rename to utama_core/geometry/__init__.py diff --git a/utama_core/shared/field_scaling.py b/utama_core/geometry/field_scaling.py similarity index 100% rename from utama_core/shared/field_scaling.py rename to utama_core/geometry/field_scaling.py diff --git a/utama_core/global_utils/math_utils.py b/utama_core/geometry/math_utils.py similarity index 100% rename from utama_core/global_utils/math_utils.py rename to utama_core/geometry/math_utils.py diff --git a/utama_core/shared/pass_and_score_geometry.py b/utama_core/geometry/pass_and_score_geometry.py similarity index 100% rename from utama_core/shared/pass_and_score_geometry.py rename to utama_core/geometry/pass_and_score_geometry.py diff --git a/utama_core/shared/tolerance.py b/utama_core/geometry/tolerance.py similarity index 100% rename from utama_core/shared/tolerance.py rename to utama_core/geometry/tolerance.py diff --git a/utama_core/global_utils/__init__.py b/utama_core/global_utils/__init__.py deleted file mode 100644 index 8b137891..00000000 --- a/utama_core/global_utils/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/utama_core/motion_planning/dwa/planner.py b/utama_core/motion_planning/dwa/planner.py index a338465f..25df6fbe 100644 --- a/utama_core/motion_planning/dwa/planner.py +++ b/utama_core/motion_planning/dwa/planner.py @@ -7,7 +7,7 @@ from utama_core.config.settings import TIMESTEP from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game, Robot -from utama_core.global_utils.math_utils import normalise_heading +from utama_core.geometry.math_utils import normalise_heading from utama_core.motion_planning.dwa.config import DynamicWindowConfig from utama_core.motion_planning.planning.geometry import ( AxisAlignedRectangle, diff --git a/utama_core/motion_planning/fastpathplanning/planner.py b/utama_core/motion_planning/fastpathplanning/planner.py index 70fae825..c52ee2ea 100644 --- a/utama_core/motion_planning/fastpathplanning/planner.py +++ b/utama_core/motion_planning/fastpathplanning/planner.py @@ -12,7 +12,7 @@ from utama_core.entities.game import Game from utama_core.entities.game.field import FieldBounds from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import ( +from utama_core.geometry.math_utils import ( closest_point_on_segment, detour_around_circle, distance, diff --git a/utama_core/motion_planning/pid/pid.py b/utama_core/motion_planning/pid/pid.py index eb8a7493..3604e84c 100644 --- a/utama_core/motion_planning/pid/pid.py +++ b/utama_core/motion_planning/pid/pid.py @@ -3,7 +3,7 @@ from utama_core.config.enums import Mode from utama_core.entities.data.vector import Vector2D -from utama_core.global_utils.math_utils import normalise_heading +from utama_core.geometry.math_utils import normalise_heading from utama_core.motion_planning.pid.configs import ( OrientationPIDConfigs, TranslationPIDConfigs, diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index 9b5ae92c..4aa78765 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -54,7 +54,7 @@ "utama_core.skills", "utama_core.motion_planning", "utama_core.engine", - "utama_core.shared.pass_and_score_geometry", + "utama_core.geometry.pass_and_score_geometry", ) # The parts of those the match process runs itself, whoever plays: looking a strategy up, the base # class a `.strategy` file's proxy inherits, and the log and stats it writes. @@ -169,7 +169,7 @@ def _load(self, name: str) -> Optional[_Module]: mod = _Module(name, base.with_suffix(".py"), is_package=False) elif (base / "__init__.py").is_file(): mod = _Module(name, base / "__init__.py", is_package=True) - elif base.is_dir() and "." in name: # namespace package, e.g. utama_core/skills + elif base.is_dir() and "." in name: # namespace package, e.g. utama_core/motion_planning/common return _Module(name, None, is_package=True) else: return None diff --git a/utama_core/global_utils/git_utils.py b/utama_core/replay/git_utils.py similarity index 100% rename from utama_core/global_utils/git_utils.py rename to utama_core/replay/git_utils.py diff --git a/utama_core/replay/replay_player.py b/utama_core/replay/replay_player.py index ba97966f..39f962b3 100644 --- a/utama_core/replay/replay_player.py +++ b/utama_core/replay/replay_player.py @@ -12,8 +12,8 @@ from utama_core.entities.game import Ball as GameBall from utama_core.entities.game import Game, GameFrame from utama_core.entities.game import Robot as GameRobot -from utama_core.global_utils.mapping_utils import map_friendly_enemy_to_colors -from utama_core.global_utils.math_utils import rad_to_deg +from utama_core.entities.game.mapping_utils import map_friendly_enemy_to_colors +from utama_core.geometry.math_utils import rad_to_deg from utama_core.replay.entities import ReplayMetadata from utama_core.rsoccer_simulator.Entities import Ball as RSoccerBall from utama_core.rsoccer_simulator.Entities import Frame as RSoccerFrame diff --git a/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py b/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py index d0e580c0..08dcc940 100644 --- a/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py +++ b/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py @@ -16,11 +16,7 @@ from utama_core.entities.data.command import RobotResponse from utama_core.entities.data.raw_vision import RawBallData, RawRobotData, RawVisionData from utama_core.entities.data.referee import RefereeData -from utama_core.global_utils.math_utils import ( - deg_to_rad, - normalise_heading_deg, - rad_to_deg, -) +from utama_core.geometry.math_utils import deg_to_rad, normalise_heading_deg, rad_to_deg from utama_core.rsoccer_simulator.Entities import Ball, Frame, Robot from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv from utama_core.rsoccer_simulator.Utils import KDTree diff --git a/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py b/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py index b28cd618..4dc5e948 100644 --- a/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py +++ b/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py @@ -10,7 +10,7 @@ import numpy as np import pygame -from utama_core.global_utils.math_utils import rad_to_deg +from utama_core.geometry.math_utils import rad_to_deg from utama_core.rsoccer_simulator.Entities import Ball, Field, Frame, Robot from utama_core.rsoccer_simulator.Render import ( COLORS, diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 2ce21eeb..31982161 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -41,13 +41,14 @@ from utama_core.entities.data.raw_vision import RawVisionData from utama_core.entities.game import Game, GameFrame, GameHistory from utama_core.entities.game.field import Field, FieldBounds -from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.mapping_utils import ( +from utama_core.entities.game.mapping_utils import ( map_colors_to_friendly_enemy, map_friendly_enemy_to_colors, map_left_right_to_colors, ) -from utama_core.global_utils.math_utils import assert_valid_bounding_box +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.geometry.math_utils import assert_valid_bounding_box +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.motion_planning.common.control_schemes import get_control_scheme from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.replay.columnar_writer import ( @@ -74,7 +75,6 @@ ) from utama_core.run.vision_stream import GameFrameRenderer, RSimVisionStreamServer from utama_core.run.vision_stream_status import VisionStreamStatusMixin -from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.skills.shielding import reset_shield_state from utama_core.strategy.pickers import reset_closer_to_ball_state from utama_core.team_controller.controllers import ( diff --git a/utama_core/skills/go_to_ball.py b/utama_core/skills/go_to_ball.py index 50e00aa6..b1f283fe 100644 --- a/utama_core/skills/go_to_ball.py +++ b/utama_core/skills/go_to_ball.py @@ -42,13 +42,13 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_enemy_defense_area, ball_intercept_point, clamp_outside_own_defense_area, enemy_defense_area_hold_point, ) +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.skills.go_to_point import go_to_point from utama_core.skills.shielding import shielded_approach_angle from utama_core.skills.utils.move_utils import move diff --git a/utama_core/skills/goalkeep.py b/utama_core/skills/goalkeep.py index 4a680db7..e498d117 100644 --- a/utama_core/skills/goalkeep.py +++ b/utama_core/skills/goalkeep.py @@ -27,14 +27,14 @@ from utama_core.data_processing.predictors.position import predict_ball_pos_at_x from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ANNOUNCE_PASS_RAD, ball_in_own_defense_area, has_ball, open_teammate, oriented_towards, ) +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.skills.go_to_point import go_to_point from utama_core.skills.kick_upfield import kick_upfield from utama_core.skills.utils.defense_utils import ( diff --git a/utama_core/skills/kick_upfield.py b/utama_core/skills/kick_upfield.py index 967af83f..ce885d4f 100644 --- a/utama_core/skills/kick_upfield.py +++ b/utama_core/skills/kick_upfield.py @@ -8,8 +8,11 @@ """ from utama_core.entities.game import Game +from utama_core.geometry.pass_and_score_geometry import ( + oriented_towards, + upfield_heading, +) from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import oriented_towards, upfield_heading from utama_core.skills.utils.move_utils import kick, turn_on_spot # A clearance only has to go upfield, not along a line: kick within ~11 degrees of it. With the diff --git a/utama_core/skills/score_goal.py b/utama_core/skills/score_goal.py index 9a893e10..d4c7db97 100644 --- a/utama_core/skills/score_goal.py +++ b/utama_core/skills/score_goal.py @@ -20,9 +20,7 @@ from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game, Robot -from utama_core.global_utils.math_utils import ( - angle_between_points as _angle_between_points, -) +from utama_core.geometry.math_utils import angle_between_points as _angle_between_points logger = logging.getLogger(__name__) diff --git a/utama_core/skills/utils/move_utils.py b/utama_core/skills/utils/move_utils.py index 5db3e54f..dcd2add5 100644 --- a/utama_core/skills/utils/move_utils.py +++ b/utama_core/skills/utils/move_utils.py @@ -7,7 +7,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.global_utils.math_utils import normalise_heading, rotate_vector +from utama_core.geometry.math_utils import normalise_heading, rotate_vector from utama_core.motion_planning.common.motion_controller import MotionController # Off its target orientation by more than this, a robot turns at least `MotionController.min_turn`. diff --git a/utama_core/tactics/_pass_and_score.py b/utama_core/tactics/_pass_and_score.py index bf1fc0fb..5e8fd518 100644 --- a/utama_core/tactics/_pass_and_score.py +++ b/utama_core/tactics/_pass_and_score.py @@ -22,8 +22,8 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.field_scaling import scale_point_from_standard_field -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.field_scaling import scale_point_from_standard_field +from utama_core.geometry.pass_and_score_geometry import ( ANNOUNCE_PASS_RAD, at_target, ball_line_receive_point, diff --git a/utama_core/tactics/block_shape.py b/utama_core/tactics/block_shape.py index 819b846a..fde95b2a 100644 --- a/utama_core/tactics/block_shape.py +++ b/utama_core/tactics/block_shape.py @@ -46,7 +46,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_own_defense_area, ball_is_loose, ) diff --git a/utama_core/tactics/clear_ball.py b/utama_core/tactics/clear_ball.py index 779dab4f..f34e5cf6 100644 --- a/utama_core/tactics/clear_ball.py +++ b/utama_core/tactics/clear_ball.py @@ -46,7 +46,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_own_defense_area, clamp_outside_own_defense_area, enemy_positions, @@ -55,7 +55,7 @@ own_defense_area_exit_point, segment_clearance, ) -from utama_core.shared.tolerance import Sticky +from utama_core.geometry.tolerance import Sticky from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.go_to_point import go_to_point from utama_core.skills.utils.move_utils import kick, turn_on_spot @@ -136,13 +136,13 @@ def _clearance_candidates(game: Game, ball_p: Vector2D) -> list[Vector2D]: def _best_clear_target(game: Game, ball_p: Vector2D, prev_target: Optional[Vector2D]) -> Vector2D: """Openest upfield lane, with hysteresis toward the previous choice. - Uses `shared.tolerance.Sticky` — this function (along with + Uses `geometry.tolerance.Sticky` — this function (along with `pass_and_shoot.assign_passer_receiver`) is the real-world shape `Sticky` was designed to fit: a fixed candidate set scored fresh each tick, sticking with the incumbent unless a challenger clears a margin. Confirmed behaviour-identical to the previous hand-rolled fold via `test_sticky_matches_hand_rolled_margin_logic_seeded_random` - (`tests/shared/test_tolerance.py`), 300 seeded-random candidate sets, + (`tests/geometry/test_tolerance.py`), 300 seeded-random candidate sets, zero mismatches. """ enemies = enemy_positions(game) diff --git a/utama_core/tactics/decoy_and_overload.py b/utama_core/tactics/decoy_and_overload.py index e786ef36..44d35c75 100644 --- a/utama_core/tactics/decoy_and_overload.py +++ b/utama_core/tactics/decoy_and_overload.py @@ -39,7 +39,7 @@ Reuses `_pass_and_score`'s `_pass_exec`/`_score_goal` for the mechanics of the pass/shot (generic two-robot ball transfer and shot-taking, not specific to any one tactic's phase sequence — same reuse rationale `GiveAndGoTactic` -gives), and `go_to_point`/`shared.pass_and_score_geometry` for movement and +gives), and `go_to_point`/`geometry.pass_and_score_geometry` for movement and shot-lane checks. What's new is only the lure decision and the dragged-marker detection layered on top. @@ -61,7 +61,7 @@ from utama_core.entities.data.object import ObjectType, TeamType from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( carry_exhausted, carry_origin, clamp_outside_enemy_defense_area, diff --git a/utama_core/tactics/defense.py b/utama_core/tactics/defense.py index d1ee13f0..5b264035 100644 --- a/utama_core/tactics/defense.py +++ b/utama_core/tactics/defense.py @@ -50,7 +50,7 @@ from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag from utama_core.entities.data.command import RobotCommand from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_own_defense_area, ball_is_loose, has_ball, diff --git a/utama_core/tactics/dribble.py b/utama_core/tactics/dribble.py index 6d63439a..3db5cd61 100644 --- a/utama_core/tactics/dribble.py +++ b/utama_core/tactics/dribble.py @@ -21,7 +21,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import at_target, has_ball +from utama_core.geometry.pass_and_score_geometry import at_target, has_ball from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.utils.move_utils import empty_command, move diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index e10e8494..5c6d8694 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -46,7 +46,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( MIN_OPEN_TEAMMATE_M, ball_in_own_defense_area, ball_line_receive_point, diff --git a/utama_core/tactics/lead_and_support.py b/utama_core/tactics/lead_and_support.py index 5aaba85b..42aada6f 100644 --- a/utama_core/tactics/lead_and_support.py +++ b/utama_core/tactics/lead_and_support.py @@ -8,7 +8,7 @@ when a lane opens, or pass to the best-scoring support point), every other assigned robot continuously re-picks the best open support point on the attacking half. Reuses existing skill/geometry primitives -(`go_to_ball`/`go_to_point`/`move`, and `shared/pass_and_score_geometry`'s +(`go_to_ball`/`go_to_point`/`move`, and `geometry/pass_and_score_geometry`'s shot-finding and pass-scoring functions) — the primitives are fundamental motion/geometry, not tactical decisions, so they were kept rather than reinvented. @@ -34,7 +34,7 @@ from utama_core.entities.data.object import TeamType from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( clamp_outside_enemy_defense_area, enemy_goal_line, enemy_positions, diff --git a/utama_core/tactics/pass_and_shoot.py b/utama_core/tactics/pass_and_shoot.py index 1cf12d0a..1a937ce4 100644 --- a/utama_core/tactics/pass_and_shoot.py +++ b/utama_core/tactics/pass_and_shoot.py @@ -35,8 +35,8 @@ from utama_core.entities.data.object import TeamType from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import carry_exhausted, carry_origin -from utama_core.shared.tolerance import Sticky +from utama_core.geometry.pass_and_score_geometry import carry_exhausted, carry_origin +from utama_core.geometry.tolerance import Sticky from utama_core.tactics._pass_and_score import ( PassAndScoreMem, _pass_exec, @@ -65,13 +65,13 @@ def assign_passer_receiver( over. Keep the previous passer unless the other robot is closer by a real margin, not just nominally closer. - Uses `shared.tolerance.Sticky` (score = negative distance, so "closer" + Uses `geometry.tolerance.Sticky` (score = negative distance, so "closer" maximizes the score the same way `Sticky` expects everywhere else it's used) — confirmed behaviour-identical to the previous hand-rolled `distances[prev_receiver] + margin >= distances[prev_passer]` check via a seeded-random equivalence probe (500 random distance pairs, 0 mismatches; see `test_sticky_matches_pass_and_shoot_margin_logic` in - `tests/shared/test_tolerance.py`). + `tests/geometry/test_tolerance.py`). """ ball_pos = game.ball.p.to_2d() distances = { diff --git a/utama_core/tactics/press_and_contain.py b/utama_core/tactics/press_and_contain.py index abc93dce..4266e9f2 100644 --- a/utama_core/tactics/press_and_contain.py +++ b/utama_core/tactics/press_and_contain.py @@ -31,12 +31,12 @@ from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag from utama_core.entities.data.command import RobotCommand from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_own_defense_area, has_ball, own_defense_area_exit_point, ) -from utama_core.shared.tolerance import Sticky +from utama_core.geometry.tolerance import Sticky from utama_core.skills.block import block_attacker from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.go_to_point import go_to_point diff --git a/utama_core/tactics/shadow_and_mark.py b/utama_core/tactics/shadow_and_mark.py index bbb2544c..6a8d73a1 100644 --- a/utama_core/tactics/shadow_and_mark.py +++ b/utama_core/tactics/shadow_and_mark.py @@ -40,7 +40,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_own_defense_area, ball_is_loose, has_ball, diff --git a/utama_core/tactics/switch_of_play.py b/utama_core/tactics/switch_of_play.py index ebdcdbfb..49df210e 100644 --- a/utama_core/tactics/switch_of_play.py +++ b/utama_core/tactics/switch_of_play.py @@ -40,7 +40,7 @@ Reuses `_pass_and_score`'s `_pass_exec`/`_score_goal` for the two legs of the relay and the final shot (generic two-robot ball transfer / shot-taking, same reuse rationale every other attack tactic here gives), and -`shared/pass_and_score_geometry` for the weak-side read and shot check. What's +`geometry/pass_and_score_geometry` for the weak-side read and shot check. What's new is only the weak-side decision, the pivot/runner positioning, and the 3-leg phase sequence layered on top. @@ -64,7 +64,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import Game -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( at_target, ball_line_receive_point, enemy_goal_line, diff --git a/utama_core/team_controller/controllers/common/sim_controller_abstract.py b/utama_core/team_controller/controllers/common/sim_controller_abstract.py index 2e00e832..a858cebb 100644 --- a/utama_core/team_controller/controllers/common/sim_controller_abstract.py +++ b/utama_core/team_controller/controllers/common/sim_controller_abstract.py @@ -2,7 +2,7 @@ from utama_core.config.settings import OFF_PITCH_OFFSET from utama_core.entities.game.field import FieldBounds -from utama_core.global_utils.math_utils import in_field_bounds +from utama_core.geometry.math_utils import in_field_bounds class AbstractSimController: diff --git a/utama_core/tests/controller/test_sim_controller.py b/utama_core/tests/controller/test_sim_controller.py index 79fd6e17..5ffd398e 100644 --- a/utama_core/tests/controller/test_sim_controller.py +++ b/utama_core/tests/controller/test_sim_controller.py @@ -281,7 +281,7 @@ def test_remove_ball_places_outside_field(self, ctrl): ctrl.remove_ball() x, y, _, _ = ctrl.teleport_ball_calls[0] # The removed position must be outside the controller's own field bounds - from utama_core.global_utils.math_utils import in_field_bounds + from utama_core.geometry.math_utils import in_field_bounds assert not in_field_bounds((x, y), ctrl.field_bounds) diff --git a/utama_core/tests/engine/test_ball_release.py b/utama_core/tests/engine/test_ball_release.py index 5beeba68..682b96b5 100644 --- a/utama_core/tests/engine/test_ball_release.py +++ b/utama_core/tests/engine/test_ball_release.py @@ -20,7 +20,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ANNOUNCE_PASS_RAD, MAX_OPEN_TEAMMATE_M, open_teammate, diff --git a/utama_core/tests/engine/test_ball_roles.py b/utama_core/tests/engine/test_ball_roles.py index a782b35a..3bc75229 100644 --- a/utama_core/tests/engine/test_ball_roles.py +++ b/utama_core/tests/engine/test_ball_roles.py @@ -18,7 +18,7 @@ from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( _DEEP_NEAR_LINE_M, _INTERCEPT_MIN_M, _PASS_ROLLING_MPS, diff --git a/utama_core/tests/engine/test_give_and_go_tactic.py b/utama_core/tests/engine/test_give_and_go_tactic.py index bb9f1806..bf03dc93 100644 --- a/utama_core/tests/engine/test_give_and_go_tactic.py +++ b/utama_core/tests/engine/test_give_and_go_tactic.py @@ -35,11 +35,11 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot -from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( MIN_OPEN_TEAMMATE_M, find_best_shot, ) +from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tactics.give_and_go import ( _FIRST_TOUCH_FORCE_SHOT_TICKS, _MAX_FIRST_TOUCH_TICKS, diff --git a/utama_core/tests/engine/test_lead_and_support_tactic.py b/utama_core/tests/engine/test_lead_and_support_tactic.py index bfa4772c..3d56561c 100644 --- a/utama_core/tests/engine/test_lead_and_support_tactic.py +++ b/utama_core/tests/engine/test_lead_and_support_tactic.py @@ -20,8 +20,8 @@ from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot +from utama_core.geometry.pass_and_score_geometry import enemy_defense_area_hold_point from utama_core.motion_planning.common.pose_ahead import PoseAhead -from utama_core.shared.pass_and_score_geometry import enemy_defense_area_hold_point from utama_core.tactics.lead_and_support import LeadAndSupportTactic diff --git a/utama_core/tests/engine/test_switch_of_play_tactic.py b/utama_core/tests/engine/test_switch_of_play_tactic.py index 8625dfd7..b969ad59 100644 --- a/utama_core/tests/engine/test_switch_of_play_tactic.py +++ b/utama_core/tests/engine/test_switch_of_play_tactic.py @@ -40,8 +40,8 @@ from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tactics.switch_of_play import ( _SETTLE_DEBOUNCE_TICKS, SwitchOfPlayMem, diff --git a/utama_core/tests/examples/test_pass_receive.py b/utama_core/tests/examples/test_pass_receive.py index 60d18ebe..22f836fd 100644 --- a/utama_core/tests/examples/test_pass_receive.py +++ b/utama_core/tests/examples/test_pass_receive.py @@ -10,7 +10,7 @@ import pytest -from utama_core.shared.pass_and_score_geometry import reset_possession_state +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot EXAMPLES = Path(__file__).resolve().parents[3] / "examples" diff --git a/utama_core/tests/examples/test_passing_rally.py b/utama_core/tests/examples/test_passing_rally.py index b63a29a3..00973f76 100644 --- a/utama_core/tests/examples/test_passing_rally.py +++ b/utama_core/tests/examples/test_passing_rally.py @@ -11,7 +11,7 @@ import pytest from utama_core.entities.data.vector import Vector2D -from utama_core.shared.pass_and_score_geometry import reset_possession_state +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot EXAMPLES = Path(__file__).resolve().parents[3] / "examples" diff --git a/utama_core/tests/examples/test_save_and_counter.py b/utama_core/tests/examples/test_save_and_counter.py index 53896cf3..0f9cf06d 100644 --- a/utama_core/tests/examples/test_save_and_counter.py +++ b/utama_core/tests/examples/test_save_and_counter.py @@ -12,8 +12,8 @@ from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.motion_planning.common.pose_ahead import PoseAhead -from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot EXAMPLES = Path(__file__).resolve().parents[3] / "examples" diff --git a/utama_core/tests/examples/test_shooting_drill.py b/utama_core/tests/examples/test_shooting_drill.py index 03294075..3a2ac103 100644 --- a/utama_core/tests/examples/test_shooting_drill.py +++ b/utama_core/tests/examples/test_shooting_drill.py @@ -12,8 +12,8 @@ from utama_core.config.enums import Mode from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D +from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.shared.pass_and_score_geometry import reset_possession_state from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot EXAMPLES = Path(__file__).resolve().parents[3] / "examples" diff --git a/utama_core/tests/fixtures/exact_math.py b/utama_core/tests/fixtures/exact_math.py index b1789945..6c1cf9f3 100644 --- a/utama_core/tests/fixtures/exact_math.py +++ b/utama_core/tests/fixtures/exact_math.py @@ -8,7 +8,7 @@ """ from utama_core.data_processing.refiners.filters import kalman -from utama_core.global_utils import math_utils +from utama_core.geometry import math_utils from utama_core.motion_planning.fastpathplanning import planner from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner diff --git a/utama_core/tests/shared/__init__.py b/utama_core/tests/geometry/__init__.py similarity index 100% rename from utama_core/tests/shared/__init__.py rename to utama_core/tests/geometry/__init__.py diff --git a/utama_core/tests/shared/test_defense_area_rules_off.py b/utama_core/tests/geometry/test_defense_area_rules_off.py similarity index 98% rename from utama_core/tests/shared/test_defense_area_rules_off.py rename to utama_core/tests/geometry/test_defense_area_rules_off.py index c0e87ded..f173104b 100644 --- a/utama_core/tests/shared/test_defense_area_rules_off.py +++ b/utama_core/tests/geometry/test_defense_area_rules_off.py @@ -16,14 +16,14 @@ from utama_core.entities.game.game_history import GameHistory from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner -from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( ball_in_enemy_defense_area, ball_in_own_defense_area, clamp_outside_enemy_defense_area, clamp_outside_own_defense_area, ) +from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner +from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner # We are on the right: our box spans x >= 3.5, the opponent's x <= -3.5 (standard field). _ENEMY_BOX = Vector2D(-4.0, 0.0) diff --git a/utama_core/tests/shared/test_geometry_edge_cases.py b/utama_core/tests/geometry/test_geometry_edge_cases.py similarity index 99% rename from utama_core/tests/shared/test_geometry_edge_cases.py rename to utama_core/tests/geometry/test_geometry_edge_cases.py index 3fc73dd1..de6a91e9 100644 --- a/utama_core/tests/shared/test_geometry_edge_cases.py +++ b/utama_core/tests/geometry/test_geometry_edge_cases.py @@ -1,7 +1,7 @@ """Boundary-condition and randomized-invariant sweep over `pass_and_score_geometry`'s public functions. -Public functions in `utama_core/shared/pass_and_score_geometry.py` (`def`/`class` +Public functions in `utama_core/geometry/pass_and_score_geometry.py` (`def`/`class` not prefixed `_`, as of this writing): `reset_possession_state`, `has_ball`, `at_target`, `oriented_towards`, `clamp_to_field`, `intercept_point`, `enemy_positions`, `ball_is_loose`, `segment_clearance`, `segment_blocked`, @@ -59,7 +59,7 @@ from utama_core.entities.game.game import Game from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.game_history import GameHistory -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( at_target, ball_is_loose, clamp_to_field, diff --git a/utama_core/tests/global_utils/test_mapping_utils.py b/utama_core/tests/geometry/test_mapping_utils.py similarity index 97% rename from utama_core/tests/global_utils/test_mapping_utils.py rename to utama_core/tests/geometry/test_mapping_utils.py index 8d646817..4b3dec08 100644 --- a/utama_core/tests/global_utils/test_mapping_utils.py +++ b/utama_core/tests/geometry/test_mapping_utils.py @@ -1,6 +1,6 @@ import pytest -from utama_core.global_utils.mapping_utils import ( +from utama_core.entities.game.mapping_utils import ( map_friendly_enemy_to_colors, map_left_right_to_colors, ) diff --git a/utama_core/tests/global_utils/test_math_utils.py b/utama_core/tests/geometry/test_math_utils.py similarity index 98% rename from utama_core/tests/global_utils/test_math_utils.py rename to utama_core/tests/geometry/test_math_utils.py index 321bdad8..aaccf3b5 100644 --- a/utama_core/tests/global_utils/test_math_utils.py +++ b/utama_core/tests/geometry/test_math_utils.py @@ -5,7 +5,7 @@ from utama_core.entities.data.vector import Vector2D from utama_core.entities.game.field import FieldBounds -from utama_core.global_utils.math_utils import ( +from utama_core.geometry.math_utils import ( angle_between_points, assert_valid_bounding_box, compute_bounding_zone_from_points, @@ -220,7 +220,7 @@ def test_find_intersection_matches_numpy_version_bit_for_bit(): """Random crossing, missing, parallel, degenerate and endpoint-touching segments, as float64 arrays, int arrays and tuples: same None-ness and exactly the same point as the numpy implementation.""" - from utama_core.global_utils.math_utils import find_intersection + from utama_core.geometry.math_utils import find_intersection rng = np.random.default_rng(3) for _ in range(20000): diff --git a/utama_core/tests/shared/test_pass_and_score_geometry.py b/utama_core/tests/geometry/test_pass_and_score_geometry.py similarity index 99% rename from utama_core/tests/shared/test_pass_and_score_geometry.py rename to utama_core/tests/geometry/test_pass_and_score_geometry.py index c3f4d2bf..57e9d72f 100644 --- a/utama_core/tests/shared/test_pass_and_score_geometry.py +++ b/utama_core/tests/geometry/test_pass_and_score_geometry.py @@ -17,8 +17,7 @@ from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot -from utama_core.motion_planning.fastpathplanning.config import fastpathplanningconfig -from utama_core.shared.pass_and_score_geometry import ( +from utama_core.geometry.pass_and_score_geometry import ( _ACQUIRE_LATERAL_MAX, _DEFENSE_AREA_CLAMP_MARGIN, _GOAL_POST_SAFETY_MARGIN, @@ -45,6 +44,7 @@ score_pass_setup, shot_heading_reachable, ) +from utama_core.motion_planning.fastpathplanning.config import fastpathplanningconfig _FIELD = Field( my_team_is_right=True, field_dims=STANDARD_FIELD_DIMS, field_bounds=STANDARD_FIELD_DIMS.full_field_bounds @@ -702,7 +702,7 @@ def test_carry_origin_starts_at_pickup_and_clears_when_the_ball_is_dropped(): from types import SimpleNamespace from utama_core.entities.data.vector import Vector3D - from utama_core.shared.pass_and_score_geometry import ( + from utama_core.geometry.pass_and_score_geometry import ( CARRY_LIMIT_M, carry_exhausted, carry_origin, @@ -733,7 +733,7 @@ def test_carry_exhausted_counts_the_distance_needed_to_stop(): from types import SimpleNamespace from utama_core.entities.data.vector import Vector2D, Vector3D - from utama_core.shared.pass_and_score_geometry import carry_exhausted + from utama_core.geometry.pass_and_score_geometry import carry_exhausted origin = Vector2D(0.0, 0.0) moving = SimpleNamespace(ball=SimpleNamespace(p=Vector3D(0.5, 0.0, 0.0), v=Vector3D(1.6, 0.0, 0.0))) @@ -756,7 +756,7 @@ def test_carry_exhausted_counts_the_reaction_time_before_braking(): from types import SimpleNamespace from utama_core.entities.data.vector import Vector2D, Vector3D - from utama_core.shared.pass_and_score_geometry import carry_exhausted + from utama_core.geometry.pass_and_score_geometry import carry_exhausted origin = Vector2D(0.0, 0.0) lure = SimpleNamespace(ball=SimpleNamespace(p=Vector3D(0.5, 0.0, 0.0), v=Vector3D(1.2, 0.0, 0.0))) diff --git a/utama_core/tests/shared/test_tolerance.py b/utama_core/tests/geometry/test_tolerance.py similarity index 98% rename from utama_core/tests/shared/test_tolerance.py rename to utama_core/tests/geometry/test_tolerance.py index 319ae711..70a281d2 100644 --- a/utama_core/tests/shared/test_tolerance.py +++ b/utama_core/tests/geometry/test_tolerance.py @@ -1,4 +1,4 @@ -"""Boundary-condition tests for `utama_core.shared.tolerance`. +"""Boundary-condition tests for `utama_core.geometry.tolerance`. Every test here pins an exact boundary (at tolerance, just under/over it, a tie, an empty list, a vanished previous choice) rather than exercising happy @@ -11,7 +11,7 @@ import pytest from utama_core.entities.data.vector import Vector2D -from utama_core.shared.tolerance import Sticky, approx_eq +from utama_core.geometry.tolerance import Sticky, approx_eq # --------------------------------------------------------------------------- # approx_eq — scalars diff --git a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py b/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py index 044fc0dd..087c4656 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py @@ -19,11 +19,11 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.global_utils.math_utils import ( +from utama_core.geometry.math_utils import ( _closest_point_on_segment_numpy as closest_point_on_segment, ) -from utama_core.global_utils.math_utils import _distance_numpy as distance -from utama_core.global_utils.math_utils import ( +from utama_core.geometry.math_utils import _distance_numpy as distance +from utama_core.geometry.math_utils import ( distance_point_to_segment, find_intersection, rotate_vector, diff --git a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py b/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py index fc852c14..6132c97c 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py +++ b/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py @@ -10,7 +10,7 @@ import pytest from utama_core.data_processing.refiners.filters import kalman -from utama_core.global_utils import math_utils +from utama_core.geometry import math_utils from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _same_segment, diff --git a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py index ed67ad36..23c970be 100644 --- a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py +++ b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py @@ -17,7 +17,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS, FieldDimensions from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import distance_point_to_segment +from utama_core.geometry.math_utils import distance_point_to_segment from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot diff --git a/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py b/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py index 798076a1..83715a65 100644 --- a/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py +++ b/utama_core/tests/motion_planning/test_fpp_pressed_against_robot.py @@ -11,7 +11,7 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.global_utils.math_utils import distance_point_to_segment +from utama_core.geometry.math_utils import distance_point_to_segment from utama_core.motion_planning.fastpathplanning.planner import ( FastPathPlanner, _leaving, diff --git a/utama_core/tests/referee/test_referee_unit.py b/utama_core/tests/referee/test_referee_unit.py index 6c143f4f..3f70d8e3 100644 --- a/utama_core/tests/referee/test_referee_unit.py +++ b/utama_core/tests/referee/test_referee_unit.py @@ -465,7 +465,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri expected = referee_actions._clamp_to_field_or_ball(approach, game, ball_pos) # The placer starts on the designated side, so it routes round the ball to the # (clamped) approach point rather than straight at it. - from utama_core.global_utils.math_utils import detour_around_circle + from utama_core.geometry.math_utils import detour_around_circle expected = detour_around_circle(Vector2D(4.0, 0.0), expected, ball_pos, referee_actions._BALL_DETOUR_RADIUS_M) assert captured[0][1].x == pytest.approx(expected.x) @@ -866,7 +866,7 @@ class TestBallPlacementOursCarry: @pytest.fixture(autouse=True) def _fresh_possession_state(self): - from utama_core.shared.pass_and_score_geometry import reset_possession_state + from utama_core.geometry.pass_and_score_geometry import reset_possession_state reset_possession_state() yield @@ -2700,7 +2700,7 @@ class TestDetourAroundCircle: """`detour_around_circle`: robots crossing the ball's keep-out circle go round it.""" def _detour(self, start, target): - from utama_core.global_utils.math_utils import detour_around_circle + from utama_core.geometry.math_utils import detour_around_circle return detour_around_circle(Vector2D(*start), Vector2D(*target), Vector2D(0.0, 0.0), 0.8) @@ -2734,7 +2734,7 @@ def test_robot_between_ball_and_spot_is_sent_clear_of_both(self, monkeypatch, st from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE from utama_core.custom_referee import actions as referee_actions - from utama_core.global_utils.math_utils import distance_point_to_segment + from utama_core.geometry.math_utils import distance_point_to_segment captured = {} diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index d743e7e5..41cd12a5 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -327,7 +327,7 @@ def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): # Imported by the runner only to reset their per-match state, so a strategy that doesn't import # them isn't affected by them, and the one that does has them in its own closure. _RUNNER_ONLY_RESETS = { - "utama_core.shared.pass_and_score_geometry", + "utama_core.geometry.pass_and_score_geometry", "utama_core.skills.shielding", "utama_core.strategy.pickers", } @@ -352,7 +352,7 @@ def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): "utama_core.run.strategy_runner": { "utama_core.engine", "utama_core.motion_planning", # builds a controller; a file's process builds its own - "utama_core.shared.pass_and_score_geometry", # reset + "utama_core.geometry.pass_and_score_geometry", # reset "utama_core.skills", # reset "utama_core.strategy", # reset }, @@ -418,7 +418,7 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "module-level state": [ "utama_core.motion_planning.fastpathplanning.planner", "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", - "utama_core.shared.pass_and_score_geometry", + "utama_core.geometry.pass_and_score_geometry", "utama_core.skills.shielding", "utama_core.strategy.pickers", ], diff --git a/utama_core/tests/skills/test_go_to_ball.py b/utama_core/tests/skills/test_go_to_ball.py index 7c01c9da..d285a96e 100644 --- a/utama_core/tests/skills/test_go_to_ball.py +++ b/utama_core/tests/skills/test_go_to_ball.py @@ -8,8 +8,8 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, Field, Game, GameFrame, GameHistory, Robot +from utama_core.geometry.pass_and_score_geometry import enemy_defense_area_hold_point from utama_core.motion_planning.common.pose_ahead import PoseAhead -from utama_core.shared.pass_and_score_geometry import enemy_defense_area_hold_point from utama_core.skills.go_to_ball import ( _APPROACH_OVERSHOOT_M, _DRIBBLE_OVERSHOOT_M, diff --git a/utama_core/tests/strategy_runner/test_change_of_ends.py b/utama_core/tests/strategy_runner/test_change_of_ends.py index b64dc62e..8c2df333 100644 --- a/utama_core/tests/strategy_runner/test_change_of_ends.py +++ b/utama_core/tests/strategy_runner/test_change_of_ends.py @@ -15,7 +15,7 @@ from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.global_utils.math_utils import in_field_bounds +from utama_core.geometry.math_utils import in_field_bounds from utama_core.run import StrategyRunner from utama_core.run.strategy_runner import _turned from utama_core.strategy.catalog import builder diff --git a/utama_core/tests/strategy_runner/test_grsim_sim_setup.py b/utama_core/tests/strategy_runner/test_grsim_sim_setup.py index 575aa1d7..67229dc6 100644 --- a/utama_core/tests/strategy_runner/test_grsim_sim_setup.py +++ b/utama_core/tests/strategy_runner/test_grsim_sim_setup.py @@ -2,7 +2,7 @@ from utama_core.config.formations import get_formations from utama_core.entities.game.field import FieldBounds -from utama_core.global_utils.mapping_utils import ( +from utama_core.entities.game.mapping_utils import ( map_friendly_enemy_to_colors, map_left_right_to_colors, ) diff --git a/utama_core/tests/strategy_runner/test_match_state_reset.py b/utama_core/tests/strategy_runner/test_match_state_reset.py index 363e5645..d09f5979 100644 --- a/utama_core/tests/strategy_runner/test_match_state_reset.py +++ b/utama_core/tests/strategy_runner/test_match_state_reset.py @@ -2,11 +2,11 @@ must not inherit the last match's per-robot hysteresis.""" from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.geometry import pass_and_score_geometry from utama_core.run.strategy_runner import StrategyRunner -from utama_core.shared import pass_and_score_geometry from utama_core.skills import shielding from utama_core.strategy.catalog import builder -from utama_core.tests.shared.test_pass_and_score_geometry import _visual_game +from utama_core.tests.geometry.test_pass_and_score_geometry import _visual_game from utama_core.tests.skills.test_shielding import _shielding diff --git a/utama_core/tests/strategy_runner/test_rsim_formations.py b/utama_core/tests/strategy_runner/test_rsim_formations.py index 790ff2d3..b8a76e24 100644 --- a/utama_core/tests/strategy_runner/test_rsim_formations.py +++ b/utama_core/tests/strategy_runner/test_rsim_formations.py @@ -6,7 +6,7 @@ from utama_core.config.formations import get_formations from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.game.field import FieldBounds -from utama_core.global_utils.mapping_utils import map_left_right_to_colors +from utama_core.entities.game.mapping_utils import map_left_right_to_colors from utama_core.run.strategy_runner import StrategyRunner from utama_core.strategy.catalog import builder from utama_core.tests.common.abstract_test_manager import ( From b60af111d84b12cbdd1c0d04979603ee2fd10f7a Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:20:11 +0000 Subject: [PATCH 37/59] tests: test_mapping_utils next to its module in entities/ Co-Authored-By: Claude Opus 5.5 --- utama_core/tests/{geometry => entities}/test_mapping_utils.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename utama_core/tests/{geometry => entities}/test_mapping_utils.py (100%) diff --git a/utama_core/tests/geometry/test_mapping_utils.py b/utama_core/tests/entities/test_mapping_utils.py similarity index 100% rename from utama_core/tests/geometry/test_mapping_utils.py rename to utama_core/tests/entities/test_mapping_utils.py From a223b1e628cf6fcb1df94d5717c81188430fa983 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:22:24 +0000 Subject: [PATCH 38/59] tests: mirror the package names under utama_core/tests - controller/ -> team_controller/ - referee/ -> custom_referee/ (one __init__.py, kept in custom_referee/) - receivers/ and refiners/ -> data_processing/ - abstract_strategy/test_assertions.py -> engine/test_abstract_strategy_assertions.py - strategy_runner/ -> run/ - every *_test.py renamed to test_*.py (no basename clashes) Path and module references updated in docs, AGENTS.md, code comments and the tests that import helpers from the moved modules. Co-Authored-By: Claude Haiku 5.5 --- AGENTS.md | 4 ++-- docs/STRATEGY_DEVELOPMENT.md | 2 +- docs/custom_referee.md | 2 +- docs/roadmap.md | 6 +++--- examples/demo_exhibition_road.py | 2 +- .../motion_planning/fastpathplanning/planner.py | 4 ++-- utama_core/replay/scenario.py | 12 ++++++------ utama_core/team_controller/README.md | 2 +- .../tests/{referee => custom_referee}/referee_sim.py | 4 ++-- .../{referee => custom_referee}/test_referee_unit.py | 0 .../wandering_strategy.py | 0 .../one_camera_ball_repro.json | 0 .../test_camera_combiner.py} | 0 .../test_kalman.py} | 0 .../test_local_camera_consistency.py | 0 .../test_position_refiner_integration.py} | 0 .../test_position_unit.py} | 0 .../test_referee_receiver.py} | 0 .../test_robot_info.py} | 0 .../test_velocity.py} | 0 .../test_vision_receiver_integration.py} | 0 .../test_vision_receiver_unit.py} | 0 .../test_abstract_strategy_assertions.py} | 0 utama_core/tests/engine/test_all_tactics.py | 2 +- .../tests/engine/test_check_strategy_branch.py | 2 +- .../tests/engine/test_pass_and_score_pass_exec.py | 2 +- .../tests/motion_planning/_kernel_test_strategies.py | 2 +- ..._contract_test.py => test_controller_contract.py} | 0 ...ge_cases_test.py => test_bang_bang_edge_cases.py} | 4 ++-- ...oller_test.py => test_trajsampling_controller.py} | 0 ...ness_test.py => test_trajsampling_correctness.py} | 0 ...ideways_test.py => test_trajsampling_sideways.py} | 0 .../motion_planning/standardized/test_scenarios.py | 2 +- ...idance_test.py => test_defense_area_avoidance.py} | 0 ...corner_test.py => test_fastpathplanner_corner.py} | 0 ...e_test.py => test_fastpathplanner_equivalence.py} | 2 +- ...ath_test.py => test_fastpathplanner_fast_math.py} | 2 +- ...bgoal_test.py => test_fastpathplanner_subgoal.py} | 0 ....py => test_motion_planning_benchmark_figures.py} | 0 ...ltiple_robots_test.py => test_multiple_robots.py} | 0 ..._test.py => test_single_robot_moving_obstacle.py} | 0 ..._test.py => test_single_robot_static_obstacle.py} | 0 utama_core/tests/referee/__init__.py | 0 .../strat_runner_test_utils.py | 0 .../test_ball_placement_rsim.py | 2 +- .../{strategy_runner => run}/test_change_of_ends.py | 0 .../{strategy_runner => run}/test_close_releases.py | 0 .../{strategy_runner => run}/test_error_handling.py | 0 .../tests/{strategy_runner => run}/test_exp_ball.py | 2 +- .../{strategy_runner => run}/test_field_check.py | 0 .../{strategy_runner => run}/test_field_fence.py | 0 .../{strategy_runner => run}/test_frame_once.py | 0 .../test_frozen_field_watchdog.py | 0 .../{strategy_runner => run}/test_game_log_sides.py | 0 .../test_goalkeeper_stability.py | 0 .../{strategy_runner => run}/test_grsim_sim_setup.py | 2 +- .../test_kick_bend_wiring.py | 0 .../test_match_state_reset.py | 0 .../{strategy_runner => run}/test_referee_rsim.py | 0 .../test_replace_strategy.py | 0 .../test_robot_feedback_snapshot.py | 0 .../{strategy_runner => run}/test_rsim_formations.py | 0 .../test_rsim_render_bounds.py | 0 .../test_run_test_timeout.py | 0 .../test_runner_misconfig.py | 2 +- .../{strategy_runner => run}/test_scenario_hooks.py | 0 .../{strategy_runner => run}/test_sim_pose_ahead.py | 0 .../test_strategy_control_scheme.py | 2 +- .../test_teleport_position_accuracy.py} | 0 .../{strategy_runner => run}/test_teleport_settle.py | 0 .../test_vision_stream_bad_frame.py | 0 .../{controller => team_controller}/__init__.py | 0 .../test_dribbler_limiter.py | 0 .../test_find_robots.py | 0 .../test_kicker_charge.py | 0 .../test_robot_profile.py | 0 .../test_sim_controller.py | 0 77 files changed, 33 insertions(+), 33 deletions(-) rename utama_core/tests/{referee => custom_referee}/referee_sim.py (97%) rename utama_core/tests/{referee => custom_referee}/test_referee_unit.py (100%) rename utama_core/tests/{referee => custom_referee}/wandering_strategy.py (100%) rename utama_core/tests/{refiners => data_processing}/one_camera_ball_repro.json (100%) rename utama_core/tests/{refiners/camera_combiner_test.py => data_processing/test_camera_combiner.py} (100%) rename utama_core/tests/{refiners/kalman_test.py => data_processing/test_kalman.py} (100%) rename utama_core/tests/{refiners => data_processing}/test_local_camera_consistency.py (100%) rename utama_core/tests/{refiners/position_refiner_integration_test.py => data_processing/test_position_refiner_integration.py} (100%) rename utama_core/tests/{refiners/position_unit_test.py => data_processing/test_position_unit.py} (100%) rename utama_core/tests/{receivers/referee_receiver_test.py => data_processing/test_referee_receiver.py} (100%) rename utama_core/tests/{refiners/robot_info_test.py => data_processing/test_robot_info.py} (100%) rename utama_core/tests/{refiners/velocity_test.py => data_processing/test_velocity.py} (100%) rename utama_core/tests/{receivers/vision_receiver_integration_test.py => data_processing/test_vision_receiver_integration.py} (100%) rename utama_core/tests/{receivers/vision_receiver_unit_test.py => data_processing/test_vision_receiver_unit.py} (100%) rename utama_core/tests/{abstract_strategy/test_assertions.py => engine/test_abstract_strategy_assertions.py} (100%) rename utama_core/tests/motion_planning/contract/{controller_contract_test.py => test_controller_contract.py} (100%) rename utama_core/tests/motion_planning/implementation/{bang_bang_edge_cases_test.py => test_bang_bang_edge_cases.py} (99%) rename utama_core/tests/motion_planning/implementation/{trajsampling_controller_test.py => test_trajsampling_controller.py} (100%) rename utama_core/tests/motion_planning/implementation/{trajsampling_correctness_test.py => test_trajsampling_correctness.py} (100%) rename utama_core/tests/motion_planning/implementation/{trajsampling_sideways_test.py => test_trajsampling_sideways.py} (100%) rename utama_core/tests/motion_planning/{defense_area_avoidance_test.py => test_defense_area_avoidance.py} (100%) rename utama_core/tests/motion_planning/{fastpathplanner_corner_test.py => test_fastpathplanner_corner.py} (100%) rename utama_core/tests/motion_planning/{fastpathplanner_equivalence_test.py => test_fastpathplanner_equivalence.py} (99%) rename utama_core/tests/motion_planning/{fastpathplanner_fast_math_test.py => test_fastpathplanner_fast_math.py} (99%) rename utama_core/tests/motion_planning/{fastpathplanner_subgoal_test.py => test_fastpathplanner_subgoal.py} (100%) rename utama_core/tests/motion_planning/{motion_planning_benchmark_figures_test.py => test_motion_planning_benchmark_figures.py} (100%) rename utama_core/tests/motion_planning/{multiple_robots_test.py => test_multiple_robots.py} (100%) rename utama_core/tests/motion_planning/{single_robot_moving_obstacle_test.py => test_single_robot_moving_obstacle.py} (100%) rename utama_core/tests/motion_planning/{single_robot_static_obstacle_test.py => test_single_robot_static_obstacle.py} (100%) delete mode 100644 utama_core/tests/referee/__init__.py rename utama_core/tests/{strategy_runner => run}/strat_runner_test_utils.py (100%) rename utama_core/tests/{strategy_runner => run}/test_ball_placement_rsim.py (99%) rename utama_core/tests/{strategy_runner => run}/test_change_of_ends.py (100%) rename utama_core/tests/{strategy_runner => run}/test_close_releases.py (100%) rename utama_core/tests/{strategy_runner => run}/test_error_handling.py (100%) rename utama_core/tests/{strategy_runner => run}/test_exp_ball.py (99%) rename utama_core/tests/{strategy_runner => run}/test_field_check.py (100%) rename utama_core/tests/{strategy_runner => run}/test_field_fence.py (100%) rename utama_core/tests/{strategy_runner => run}/test_frame_once.py (100%) rename utama_core/tests/{strategy_runner => run}/test_frozen_field_watchdog.py (100%) rename utama_core/tests/{strategy_runner => run}/test_game_log_sides.py (100%) rename utama_core/tests/{strategy_runner => run}/test_goalkeeper_stability.py (100%) rename utama_core/tests/{strategy_runner => run}/test_grsim_sim_setup.py (98%) rename utama_core/tests/{strategy_runner => run}/test_kick_bend_wiring.py (100%) rename utama_core/tests/{strategy_runner => run}/test_match_state_reset.py (100%) rename utama_core/tests/{strategy_runner => run}/test_referee_rsim.py (100%) rename utama_core/tests/{strategy_runner => run}/test_replace_strategy.py (100%) rename utama_core/tests/{strategy_runner => run}/test_robot_feedback_snapshot.py (100%) rename utama_core/tests/{strategy_runner => run}/test_rsim_formations.py (100%) rename utama_core/tests/{strategy_runner => run}/test_rsim_render_bounds.py (100%) rename utama_core/tests/{strategy_runner => run}/test_run_test_timeout.py (100%) rename utama_core/tests/{strategy_runner => run}/test_runner_misconfig.py (99%) rename utama_core/tests/{strategy_runner => run}/test_scenario_hooks.py (100%) rename utama_core/tests/{strategy_runner => run}/test_sim_pose_ahead.py (100%) rename utama_core/tests/{strategy_runner => run}/test_strategy_control_scheme.py (98%) rename utama_core/tests/{strategy_runner/teleport_position_accuracy_test.py => run/test_teleport_position_accuracy.py} (100%) rename utama_core/tests/{strategy_runner => run}/test_teleport_settle.py (100%) rename utama_core/tests/{strategy_runner => run}/test_vision_stream_bad_frame.py (100%) rename utama_core/tests/{controller => team_controller}/__init__.py (100%) rename utama_core/tests/{controller => team_controller}/test_dribbler_limiter.py (100%) rename utama_core/tests/{controller => team_controller}/test_find_robots.py (100%) rename utama_core/tests/{controller => team_controller}/test_kicker_charge.py (100%) rename utama_core/tests/{controller => team_controller}/test_robot_profile.py (100%) rename utama_core/tests/{controller => team_controller}/test_sim_controller.py (100%) diff --git a/AGENTS.md b/AGENTS.md index ff4338f4..82fbe661 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -143,7 +143,7 @@ declarations) — check there before reintroducing one of them. In rsim, `run_test`'s `episode_timeout` is game time (rsim runs several times faster than real time), so a test's budget doesn't depend on machine load. - A known defect is a `strict=True` xfail on exactly the cases that hit it (see - `bang_bang_edge_cases_test.py`'s `_seeds_with_known_defect`), so a fix shows as XPASS and + `test_bang_bang_edge_cases.py`'s `_seeds_with_known_defect`), so a fix shows as XPASS and a regression elsewhere fails. Don't chase rsim-only dribble test failures as if they were kernel bugs; verify on grsim if genuinely unsure. - Before trusting any test result (yours or another agent's), prefer independently @@ -186,6 +186,6 @@ need most: diagnostics, not objectives. - `docs/strategies.md` — strategy catalog: core or reserve, description, and real match results per strategy. -- `utama_core/tests/engine/` and `utama_core/tests/strategy_runner/` — the real +- `utama_core/tests/engine/` and `utama_core/tests/run/` — the real tactic-kernel test surface; everywhere else is largely infrastructure (motion planning, vision, controllers) that predates and sits below the kernel model. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 8317da91..36ae8081 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -532,7 +532,7 @@ way whatever the strategy. Moments are captured from replays (`capture`); hand-m | Symptom | Looked like | Cause | Fix | Test | |---|---|---|---|---| -| Defender pushed off the pitch during their corner placement | robot leaving the field | override push-out target off the pitch in a corner | `14038121` | `tests/referee/test_referee_unit.py` | +| Defender pushed off the pitch during their corner placement | robot leaving the field | override push-out target off the pitch in a corner | `14038121` | `tests/custom_referee/test_referee_unit.py` | | Defender stuck against their placer | robot ignoring the restart | planner found no path out for a robot inside another's clearance | `c64fc6f9` | `test_fpp_pressed_against_robot.py` | | Defender boxed in a corner closes on the ball | robot driving in | planner detour led back toward the ball; the keep-out guard skipped robots already inside | `935da778` | `test_fpp_inside_ball_keep_out.py` | | Same moment still failing after the fix | robot driving in | `keeps_clear` counted the ball placed onto a robot standing still | `20ca1974` | `test_moments.py` | diff --git a/docs/custom_referee.md b/docs/custom_referee.md index 263af426..e4e4f121 100644 --- a/docs/custom_referee.md +++ b/docs/custom_referee.md @@ -140,7 +140,7 @@ last-touch heuristic and its yellow default (replaced by `infer_last_touch_team` ball speed, full-episode reset, teams changing ends at half-time, `bt_nodes` → `debug_status` rename, auto-advance after goals/timeouts, keep-out during bare `STOP`, blue-perspective goal tests, `StrategyRunner` integration tests -(`tests/strategy_runner/test_referee_rsim.py`, `test_ball_placement_rsim.py`), +(`tests/run/test_referee_rsim.py`, `test_ball_placement_rsim.py`), `force_start_after_goal`. ## Running diff --git a/docs/roadmap.md b/docs/roadmap.md index f2877b60..a204d054 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -33,7 +33,7 @@ entry by its title, not its number. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). - **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion at the last release (a frozen `.strategy` file) in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded sim noise (the simulated world and robots from `world.json` and `robots.json`). Candidate and reference meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 better, <= 0.2 worse, undecided after 6 rounds (`analysis/ratings.py`); the match results store (`replays/match_results/`) never replays a fixture it already has, and `tools/evaluation/explain.py` draws where the robots stand. Until 2026-11-12 it used `opponents.json` with held-out opponents and a ledger (`replays/eval/ledger.jsonl`). The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. -- **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. +- **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`test_fastpathplanner_corner.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. - **Shared hysteresis helper** — `Sticky` in `geometry/tolerance.py` (`fd87c7f6`), now used by `PassAndShootTactic`'s passer choice, `ClearBallTactic`'s target choice and `PressAndContainTactic`'s presser choice instead of per-site margins — `0ce4e2a2`. (`pickers.friendly_closer_to_ball` keeps its own tick-count hysteresis.) @@ -48,8 +48,8 @@ entry by its title, not its number. 2. **`BangBang1D` defects** — required-overshoot and `v0 > v_max` cases produce discontinuous trajectories, pinned as 78 strict xfails on the enumerated defect seeds - (`utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py`; - `trajsampling_correctness_test.py` pins the same defect). A correct fix (`b26a550`) was + (`utama_core/tests/motion_planning/implementation/test_bang_bang_edge_cases.py`; + `test_trajsampling_correctness.py` pins the same defect). A correct fix (`b26a550`) was reverted (`90d068c`) because physically correct trajectories let mutually blocked robots stall at kickoff (231/231). trajsample has since gained Sumatra's all-candidates-collide fallback (`a1b8bdd6`), so re-applying the fix means validating it against that; there is diff --git a/examples/demo_exhibition_road.py b/examples/demo_exhibition_road.py index b84125e9..44d6364a 100644 --- a/examples/demo_exhibition_road.py +++ b/examples/demo_exhibition_road.py @@ -49,7 +49,7 @@ from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.run import StrategyRunner -from utama_core.tests.referee.wandering_strategy import wandering_strategy +from utama_core.tests.custom_referee.wandering_strategy import wandering_strategy # --------------------------------------------------------------------------- # Configuration diff --git a/utama_core/motion_planning/fastpathplanning/planner.py b/utama_core/motion_planning/fastpathplanning/planner.py index c52ee2ea..bf2d4038 100644 --- a/utama_core/motion_planning/fastpathplanning/planner.py +++ b/utama_core/motion_planning/fastpathplanning/planner.py @@ -666,7 +666,7 @@ def _find_subgoal_exact( # `multiple` (and which obstacle blocked last) changes, so this loops # instead, computing the direction once. Same arithmetic, same order, # so the same subgoal bit-for-bit (pinned against the recursive - # version in fastpathplanner_equivalence_test.py). + # version in test_fastpathplanner_equivalence.py). direction = target - robot_pos direction_norm = math.hypot(direction[0], direction[1]) unitvec = None @@ -1301,7 +1301,7 @@ def smooth_path( # A first subgoal sitting exactly on the robot (the detour recursion can # produce one) has no direction to normalise: dividing by its zero length # returned a NaN carrot. Skip such segments. Found by - # fastpathplanner_corner_test.py (a robot beside two blockers at the + # test_fastpathplanner_corner.py (a robot beside two blockers at the # enemy box corner). while len(trajectory) > 1 and math.hypot(*(trajectory[0][1] - robot_position)) == 0.0: trajectory = trajectory[1:] diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 38e9d53a..0668e955 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -17,7 +17,7 @@ `utama_core/rsoccer_simulator/ssl/ssl_gym_base.py`'s `teleport_ball`/ `teleport_robot`, which do the y-flip into rsim's internal frame themselves; callers, including the teleport accuracy test in -`utama_core/tests/strategy_runner/teleport_position_accuracy_test.py`, pass +`utama_core/tests/run/test_teleport_position_accuracy.py`, pass plain (x, y) metres and get them back unchanged on the next frame). There is no additional per-team-color mirroring at the `GameFrame` layer — that only exists one level up, in kernel-tactic target *storage* (see @@ -26,7 +26,7 @@ `p.x`/`p.y`/`orientation` and hand them to `apply_scenario` unchanged; this is verified by `apply_scenario` itself reading back the first post-teleport `GameFrame` and asserting positions match within a few cm (mirroring -`teleport_position_accuracy_test.py`'s `POSITION_TOLERANCE`). +`test_teleport_position_accuracy.py`'s `POSITION_TOLERANCE`). A replay only ever records one side's perspective (`ReplayWriterConfig`/ `ColumnarReplayWriterConfig.is_my_perspective`, and @@ -100,7 +100,7 @@ logger = logging.getLogger(__name__) -_POSITION_TOLERANCE_M = 0.15 # mirrors teleport_position_accuracy_test.py's POSITION_TOLERANCE +_POSITION_TOLERANCE_M = 0.15 # mirrors test_teleport_position_accuracy.py's POSITION_TOLERANCE _VERIFY_MAX_TICKS = 10 # see apply_scenario's verify=True docstring for why more than 1 tick is needed _SHOWING_WINDOW_S = 0.5 # how far past `t_seconds` `scenario_from_replay(showing=...)` looks _CLOCK_EPS_S = 1e-6 # float slack when a frame time sits exactly on a window edge @@ -428,7 +428,7 @@ def _make_robot(rs: RobotState, is_friendly: bool) -> Robot: def apply_scenario(runner, scenario: Scenario, *, verify: bool = True) -> None: """Teleport `runner`'s ball and every robot into `scenario`'s field state, through `runner.sim_controller` (the same public attribute - `teleport_position_accuracy_test.py` drives directly). + `test_teleport_position_accuracy.py` drives directly). Friendly robots are teleported as `runner.my_team_is_yellow`'s color, enemy robots as the opposite color — matching how the replay was @@ -456,7 +456,7 @@ def apply_scenario(runner, scenario: Scenario, *, verify: bool = True) -> None: a coordinate-frame regression fails loudly instead of silently producing a wrong repro. More than one tick is needed in practice, not just the "one frame of physics settling" - `teleport_position_accuracy_test.py`'s `POSITION_TOLERANCE` was sized + `test_teleport_position_accuracy.py`'s `POSITION_TOLERANCE` was sized for: a robot/ball teleported far from wherever the runner's initial formation placed it (the normal case here — a real match's positions are essentially always far from a fresh runner's starting formation, @@ -492,7 +492,7 @@ def apply_scenario(runner, scenario: Scenario, *, verify: bool = True) -> None: # direction of travel (observed: robot teleported to x=0.68 landed at # x=1.35 one tick later — reproduces exactly from the filter's own # closed-form update, not noise or a coordinate-frame bug). - # `teleport_position_accuracy_test.py` never hits this because it + # `test_teleport_position_accuracy.py` never hits this because it # teleports inside `reset_field()`, which `StrategyRunner._reset_game()` # always follows with `position_refiner.reset()` *and* a full # `GameGater`-driven `_load_game()` reload — which is what actually diff --git a/utama_core/team_controller/README.md b/utama_core/team_controller/README.md index 22db8c51..843f91fd 100644 --- a/utama_core/team_controller/README.md +++ b/utama_core/team_controller/README.md @@ -32,7 +32,7 @@ This folder contains all the files which perform the initial processing of data - Updates internal data structures with the latest referee commands, stage, team information, and designated ball placement positions. - Provides methods to retrieve the latest referee data, command, stage, and other relevant information. - **Vision Data** - - The `VisionDataReceiver` class is responsible for receiving and managing vision data for robots and the ball in a multi-robot game environment. It interfaces with a network manager to receive packets containing positional data for the ball and robots on both teams. The class updates internal data structures accordingly. Here is an [example usage](../tests/receivers/vision_receiver_unit_test.py) (and an [integration test](../tests/receivers/vision_receiver_integration_test.py)). + - The `VisionDataReceiver` class is responsible for receiving and managing vision data for robots and the ball in a multi-robot game environment. It interfaces with a network manager to receive packets containing positional data for the ball and robots on both teams. The class updates internal data structures accordingly. Here is an [example usage](../tests/data_processing/test_vision_receiver_unit.py) (and an [integration test](../tests/data_processing/test_vision_receiver_integration.py)). - **Data Types**: - `Ball`: A named tuple representing the ball's position with fields `x`, `y`, and `z`. - `Robot`: A named tuple representing a robot's position with fields `x`, `y`, and `orientation`. diff --git a/utama_core/tests/referee/referee_sim.py b/utama_core/tests/custom_referee/referee_sim.py similarity index 97% rename from utama_core/tests/referee/referee_sim.py rename to utama_core/tests/custom_referee/referee_sim.py index b3f440c4..f357748f 100644 --- a/utama_core/tests/referee/referee_sim.py +++ b/utama_core/tests/custom_referee/referee_sim.py @@ -1,7 +1,7 @@ """Visual RSim simulation for verifying referee command behaviour. Run with: - pixi run python utama_core/tests/referee/referee_sim.py + pixi run python utama_core/tests/custom_referee/referee_sim.py What it does: - Starts a 3v3 RSim with WanderingTactic as the base strategy. @@ -31,7 +31,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.run import StrategyRunner -from utama_core.tests.referee.wandering_strategy import wandering_strategy +from utama_core.tests.custom_referee.wandering_strategy import wandering_strategy # --------------------------------------------------------------------------- # Configuration diff --git a/utama_core/tests/referee/test_referee_unit.py b/utama_core/tests/custom_referee/test_referee_unit.py similarity index 100% rename from utama_core/tests/referee/test_referee_unit.py rename to utama_core/tests/custom_referee/test_referee_unit.py diff --git a/utama_core/tests/referee/wandering_strategy.py b/utama_core/tests/custom_referee/wandering_strategy.py similarity index 100% rename from utama_core/tests/referee/wandering_strategy.py rename to utama_core/tests/custom_referee/wandering_strategy.py diff --git a/utama_core/tests/refiners/one_camera_ball_repro.json b/utama_core/tests/data_processing/one_camera_ball_repro.json similarity index 100% rename from utama_core/tests/refiners/one_camera_ball_repro.json rename to utama_core/tests/data_processing/one_camera_ball_repro.json diff --git a/utama_core/tests/refiners/camera_combiner_test.py b/utama_core/tests/data_processing/test_camera_combiner.py similarity index 100% rename from utama_core/tests/refiners/camera_combiner_test.py rename to utama_core/tests/data_processing/test_camera_combiner.py diff --git a/utama_core/tests/refiners/kalman_test.py b/utama_core/tests/data_processing/test_kalman.py similarity index 100% rename from utama_core/tests/refiners/kalman_test.py rename to utama_core/tests/data_processing/test_kalman.py diff --git a/utama_core/tests/refiners/test_local_camera_consistency.py b/utama_core/tests/data_processing/test_local_camera_consistency.py similarity index 100% rename from utama_core/tests/refiners/test_local_camera_consistency.py rename to utama_core/tests/data_processing/test_local_camera_consistency.py diff --git a/utama_core/tests/refiners/position_refiner_integration_test.py b/utama_core/tests/data_processing/test_position_refiner_integration.py similarity index 100% rename from utama_core/tests/refiners/position_refiner_integration_test.py rename to utama_core/tests/data_processing/test_position_refiner_integration.py diff --git a/utama_core/tests/refiners/position_unit_test.py b/utama_core/tests/data_processing/test_position_unit.py similarity index 100% rename from utama_core/tests/refiners/position_unit_test.py rename to utama_core/tests/data_processing/test_position_unit.py diff --git a/utama_core/tests/receivers/referee_receiver_test.py b/utama_core/tests/data_processing/test_referee_receiver.py similarity index 100% rename from utama_core/tests/receivers/referee_receiver_test.py rename to utama_core/tests/data_processing/test_referee_receiver.py diff --git a/utama_core/tests/refiners/robot_info_test.py b/utama_core/tests/data_processing/test_robot_info.py similarity index 100% rename from utama_core/tests/refiners/robot_info_test.py rename to utama_core/tests/data_processing/test_robot_info.py diff --git a/utama_core/tests/refiners/velocity_test.py b/utama_core/tests/data_processing/test_velocity.py similarity index 100% rename from utama_core/tests/refiners/velocity_test.py rename to utama_core/tests/data_processing/test_velocity.py diff --git a/utama_core/tests/receivers/vision_receiver_integration_test.py b/utama_core/tests/data_processing/test_vision_receiver_integration.py similarity index 100% rename from utama_core/tests/receivers/vision_receiver_integration_test.py rename to utama_core/tests/data_processing/test_vision_receiver_integration.py diff --git a/utama_core/tests/receivers/vision_receiver_unit_test.py b/utama_core/tests/data_processing/test_vision_receiver_unit.py similarity index 100% rename from utama_core/tests/receivers/vision_receiver_unit_test.py rename to utama_core/tests/data_processing/test_vision_receiver_unit.py diff --git a/utama_core/tests/abstract_strategy/test_assertions.py b/utama_core/tests/engine/test_abstract_strategy_assertions.py similarity index 100% rename from utama_core/tests/abstract_strategy/test_assertions.py rename to utama_core/tests/engine/test_abstract_strategy_assertions.py diff --git a/utama_core/tests/engine/test_all_tactics.py b/utama_core/tests/engine/test_all_tactics.py index 69991268..6bdbae81 100644 --- a/utama_core/tests/engine/test_all_tactics.py +++ b/utama_core/tests/engine/test_all_tactics.py @@ -58,7 +58,7 @@ @pytest.fixture def runner_factory(): from utama_core.run.strategy_runner import StrategyRunner - from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy + from utama_core.tests.run.strat_runner_test_utils import DummyStrategy made = [] diff --git a/utama_core/tests/engine/test_check_strategy_branch.py b/utama_core/tests/engine/test_check_strategy_branch.py index cd8b8b53..282cf80c 100644 --- a/utama_core/tests/engine/test_check_strategy_branch.py +++ b/utama_core/tests/engine/test_check_strategy_branch.py @@ -47,7 +47,7 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): ".github/workflows/ci.yml", # Prefix matches on whole directory names only. "utama_core/strategy_runner/x.py", - "utama_core/tests/strategy_runner/test_x.py", + "utama_core/tests/run/test_x.py", "docs/strategies.md.bak", ], ) diff --git a/utama_core/tests/engine/test_pass_and_score_pass_exec.py b/utama_core/tests/engine/test_pass_and_score_pass_exec.py index 3e49363a..e88acf14 100644 --- a/utama_core/tests/engine/test_pass_and_score_pass_exec.py +++ b/utama_core/tests/engine/test_pass_and_score_pass_exec.py @@ -30,7 +30,7 @@ def runner(): # `runner_factory` (not shared via conftest — duplicated here rather # than introducing new shared test infra for one extra file). from utama_core.run.strategy_runner import StrategyRunner - from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy + from utama_core.tests.run.strat_runner_test_utils import DummyStrategy r = StrategyRunner( strategy=DummyStrategy(), diff --git a/utama_core/tests/motion_planning/_kernel_test_strategies.py b/utama_core/tests/motion_planning/_kernel_test_strategies.py index f1665cbd..2940268a 100644 --- a/utama_core/tests/motion_planning/_kernel_test_strategies.py +++ b/utama_core/tests/motion_planning/_kernel_test_strategies.py @@ -199,7 +199,7 @@ def tick( def oscillating_obstacle_strategy(obstacle_configs: list) -> AbstractStrategy: """`obstacle_configs`: list of objects with `center_position`, `oscillation_axis`, `amplitude`, `direction_up_or_right`, `speed` - (matching `MovingObstacleConfig` in `single_robot_moving_obstacle_test.py`) + (matching `MovingObstacleConfig` in `test_single_robot_moving_obstacle.py`) — obstacle_id is assigned by list position (0, 1, 2, ...), matching the deleted BT strategy's convention.""" configs = [ diff --git a/utama_core/tests/motion_planning/contract/controller_contract_test.py b/utama_core/tests/motion_planning/contract/test_controller_contract.py similarity index 100% rename from utama_core/tests/motion_planning/contract/controller_contract_test.py rename to utama_core/tests/motion_planning/contract/test_controller_contract.py diff --git a/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py b/utama_core/tests/motion_planning/implementation/test_bang_bang_edge_cases.py similarity index 99% rename from utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py rename to utama_core/tests/motion_planning/implementation/test_bang_bang_edge_cases.py index 0565c4e8..8a4b3330 100644 --- a/utama_core/tests/motion_planning/implementation/bang_bang_edge_cases_test.py +++ b/utama_core/tests/motion_planning/implementation/test_bang_bang_edge_cases.py @@ -1,7 +1,7 @@ """Boundary-condition and randomized-invariant sweep over `BangBang1D`/ `Trajectory2D` (`utama_core/motion_planning/trajsampling/bang_bang.py`). -`trajsampling_correctness_test.py` (read before writing this file) already +`test_trajsampling_correctness.py` (read before writing this file) already covers: rejecting non-positive `v_max`/`a_max`; endpoint/kinematic invariants for a handful of hand-picked (p0, v0, p1, v_max, a_max) tuples, including one opposing-v0 case; position-continuity at the trajectory's own end time; @@ -393,7 +393,7 @@ def test_trajectory_2d_random_velocity_cap_and_continuity(seed): @pytest.mark.parametrize("seed", range(50)) def test_trajectory_2d_p0_equals_p1_with_nonzero_v0(seed): """The degenerate zero-distance case (pins fe6a07e's fix at the - `Trajectory2D` level, complementing `trajsampling_correctness_test.py`'s + `Trajectory2D` level, complementing `test_trajsampling_correctness.py`'s single hand-picked case with a random sweep): braking uses v0's own direction, not a fixed axis, so the full speed is captured and the robot actually comes to rest at p0.""" diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py b/utama_core/tests/motion_planning/implementation/test_trajsampling_controller.py similarity index 100% rename from utama_core/tests/motion_planning/implementation/trajsampling_controller_test.py rename to utama_core/tests/motion_planning/implementation/test_trajsampling_controller.py diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py b/utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py similarity index 100% rename from utama_core/tests/motion_planning/implementation/trajsampling_correctness_test.py rename to utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py diff --git a/utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py b/utama_core/tests/motion_planning/implementation/test_trajsampling_sideways.py similarity index 100% rename from utama_core/tests/motion_planning/implementation/trajsampling_sideways_test.py rename to utama_core/tests/motion_planning/implementation/test_trajsampling_sideways.py diff --git a/utama_core/tests/motion_planning/standardized/test_scenarios.py b/utama_core/tests/motion_planning/standardized/test_scenarios.py index f661fbd1..dc46bba0 100644 --- a/utama_core/tests/motion_planning/standardized/test_scenarios.py +++ b/utama_core/tests/motion_planning/standardized/test_scenarios.py @@ -171,7 +171,7 @@ # trajectory, per the fix's own roadmap entry), not a hard veto this # simpler shape reproduces standalone. The exact boundary condition # (`first_collision_numba`'s escape grace) is pinned deterministically - # by a dedicated unit test instead (see trajsampling_correctness_test.py); + # by a dedicated unit test instead (see test_trajsampling_correctness.py); # this scenario keeps the realistic "start already overlapping" case # in the black-box regression suite going forward. friendly_starts=((0.10, 0.0),), diff --git a/utama_core/tests/motion_planning/defense_area_avoidance_test.py b/utama_core/tests/motion_planning/test_defense_area_avoidance.py similarity index 100% rename from utama_core/tests/motion_planning/defense_area_avoidance_test.py rename to utama_core/tests/motion_planning/test_defense_area_avoidance.py diff --git a/utama_core/tests/motion_planning/fastpathplanner_corner_test.py b/utama_core/tests/motion_planning/test_fastpathplanner_corner.py similarity index 100% rename from utama_core/tests/motion_planning/fastpathplanner_corner_test.py rename to utama_core/tests/motion_planning/test_fastpathplanner_corner.py diff --git a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py b/utama_core/tests/motion_planning/test_fastpathplanner_equivalence.py similarity index 99% rename from utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py rename to utama_core/tests/motion_planning/test_fastpathplanner_equivalence.py index 087c4656..c1a853fe 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_equivalence_test.py +++ b/utama_core/tests/motion_planning/test_fastpathplanner_equivalence.py @@ -10,7 +10,7 @@ This is the exact-numerics contract (`EXACT_MATH`, settings.py), so every test here runs with the exact implementations selected whatever the -environment says; fastpathplanner_fast_math_test.py covers the fast ones. +environment says; test_fastpathplanner_fast_math.py covers the fast ones. """ import math diff --git a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py b/utama_core/tests/motion_planning/test_fastpathplanner_fast_math.py similarity index 99% rename from utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py rename to utama_core/tests/motion_planning/test_fastpathplanner_fast_math.py index 6132c97c..b09a0543 100644 --- a/utama_core/tests/motion_planning/fastpathplanner_fast_math_test.py +++ b/utama_core/tests/motion_planning/test_fastpathplanner_fast_math.py @@ -1,7 +1,7 @@ """The fast numerics (`EXACT_MATH` off, the default) compute what the exact ones do, up to rounding: on random scenes every fast planner step makes the same choice (same obstacle, same None/not-None) and lands within 1e-9 m of -the exact result. fastpathplanner_equivalence_test.py pins the exact ones bit +the exact result. test_fastpathplanner_equivalence.py pins the exact ones bit for bit against the pre-rewrite code.""" import math diff --git a/utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py b/utama_core/tests/motion_planning/test_fastpathplanner_subgoal.py similarity index 100% rename from utama_core/tests/motion_planning/fastpathplanner_subgoal_test.py rename to utama_core/tests/motion_planning/test_fastpathplanner_subgoal.py diff --git a/utama_core/tests/motion_planning/motion_planning_benchmark_figures_test.py b/utama_core/tests/motion_planning/test_motion_planning_benchmark_figures.py similarity index 100% rename from utama_core/tests/motion_planning/motion_planning_benchmark_figures_test.py rename to utama_core/tests/motion_planning/test_motion_planning_benchmark_figures.py diff --git a/utama_core/tests/motion_planning/multiple_robots_test.py b/utama_core/tests/motion_planning/test_multiple_robots.py similarity index 100% rename from utama_core/tests/motion_planning/multiple_robots_test.py rename to utama_core/tests/motion_planning/test_multiple_robots.py diff --git a/utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py b/utama_core/tests/motion_planning/test_single_robot_moving_obstacle.py similarity index 100% rename from utama_core/tests/motion_planning/single_robot_moving_obstacle_test.py rename to utama_core/tests/motion_planning/test_single_robot_moving_obstacle.py diff --git a/utama_core/tests/motion_planning/single_robot_static_obstacle_test.py b/utama_core/tests/motion_planning/test_single_robot_static_obstacle.py similarity index 100% rename from utama_core/tests/motion_planning/single_robot_static_obstacle_test.py rename to utama_core/tests/motion_planning/test_single_robot_static_obstacle.py diff --git a/utama_core/tests/referee/__init__.py b/utama_core/tests/referee/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/utama_core/tests/strategy_runner/strat_runner_test_utils.py b/utama_core/tests/run/strat_runner_test_utils.py similarity index 100% rename from utama_core/tests/strategy_runner/strat_runner_test_utils.py rename to utama_core/tests/run/strat_runner_test_utils.py diff --git a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py b/utama_core/tests/run/test_ball_placement_rsim.py similarity index 99% rename from utama_core/tests/strategy_runner/test_ball_placement_rsim.py rename to utama_core/tests/run/test_ball_placement_rsim.py index 1f8f1342..196d6b50 100644 --- a/utama_core/tests/strategy_runner/test_ball_placement_rsim.py +++ b/utama_core/tests/run/test_ball_placement_rsim.py @@ -27,7 +27,7 @@ Running ------- - pixi run pytest utama_core/tests/strategy_runner/test_ball_placement_rsim.py -v + pixi run pytest utama_core/tests/run/test_ball_placement_rsim.py -v Known gap --------- diff --git a/utama_core/tests/strategy_runner/test_change_of_ends.py b/utama_core/tests/run/test_change_of_ends.py similarity index 100% rename from utama_core/tests/strategy_runner/test_change_of_ends.py rename to utama_core/tests/run/test_change_of_ends.py diff --git a/utama_core/tests/strategy_runner/test_close_releases.py b/utama_core/tests/run/test_close_releases.py similarity index 100% rename from utama_core/tests/strategy_runner/test_close_releases.py rename to utama_core/tests/run/test_close_releases.py diff --git a/utama_core/tests/strategy_runner/test_error_handling.py b/utama_core/tests/run/test_error_handling.py similarity index 100% rename from utama_core/tests/strategy_runner/test_error_handling.py rename to utama_core/tests/run/test_error_handling.py diff --git a/utama_core/tests/strategy_runner/test_exp_ball.py b/utama_core/tests/run/test_exp_ball.py similarity index 99% rename from utama_core/tests/strategy_runner/test_exp_ball.py rename to utama_core/tests/run/test_exp_ball.py index a4981919..94eefb24 100644 --- a/utama_core/tests/strategy_runner/test_exp_ball.py +++ b/utama_core/tests/run/test_exp_ball.py @@ -21,7 +21,7 @@ AbstractTestManager, TestingStatus, ) -from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy +from utama_core.tests.run.strat_runner_test_utils import DummyStrategy os.environ["SDL_VIDEO_WINDOW_POS"] = "100,100" diff --git a/utama_core/tests/strategy_runner/test_field_check.py b/utama_core/tests/run/test_field_check.py similarity index 100% rename from utama_core/tests/strategy_runner/test_field_check.py rename to utama_core/tests/run/test_field_check.py diff --git a/utama_core/tests/strategy_runner/test_field_fence.py b/utama_core/tests/run/test_field_fence.py similarity index 100% rename from utama_core/tests/strategy_runner/test_field_fence.py rename to utama_core/tests/run/test_field_fence.py diff --git a/utama_core/tests/strategy_runner/test_frame_once.py b/utama_core/tests/run/test_frame_once.py similarity index 100% rename from utama_core/tests/strategy_runner/test_frame_once.py rename to utama_core/tests/run/test_frame_once.py diff --git a/utama_core/tests/strategy_runner/test_frozen_field_watchdog.py b/utama_core/tests/run/test_frozen_field_watchdog.py similarity index 100% rename from utama_core/tests/strategy_runner/test_frozen_field_watchdog.py rename to utama_core/tests/run/test_frozen_field_watchdog.py diff --git a/utama_core/tests/strategy_runner/test_game_log_sides.py b/utama_core/tests/run/test_game_log_sides.py similarity index 100% rename from utama_core/tests/strategy_runner/test_game_log_sides.py rename to utama_core/tests/run/test_game_log_sides.py diff --git a/utama_core/tests/strategy_runner/test_goalkeeper_stability.py b/utama_core/tests/run/test_goalkeeper_stability.py similarity index 100% rename from utama_core/tests/strategy_runner/test_goalkeeper_stability.py rename to utama_core/tests/run/test_goalkeeper_stability.py diff --git a/utama_core/tests/strategy_runner/test_grsim_sim_setup.py b/utama_core/tests/run/test_grsim_sim_setup.py similarity index 98% rename from utama_core/tests/strategy_runner/test_grsim_sim_setup.py rename to utama_core/tests/run/test_grsim_sim_setup.py index 67229dc6..8d02f1e1 100644 --- a/utama_core/tests/strategy_runner/test_grsim_sim_setup.py +++ b/utama_core/tests/run/test_grsim_sim_setup.py @@ -7,7 +7,7 @@ map_left_right_to_colors, ) from utama_core.run.strategy_runner import StrategyRunner -from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy +from utama_core.tests.run.strat_runner_test_utils import DummyStrategy class _FakeGRSimController: diff --git a/utama_core/tests/strategy_runner/test_kick_bend_wiring.py b/utama_core/tests/run/test_kick_bend_wiring.py similarity index 100% rename from utama_core/tests/strategy_runner/test_kick_bend_wiring.py rename to utama_core/tests/run/test_kick_bend_wiring.py diff --git a/utama_core/tests/strategy_runner/test_match_state_reset.py b/utama_core/tests/run/test_match_state_reset.py similarity index 100% rename from utama_core/tests/strategy_runner/test_match_state_reset.py rename to utama_core/tests/run/test_match_state_reset.py diff --git a/utama_core/tests/strategy_runner/test_referee_rsim.py b/utama_core/tests/run/test_referee_rsim.py similarity index 100% rename from utama_core/tests/strategy_runner/test_referee_rsim.py rename to utama_core/tests/run/test_referee_rsim.py diff --git a/utama_core/tests/strategy_runner/test_replace_strategy.py b/utama_core/tests/run/test_replace_strategy.py similarity index 100% rename from utama_core/tests/strategy_runner/test_replace_strategy.py rename to utama_core/tests/run/test_replace_strategy.py diff --git a/utama_core/tests/strategy_runner/test_robot_feedback_snapshot.py b/utama_core/tests/run/test_robot_feedback_snapshot.py similarity index 100% rename from utama_core/tests/strategy_runner/test_robot_feedback_snapshot.py rename to utama_core/tests/run/test_robot_feedback_snapshot.py diff --git a/utama_core/tests/strategy_runner/test_rsim_formations.py b/utama_core/tests/run/test_rsim_formations.py similarity index 100% rename from utama_core/tests/strategy_runner/test_rsim_formations.py rename to utama_core/tests/run/test_rsim_formations.py diff --git a/utama_core/tests/strategy_runner/test_rsim_render_bounds.py b/utama_core/tests/run/test_rsim_render_bounds.py similarity index 100% rename from utama_core/tests/strategy_runner/test_rsim_render_bounds.py rename to utama_core/tests/run/test_rsim_render_bounds.py diff --git a/utama_core/tests/strategy_runner/test_run_test_timeout.py b/utama_core/tests/run/test_run_test_timeout.py similarity index 100% rename from utama_core/tests/strategy_runner/test_run_test_timeout.py rename to utama_core/tests/run/test_run_test_timeout.py diff --git a/utama_core/tests/strategy_runner/test_runner_misconfig.py b/utama_core/tests/run/test_runner_misconfig.py similarity index 99% rename from utama_core/tests/strategy_runner/test_runner_misconfig.py rename to utama_core/tests/run/test_runner_misconfig.py index 7b1a30c1..5a3e517e 100644 --- a/utama_core/tests/strategy_runner/test_runner_misconfig.py +++ b/utama_core/tests/run/test_runner_misconfig.py @@ -13,7 +13,7 @@ from utama_core.entities.game.field import FieldBounds from utama_core.run.referee_source import OfficialReferee from utama_core.run.strategy_runner import StrategyRunner -from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy +from utama_core.tests.run.strat_runner_test_utils import DummyStrategy @pytest.fixture diff --git a/utama_core/tests/strategy_runner/test_scenario_hooks.py b/utama_core/tests/run/test_scenario_hooks.py similarity index 100% rename from utama_core/tests/strategy_runner/test_scenario_hooks.py rename to utama_core/tests/run/test_scenario_hooks.py diff --git a/utama_core/tests/strategy_runner/test_sim_pose_ahead.py b/utama_core/tests/run/test_sim_pose_ahead.py similarity index 100% rename from utama_core/tests/strategy_runner/test_sim_pose_ahead.py rename to utama_core/tests/run/test_sim_pose_ahead.py diff --git a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py b/utama_core/tests/run/test_strategy_control_scheme.py similarity index 98% rename from utama_core/tests/strategy_runner/test_strategy_control_scheme.py rename to utama_core/tests/run/test_strategy_control_scheme.py index 83a97d57..09db0d3e 100644 --- a/utama_core/tests/strategy_runner/test_strategy_control_scheme.py +++ b/utama_core/tests/run/test_strategy_control_scheme.py @@ -13,7 +13,7 @@ ) from utama_core.run.strategy_runner import StrategyRunner from utama_core.strategy.catalog import builder -from utama_core.tests.strategy_runner.strat_runner_test_utils import DummyStrategy +from utama_core.tests.run.strat_runner_test_utils import DummyStrategy def _dummy_factory(motion_controller): diff --git a/utama_core/tests/strategy_runner/teleport_position_accuracy_test.py b/utama_core/tests/run/test_teleport_position_accuracy.py similarity index 100% rename from utama_core/tests/strategy_runner/teleport_position_accuracy_test.py rename to utama_core/tests/run/test_teleport_position_accuracy.py diff --git a/utama_core/tests/strategy_runner/test_teleport_settle.py b/utama_core/tests/run/test_teleport_settle.py similarity index 100% rename from utama_core/tests/strategy_runner/test_teleport_settle.py rename to utama_core/tests/run/test_teleport_settle.py diff --git a/utama_core/tests/strategy_runner/test_vision_stream_bad_frame.py b/utama_core/tests/run/test_vision_stream_bad_frame.py similarity index 100% rename from utama_core/tests/strategy_runner/test_vision_stream_bad_frame.py rename to utama_core/tests/run/test_vision_stream_bad_frame.py diff --git a/utama_core/tests/controller/__init__.py b/utama_core/tests/team_controller/__init__.py similarity index 100% rename from utama_core/tests/controller/__init__.py rename to utama_core/tests/team_controller/__init__.py diff --git a/utama_core/tests/controller/test_dribbler_limiter.py b/utama_core/tests/team_controller/test_dribbler_limiter.py similarity index 100% rename from utama_core/tests/controller/test_dribbler_limiter.py rename to utama_core/tests/team_controller/test_dribbler_limiter.py diff --git a/utama_core/tests/controller/test_find_robots.py b/utama_core/tests/team_controller/test_find_robots.py similarity index 100% rename from utama_core/tests/controller/test_find_robots.py rename to utama_core/tests/team_controller/test_find_robots.py diff --git a/utama_core/tests/controller/test_kicker_charge.py b/utama_core/tests/team_controller/test_kicker_charge.py similarity index 100% rename from utama_core/tests/controller/test_kicker_charge.py rename to utama_core/tests/team_controller/test_kicker_charge.py diff --git a/utama_core/tests/controller/test_robot_profile.py b/utama_core/tests/team_controller/test_robot_profile.py similarity index 100% rename from utama_core/tests/controller/test_robot_profile.py rename to utama_core/tests/team_controller/test_robot_profile.py diff --git a/utama_core/tests/controller/test_sim_controller.py b/utama_core/tests/team_controller/test_sim_controller.py similarity index 100% rename from utama_core/tests/controller/test_sim_controller.py rename to utama_core/tests/team_controller/test_sim_controller.py From 3e641691beccbeae303c6c62d30ef50c987282b8 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:25:43 +0000 Subject: [PATCH 39/59] tools: group scripts by who uses them - tools/debug/: find_bugs, debug_match, match_timeline, replay_trace, repro_from_replay, restart_picture, plan_trace, plan_snapshot, pitch_maps, moments, figure_style - tools/field/: field_check, field_physics, vision_check, package_logs, trim_idle_log, robot_calibration, field_sessions.json, ssl-vision-lab-field.patch - tools/realism/: realism_scorecard, convert_ssl_log - tools/dev/: setup_worktree.sh, package_graph, check_strategy_branch, build_strategy - tools/motion_planning_benchmark.py stays at the top level - tools/sim_setup.py is a library: now utama_core/run/sim_setup.py Scripts resolve the repo root one level deeper (parents[2]); field_check's sibling import now points at tools/field. moments.py's worktree snapshot copies itself to tools/debug/ and creates the directory first. CI and CODEOWNERS point at tools/dev/check_strategy_branch.py. tools/ and each group get an empty __init__.py. Co-Authored-By: Claude Haiku 5.5 --- .claude/skills/change-strategy/SKILL.md | 4 +- .claude/skills/debug-incident/SKILL.md | 26 ++++---- .claude/skills/explain-result/SKILL.md | 4 +- .claude/skills/field-session/SKILL.md | 12 ++-- .github/CODEOWNERS | 2 +- .github/workflows/ci.yml | 4 +- AGENTS.md | 10 ++-- README.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 54 ++++++++--------- docs/architecture.md | 4 +- docs/contributing.md | 2 +- docs/field_log_replay.md | 6 +- docs/field_logs.md | 16 ++--- docs/img/architecture/make_match_data_flow.py | 10 ++-- docs/in_house_vision.md | 8 +-- docs/motion_planning_comparison.md | 4 +- docs/real_robot_setup.md | 12 ++-- docs/roadmap.md | 4 +- docs/signals.md | 2 +- docs/sim_realism.md | 12 ++-- docs/strategies.md | 2 +- docs/tools.md | 60 +++++++++---------- docs/visual_guide.md | 12 ++-- examples/score_goal.py | 2 +- examples/shooting_drill.py | 4 +- main.py | 4 +- pixi.toml | 8 +-- tools/__init__.py | 0 tools/debug/__init__.py | 0 tools/{ => debug}/debug_match.py | 8 +-- tools/{ => debug}/figure_style.py | 0 tools/{ => debug}/find_bugs.py | 16 ++--- tools/{ => debug}/match_timeline.py | 10 ++-- tools/{ => debug}/moments.py | 26 ++++---- tools/{ => debug}/pitch_maps.py | 6 +- tools/{ => debug}/plan_snapshot.py | 6 +- tools/{ => debug}/plan_trace.py | 6 +- tools/{ => debug}/replay_trace.py | 4 +- tools/{ => debug}/repro_from_replay.py | 8 +-- tools/{ => debug}/restart_picture.py | 8 +-- tools/dev/__init__.py | 0 tools/{ => dev}/build_strategy.py | 6 +- tools/{ => dev}/check_strategy_branch.py | 4 +- tools/{ => dev}/package_graph.py | 4 +- tools/{ => dev}/setup_worktree.sh | 4 +- tools/evaluation/explain.py | 12 ++-- tools/evaluation/match.py | 16 ++--- tools/evaluation/reference/world.json | 4 +- tools/field/__init__.py | 0 tools/{ => field}/field_check.py | 6 +- tools/{ => field}/field_physics.py | 6 +- tools/{ => field}/field_sessions.json | 2 +- tools/{ => field}/package_logs.py | 6 +- tools/{ => field}/robot_calibration.py | 4 +- tools/{ => field}/ssl-vision-lab-field.patch | 0 tools/{ => field}/trim_idle_log.py | 6 +- tools/{ => field}/vision_check.py | 6 +- tools/motion_planning_benchmark.py | 2 +- tools/realism/__init__.py | 0 tools/{ => realism}/convert_ssl_log.py | 6 +- tools/{ => realism}/realism_scorecard.py | 8 +-- utama_core/analysis/close_calls.py | 2 +- utama_core/analysis/findings.py | 2 +- utama_core/analysis/fouls.py | 4 +- utama_core/analysis/matches.py | 2 +- utama_core/analysis/plan_snapshot.py | 4 +- utama_core/analysis/plan_trace.py | 4 +- utama_core/analysis/restart_picture.py | 2 +- utama_core/analysis/robot_calibration.py | 2 +- utama_core/analysis/stuck_detector.py | 2 +- utama_core/dashboard/static/timeline.js | 2 +- utama_core/dashboard/views/demo.py | 2 +- utama_core/motion_planning/pid/pid.py | 2 +- utama_core/replay/game_log_writer.py | 2 +- utama_core/replay/scenario.py | 12 ++-- utama_core/replay/ssl_log.py | 4 +- {tools => utama_core/run}/sim_setup.py | 4 +- utama_core/run/strategy_runner.py | 2 +- utama_core/tactics/scripted_moves.py | 2 +- utama_core/tactics/switch_of_play.py | 2 +- .../tests/analysis/test_field_physics.py | 4 +- utama_core/tests/analysis/test_find_bugs.py | 4 +- utama_core/tests/analysis/test_fouls.py | 4 +- .../tests/analysis/test_match_timeline.py | 2 +- utama_core/tests/analysis/test_pitch_maps.py | 4 +- .../tests/analysis/test_plan_snapshot.py | 2 +- utama_core/tests/analysis/test_plan_trace.py | 2 +- .../tests/analysis/test_restart_picture.py | 2 +- .../tests/engine/test_all_strategy_configs.py | 2 +- .../engine/test_check_strategy_branch.py | 6 +- utama_core/tests/engine/test_explain.py | 2 +- .../tests/engine/test_tournament_match_end.py | 2 +- .../tests/moments/test_moment_authoring.py | 6 +- utama_core/tests/moments/test_moments.py | 4 +- utama_core/tests/moments/test_play_options.py | 4 +- .../moments/test_requires_and_outcomes.py | 4 +- .../test_trajsampling_correctness.py | 2 +- .../tests/replay/test_convert_corpus.py | 6 +- utama_core/tests/replay/test_fingerprint.py | 2 +- .../tests/replay/test_replay_trace_tool.py | 2 +- utama_core/tests/replay/test_repro_summary.py | 4 +- .../tests/replay/test_ssl_log_extras.py | 4 +- .../tests/tools/test_field_check_tool.py | 4 +- utama_core/tests/tools/test_package_graph.py | 4 +- utama_core/tests/tools/test_package_logs.py | 4 +- utama_core/tests/tools/test_sim_setup.py | 4 +- utama_core/tests/tools/test_trim_idle_log.py | 4 +- utama_core/tests/tools/test_vision_check.py | 4 +- 108 files changed, 325 insertions(+), 321 deletions(-) create mode 100644 tools/__init__.py create mode 100644 tools/debug/__init__.py rename tools/{ => debug}/debug_match.py (97%) rename tools/{ => debug}/figure_style.py (100%) rename tools/{ => debug}/find_bugs.py (96%) rename tools/{ => debug}/match_timeline.py (98%) rename tools/{ => debug}/moments.py (97%) rename tools/{ => debug}/pitch_maps.py (99%) rename tools/{ => debug}/plan_snapshot.py (95%) rename tools/{ => debug}/plan_trace.py (95%) rename tools/{ => debug}/replay_trace.py (98%) rename tools/{ => debug}/repro_from_replay.py (98%) rename tools/{ => debug}/restart_picture.py (95%) create mode 100644 tools/dev/__init__.py rename tools/{ => dev}/build_strategy.py (80%) rename tools/{ => dev}/check_strategy_branch.py (98%) rename tools/{ => dev}/package_graph.py (98%) rename tools/{ => dev}/setup_worktree.sh (92%) create mode 100644 tools/field/__init__.py rename tools/{ => field}/field_check.py (94%) rename tools/{ => field}/field_physics.py (97%) rename tools/{ => field}/field_sessions.json (88%) rename tools/{ => field}/package_logs.py (97%) rename tools/{ => field}/robot_calibration.py (74%) rename tools/{ => field}/ssl-vision-lab-field.patch (100%) rename tools/{ => field}/trim_idle_log.py (97%) rename tools/{ => field}/vision_check.py (98%) create mode 100644 tools/realism/__init__.py rename tools/{ => realism}/convert_ssl_log.py (97%) rename tools/{ => realism}/realism_scorecard.py (91%) rename {tools => utama_core/run}/sim_setup.py (96%) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index a36ea664..5df01e2d 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -12,7 +12,7 @@ to forget. ## 1. Branch -`strategy/` from `main`. In a git worktree run `tools/setup_worktree.sh`, and symlink +`strategy/` from `main`. In a git worktree run `tools/dev/setup_worktree.sh`, and symlink `replays` from the main checkout so the match results store is shared. ## 2. Change one thing @@ -27,7 +27,7 @@ to forget. change the copy. - No module-level state (keep it inside `build`), no import-time effects, no imports of another strategy. CI checks a `strategy/*` branch touches only `strategy/`, new `tactics/` modules, - `tests/strategy/` and `docs/strategies.md` (`tools/check_strategy_branch.py`). + `tests/strategy/` and `docs/strategies.md` (`tools/dev/check_strategy_branch.py`). - Every change needs a reason in game terms (what the robots will do differently, and why that wins goals), not a threshold nudged until results move. diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md index dbd3a368..70bd44fb 100644 --- a/.claude/skills/debug-incident/SKILL.md +++ b/.claude/skills/debug-incident/SKILL.md @@ -1,6 +1,6 @@ --- name: debug-incident -description: Take one bad moment in a match (a foul, a stall, a robot thrashing, driving into the ball at a restart, a strange path near an obstacle) from symptom to a fixed cause with a regression test. Use when find_bugs.py or a replay shows a specific incident, or the user points at a time in a match. Not for "why did this strategy lose" in general (that is the explain-result skill). +description: Take one bad moment in a match (a foul, a stall, a robot thrashing, driving into the ball at a restart, a strange path near an obstacle) from symptom to a fixed cause with a regression test. Use when tools/debug/find_bugs.py or a replay shows a specific incident, or the user points at a time in a match. Not for "why did this strategy lose" in general (that is the explain-result skill). --- # Debug one incident @@ -12,28 +12,28 @@ so far, is `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure"; read i below that is unclear. Inputs: a replay `REPLAY` (`replays/eval_/round_/
_vs_.npz`, or any `.npz`) and a -time `S` in seconds. In a parallel worktree, run `tools/setup_worktree.sh` first. +time `S` in seconds. In a parallel worktree, run `tools/dev/setup_worktree.sh` first. ## 1. Find it -`pixi run python tools/find_bugs.py ROUND_DIR --strategy NAME` → `find_bugs/index.md`, then +`pixi run python tools/debug/find_bugs.py ROUND_DIR --strategy NAME` → `find_bugs/index.md`, then filter `find_bugs/findings.jsonl` on the kind you care about. Open the finding's picture, then confirm with the numbers in its message. Only the friendly side (config_a) is checked. ## 2. Look at it -Pick the tool by the question. `match_timeline.py`, `restart_picture.py` and `plan_trace.py` take +Pick the tool by the question. `tools/debug/match_timeline.py`, `tools/debug/restart_picture.py` and `tools/debug/plan_trace.py` take `--findings` to write their flags as JSON. | Question | Command | |---|---| -| What happened in this window, in text? | `tools/replay_trace.py REPLAY T0 T1` (`--events`: kicks, possession, referee changes, fouls) | -| Which tactic was each robot in, and what was it aiming at? | `tools/repro_from_replay.py REPLAY --t S --summary IDS` (replays the state with tracing on, prints tactic, position, target every 0.25 s) | -| Swimlanes: referee, each robot's tactic, distance to ball | `tools/match_timeline.py REPLAY T0 T1 --side friendly` | -| Where did the referee override send everyone at this restart? Legal? | `tools/restart_picture.py REPLAY --t S` (`--all-restarts`, `--side enemy`) | -| What did the planner decide on this tick? | `tools/plan_snapshot.py REPLAY --t S --robot ID --target X Y` (`--side enemy`) | -| How did the plan evolve over a few seconds? | `tools/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` | -| Run a fresh short match with my own traces | `tools/debug_match.py --strategy A --opponent B --duration 60 --stop-on-goal`, with `ctx.match_log.trace(...)` calls added in the tactic | +| What happened in this window, in text? | `tools/debug/replay_trace.py REPLAY T0 T1` (`--events`: kicks, possession, referee changes, fouls) | +| Which tactic was each robot in, and what was it aiming at? | `tools/debug/repro_from_replay.py REPLAY --t S --summary IDS` (replays the state with tracing on, prints tactic, position, target every 0.25 s) | +| Swimlanes: referee, each robot's tactic, distance to ball | `tools/debug/match_timeline.py REPLAY T0 T1 --side friendly` | +| Where did the referee override send everyone at this restart? Legal? | `tools/debug/restart_picture.py REPLAY --t S` (`--all-restarts`, `--side enemy`) | +| What did the planner decide on this tick? | `tools/debug/plan_snapshot.py REPLAY --t S --robot ID --target X Y` (`--side enemy`) | +| How did the plan evolve over a few seconds? | `tools/debug/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` | +| Run a fresh short match with my own traces | `tools/debug/debug_match.py --strategy A --opponent B --duration 60 --stop-on-goal`, with `ctx.match_log.trace(...)` calls added in the tactic | All run as `pixi run python tools/.py ...`. Never conclude from a picture alone. @@ -56,8 +56,8 @@ Only when a field state alone decides the behaviour (restart and placement geome referee override); open-play fouls almost never reproduce from a captured state. ``` -pixi run python tools/moments.py capture REPLAY --t S --name NAME --check CHECK --note "..." -pixi run python tools/moments.py play utama_core/tests/moments/NAME.json --seeds 0-4 +pixi run python tools/debug/moments.py capture REPLAY --t S --name NAME --check CHECK --note "..." +pixi run python tools/debug/moments.py play utama_core/tests/moments/NAME.json --seeds 0-4 ``` It must fail on at least 4 of 5 seeds before the fix. If the fix is not in the same change, diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md index e309c8e0..f413101a 100644 --- a/.claude/skills/explain-result/SKILL.md +++ b/.claude/skills/explain-result/SKILL.md @@ -24,7 +24,7 @@ they suggest changing, never a new ranking. the stall coverage. Look up any signal in `docs/signals.md`: where it lives, its reference range, and what an off value usually means. -2. **Is something broken?** `pixi run python tools/find_bugs.py ROUND_DIR --strategy NAME` +2. **Is something broken?** `pixi run python tools/debug/find_bugs.py ROUND_DIR --strategy NAME` (about 20 s a match; `--restarts` adds restart geometry, a minute a match). Open `find_bugs/index.md` first: the worst matches, findings by kind, a picture each. Our fouls by rule: `--fouls --by strategy,rule`. A stall, thrash or foul is a bug, not a style: hand it to @@ -38,7 +38,7 @@ they suggest changing, never a new ranking. from?". 4. **How does it play, on the pitch?** - - One strategy against the field: `pixi run python tools/pitch_maps.py ROUND_DIR --out DIR` + - One strategy against the field: `pixi run python tools/debug/pitch_maps.py ROUND_DIR --out DIR` (positions with and without the ball, shots, fouls; every panel turned so the strategy attacks right). - A candidate against the champion, side by side on one scale: diff --git a/.claude/skills/field-session/SKILL.md b/.claude/skills/field-session/SKILL.md index 9ceba380..47b83796 100644 --- a/.claude/skills/field-session/SKILL.md +++ b/.claude/skills/field-session/SKILL.md @@ -18,7 +18,7 @@ fix only those. "!!". It cannot see batteries or kicker charge. 2. On a "!!": - **Vision quiet or dropping**: check the network link before any code. Multicast over a - 2.4 GHz phone hotspot dropped frames on 2026-10-29. `pixi run python tools/vision_check.py + 2.4 GHz phone hotspot dropped frames on 2026-10-29. `pixi run python tools/field/vision_check.py --seconds 5` listens alone; `--guided ball` checks cameras against 9 known spots. - **Under 80% of commands answered**: range, interference or a flat battery. - **Lid swapped**: `pixi run find-robots`, and calibrate again (the profile's tag offset @@ -44,19 +44,19 @@ caps are 0.3 m/s and 0.6 rad/s on real robots (balls are lost turning faster). 1. **Keep the raw logs.** `replays/field/_real_.log.gz`. Never delete an untrimmed log or archive; ask before deleting anything under `replays/`. -2. **Trim dead time** to new files: `pixi run python tools/trim_idle_log.py +2. **Trim dead time** to new files: `pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --dry-run`, then without `--dry-run` (`--in-place` only on copies). -3. **Register the session** in `tools/field_sessions.json`: its setup, and which measurements +3. **Register the session** in `tools/field/field_sessions.json`: its setup, and which measurements (`loop_delay`, `ball_roll`, `ball_noise`, `robot_noise`) it may be used for. Only registered sessions are read. -4. **Measure the world**: `pixi run python tools/field_physics.py [--json OUT]` prints each +4. **Measure the world**: `pixi run python tools/field/field_physics.py [--json OUT]` prints each measurement per (day, radio) with its spread and whether the days agree. Stop rule: a number enters the sim (`tools/evaluation/reference/world.json`) only if it repeats across days, or its spread is deliberately used as the range. Changing `world.json` changes every match's environment: every stored result plays again, so batch it and ask first. -5. **One robot's numbers from a log**: `pixi run python tools/robot_calibration.py +5. **One robot's numbers from a log**: `pixi run python tools/field/robot_calibration.py replays/field/.log [--json OUT]`. -6. **Share**: `pixi run python tools/package_logs.py field [DIR] [--dry-run]` compresses the +6. **Share**: `pixi run python tools/field/package_logs.py field [DIR] [--dry-run]` compresses the logs and bundles calibration and hardware config. 7. **Write down** what broke and what was measured (a dated note; open follow-ups listed). Bugs seen on the pitch go through the `debug-incident` skill with the field log as the diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 1a953d02..b8064f9d 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -1,3 +1,3 @@ # Changes here decide what a strategy branch may touch and how it is scored. /.github/ @isaac0804 -/tools/check_strategy_branch.py @isaac0804 +/tools/dev/check_strategy_branch.py @isaac0804 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a9d7cb4b..c8557f7d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -10,7 +10,7 @@ concurrency: cancel-in-progress: true jobs: - # A strategy branch may change only strategy code, not its opponents (tools/check_strategy_branch.py). + # A strategy branch may change only strategy code, not its opponents (tools/dev/check_strategy_branch.py). # Runs the base branch's copy of the checker, so the branch under test can't loosen it. strategy-branch: if: github.event_name == 'pull_request' && startsWith(github.head_ref, 'strategy/') @@ -21,7 +21,7 @@ jobs: fetch-depth: 0 - name: Only strategy code changed run: | - git show "origin/${{ github.base_ref }}:tools/check_strategy_branch.py" > "$RUNNER_TEMP/check_strategy_branch.py" + git show "origin/${{ github.base_ref }}:tools/dev/check_strategy_branch.py" > "$RUNNER_TEMP/check_strategy_branch.py" python3 "$RUNNER_TEMP/check_strategy_branch.py" --base "origin/${{ github.base_ref }}" test: diff --git a/AGENTS.md b/AGENTS.md index 82fbe661..cace7e79 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -37,7 +37,7 @@ One term per thing; reuse these instead of coining new ones. - **Motion planning benchmark** — `tools/motion_planning_benchmark.py`: the planner alone on fixed scenarios. Unrelated to any strategy. - **Moment / regression moment** — a field state (captured from a replay) that reproduced a - bug, with a check of the right behaviour (`utama_core/tests/moments/*.json`, `tools/moments.py`). + bug, with a check of the right behaviour (`utama_core/tests/moments/*.json`, `tools/debug/moments.py`). A cheap end-to-end check, run in `pixi run test`, that a fixed bug stays fixed; the unit test at the cause is the real protection. Not a ranking and not a gate on strategies. The workflow and the bugs found so far: `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure". @@ -45,7 +45,7 @@ One term per thing; reuse these instead of coining new ones. box, danger: defined once, with a diagram, in `docs/pitch_zones.md`. Use those names. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). - **Position map / shot map** — on-pitch pictures of a strategy over many matches, drawn by - `tools/pitch_maps.py` (and `tools/evaluation/explain.py` for a candidate against the champion), always + `tools/debug/pitch_maps.py` (and `tools/evaluation/explain.py` for a candidate against the champion), always turned so the strategy attacks right. Position map: a heatmap of where the outfield robots stand in live play, with the ball and without it, plus each robot's mean position. Shot map: every shot at the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. @@ -62,7 +62,7 @@ One term per thing; reuse these instead of coining new ones. the store holds is never played again. Promoting is a one-line change to `players.json` in a PR; it takes effect as the reference at the next release. Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. -- **Strategy file** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a +- **Strategy file** — a `.strategy` file (`utama_core/bundle/`, `tools/dev/build_strategy.py`) is a zip of one strategy and the whole `utama_core` package at one commit; it plays in its own process, game frames in and robot commands out, in simulation or on real robots (`BundledStrategy(path, robot_ids)`). `evaluate.py` plays the reference from such a file of the last release (kept in `replays/eval/frozen/`), so a change to shared code never moves @@ -71,7 +71,7 @@ One term per thing; reuse these instead of coining new ones. friction, vision noise and dropouts, latency) comes from measurements; robot capability (kick, dribbler, motors) is assumed good at league level, and real robots' shortfalls are compensated in the control layer. The test: would better robots change it? `tools/evaluation/reference/ - world.json`, `robots.json`; field sessions in `tools/field_sessions.json`. + world.json`, `robots.json`; field sessions in `tools/field/field_sessions.json`. - **Situation / goal sources** — a situation starts when a restart goes live or a side wins the ball in open play; the goal sources (`utama_core/analysis/goal_sources.py`) gives each goal to the latest situation less than 10 s before it, so goals per match = Σ situations per match × @@ -130,7 +130,7 @@ declarations) — check there before reintroducing one of them. - **Always pass `--headless`** when running any simulator/integration test: `pixi run pytest utama_core/tests/ --headless`. Much faster; there is no reason to run with graphics in an agent loop. -- A git worktree for a parallel agent: run `tools/setup_worktree.sh` inside it (links `.pixi`, +- A git worktree for a parallel agent: run `tools/dev/setup_worktree.sh` inside it (links `.pixi`, copies the compiled planner/simulator `.so` files; without them tests differ). - `pixi run test` runs the default suite; `pixi run lint` runs the full pre-commit stack (black, ruff, isort) — run both before considering a change done. diff --git a/README.md b/README.md index 8e3bbfa8..53eb1ab5 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ real robots are optional ([external setup](docs/setup_external.md)). |---|---| | Your first strategy | [docs/first_strategy.md](docs/first_strategy.md) | | Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/strategies.md](docs/strategies.md) | -| Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/find_bugs.py RUN_DIR` for a run's worst problems | +| Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/debug/find_bugs.py RUN_DIR` for a run's worst problems | | Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md) | | The referee | [docs/custom_referee.md](docs/custom_referee.md) | | Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 36ae8081..4614002e 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -97,7 +97,7 @@ every outfield robot *before* any `Tactic` ticks, reusing the `*Step` classes in `custom_referee/actions.py`. Strategies can override a restart formation via `Strategy(referee_overrides=...)`. See `docs/custom_referee.md`. -To see where the override sends every robot for a restart, run `tools/restart_picture.py` +To see where the override sends every robot for a restart, run `tools/debug/restart_picture.py` (`REPLAY.npz --t S`, or `--all-restarts` for one small panel per restart command in the replay). It records each commanded target without changing the engine, and flags a target inside the 0.8 m keep-out or a defence area it must avoid. Shown below: one match's restarts from our side (top) and from the other @@ -327,7 +327,7 @@ flowchart TD strategy was checked; "unknown" means none was. - **Output.** `replays/eval_/report.json` (verdicts, per-opponent tables, round 1's signals) and per round `round_/`: each played match's replay, intention log and stats as `_vs_.*`, - `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` + `summary.json` and `ball_losses.md`, the layout `tools/debug/find_bugs.py`, `tools/debug/pitch_maps.py` and `goal_sources` read. A match taken from the store is linked in (symlinks) from the run that played it, so a round folder holds all of its matches; one played before 2026-11-12, or whose run was deleted, has none. - **Two traps in a "better".** The reference's results on every seed are stored and reused, so @@ -360,7 +360,7 @@ reaches `main` by pull request: 2. Change only `utama_core/strategy/`, `utama_core/tactics/` (new modules only), `utama_core/tests/strategy/` (tests for your strategy and any tactic you add) and `docs/strategies.md`. CI fails a `strategy/*` pull request that changes anything else - (`tools/check_strategy_branch.py`, run from `main`'s copy). Anything else it needs, such as a + (`tools/dev/check_strategy_branch.py`, run from `main`'s copy). Anything else it needs, such as a skill or an engine primitive, is a separate change on an ordinary branch. 3. Leave the opponents as they are on `main`: either add new strategy modules or change exactly one existing strategy, never both, and never `pickers.py`, `catalog.py` or an existing tactic: the opponents run those. To improve a tactic, copy it into @@ -399,7 +399,7 @@ whoever runs it. robot/ball trails over a window, optionally anchored on a `MatchLog` event. **Default to this over `load_frames_in_range()`**: a coordinate dump is expensive in context and easy to misread spatially. Use raw frames only for an exact number once the picture has localized the issue. -- **`tools/match_timeline.py`** — one match window as swimlanes on a shared time axis: the referee +- **`tools/debug/match_timeline.py`** — one match window as swimlanes on a shared time axis: the referee command band, one lane per robot coloured by the tactic it was in (a thin tick at each switch, a dark strip where it had the ball), each robot's distance to the ball, and goals, fouls and shots on top. Use it for thrashing (a robot switching tactics every few ticks), a tactic stuck committed, or @@ -410,7 +410,7 @@ whoever runs it. Thrashing in `pendulum` against `weaver`: robots 2-4 flip between the attack and defence slots about every 1.5 s, in pairs of rows at the same tick. It is not pendulum's alone: most strategies that split attack and defence on possession take a tactic for under 1 s and revert about - 5 times a minute (the `tactic_thrash` finding, with the numbers per strategy in `match_timeline.py`): + 5 times a minute (the `tactic_thrash` finding, with the numbers per strategy in `tools/debug/match_timeline.py`): ![pendulum lanes thrashing between attack and defence slots](img/match_timeline/pendulum_100-160.png) - **`render_clip()`** (`analysis/render_clip.py`) — MP4 of a window for humans, ball-following or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind @@ -418,7 +418,7 @@ whoever runs it. - **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. - **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`); see [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: - `tools/repro_from_replay.py` restarts it from any moment with tracing on. + `tools/debug/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and writes `ball_losses.md`; see [Reading a round](#reading-a-round). `python -m utama_core.analysis.turnover_breakdown ` re-runs it on an older run. @@ -439,9 +439,9 @@ whoever runs it. stay paired; the same seed replays a match exactly. Settings and draws go into each replay (`columnar_reader.load_sim_noise`) and `summary.json`, and into the match key only when set. Ranges and their sources are in `tools/evaluation/reference/world.json` (the Phase 1 numbers are in `docs/sim_realism.md`). -- **`tools/replay_trace.py REPLAY.npz T0 T1`** — text trace of a window: referee command and +- **`tools/debug/replay_trace.py REPLAY.npz T0 T1`** — text trace of a window: referee command and why it changed, ball, nearest robot per side. The first look at a stall or a voided restart. -- **`tools/repro_from_replay.py`** — reload a replay's field state at time *t* into a fresh headless +- **`tools/debug/repro_from_replay.py`** — reload a replay's field state at time *t* into a fresh headless match with tracing on, instead of re-running the whole match (`--help` for flags). ### Debugging a foul or failure @@ -451,9 +451,9 @@ override, the planner, the referee itself, or the check that flagged it. Of the this way (table below), two were the referee or the check, not the robot. The steps alone, as a checklist, are the `debug-incident` skill (`.claude/skills/`); this section keeps the reasons and the bugs found. -Start with `tools/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind +Start with `tools/debug/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind and the pictured findings. Filter `findings.jsonl` on the kind you care about, open that finding's picture to see what it -means, and confirm with the numbers in its message (or `replay_trace.py --events`) before concluding anything. `find_bugs.py` reads only the friendly side of +means, and confirm with the numbers in its message (or `tools/debug/replay_trace.py --events`) before concluding anything. `tools/debug/find_bugs.py` reads only the friendly side of each match (the intentions log is written for it): a strategy's matches where it is config_a. In a round each pair plays once, so a strategy is config_a in only some of its matches (`summary.json`'s `stalls_checked` counts them). @@ -461,10 +461,10 @@ The same steps as a flowchart; the moment branch is the optional step 5. ```mermaid flowchart TD - find["1. Find it
find_bugs.py RUN_DIR --strategy NAME
(index.md, then findings.jsonl)"] - look["2. Look at it
replay_trace.py REPLAY T0 T1 --events
repro_from_replay.py REPLAY --t S --summary IDS"] + find["1. Find it
tools/debug/find_bugs.py RUN_DIR --strategy NAME
(index.md, then findings.jsonl)"] + look["2. Look at it
tools/debug/replay_trace.py REPLAY T0 T1 --events
tools/debug/repro_from_replay.py REPLAY --t S --summary IDS"] q{"Restart or placement geometry?
a field state alone decides it"} - moment["Capture a moment
moments.py capture REPLAY --t S
play --seeds 0-4 must fail on 4 of 5"] + moment["Capture a moment
tools/debug/moments.py capture REPLAY --t S
play --seeds 0-4 must fail on 4 of 5"] cause["3. Find the cause in the code
tactic or override, target, planner;
was the rule really broken?"] fix["4. Fix the cause
with a unit test at the boundary"] done["Done: the unit test is the protection
(a captured moment stays as a check)"] @@ -475,28 +475,28 @@ flowchart TD cause --> fix --> done ``` -The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, `pitch_maps.py`) write their flags as JSON with `--findings`: filter on that, open the picture to understand a flag, and never conclude from a picture alone. +The picture tools (`tools/debug/match_timeline.py`, `tools/debug/restart_picture.py`, `tools/debug/plan_trace.py`, `tools/debug/pitch_maps.py`) write their flags as JSON with `--findings`: filter on that, open the picture to understand a flag, and never conclude from a picture alone. -1. **Find it.** `tools/find_bugs.py` is the one starting point for "what went wrong in a run" (see the +1. **Find it.** `tools/debug/find_bugs.py` is the one starting point for "what went wrong in a run" (see the start of this section). It flags thrashing and stalls, and restart geometry with `--restarts`. - For our side's fouls by rule, `pixi run python tools/find_bugs.py ROUND_DIR --fouls --by + For our side's fouls by rule, `pixi run python tools/debug/find_bugs.py ROUND_DIR --fouls --by strategy,rule` counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball leaving the field, is a stoppage and left out unless `--include-stoppages`); without `--by` it lists each with its time, robot, tactic and the referee command then active (`--skip-own-restart` drops fouls during our own restarts; `--json` writes either form as JSON). -2. **Look at it.** `tools/replay_trace.py REPLAY T0 T1` is the text timeline of the window: +2. **Look at it.** `tools/debug/replay_trace.py REPLAY T0 T1` is the text timeline of the window: referee command, ball, nearest robot per side; `--events` lists the kicks, possession, referee changes and fouls instead; `--json` gives either as JSON. - `tools/repro_from_replay.py REPLAY --t S --summary 3` replays that state with the tactics' + `tools/debug/repro_from_replay.py REPLAY --t S --summary 3` replays that state with the tactics' `match_log` tracing on and prints each listed robot's tactic, position and target every 0.25 s (trace keys name tactics, not strategies). In a parallel worktree, run - `tools/setup_worktree.sh` first. + `tools/dev/setup_worktree.sh` first. When a robot does something odd near an obstacle or a keep-out zone (a carrot that swings round a robot, - a robot parked just inside a circle), `tools/plan_snapshot.py REPLAY --t S --robot ID --target X Y` + a robot parked just inside a circle), `tools/debug/plan_snapshot.py REPLAY --t S --robot ID --target X Y` draws what the planner decided on that tick: the obstacles and clearance rings, the keep-out circle, the target and the carrot it returned (`--side enemy` for the other strategy's robot; example: ![kick-off robot parked inside the keep-out circle](img/plan_snapshot/kickoff_keep_out.png)). - `tools/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` runs the same planner on every + `tools/debug/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` runs the same planner on every tick of a window and draws the robot's path, each tick's carrot and the distances over time, so a defect that unfolds over seconds shows as a trace (example: the kick-off robot of ![a kick-off window](img/plan_trace/kickoff_keep_out.png)). The robot's positions are the replay's, @@ -510,7 +510,7 @@ The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, ` target is off the field". That test is the protection, and it does not need the foul to reproduce. 5. **Optionally keep a moment**, where a field state alone decides the behaviour (restart and - placement geometry under the referee override). `tools/moments.py capture REPLAY --t S --name + placement geometry under the referee override). `tools/debug/moments.py capture REPLAY --t S --name ... --check ... --note "..." [--out PATH]` saves the state; `play JSON --seeds 0-4` must fail on at least 4 of 5 before the fix (`--against REF` plays the code at REF beside it; `--events` lists referee changes, fouls, keep-out entries and kicks; `--strategy scratch.py:function` @@ -524,11 +524,11 @@ steered along their recorded paths for 1-2 s (tried 2026-10-17, reverted in `9c2 velocities cannot be set either: every rsim teleport resets all robots (`SSLWorld::replace`). So for open play, go from the trace to the code and a unit test. -A moment's `checks` are `tools/moments.py`'s `CHECKS` (`keeps_clear`, `stop_speed`) or referee rule names; its `requires` (`restart_lasts`, +A moment's `checks` are `tools/debug/moments.py`'s `CHECKS` (`keeps_clear`, `stop_speed`) or referee rule names; its `requires` (`restart_lasts`, `robot_near_ball`) fail it with `did not arise` when the situation it tests never happened. A restart moment plays one strategy, since the referee override moves every outfield robot the same way whatever the strategy. Moments are captured from replays (`capture`); hand-made templates -(`moments.py new`) were removed on 2026-11-11. Moments are not a gate on strategies: they pin shared-code bugs. +(`tools/debug/moments.py new`) were removed on 2026-11-11. Moments are not a gate on strategies: they pin shared-code bugs. | Symptom | Looked like | Cause | Fix | Test | |---|---|---|---|---| @@ -582,11 +582,11 @@ planner, the referee) is failing every strategy at once. ## Real matches -`tools/convert_ssl_log.py` turns the league's official game logs +`tools/realism/convert_ssl_log.py` turns the league's official game logs (https://ssl.robocup.org/game-logs/) into replays in our format, so `load_columnar_replay`, `render_window`, `scenario_from_replay` and the analyses read a real match like one of ours: - pixi run python -I tools/convert_ssl_log.py --corpus 2022-2026 --jobs 2 --out

+ pixi run python -I tools/realism/convert_ssl_log.py --corpus 2022-2026 --jobs 2 --out Only the converted files are kept: each raw log (up to 370 MB) is deleted once converted, and a converted match takes about 35 MB. The published Division B logs for 2022-2026 are 118 @@ -631,4 +631,4 @@ What a converted match holds, and where it differs from a sim replay (the detail filtering (ghost robots, ball jumps), and their referee also sends `GOAL_*` and `INDIRECT_FREE_*`. The corpus above starts in 2022. -The scenario bench (retired 2026-10-17) replayed 10 s starts harvested from replays; to look at one point in a replay use `tools/repro_from_replay.py --t `, and to pin a failure there add a regression moment ("Debugging a foul or failure", above), and `analysis/goal_sources.py` lists a replay's situations and goals. +The scenario bench (retired 2026-10-17) replayed 10 s starts harvested from replays; to look at one point in a replay use `tools/debug/repro_from_replay.py --t `, and to pin a failure there add a regression moment ("Debugging a foul or failure", above), and `analysis/goal_sources.py` lists a replay's situations and goals. diff --git a/docs/architecture.md b/docs/architecture.md index 61f69c82..b1354f8e 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -79,11 +79,11 @@ in the match results store. ## Package dependencies -Generated by `tools/package_graph.py` from the imports of every `.py` under `utama_core/` (tests +Generated by `tools/dev/package_graph.py` from the imports of every `.py` under `utama_core/` (tests excluded as sources). Each edge is one first-level package importing another, labelled with its number of imports; packages with no edges are left out. Regenerate and paste the output below: - pixi run python tools/package_graph.py + pixi run python tools/dev/package_graph.py The only edge into `tests` is `run` (the runner imports `utama_core/tests/common`'s test manager). The rule the script checks: `replay/` never imports `analysis/` (see [AGENTS.md](../AGENTS.md)). diff --git a/docs/contributing.md b/docs/contributing.md index 5a3d39ca..0fd3eed6 100644 --- a/docs/contributing.md +++ b/docs/contributing.md @@ -66,7 +66,7 @@ A pull request into `main` needs: 4. every Copilot comment reviewed (not all must be addressed: Copilot makes mistakes too); 5. an approval from an assigned reviewer. -A strategy branch (`strategy/*`) is also checked by `tools/check_strategy_branch.py`: it must not +A strategy branch (`strategy/*`) is also checked by `tools/dev/check_strategy_branch.py`: it must not change the evaluation or the opponents it is scored against. ## `CLAUDE.md` and `AGENTS.md` diff --git a/docs/field_log_replay.md b/docs/field_log_replay.md index 6487f10e..203aeaab 100644 --- a/docs/field_log_replay.md +++ b/docs/field_log_replay.md @@ -23,8 +23,8 @@ whole loop, so a field symptom becomes a cause, and then a regression test, in m - operator notes (`NOTE`, from the dashboard's Note box); - the run info: code version, the vision-to-radio mapping, the field. - Beside the log is a `.npz` replay of the world the strategy saw. -- `analysis/robot_calibration.py` reads the log for one robot's numbers. `tools/plan_snapshot.py` - draws one planner decision from an `.npz`, and `tools/moments.py` turns an `.npz` tick into a +- `analysis/robot_calibration.py` reads the log for one robot's numbers. `tools/debug/plan_snapshot.py` + draws one planner decision from an `.npz`, and `tools/debug/moments.py` turns an `.npz` tick into a regression moment. Missing: @@ -80,7 +80,7 @@ pictures in the same style as `plan_snapshot`, not plots against time. still move as they really did. So it says what the fixed code would have decided at the moment it went wrong, not what would have happened next. That is exactly the check a fix needs, and why the result is a test and not a claim. -5. `--moment` writes the first diverging tick as a regression moment (`tools/moments.py`'s format) +5. `--moment` writes the first diverging tick as a regression moment (`tools/debug/moments.py`'s format) or a unit-test fixture: robot, ball and referee state, and the command it should have given. The fix's regression test then starts from the real field state. diff --git a/docs/field_logs.md b/docs/field_logs.md index f80ac460..1d806211 100644 --- a/docs/field_logs.md +++ b/docs/field_logs.md @@ -34,10 +34,10 @@ bidirectional radio packets, and session metadata. Every field log contains the ground-truth signals needed to evaluate robot hardware: -### Robot Calibration (`tools/robot_calibration.py`) +### Robot Calibration (`tools/field/robot_calibration.py`) Recovers physical dynamics and kicker geometry from a field test: ```bash -pixi run python tools/robot_calibration.py replays/field/.log.gz +pixi run python tools/field/robot_calibration.py replays/field/.log.gz ``` - **Loop Latency**: Sensing-to-action delay measured between commanded motion and camera-observed velocity (~61–62 ms). - **Acceleration Limits**: Measured forward acceleration (~4.0–6.0 m/s²) vs. lateral acceleration (~2.7–3.6 m/s²). @@ -58,10 +58,10 @@ Scans logs for incidents where robots came closer than 0.25 m: pixi run python -m utama_core.analysis.close_calls replays/field/*real*.log.gz ``` -### Converting to Replay (`tools/convert_ssl_log.py`) +### Converting to Replay (`tools/realism/convert_ssl_log.py`) Converts an SSL game log into our columnar `.npz` + `.pkl` replay format for replay visualization and scenario debugging: ```bash -pixi run python tools/convert_ssl_log.py replays/field/.log.gz --out replays/field/ +pixi run python tools/realism/convert_ssl_log.py replays/field/.log.gz --out replays/field/ ``` --- @@ -77,14 +77,14 @@ pixi run package-field --compress-in-place ``` Reduces log sizes by **50%–60%** with zero data loss. All analysis tools support `.log.gz` out of the box. -### 2. Trimming Idle Time Sectors (`tools/trim_idle_log.py`) +### 2. Trimming Idle Time Sectors (`tools/field/trim_idle_log.py`) Field sessions frequently capture long periods of inactivity where the referee command is `HALT` or `STOP` (e.g. operators manually setting up the ball or discussing tests). Over **55% of field log duration is trailing dead time**: ```bash # Preview reduction without modifying files -pixi run python tools/trim_idle_log.py replays/field/.log.gz --dry-run +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --dry-run # Trim dead stretches and trailing halt in-place -pixi run python tools/trim_idle_log.py replays/field/.log.gz --in-place +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --in-place # Or batch trim all field logs: pixi run trim-field ``` @@ -92,7 +92,7 @@ pixi run trim-field - Fully strips trailing idle time recorded after drills end. - Typically cuts file size by **65%–75%** while preserving every active drill frame. -### 3. Packaging & Distributing (`tools/package_logs.py`) +### 3. Packaging & Distributing (`tools/field/package_logs.py`) Creates self-contained release archives of field logs and calibration results: ```bash pixi run package-field diff --git a/docs/img/architecture/make_match_data_flow.py b/docs/img/architecture/make_match_data_flow.py index 4cbd7572..7f640559 100644 --- a/docs/img/architecture/make_match_data_flow.py +++ b/docs/img/architecture/make_match_data_flow.py @@ -14,7 +14,7 @@ NAMES = [ "StrategyRunner", "tools/evaluation/evaluate.py", - "tools/convert_ssl_log.py", + "tools/realism/convert_ssl_log.py", "utama_core/run/strategy_runner.py", "utama_core/replay/ssl_log.py", "utama_core/replay/columnar_writer.py", @@ -29,9 +29,9 @@ "utama_core/analysis/turnover_breakdown.py", "utama_core/analysis/restart_outcomes.py", "utama_core/analysis/stuck_detector.py", - "tools/moments.py", - "tools/replay_trace.py", - "tools/repro_from_replay.py", + "tools/debug/moments.py", + "tools/debug/replay_trace.py", + "tools/debug/repro_from_replay.py", ] d = Diagram( @@ -97,7 +97,7 @@ "chances, turnover_breakdown,\nrestart_outcomes, stuck_detector", kind="output", ) -d.box(165, 48, 34, 18, "tools/", "moments.py,\nreplay_trace.py,\nrepro_from_replay.py", kind="output") +d.box(165, 48, 34, 18, "tools/debug/", "moments.py,\nreplay_trace.py,\nrepro_from_replay.py", kind="output") d.box(165, 26, 34, 12, "ratings.py", "the verdict's test", kind="output") d.arrow((142, 98), (148, 92)) d.arrow((142, 94), (148, 72)) diff --git a/docs/in_house_vision.md b/docs/in_house_vision.md index 38a71ada..bbcfe293 100644 --- a/docs/in_house_vision.md +++ b/docs/in_house_vision.md @@ -17,7 +17,7 @@ per camera, our stack in WSL on the robot laptop (`docs/real_robot_setup.md`). early on; after the distortion was retuned in ssl-vision, 5 cm, then 85 mm later in the day (`replays/field/20261022_211142_score_goal.log`, constant 83–85 mm in every frame). Something moved between those checks, and nothing tells us when. -- **Against known spots** (`vision_check.py --guided ball`, +- **Against known spots** (`tools/field/vision_check.py --guided ball`, `replays/field/20261022_212332_vision_truth_ball.json`): camera 0 saw 7 of 9 points, 33 mm mean error, 61 mm worst; camera 1 saw 5 of 9, 55 mm mean, 92 mm worst. Neither saw the ball at (1500, 0), right in front of the +x goal. @@ -51,7 +51,7 @@ Built during the test day; it hides the cameras' disagreement but cannot remove - `PositionRefiner` takes a ball inside the field or a goal over one outside them, then the one nearest the last ball. Replayed, `20261022_213347_score_goal.log`'s ball jumps of over 0.3 m in one frame went from 5,439 to 4. -- `tools/vision_check.py` prints where each camera puts each robot and ball and the gap +- `tools/field/vision_check.py` prints where each camera puts each robot and ball and the gap between them, and with `--guided` checks each camera against 9 known spots and saves the result as a baseline. @@ -202,7 +202,7 @@ Run on recorded frames where possible, so they need no test-day time beyond the focal length and distortion. - Tags or checkerboards on known spots for each camera's position and height; feed the result into ssl-vision. -- Rerun `vision_check.py --guided ball` and compare with the 2026-10-22 baseline above. +- Rerun `tools/field/vision_check.py --guided ball` and compare with the 2026-10-22 baseline above. - **Down to about 1 cm:** calibration was the main problem. Stay on ssl-vision with our calibration tool (option 1), and assumption 2 is wrong. - **Not down:** the error is elsewhere (colour, ssl-vision's simpler camera model), which @@ -222,7 +222,7 @@ None yet. Record each result here with its date, the recording it used and the n ## Plan now (team decision, 2026-10-25) -The team chose the full in-house stack. The guided check by hand (`vision_check.py --guided`) +The team chose the full in-house stack. The guided check by hand (`tools/field/vision_check.py --guided`) took too long to run every session, and we have one ball, which rolls off its spot. So experiments 1 and 2 no longer decide anything: their questions become pass marks below. Every step is measured on recordings, so most of the work happens off test days. diff --git a/docs/motion_planning_comparison.md b/docs/motion_planning_comparison.md index 7da01c0d..b3ebcc07 100644 --- a/docs/motion_planning_comparison.md +++ b/docs/motion_planning_comparison.md @@ -74,8 +74,8 @@ restarts occur. ### FastPathPlanner (`fpp`) decisions per tick Each tick, `FastPathPlanner._path_to` turns the robot's target into a carrot point for the PID. The -flowchart is that call's decision order. `tools/plan_snapshot.py` draws the carrot and the planner's -inputs for one logged tick. `tools/plan_trace.py` runs the same `_path_to` on every tick of a window and +flowchart is that call's decision order. `tools/debug/plan_snapshot.py` draws the carrot and the planner's +inputs for one logged tick. `tools/debug/plan_trace.py` runs the same `_path_to` on every tick of a window and draws how the carrot moved against the robot's path, which a single tick cannot show. Robot positions are the replay's, not re-simulated, so it shows what the current planner would do from each recorded state; the kick-off example is in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure". diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index e47df6d9..9ae0656f 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -2,12 +2,12 @@ The procedure for a test day with real robots: ssl-vision on its own Linux laptop sending vision over the network, and our stack on a Windows laptop in WSL with the radio dongle. Each part is -checked on its own before anything drives a robot: vision with `tools/vision_check.py`, the radio +checked on its own before anything drives a robot: vision with `tools/field/vision_check.py`, the radio with teleop, then both together in the field check of `examples/shooting_drill.py`. ``` vision laptop (Linux) robot laptop (Windows + WSL) - cameras -> ssl-vision --multicast--> tools/vision_check.py, then the runner + cameras -> ssl-vision --multicast--> tools/field/vision_check.py, then the runner 224.5.23.2:10006 radio dongle (USB, passed into WSL) -> robots ``` @@ -22,7 +22,7 @@ vision laptop (Linux) robot laptop (Windows + WSL) README lists, then `sudo sh install_spinnaker.sh`: yes to the udev entry (add your user to `flirimaging`) and to USB-FS 1000 MB. Build ssl-vision with `cmake -B build -DUSE_SPINNAKER=true -DUSE_V4L=true && make -C build`. -2. Add our field as a preset: `git apply tools/ssl-vision-lab-field.patch` in the ssl-vision +2. Add our field as a preset: `git apply tools/field/ssl-vision-lab-field.patch` in the ssl-vision checkout (copy the file over), then rebuild. Field Configuration gets a **Lab Field** button (3 m x 2.25 m, goal 0.8 m, defense area 1 m x 0.5 m, two cameras). Do not use the Division B button with two cameras: it sets the camera count to 1. @@ -91,14 +91,14 @@ with **Save Settings**, not on a crash. On the robot laptop, in WSL: ``` -pixi run python tools/vision_check.py +pixi run python tools/field/vision_check.py ``` Expect each camera at about its frame rate and the field at 3000 x 2250 mm. Nothing at all means the network or the firewall (steps 3-4 above, step 1 here); one camera missing means its capture is not running. -After a calibration, check it against known spots: `tools/vision_check.py --guided ball`, then +After a calibration, check it against known spots: `tools/field/vision_check.py --guided ball`, then `--guided "blue 2"` (any robot, facing +x). It asks for the ball or robot on the 9 points (corners, edge midpoints, centre) and prints each camera's error there; the results land in `replays/field/*_vision_truth_*.json` to compare with the next setup. The pattern points at the @@ -261,7 +261,7 @@ the new profile is no worse. Ten kicks a side tell apart only differences of a f Calibrate every robot, twice per session (early and late): how far the two runs disagree is how far to trust them. An older log is measured again with -`pixi run python tools/robot_calibration.py replays/field/.log --tag yellow:0 0 -0.002` +`pixi run python tools/field/robot_calibration.py replays/field/.log --tag yellow:0 0 -0.002` (`--tag` per robot: its `tag_forward_m`, `tag_left_m`). diff --git a/docs/roadmap.md b/docs/roadmap.md index a204d054..fbb3f8db 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -86,7 +86,7 @@ entry by its title, not its number. (`ci.yml:41,43`). 7. **Match timeline in the dashboard.** Built 2026-10-21 (`dashboard/static/timeline.js`): the - swimlanes of `tools/match_timeline.py` (referee band, each robot's tactic, possession, distance + swimlanes of `tools/debug/match_timeline.py` (referee band, each robot's tactic, possession, distance to the ball, events) under the Replay tab's controls, following the cursor, click or drag to seek; and in the Live tab, the last minutes up to now. Switch ticks, shots and a possession band (each situation's side) as in the tool. The Replay side panel's Play list replaces the raw @@ -161,7 +161,7 @@ entry by its title, not its number. spread in the sim (more realistic, but noisier round-robins). - *Measuring, built 2026-10-21:* every camera run records an SSL game log (raw vision, referee, radio bytes both ways: `GameLogWriter`); `examples/shooting_drill.py - --calibrate` plays fixed moves (`tactics/scripted_moves.py`), and `tools/robot_calibration.py` + --calibrate` plays fixed moves (`tactics/scripted_moves.py`), and `tools/field/robot_calibration.py` measures loop delay, speed gain, acceleration, vision noise and kick speed from any such log. Checked on a synthetic robot (delay within 10 ms, acceleration within 15 %; turn acceleration only roughly, its ramp lasts a few frames) and on grSim; not yet on a real robot. diff --git a/docs/signals.md b/docs/signals.md index 94601d3e..2408eed5 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -86,7 +86,7 @@ Check these first: a broken strategy's other signals mean nothing. | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Stalls | STALLS; `stats.stall_events` | `RESTART_STALL`: a restart held > 15 s, with a one-line diagnosis. `COMMITTED_FROZEN`: ball moved < 5 cm for > 10 s in live play while a slot was committed, with who holds the ball | 10 of 231 matches | A bug to fix before anything else. Restart it from its replay with `tools/repro_from_replay.py`, look with `tools/replay_trace.py` and `render_window()` | +| Stalls | STALLS; `stats.stall_events` | `RESTART_STALL`: a restart held > 15 s, with a one-line diagnosis. `COMMITTED_FROZEN`: ball moved < 5 cm for > 10 s in live play while a slot was committed, with who holds the ball | 10 of 231 matches | A bug to fix before anything else. Restart it from its replay with `tools/debug/repro_from_replay.py`, look with `tools/debug/replay_trace.py` and `render_window()` | | Possession backstop | `results[*].possession_backstop` | possession pinned 100/0 with the ball barely moving: a freeze the watchdog missed | 0 | Same as a stall | | Restarts not taken | RESTARTS; `restarts.by_kind[*].outcomes` | a kickoff, free kick or penalty `voided`, `timeout`, `stopped_before_kick` instead of `taken` | free kicks: 3414 taken of 3467 | The taker can't reach or kick the ball: restart positioning, a planner clamp, a keep-out circle | | Fouls by rule | FOULS; `fouls` | every foul by rule, then strategy/tactic of the offending robot | per strategy 6.3 (`chameleon`) · 7.9 · 23.3 (`three_slot`); run: out_of_bounds 2938, excessive_dribbling 448, defense_area 310, crashing 307 | One tactic dominating a rule is its bug: dribbling too far, entering the box, driving into robots | diff --git a/docs/sim_realism.md b/docs/sim_realism.md index a2e6c94e..24a53501 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -43,7 +43,7 @@ and are replaced by our own measurements once hardware tests are possible. ## What we found (2026-10-14) -Real: 54 official Division B matches from 2025–2026 (`tools/convert_ssl_log.py`). Sim: the +Real: 54 official Division B matches from 2025–2026 (`tools/realism/convert_ssl_log.py`). Sim: the baseline round-robin `tournament_20261014_144456` (66 matches). An expected-goals (xG) model was fitted on real shots. On held-out matches it ranks shots with AUC 0.82 and its predicted rates agree with observed ones. @@ -92,7 +92,7 @@ friction). **Within** means kick-to-kick noise for the same robot. | Parameter | Why it matters | From official logs? | rsim today | |---|---|---|---| -| Sensing-to-action latency (vision, decision, radio, motor response) | Likeliest cause of the keeper gap | Only as other teams' total reaction time: from a kick to their keeper accelerating; for our robots, `tools/robot_calibration.py` on a recorded field test (command sent to motion seen) | None: commands act on the next tick | +| Sensing-to-action latency (vision, decision, radio, motor response) | Likeliest cause of the keeper gap | Only as other teams' total reaction time: from a kick to their keeper accelerating; for our robots, `tools/field/robot_calibration.py` on a recorded field test (command sent to motion seen) | None: commands act on the next tick | | Ball rolling deceleration (and the switch from sliding to rolling) | Pass and shot timing; keeper reaction time | Yes: fit free-rolling segments, per match (venue carpet) | Fixed in the C++ physics (`vendor/rSim`) | | Kick speed: between and within | How much time the keeper has; pass weight | Yes: peak ball speed after each kick, per team | Fixed | | Kick direction error | Wide rate (6% vs 22%) | Partly: shot miss distance, pass error relative to the receiver | None: exact | @@ -165,7 +165,7 @@ starts. Evaluation changes and strategy changes go in separate commits. ### Phase 0: Bring the analysis into the repo (2–3 days) — done 2026-10-16 -`pixi run python tools/realism_scorecard.py` (see `docs/tools.md`); package +`pixi run python tools/realism/realism_scorecard.py` (see `docs/tools.md`); package `utama_core/analysis/realism/`, real reference `real_2025_2026.json`. On the baseline it reproduces the outcome numbers above. Rows failing on the baseline: goal rate in every xG band, keeper and defender share, wide or post, ball speed kept, kick speed spread, keeper @@ -179,7 +179,7 @@ The xG and shot-outcome analysis currently lives outside the repo (`~/dev/ssl/xg minutes late. - `xg.py`: the model fit and the decomposition. - `shot_outcomes.py`: what happened to each shot. -- Add a `tools/realism_scorecard.py` entry point, and unit tests on the shot detector and goal +- Add a `tools/realism/realism_scorecard.py` entry point, and unit tests on the shot detector and goal linking using small synthetic frames. - Commit the fitted real xG coefficients as data, so the sim side doesn't need the real logs. - Done when: the scorecard reproduces the numbers above for the baseline. @@ -424,7 +424,7 @@ From the logs in `replays/field/20261022_*_real_*.log`, one robot (blue 2, firmw and kicked 9 times, so these are small samples. The radio log (`RADIO_OUT`) says when the dribbler and kicker were commanded. Kicks and ball slow-down come from one camera's raw ball detections, because the two cameras disagreed by several cm. Vision noise comes from -`tools/robot_calibration.py`. +`tools/field/robot_calibration.py`. | Measure | Ours | League / sim | |---|---|---| @@ -575,5 +575,5 @@ from one match per pairing is not evidence. - [`signals.md`](signals.md): how strategies are measured. - [`roadmap.md`](roadmap.md): the workstream entry. -- `tools/convert_ssl_log.py`: official logs as replays. +- `tools/realism/convert_ssl_log.py`: official logs as replays. - `vendor/rSim/FORK_NOTES.md`: physics fork changes. diff --git a/docs/strategies.md b/docs/strategies.md index 12ece412..82af76b5 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -9,7 +9,7 @@ Run: at the last release: stalls and signals (`--all` plays every strategy). - `pixi run python tools/evaluation/evaluate.py ` — judges a candidate against the champion at the last release. The way to judge a strategy. `--help` lists the flags. -- `pixi run python tools/debug_match.py --strategy --opponent [--dump-ticks PATH]` — one +- `pixi run python tools/debug/debug_match.py --strategy --opponent [--dump-ticks PATH]` — one instrumented matchup. rsim is deterministic: re-running an identical match gives an identical result. Variance comes diff --git a/docs/tools.md b/docs/tools.md index d85d6df8..dbcc873a 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -29,9 +29,9 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion at the last release. The only verdict | | Does everything still run after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches); `--all` for the whole catalog, occasionally | | Did a shared-code change help? | `tools/evaluation/evaluate.py `: today's champion, on today's shared code, against itself at the last release | -| What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | -| Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | -| Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | +| What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/debug/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | +| Keep a fixed bug fixed? | A unit test at the cause. `tools/debug/moments.py capture` writes a regression moment, which runs in `pixi run test` | +| Look closely at one thing? | `tools/debug/repro_from_replay.py`, `tools/debug/replay_trace.py`, the picture tools, `tools/debug/debug_match.py` | | Is the simulator realistic? | [Simulator realism](#simulator-realism). Not strategy development | ## pixi tasks @@ -48,7 +48,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `replay [-n NAME] [-p]` | play a legacy pickle replay `replays/NAME.pkl` in the rSoccer viewer (newest if no name; `-p` step by step). Today's `.npz` replays open in the dashboard instead | | `runs` | list the tournament runs in `replays/`: start time, commit, matches, stalls, arguments | | `debug-robots` | keyboard/click teleoperation GUI for real robots over the serial radio (robots chosen by radio ID; [real_robot_setup.md](real_robot_setup.md)) | -| `field-check` | the start of a test day in one command (`tools/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([real_robot_setup.md](real_robot_setup.md#each-test-day)) | +| `field-check` | the start of a test day in one command (`tools/field/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([real_robot_setup.md](real_robot_setup.md#each-test-day)) | | `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | | `demos` | every dashboard demo from one command (`examples/demos.py`, `--mode rsim` to rehearse, `--demo` the first): one dashboard stays up and the Live tab's Demo panel switches demo while halted (robots stopped, log saved, radio and vision released, the page reloads by itself), sets the first robot, camera half and rules for the next run, runs the field check, and offers teleop by keyboard ([real_robot_setup.md](real_robot_setup.md#running-the-demos)) | | `calibrate` | measure one real robot from the terminal and write its profile (`examples/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | @@ -57,7 +57,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Script | Purpose | |---|---| -| `tools/setup_worktree.sh` | Run inside a git worktree: links `.pixi` to the main checkout's and copies the gitignored compiled `.so` extensions (planner, rsim). Idempotent; one line per action | +| `tools/dev/setup_worktree.sh` | Run inside a git worktree: links `.pixi` to the main checkout's and copies the gitignored compiled `.so` extensions (planner, rsim). Idempotent; one line per action | ## Playing matches @@ -65,10 +65,10 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ |---|---| | `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the open candidates: a screen on seeds 1-6 that drops a candidate whose mean paired diff against the reference is <= 0, then the survivors on fresh seeds 101-106, better if a one-sided paired t-test gives p <= 0.05, else undecided (`analysis/ratings.py`). Each round uses one sim-noise seed in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | | `tools/evaluation/verdict_sim.py` | How often `evaluate.py`'s rule is right, on simulated results (no matches): better / dropped / undecided rates per effect size, correlation and number of opponents. Rerun after changing the rule or `analysis/ratings.py` | -| `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | -| `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | +| `utama_core/run/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `tools/debug/repro_from_replay.py`, `tools/debug/moments.py`, `tools/debug/debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | +| `tools/dev/build_strategy.py` | `tools/dev/build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | -| `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `tools/sim_setup.py` (not run directly) | +| `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `utama_core/run/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: recorded replays and run results | @@ -79,19 +79,19 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | +| `tools/debug/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | | `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | -| `tools/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | +| `tools/dev/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | ## Real matches | Script | Purpose | |---|---| -| `tools/convert_ssl_log.py` | Official RoboCup SSL game logs to replays in our format, so the analyses run on real matches: given logs, or `--corpus 2022-2026` to download and convert every published Division B match, deleting each raw log once converted (`--keep-raw` keeps it; downloads cut short are resumed; each conversion's memory is capped by `--max-memory-gb`). Also writes sidecars for measuring physics: the tracker's kicks and visibility, and with `--raw-vision` every raw camera detection; `--backfill-extras` adds them to matches already converted. What a converted match holds and its limits: [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md#real-matches) | +| `tools/realism/convert_ssl_log.py` | Official RoboCup SSL game logs to replays in our format, so the analyses run on real matches: given logs, or `--corpus 2022-2026` to download and convert every published Division B match, deleting each raw log once converted (`--keep-raw` keeps it; downloads cut short are resumed; each conversion's memory is capped by `--max-memory-gb`). Also writes sidecars for measuring physics: the tracker's kicks and visibility, and with `--raw-vision` every raw camera detection; `--backfill-extras` adds them to matches already converted. What a converted match holds and its limits: [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md#real-matches) | ## Debugging a match -The four picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, `pitch_maps.py`) each take +The four picture tools (`tools/debug/match_timeline.py`, `tools/debug/restart_picture.py`, `tools/debug/plan_trace.py`, `tools/debug/pitch_maps.py`) each take `--findings PATH` (`-` for stdout) and write the problems they flag as JSON lines, one `Finding` per line (`utama_core/analysis/findings.py`): @@ -105,15 +105,15 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or | Script | Purpose | |---|---| -| `tools/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its matches in a round), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | -| `tools/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | -| `tools/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | -| `tools/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Referee handling" | -| `tools/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `find_bugs.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/debug_match.py` | One ad hoc match between two strategies for tactic debugging; `--dump-ticks` writes per-tick poses and commanded targets | +| `tools/debug/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its matches in a round), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `tools/debug/moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | +| `tools/debug/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | +| `tools/debug/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | +| `tools/debug/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Referee handling" | +| `tools/debug/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `tools/debug/find_bugs.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/debug_match.py` | One ad hoc match between two strategies for tactic debugging; `--dump-ticks` writes per-tick poses and commanded targets | Library helpers for the same job (`render_window`, `render_clip`, `MatchLog.trace()`) are described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). @@ -123,21 +123,21 @@ described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). Is the simulator close to the real league, and are its physics settings measured? These tools judge the simulator, not a strategy: none of them is part of strategy development. The plan and the results are in [sim_realism.md](sim_realism.md). Their inputs are the official logs converted by -`tools/convert_ssl_log.py` (its kick and visibility sidecars, see [Real matches](#real-matches)) and +`tools/realism/convert_ssl_log.py` (its kick and visibility sidecars, see [Real matches](#real-matches)) and the field logs in `replays/field/`. | Script | Purpose | |---|---| -| `tools/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. See [sim_realism.md](sim_realism.md) | +| `tools/realism/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. See [sim_realism.md](sim_realism.md) | | `utama_core/analysis/physics_ranges.py` | `python -m utama_core.analysis.physics_ranges --real --sim `: physics parameter ranges for the sim-realism plan ([sim_realism.md](sim_realism.md)): ball deceleration by speed and time since a kick, rolling-segment fits, robot speed, acceleration, braking and turn-rate percentiles per robot, and dropped detections, with spreads between matches, robots and teams | -| `tools/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field_sessions.json` allows, and prints how well runs, days and radios agree. | -| `tools/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/convert_ssl_log.py` | +| `tools/field/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field/field_sessions.json` allows, and prints how well runs, days and radios agree. | +| `tools/field/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/realism/convert_ssl_log.py` | ## Architecture | Script | Purpose | |---|---| -| `tools/package_graph.py` | The import graph between `utama_core/` packages, as a Mermaid flowchart with import counts, from `ast` (nothing is imported), plus any violation of the stated import rules (`replay/` never imports `analysis/`). Its output is kept in [architecture.md](architecture.md) | +| `tools/dev/package_graph.py` | The import graph between `utama_core/` packages, as a Mermaid flowchart with import counts, from `ast` (nothing is imported), plus any violation of the stated import rules (`replay/` never imports `analysis/`). Its output is kept in [architecture.md](architecture.md) | ## Benchmarks @@ -164,10 +164,10 @@ the field logs in `replays/field/`. | `examples/score_goal.py` | One robot, no opponent, takes the ball and scores, on a real robot (or `--mode rsim`); also a demo in `pixi run demos` | | `examples/dribble_and_shoot.py` | `score_goal.py`'s robot dribbles a lap of the field, then scores | | `examples/passing_rally.py` | `pass_receive.py`'s pair passing their way along the field in two lanes, turning round `TURN_M` from each end line, for ever (no shots) | -| `tools/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | -| `tools/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([field_logs.md](field_logs.md)) | -| `tools/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([field_logs.md](field_logs.md)) | -| `tools/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | +| `tools/field/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | +| `tools/field/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([field_logs.md](field_logs.md)) | +| `tools/field/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([field_logs.md](field_logs.md)) | +| `tools/field/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | | `examples/demo_dribbler_test.py` | One robot dribbling round a rectangle on the Exhibition Road field | diff --git a/docs/visual_guide.md b/docs/visual_guide.md index 1e7bd27b..152f5cf5 100644 --- a/docs/visual_guide.md +++ b/docs/visual_guide.md @@ -17,7 +17,7 @@ so the studied strategy attacks right. Zone names (defensive third, the box, ... ## Start here: find bugs -`pixi run python tools/find_bugs.py RUN_DIR --strategy NAME` picks the strategy's worst matches (by goal +`pixi run python tools/debug/find_bugs.py RUN_DIR --strategy NAME` picks the strategy's worst matches (by goal difference, among those it played as config_a), collects every problem the tools flag (tactic flip-backs, stalls, and with `--restarts` illegal restart targets), and draws the worst few with the picture for that kind. Read its `index.md` first: each problem's numbers, then the picture path. About 20 s a match @@ -81,7 +81,7 @@ two and a half times the next strategy; the others take 69-98. Each foul at the ball's spot, coloured by rule (one fixed colour per rule, the same in every panel): which rules a strategy breaks, and where on the pitch. -Draw: `pixi run python tools/pitch_maps.py replays/tournament_` (a full round-robin, about 3 min). +Draw: `pixi run python tools/debug/pitch_maps.py replays/tournament_` (a full round-robin, about 3 min). ## 2. A candidate against the champion @@ -109,7 +109,7 @@ whole round-robin, a tactic held under 1 s and then reverted (a flip-back) happe minute in most strategies that split attack and defence on possession, 13 in `terrier`, and almost never in `ricochet`, `wolfpack` or `mirage`. Not fixed yet. -Draw: `pixi run python tools/match_timeline.py REPLAY.npz T0 T1`. +Draw: `pixi run python tools/debug/match_timeline.py REPLAY.npz T0 T1`. ## 4. A restart @@ -123,7 +123,7 @@ Robot 3 starts inside the circle and is sent to exactly 0.80 m. Across more replays this picture found a real defect: the step that clears robots out of the circle stops 1 cm short and leaves them at 0.79 m (`keep_out_short` in the findings). Fixed. -Draw: `pixi run python tools/restart_picture.py REPLAY.npz --t S`, or `--all-restarts` for one panel per +Draw: `pixi run python tools/debug/restart_picture.py REPLAY.npz --t S`, or `--all-restarts` for one panel per restart command in the match. ## 5. The motion planner on fixed scenarios @@ -163,7 +163,7 @@ tick). Here `weaver`'s robot 4 (the replay's enemy side) sits on the keep-out ci (−1.0, −0.3) is across the circle. The planner's answer is a carrot 5 cm away: push the robot out to 0.85 m first. -Draw: `pixi run python tools/plan_snapshot.py REPLAY.npz --t S --robot ID [--side enemy] [--target X Y]`. +Draw: `pixi run python tools/debug/plan_snapshot.py REPLAY.npz --t S --robot ID [--side enemy] [--target X Y]`. ### A window @@ -180,7 +180,7 @@ robot's path is the old behaviour, and the carrot line (0.05 m, at 0.85 m from t planner would do from there: push out first. The annotation names it "pushed out of the keep-out"; a short carrot with nothing to push out of is labelled "parked". -Draw: `pixi run python tools/plan_trace.py REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] +Draw: `pixi run python tools/debug/plan_trace.py REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y]`. ## Which picture for which question diff --git a/examples/score_goal.py b/examples/score_goal.py index f5a659f0..a7b6bd0c 100644 --- a/examples/score_goal.py +++ b/examples/score_goal.py @@ -19,7 +19,7 @@ (that one halts on the second robot it never sees): it plays fixed moves (`tactics/scripted_moves.py`) instead of shooting. Put it near the middle of the camera's view facing +x, with 0.8 m clear ahead and 0.6 m to its left, and a ball at rest in view; Force Start. -Then: pixi run python tools/robot_calibration.py replays/field/_calibrate.log +Then: pixi run python tools/field/robot_calibration.py replays/field/_calibrate.log """ import sys diff --git a/examples/shooting_drill.py b/examples/shooting_drill.py index 7c44cc8e..774a0569 100644 --- a/examples/shooting_drill.py +++ b/examples/shooting_drill.py @@ -31,7 +31,7 @@ 1 m/s, sideways, turns) while the other stands still. Put it 1 m inside the area, facing along the field's long side, and a ball at rest in view; Force Start. Halting (to put it back) restarts the interrupted move. Then measure it from the recorded log: - pixi run python tools/robot_calibration.py replays/field/.log + pixi run python tools/field/robot_calibration.py replays/field/.log Calibrate near the middle of the camera's view: its noise grows towards the image edges. Run it twice per robot (early and late): how far the two runs disagree is how far to trust them. Gain and loop delay should agree closely; acceleration, turning above all, is only rough. @@ -39,7 +39,7 @@ The rest of a test day's measurements, any run (every real run records a log): - Floor friction: roll the ball by hand across open floor 8-10 times at different speeds, away from robots. Then convert the log and fit its free-rolling segments: - pixi run python tools/convert_ssl_log.py replays/field/.log --out replays/field/converted + pixi run python tools/realism/convert_ssl_log.py replays/field/.log --out replays/field/converted pixi run python -m utama_core.analysis.physics_ranges --real replays/field/converted The result replaces BALL_ROLL_DECEL (`config/settings.py`, the league's 0.29 m/s^2). - Kick speed: 5+ kicks per robot with the ball placed at its kicker (the attacker kicks in diff --git a/main.py b/main.py index 150334d3..d59996c4 100644 --- a/main.py +++ b/main.py @@ -4,7 +4,7 @@ Run: pixi run main # pendulum vs wolfpack pixi run main pendulum riptide # any two names from docs/strategies.md - pixi run main a.strategy wolfpack # or a .strategy file (tools/build_strategy.py) + pixi run main a.strategy wolfpack # or a .strategy file (tools/dev/build_strategy.py) # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop Yellow (the first strategy) starts on the right and kicks off. For many matches with @@ -13,11 +13,11 @@ import argparse -from tools.sim_setup import UnknownStrategy, load_side, sim_referee, sim_runner from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.run.sim_setup import UnknownStrategy, load_side, sim_referee, sim_runner def _strategy(name: str) -> AbstractStrategy: diff --git a/pixi.toml b/pixi.toml index 8561e4ba..691381e1 100644 --- a/pixi.toml +++ b/pixi.toml @@ -62,11 +62,11 @@ runs = "python -m utama_core.analysis.list_runs" debug-robots = "python -m utama_core.team_controller.debug_utils.telop_gui" calibrate = "python examples/calibrate_robot.py" find-robots = "python -m utama_core.team_controller.controllers.real.find_robots" -field-check = "python tools/field_check.py" +field-check = "python tools/field/field_check.py" demos = "python examples/demos.py" -package-results = "python tools/package_logs.py tournament" -package-field = "python tools/package_logs.py field" -trim-field = "python tools/trim_idle_log.py replays/field/*.log.gz" +package-results = "python tools/field/package_logs.py tournament" +package-field = "python tools/field/package_logs.py field" +trim-field = "python tools/field/trim_idle_log.py replays/field/*.log.gz" precommit-install = "pre-commit install && pixi run pre-commit install --hook-type pre-commit" precommit-uninstall = "pre-commit uninstall" diff --git a/tools/__init__.py b/tools/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tools/debug/__init__.py b/tools/debug/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tools/debug_match.py b/tools/debug/debug_match.py similarity index 97% rename from tools/debug_match.py rename to tools/debug/debug_match.py index 8c433363..e88a3c8c 100644 --- a/tools/debug_match.py +++ b/tools/debug/debug_match.py @@ -1,7 +1,7 @@ -"""debug_match.py — one-off ad hoc match runner for tactic debugging. +"""tools/debug/debug_match.py — one-off ad hoc match runner for tactic debugging. Run: - pixi run python tools/debug_match.py --strategy riptide \\ + pixi run python tools/debug/debug_match.py --strategy riptide \\ --opponent wolfpack --duration 90 --headless Replaces the pattern of hand-writing a fresh `StrategyRunner(...)` block per @@ -38,14 +38,14 @@ import sys from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) from tools.evaluation.match import TICKS_PER_SECOND -from tools.sim_setup import UnknownStrategy, load_side, sim_runner from utama_core.engine.match_log import load_jsonl from utama_core.run import StrategyRunner +from utama_core.run.sim_setup import UnknownStrategy, load_side, sim_runner class _TargetRecorder: diff --git a/tools/figure_style.py b/tools/debug/figure_style.py similarity index 100% rename from tools/figure_style.py rename to tools/debug/figure_style.py diff --git a/tools/find_bugs.py b/tools/debug/find_bugs.py similarity index 96% rename from tools/find_bugs.py rename to tools/debug/find_bugs.py index d2bd97a2..4885f2d3 100644 --- a/tools/find_bugs.py +++ b/tools/debug/find_bugs.py @@ -2,7 +2,7 @@ # ruff: noqa: E402 """Find the bugs in a run dir: which problems happened in which matches, with the numbers, and a picture for the worst. - pixi run python tools/find_bugs.py REPLAYS_OR_RUN_DIR [--strategy NAME ...] [--matches 3] [--out DIR] + pixi run python tools/debug/find_bugs.py REPLAYS_OR_RUN_DIR [--strategy NAME ...] [--matches 3] [--out DIR] [--max-pictures 8] [--workers 2] [--restarts] Start here when a strategy plays badly. For each strategy the friendly side (config_a, the only side the @@ -12,7 +12,7 @@ - `stall` (`stuck_detector.find_stuck_windows`): a window with the ball frozen while a friendly robot oscillates, or a restart held far too long (`restart_stall`). No `plan_trace` here: it needs the robot's target, which the replay does not record, and a guessed target draws carrots that mean nothing; trace a stalled robot by hand - with `tools/plan_trace.py --target X Y` once you know where it was going; + with `tools/debug/plan_trace.py --target X Y` once you know where it was going; - `target_in_keep_out`, `keep_out_short`, `target_in_defense_area` (`restart_picture.restart_findings`): only with `--restarts`, which is slow (about 45 s a match). @@ -27,12 +27,12 @@ `--fouls` instead lists our side's (config_a's) fouls in a round-robin run, each with the referee command active then and whether that restart was ours or theirs: the starting points for a regression moment -(`tools/moments.py capture`). `--rule NAME` keeps one rule, `--skip-own-restart` leaves out fouls during our +(`tools/debug/moments.py capture`). `--rule NAME` keeps one rule, `--skip-own-restart` leaves out fouls during our own restarts, `--by strategy,rule` counts per combination instead (columns: strategy, rule, tactic, restart), `--json` writes JSON. `out_of_bounds`, the ball leaving the field, is a stoppage and is left out -unless `--include-stoppages` (`utama_core/analysis/fouls.py`; until 2026-11-11 `moments.py fouls`). +unless `--include-stoppages` (`utama_core/analysis/fouls.py`; until 2026-11-11 `tools/debug/moments.py fouls`). - pixi run python tools/find_bugs.py replays/eval_/round_1 --fouls [--rule keep_out] [--by strategy,rule] + pixi run python tools/debug/find_bugs.py replays/eval_/round_1 --fouls [--rule keep_out] [--by strategy,rule] """ from __future__ import annotations @@ -51,13 +51,13 @@ os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import match_timeline +from tools.debug import match_timeline +from tools.debug.plan_trace import replay_game_at from tools.evaluation.match import _short_name -from tools.plan_trace import replay_game_at from utama_core.analysis import fouls as fouls_lib from utama_core.analysis.findings import Finding, write_jsonl from utama_core.analysis.matches import STEM, Match, load_match diff --git a/tools/match_timeline.py b/tools/debug/match_timeline.py similarity index 98% rename from tools/match_timeline.py rename to tools/debug/match_timeline.py index 847960c9..9305c04b 100644 --- a/tools/match_timeline.py +++ b/tools/debug/match_timeline.py @@ -2,7 +2,7 @@ # ruff: noqa: E402 """One match window as swimlanes: referee command, each robot's tactic, distance to the ball, events. - pixi run python tools/match_timeline.py replays/eval_/round_1/_vs_.npz 100 160 --side friendly + pixi run python tools/debug/match_timeline.py replays/eval_/round_1/_vs_.npz 100 160 --side friendly Stacked panels on one time axis (Gantt-style, no dual axes): 1. the referee command band: live play, STOP, kickoff, free kick, penalty, placement, HALT (goal and @@ -19,7 +19,7 @@ Prints, for the side: tactic switches per minute and the longest single tactic span, per robot. `--out` defaults to a `.timeline__-.png` beside the replay. -Reuses `tools/replay_trace.py` for the event list (kicks, possession, referee changes, fouls, goals) and +Reuses `tools/debug/replay_trace.py` for the event list (kicks, possession, referee changes, fouls, goals) and the status messages, and `analysis/turnover_breakdown.analyse_match` for shots. """ @@ -42,11 +42,11 @@ import numpy as np # noqa: E402 from matplotlib.patches import Patch # noqa: E402 -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import replay_trace # noqa: E402 +from tools.debug import replay_trace # noqa: E402 from utama_core.analysis import turnover_breakdown # noqa: E402 from utama_core.analysis.findings import Finding, write_jsonl # noqa: E402 from utama_core.entities.referee.referee_command import RefereeCommand # noqa: E402 @@ -64,7 +64,7 @@ # Under this much live play a rate is noise (one switch in 10 s reads as 6 per minute): no thrash finding. MIN_LIVE_S = 30.0 -# Styling shared with tools/figure_style.py so the figures read as one set. +# Styling shared with tools/debug/figure_style.py so the figures read as one set. INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" FOR, AGAINST = "#2a78d6", "#eb6834" # categorical slots 1 and 2 SLOTS = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6"] diff --git a/tools/moments.py b/tools/debug/moments.py similarity index 97% rename from tools/moments.py rename to tools/debug/moments.py index bd5a3e78..8bb8c8e6 100644 --- a/tools/moments.py +++ b/tools/debug/moments.py @@ -34,19 +34,19 @@ A moment comes from a replay (`capture`); `save` and `load` refuse an invalid one, naming each problem (ids, field lines, check and strategy names). Starting points: our side's fouls in a run, -`pixi run python tools/find_bugs.py replays/eval_/round_1 --fouls` (until 2026-11-11 `moments.py fouls`). +`pixi run python tools/debug/find_bugs.py replays/eval_/round_1 --fouls` (until 2026-11-11 `tools/debug/moments.py fouls`). Capture one from a replay (its noise and designated position come with it; `--out` writes elsewhere than utama_core/tests/moments/): - pixi run python tools/moments.py capture replays/eval_/round_1/_vs_.npz --t 254.65 \\ + pixi run python tools/debug/moments.py capture replays/eval_/round_1/_vs_.npz --t 254.65 \\ --name free_kick_defender_drives_in --check keeps_clear --strategy --opponent \\ --note "..." [--out PATH] Play one (`--seed N` replays its noise with another seed, the JSON untouched): - pixi run python tools/moments.py play utama_core/tests/moments/.json [--strategy NAME] [--seed N] + pixi run python tools/debug/moments.py play utama_core/tests/moments/.json [--strategy NAME] [--seed N] Play it under several seeds as one table, compare with the code at a git ref (a worktree under `AGAINST_DIR`, to remove with `git worktree remove --force`), look at its events (referee changes, fouls, keep-out entries, kicks, closest approaches), or try a scratch strategy file's factory: - pixi run python tools/moments.py play --seeds 0-4 [--against HEAD~3] [--events] - pixi run python tools/moments.py play --strategy path/to/scratch.py:my + pixi run python tools/debug/moments.py play --seeds 0-4 [--against HEAD~3] [--events] + pixi run python tools/debug/moments.py play --strategy path/to/scratch.py:my """ from __future__ import annotations @@ -67,11 +67,10 @@ from pathlib import Path from typing import Callable, Optional -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import sim_setup # noqa: E402 from tools.evaluation.match import ( # noqa: E402 N_OUTFIELD, OUTFIELD_ROBOT_IDS, @@ -84,6 +83,7 @@ Scenario, scenario_from_replay, ) +from utama_core.run import sim_setup # noqa: E402 from utama_core.strategy.catalog import plain_name # noqa: E402 MOMENTS_DIR = REPO_ROOT / "utama_core" / "tests" / "moments" @@ -671,7 +671,7 @@ def _git(*args: str, cwd: Path = REPO_ROOT) -> str: def ref_worktree(ref: str) -> Path: """A worktree of the tree at `ref` under `AGAINST_DIR` (reused if it is there at that commit), - with the main tree's `.pixi` and compiled extensions, and this `tools/moments.py` in place of + with the main tree's `.pixi` and compiled extensions, and this `tools/debug/moments.py` in place of its own: the same judge plays the moment, only the code under test differs, so any commit can be compared, including ones from before `--seeds`. Not removed afterwards.""" sha = _git("rev-parse", "--verify", f"{ref}^{{commit}}") @@ -689,12 +689,16 @@ def ref_worktree(ref: str) -> Path: for pattern in BUILD_ARTIFACTS: for src in REPO_ROOT.glob(pattern): shutil.copy2(src, path / src.relative_to(REPO_ROOT)) - shutil.copy2(Path(__file__).resolve(), path / "tools" / "moments.py") + (path / "tools" / "debug").mkdir(parents=True, exist_ok=True) + shutil.copy2(Path(__file__).resolve(), path / "tools" / "debug" / "moments.py") + sim = path / "utama_core" / "run" / "sim_setup.py" + if not sim.exists(): # a commit from before sim_setup moved into utama_core: the judge needs it + shutil.copy2(sim_setup.__file__, sim) return path def ref_cells(json_path: Path, name: str, seeds: list[int], tree: Path) -> dict[int, list[str]]: - """{seed: failures} for one strategy, played in `tree` by this `tools/moments.py` (copied there by + """{seed: failures} for one strategy, played in `tree` by this `tools/debug/moments.py` (copied there by `ref_worktree`; its env's python, run directly so pixi cannot re-solve the shared env).""" fd, out = tempfile.mkstemp(dir=AGAINST_DIR, suffix=".json") os.close(fd) @@ -702,7 +706,7 @@ def ref_cells(json_path: Path, name: str, seeds: list[int], tree: Path) -> dict[ env = {**os.environ, "PATH": f"{python.parent}{os.pathsep}{os.environ.get('PATH', '')}"} cmd = [ str(python), - "tools/moments.py", + "tools/debug/moments.py", "play", str(json_path), "--strategy", diff --git a/tools/pitch_maps.py b/tools/debug/pitch_maps.py similarity index 99% rename from tools/pitch_maps.py rename to tools/debug/pitch_maps.py index aff46537..411ee050 100644 --- a/tools/pitch_maps.py +++ b/tools/debug/pitch_maps.py @@ -1,6 +1,6 @@ """On-pitch pictures of how each strategy plays, from one round-robin run. - pixi run python tools/pitch_maps.py replays/eval_/round_1 [--out docs/img/signals] + pixi run python tools/debug/pitch_maps.py replays/eval_/round_1 [--out docs/img/signals] Every strategy gets one panel per figure, in name order (never a ranking). All panels use one frame: the strategy attacks toward +x, its own goal is on the left (-x), and @@ -41,11 +41,11 @@ from matplotlib.colors import LinearSegmentedColormap # noqa: E402 from matplotlib.patches import Circle, Rectangle # noqa: E402 -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import figure_style as sr # noqa: E402 +from tools.debug import figure_style as sr # noqa: E402 from utama_core.analysis import turnover_breakdown # noqa: E402 from utama_core.analysis.findings import Finding, write_jsonl # noqa: E402 from utama_core.config.field_params import STANDARD_FIELD_DIMS as F # noqa: E402 diff --git a/tools/plan_snapshot.py b/tools/debug/plan_snapshot.py similarity index 95% rename from tools/plan_snapshot.py rename to tools/debug/plan_snapshot.py index 5efcf5d1..a8442dc2 100644 --- a/tools/plan_snapshot.py +++ b/tools/debug/plan_snapshot.py @@ -1,6 +1,6 @@ """Picture of what the fast-path planner decided for one robot on one tick. - pixi run python tools/plan_snapshot.py REPLAY.npz --t 260 --robot 4 --target -1.0 -0.3 --side enemy + pixi run python tools/debug/plan_snapshot.py REPLAY.npz --t 260 --robot 4 --target -1.0 -0.3 --side enemy Rebuilds the field state at `--t` from the replay (`utama_core.replay.scenario`), runs the planner's `_path_to` for the robot toward `--target`, and writes a PNG: the pitch around the robot, every robot @@ -12,7 +12,7 @@ Use it when a robot does something odd near an obstacle or a keep-out zone (see docs/STRATEGY_DEVELOPMENT.md, "Debugging a foul or failure"). The picture is one tick: pair it with -`tools/replay_trace.py` for the timeline. +`tools/debug/replay_trace.py` for the timeline. """ from __future__ import annotations @@ -21,7 +21,7 @@ import sys from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/plan_trace.py b/tools/debug/plan_trace.py similarity index 95% rename from tools/plan_trace.py rename to tools/debug/plan_trace.py index c89ccb65..a76df0a5 100644 --- a/tools/plan_trace.py +++ b/tools/debug/plan_trace.py @@ -1,6 +1,6 @@ """The fast-path planner over a time window: one robot's plan, tick by tick. - pixi run python tools/plan_trace.py REPLAY.npz --t0 250 --t1 262 --robot 4 --side enemy --target -1.0 -0.3 + pixi run python tools/debug/plan_trace.py REPLAY.npz --t0 250 --t1 262 --robot 4 --side enemy --target -1.0 -0.3 For each sampled time in [t0, t1] (every `--step` s) it rebuilds the field state from the replay (`utama_core.replay.scenario`), runs the planner's `_path_to` for the robot, and records the robot's @@ -9,7 +9,7 @@ carrot joined to the robot, above time panels for robot-to-ball distance (with the keep-out distance), robot-to-carrot length, speed and the referee command. Read-only; the planner is not changed. Without `--target` each tick's target is the robot's position `--lookahead` s later, the -stand-in `tools/plan_snapshot.py` uses; the figure says so. `--json` prints the per-sample rows. +stand-in `tools/debug/plan_snapshot.py` uses; the figure says so. `--json` prints the per-sample rows. Use it when a robot's behaviour near an obstacle or keep-out zone unfolds over time, where one `plan_snapshot` tick cannot show it (see docs/STRATEGY_DEVELOPMENT.md, "Debugging a foul or failure"). @@ -26,7 +26,7 @@ os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") # keep pygame's banner off stdout (--findings -) -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/replay_trace.py b/tools/debug/replay_trace.py similarity index 98% rename from tools/replay_trace.py rename to tools/debug/replay_trace.py index a7da13d4..784c4bdb 100644 --- a/tools/replay_trace.py +++ b/tools/debug/replay_trace.py @@ -5,7 +5,7 @@ The first thing to run on a stalled match or a voided restart, before rendering it: - pixi run python tools/replay_trace.py replays/tournament_/_vs_.npz 20 40 + pixi run python tools/debug/replay_trace.py replays/tournament_/_vs_.npz 20 40 `--events` prints the events in the window instead of the periodic rows, one line each: KICK the ball's speed rises by >= 0.5 m/s in one tick, or leaves rest (< 0.5 to >= 1.0 m/s); @@ -40,7 +40,7 @@ import numpy as np -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/repro_from_replay.py b/tools/debug/repro_from_replay.py similarity index 98% rename from tools/repro_from_replay.py rename to tools/debug/repro_from_replay.py index c21e234b..13c92713 100644 --- a/tools/repro_from_replay.py +++ b/tools/debug/repro_from_replay.py @@ -1,4 +1,4 @@ -"""repro_from_replay.py — reload a replay's field state at a given timestamp +"""tools/debug/repro_from_replay.py — reload a replay's field state at a given timestamp into a fresh headless rsim match, and tick forward with match_log tracing on. Why this exists: finding a stall today means running an evaluation @@ -41,7 +41,7 @@ starts with whatever the freshly-seeded `CustomReferee` defaults to. Usage: - pixi run python tools/repro_from_replay.py replays/tournament_.../match.npz \\ + pixi run python tools/debug/repro_from_replay.py replays/tournament_.../match.npz \\ --t 260 --duration 15 --control-scheme trajsample \\ --trace-out /tmp/repro_trace.jsonl @@ -87,18 +87,18 @@ class name (e.g. "DecoyOverloadTactic"), on a release why, else null. Written wh from pathlib import Path from typing import Optional -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) from tools.evaluation.match import N_OUTFIELD, OUTFIELD_ROBOT_IDS, TICKS_PER_SECOND -from tools.sim_setup import load_side, sim_runner from utama_core.bundle.strategy_file import SUFFIX from utama_core.engine.match_log import load_jsonl from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.columnar_reader import load_sim_noise from utama_core.replay.scenario import Scenario, apply_scenario, scenario_from_replay from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise +from utama_core.run.sim_setup import load_side, sim_runner from utama_core.strategy import catalog _STILL_STALLED_WINDOW_S = 10.0 diff --git a/tools/restart_picture.py b/tools/debug/restart_picture.py similarity index 95% rename from tools/restart_picture.py rename to tools/debug/restart_picture.py index 46693d25..844d979d 100644 --- a/tools/restart_picture.py +++ b/tools/debug/restart_picture.py @@ -1,8 +1,8 @@ """Picture of where the referee override sends every robot for one restart. - pixi run python tools/restart_picture.py REPLAY.npz --t 260 [--side enemy] [--out PATH] - pixi run python tools/restart_picture.py REPLAY.npz --all-restarts [--side enemy] [--out PATH] - pixi run python tools/restart_picture.py REPLAY.npz --findings - [--side enemy] + pixi run python tools/debug/restart_picture.py REPLAY.npz --t 260 [--side enemy] [--out PATH] + pixi run python tools/debug/restart_picture.py REPLAY.npz --all-restarts [--side enemy] [--out PATH] + pixi run python tools/debug/restart_picture.py REPLAY.npz --findings - [--side enemy] Rebuilds the field state at `--t` from the replay (`utama_core.replay.scenario`), runs `RefereeOverride.tick` for the replay's referee command there, exactly as the strategy does, and draws @@ -34,7 +34,7 @@ os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1") # keep pygame's banner off stdout (--findings -) -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/dev/__init__.py b/tools/dev/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tools/build_strategy.py b/tools/dev/build_strategy.py similarity index 80% rename from tools/build_strategy.py rename to tools/dev/build_strategy.py index dadfb347..0ab97b0c 100644 --- a/tools/build_strategy.py +++ b/tools/dev/build_strategy.py @@ -1,7 +1,7 @@ """Pack one strategy and the code it runs on into a `.strategy` file. - pixi run python tools/build_strategy.py pendulum pendulum.strategy - pixi run python tools/build_strategy.py pendulum frozen.strategy --ref v2.5.0 + pixi run python tools/dev/build_strategy.py pendulum pendulum.strategy + pixi run python tools/dev/build_strategy.py pendulum frozen.strategy --ref v2.5.0 Without `--ref` it takes the working tree as it stands, uncommitted changes included. """ @@ -10,7 +10,7 @@ import sys from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/check_strategy_branch.py b/tools/dev/check_strategy_branch.py similarity index 98% rename from tools/check_strategy_branch.py rename to tools/dev/check_strategy_branch.py index 0de78253..2498cfac 100644 --- a/tools/check_strategy_branch.py +++ b/tools/dev/check_strategy_branch.py @@ -1,7 +1,7 @@ -"""check_strategy_branch.py — fail if a strategy branch could score better without playing better. +"""tools/dev/check_strategy_branch.py — fail if a strategy branch could score better without playing better. Run: - python tools/check_strategy_branch.py --base origin/main + python tools/dev/check_strategy_branch.py --base origin/main A strategy is scored by the round-robin and the evaluation. If the branch that changes it, often written by an agent, could also change the evaluation or its opponents, it could raise its score diff --git a/tools/package_graph.py b/tools/dev/package_graph.py similarity index 98% rename from tools/package_graph.py rename to tools/dev/package_graph.py index 15e519b7..f805f96c 100644 --- a/tools/package_graph.py +++ b/tools/dev/package_graph.py @@ -1,6 +1,6 @@ """Package dependency graph of `utama_core/`, as a Mermaid flowchart, and the stated import rules it breaks. - pixi run python tools/package_graph.py + pixi run python tools/dev/package_graph.py Parses every `.py` under `utama_core/` with `ast` (nothing is imported) and counts imports between first-level packages (`engine`, `replay`, ...). Test code is not scanned as a source, but an import @@ -21,7 +21,7 @@ from dataclasses import dataclass from pathlib import Path -ROOT = Path(__file__).resolve().parent.parent +ROOT = Path(__file__).resolve().parents[2] PACKAGE = "utama_core" TESTS = "tests" diff --git a/tools/setup_worktree.sh b/tools/dev/setup_worktree.sh similarity index 92% rename from tools/setup_worktree.sh rename to tools/dev/setup_worktree.sh index 2641b0b4..758c4c8d 100755 --- a/tools/setup_worktree.sh +++ b/tools/dev/setup_worktree.sh @@ -1,5 +1,5 @@ #!/usr/bin/env bash -# setup_worktree.sh — prepare a git worktree of this repo to run tests and tools. +# tools/dev/setup_worktree.sh — prepare a git worktree of this repo to run tests and tools. # # Run inside the worktree (not the main checkout). It makes the worktree usable without a # fresh `pixi install` or planner build: @@ -8,7 +8,7 @@ # the main checkout. Without them the planner falls back to Python and results differ. # Idempotent: re-running changes nothing that is already in place. Prints one line per action. # -# Usage: tools/setup_worktree.sh +# Usage: tools/dev/setup_worktree.sh set -euo pipefail wt_root="$(git rev-parse --show-toplevel)" diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index dc5338e0..58c5cc9a 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -15,9 +15,9 @@ - `fouls.png`: each strategy's fouls by rule, one fixed colour per rule (`pitch_maps.plot_fouls`); - `summary.json`: the numbers behind the pictures per side, and the paired goal difference per opponent (same opponent, seed and colour, as `evaluate.py` pairs them), where the run has them. -- `find_bugs/`: `tools/find_bugs.py` on the candidate's two worst matches as config_a (`index.md` first). +- `find_bugs/`: `tools/debug/find_bugs.py` on the candidate's two worst matches as config_a (`index.md` first). -Everything is in the attacking frame of `pitch_maps.py` (attacking right). Goals come from the +Everything is in the attacking frame of `tools/debug/pitch_maps.py` (attacking right). Goals come from the replay's final referee state (the score), fouls from the match's `.stats.json`. """ @@ -40,9 +40,9 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools import figure_style as sr # noqa: E402 -from tools import find_bugs # noqa: E402 -from tools import pitch_maps as pm # noqa: E402 +from tools.debug import figure_style as sr # noqa: E402 +from tools.debug import find_bugs # noqa: E402 +from tools.debug import pitch_maps as pm # noqa: E402 from tools.evaluation.match import _short_name # noqa: E402 from utama_core.analysis.matches import Match, find_matches # noqa: E402 @@ -194,7 +194,7 @@ def explain(run_dir, candidate: str, champion: str, out_dir, workers: int = 2) - "fouls_rules_shown": pm.top_rules(views), "notes": ( "Matches are those in the run dir; a match reused from the store is a link to the run that played it. " - "Positions and fouls exclude the goalkeeper and out-of-bounds (as pitch_maps.py)." + "Positions and fouls exclude the goalkeeper and out-of-bounds (as tools/debug/pitch_maps.py)." ), } (out_dir / "summary.json").write_text(json.dumps(summary, indent=2)) diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index 15aecbbb..1dda4d01 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -14,7 +14,7 @@ that logic lives now; each script above is a thin CLI over it, differing only in which strategies it selects, what duration it uses, and whether it sweeps side/kickoff as independent axes. The strategies, referee and rsim runner of a -match come from `tools/sim_setup.py`, the one set-up the debugging tools share. +match come from `utama_core/run/sim_setup.py`, the one set-up the debugging tools share. """ from __future__ import annotations @@ -24,13 +24,6 @@ from pathlib import Path from typing import Optional -from tools.sim_setup import ( # noqa: F401 -- re-exported - N_OUTFIELD, - OUTFIELD_ROBOT_IDS, - load_side, - sim_referee, - sim_runner, -) from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy from utama_core.config.settings import REPLAY_BASE_PATH from utama_core.entities.referee.referee_command import RefereeCommand @@ -40,6 +33,13 @@ enable_sim_reuse, ) from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise +from utama_core.run.sim_setup import ( # noqa: F401 -- re-exported + N_OUTFIELD, + OUTFIELD_ROBOT_IDS, + load_side, + sim_referee, + sim_runner, +) from utama_core.strategy import catalog from utama_core.strategy.catalog import plain_name diff --git a/tools/evaluation/reference/world.json b/tools/evaluation/reference/world.json index 3220a7e4..4382ddd7 100644 --- a/tools/evaluation/reference/world.json +++ b/tools/evaluation/reference/world.json @@ -8,10 +8,10 @@ "ball_slide_decel": [2.5, 4.0] }, "sources": { - "latency_s": "Field logs (tools/field_physics.py, tools/field_sessions.json): command to vision about 50 to 60 ms on 2026-10-28 (2 radios, wired vision), 80 to 88 ms on 2026-10-27 (one calibration run). The range spans both.", + "latency_s": "Field logs (tools/field/field_physics.py, tools/field/field_sessions.json): command to vision about 50 to 60 ms on 2026-10-28 (2 radios, wired vision), 80 to 88 ms on 2026-10-27 (one calibration run). The range spans both.", "vision": "League logs, docs/sim_realism.md: robot noise 0.4 to 1 mm, heading 0.2 to 0.3 degrees. Our lab's ball at rest measures 0.3 to 0.7 mm.", "vanishing": "League logs, docs/sim_realism.md: 0.1 to 0.9% of detections missing.", - "ball_roll_decel": "Spans our carpet, about 0.20 m/s^2 (2026-10-28, 43 kicks, tools/field_physics.py), to the league's, about 0.29 (docs/sim_realism.md) and a little above.", + "ball_roll_decel": "Spans our carpet, about 0.20 m/s^2 (2026-10-28, 43 kicks, tools/field/field_physics.py), to the league's, about 0.29 (docs/sim_realism.md) and a little above.", "ball_slide_decel": "docs/sim_realism.md, unchanged from the 2026-10-17 settings." } } diff --git a/tools/field/__init__.py b/tools/field/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tools/field_check.py b/tools/field/field_check.py similarity index 94% rename from tools/field_check.py rename to tools/field/field_check.py index 714b5335..d533291a 100644 --- a/tools/field_check.py +++ b/tools/field/field_check.py @@ -6,7 +6,7 @@ pixi run field-check # radios 0 to 7 pixi run field-check --radios 0 1 -1. Vision (`vision_check.py`, 2 s): cameras and their packets per second, the field size, the ball +1. Vision (`tools/field/vision_check.py`, 2 s): cameras and their packets per second, the field size, the ball and the lids in view. Nothing heard: it stops there. 2. Robots (`find-robots`): each radio that answers turns about 70 degrees on the spot and back; the lid that turned is its; the share of its commands it answered; its profile. The pairing is @@ -21,8 +21,8 @@ import sys from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] -for p in (REPO_ROOT, REPO_ROOT / "tools"): +REPO_ROOT = Path(__file__).resolve().parents[2] +for p in (REPO_ROOT, REPO_ROOT / "tools" / "field"): if str(p) not in sys.path: sys.path.insert(0, str(p)) diff --git a/tools/field_physics.py b/tools/field/field_physics.py similarity index 97% rename from tools/field_physics.py rename to tools/field/field_physics.py index 9d19ba1d..586b5e29 100644 --- a/tools/field_physics.py +++ b/tools/field/field_physics.py @@ -1,11 +1,11 @@ """World physics measured from field logs, for the sim's settings: loop delay, ball rolling deceleration, and detection noise at rest for the ball and the robots. -Only the sessions and measurements allowed in `tools/field_sessions.json` are read. Each log's +Only the sessions and measurements allowed in `tools/field/field_sessions.json` are read. Each log's values are grouped by (day, radio) and printed as a median with its middle half and count, then checked for agreement across the groups: a setting is only trusted if the days repeat it. - pixi run python tools/field_physics.py [--logs replays/field] [--workers 2] [--json OUT] + pixi run python tools/field/field_physics.py [--logs replays/field] [--workers 2] [--json OUT] """ from __future__ import annotations @@ -21,7 +21,7 @@ import numpy as np -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/field_sessions.json b/tools/field/field_sessions.json similarity index 88% rename from tools/field_sessions.json rename to tools/field/field_sessions.json index 1557b969..0e9fa976 100644 --- a/tools/field_sessions.json +++ b/tools/field/field_sessions.json @@ -1,5 +1,5 @@ { - "note": "Every field session, and which measurements it may be used for. tools/field_physics.py reads only what is allowed here. Stop rule: a number enters the sim only if it repeats across runs, or its spread is deliberately used as the range.", + "note": "Every field session, and which measurements it may be used for. tools/field/field_physics.py reads only what is allowed here. Stop rule: a number enters the sim only if it repeats across runs, or its spread is deliberately used as the range.", "source_archive": "replays/field_logs_20261102_211613.tar.gz (untrimmed, local only; do not delete). Trimmed logs: release v2.5.0, field_logs_20261102_233700.tar.gz.", "measurements": ["loop_delay", "ball_roll", "ball_noise", "robot_noise"], "sessions": { diff --git a/tools/package_logs.py b/tools/field/package_logs.py similarity index 97% rename from tools/package_logs.py rename to tools/field/package_logs.py index ebaa110b..17fd3584 100644 --- a/tools/package_logs.py +++ b/tools/field/package_logs.py @@ -8,8 +8,8 @@ with calibration files and hardware configurations for sharing. Usage: - pixi run python tools/package_logs.py tournament [DIR_OR_ID] [--out OUT] [--with-intentions] [--dry-run] - pixi run python tools/package_logs.py field [DIR] [--out OUT] [--compress-in-place] [--dry-run] + pixi run python tools/field/package_logs.py tournament [DIR_OR_ID] [--out OUT] [--with-intentions] [--dry-run] + pixi run python tools/field/package_logs.py field [DIR] [--out OUT] [--compress-in-place] [--dry-run] """ from __future__ import annotations @@ -24,7 +24,7 @@ from pathlib import Path from typing import Optional, Sequence -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] def find_latest_tournament(replays_dir: Path) -> Optional[Path]: diff --git a/tools/robot_calibration.py b/tools/field/robot_calibration.py similarity index 74% rename from tools/robot_calibration.py rename to tools/field/robot_calibration.py index 6e7b733e..c799f992 100644 --- a/tools/robot_calibration.py +++ b/tools/field/robot_calibration.py @@ -2,13 +2,13 @@ """A robot's numbers (loop delay, speed and turn tracking, acceleration, vision noise, kick speed) from a recorded field test. See `utama_core/analysis/robot_calibration.py`. - pixi run python tools/robot_calibration.py replays/field/.log [--json OUT] + pixi run python tools/field/robot_calibration.py replays/field/.log [--json OUT] """ import sys from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/ssl-vision-lab-field.patch b/tools/field/ssl-vision-lab-field.patch similarity index 100% rename from tools/ssl-vision-lab-field.patch rename to tools/field/ssl-vision-lab-field.patch diff --git a/tools/trim_idle_log.py b/tools/field/trim_idle_log.py similarity index 97% rename from tools/trim_idle_log.py rename to tools/field/trim_idle_log.py index e49bfe8f..10b7e914 100644 --- a/tools/trim_idle_log.py +++ b/tools/field/trim_idle_log.py @@ -7,8 +7,8 @@ transitions. Usage: - pixi run python tools/trim_idle_log.py replays/field/.log.gz [--out OUT] [--dry-run] - pixi run python tools/trim_idle_log.py replays/field/*.log.gz --in-place + pixi run python tools/field/trim_idle_log.py replays/field/.log.gz [--out OUT] [--dry-run] + pixi run python tools/field/trim_idle_log.py replays/field/*.log.gz --in-place """ from __future__ import annotations @@ -21,7 +21,7 @@ from pathlib import Path from typing import Iterator, Optional, Sequence -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/vision_check.py b/tools/field/vision_check.py similarity index 98% rename from tools/vision_check.py rename to tools/field/vision_check.py index cf5a7405..c1b34b01 100644 --- a/tools/vision_check.py +++ b/tools/field/vision_check.py @@ -13,8 +13,8 @@ each camera's error at each point. Cameras that agree with each other can both be wrong; this says by how much. The results are saved to `replays/field/` as the baseline for the next setup. - pixi run python tools/vision_check.py [--seconds 5] - pixi run python tools/vision_check.py --guided ball [--seconds 2] + pixi run python tools/field/vision_check.py [--seconds 5] + pixi run python tools/field/vision_check.py --guided ball [--seconds 2] """ import argparse @@ -28,7 +28,7 @@ from itertools import combinations from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index 2ae462b9..2eb33ab4 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -1198,7 +1198,7 @@ def markdown_report(payload: dict) -> str: # --- Figures (`--figures DIR`) ------------------------------------------------------------- -# Style copied from tools/figure_style.py. matplotlib is imported only when figures are written, +# Style copied from tools/debug/figure_style.py. matplotlib is imported only when figures are written, # so a default run neither loads it nor changes its output. INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" # Categorical slots in fixed order. A scheme keeps the same slot in every figure; slots are never cycled. diff --git a/tools/realism/__init__.py b/tools/realism/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tools/convert_ssl_log.py b/tools/realism/convert_ssl_log.py similarity index 97% rename from tools/convert_ssl_log.py rename to tools/realism/convert_ssl_log.py index 37df43cd..481c73c6 100644 --- a/tools/convert_ssl_log.py +++ b/tools/realism/convert_ssl_log.py @@ -1,7 +1,7 @@ """Official RoboCup SSL game logs as replays in our format (`utama_core/replay/ssl_log.py`). - pixi run python tools/convert_ssl_log.py LOG_OR_DIR ... --out DIR [--raw-vision] - pixi run python tools/convert_ssl_log.py --corpus 2022-2026 --out DIR [--division div-b] [--jobs 4] + pixi run python tools/realism/convert_ssl_log.py LOG_OR_DIR ... --out DIR [--raw-vision] + pixi run python tools/realism/convert_ssl_log.py --corpus 2022-2026 --out DIR [--division div-b] [--jobs 4] [--raw-vision] [--backfill-extras] The first form converts game logs (`*.log.gz`; a directory: every log under it). The second @@ -44,7 +44,7 @@ from concurrent.futures import ProcessPoolExecutor from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parents[1] +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/tools/realism_scorecard.py b/tools/realism/realism_scorecard.py similarity index 91% rename from tools/realism_scorecard.py rename to tools/realism/realism_scorecard.py index 83f22abc..318ad686 100644 --- a/tools/realism_scorecard.py +++ b/tools/realism/realism_scorecard.py @@ -3,12 +3,12 @@ """Realism scorecard: a round-robin's matches against real Division B matches, component by component (attempts, chance quality, keeper saves, misses, ball slow-down, kick speed ...). - # the real side, from converted official logs (`tools/convert_ssl_log.py`); rewrites the + # the real side, from converted official logs (`tools/realism/convert_ssl_log.py`); rewrites the # committed reference (xG model + real rows) - pixi run python tools/realism_scorecard.py --real ~/dev/ssl/official-logs/2025 ~/dev/ssl/official-logs/2026 + pixi run python tools/realism/realism_scorecard.py --real ~/dev/ssl/official-logs/2025 ~/dev/ssl/official-logs/2026 # a round-robin against the reference - pixi run python tools/realism_scorecard.py --sim replays/tournament_ + pixi run python tools/realism/realism_scorecard.py --sim replays/tournament_ Per-match shot records are cached: the real ones in `--real-cache`, the sim ones in `/realism_shots.jsonl`; a cache is reused unless `--refresh`. What each row means and @@ -23,7 +23,7 @@ from concurrent.futures import ProcessPoolExecutor from pathlib import Path -REPO_ROOT = Path(__file__).resolve().parent.parent +REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) diff --git a/utama_core/analysis/close_calls.py b/utama_core/analysis/close_calls.py index 91fef62c..76c845b7 100644 --- a/utama_core/analysis/close_calls.py +++ b/utama_core/analysis/close_calls.py @@ -4,7 +4,7 @@ Reads SSL game logs written on real robots (`StrategyRunner(game_log_path=...)`): the camera's raw detections (one camera per robot, `robot_calibration._main_camera`) and the referee's commands. Each robot's track is the camera's view of its tag; pass a robot's tag offset -(`--tag`, as `tools/robot_calibration.py` takes it) to measure from the robot's centre. +(`--tag`, as `tools/field/robot_calibration.py` takes it) to measure from the robot's centre. Only the robots a run drove count (its run info's `vision_to_cmd`): ssl-vision misreads a tag as another pattern now and then. A close call is one stretch with the two centres nearer than diff --git a/utama_core/analysis/findings.py b/utama_core/analysis/findings.py index c5419e7a..2e47ee20 100644 --- a/utama_core/analysis/findings.py +++ b/utama_core/analysis/findings.py @@ -1,7 +1,7 @@ """One shared format for the problems the picture tools flag (`--findings PATH` on each tool). A picture is for understanding a flagged problem, never the only evidence for it: each tool also emits -its flags as JSON lines, one `Finding` per line, so an agent (or `tools/find_bugs.py`) can filter on the +its flags as JSON lines, one `Finding` per line, so an agent (or `tools/debug/find_bugs.py`) can filter on the JSON and open the picture only to see what it means. {"tool": "match_timeline", "kind": "tactic_thrash", "replay": "replays/.../a_vs_b.npz", "side": "friendly", diff --git a/utama_core/analysis/fouls.py b/utama_core/analysis/fouls.py index 96f6d50e..ccc4f3f1 100644 --- a/utama_core/analysis/fouls.py +++ b/utama_core/analysis/fouls.py @@ -1,6 +1,6 @@ """Our side's fouls in a round-robin run, with the referee command active at each: the starting points for -new regression moments. `tools/find_bugs.py --fouls` prints them; `tools/moments.py` uses `restart_side` in -its checks. (Until 2026-11-11 this was `moments.py fouls`.) +new regression moments. `tools/debug/find_bugs.py --fouls` prints them; `tools/debug/moments.py` uses `restart_side` in +its checks. (Until 2026-11-11 this was `tools/debug/moments.py fouls`.) `out_of_bounds`, the ball leaving the field, is a stoppage rather than a rules foul (`STOPPAGE_RULES`). """ diff --git a/utama_core/analysis/matches.py b/utama_core/analysis/matches.py index 3d277287..374665e1 100644 --- a/utama_core/analysis/matches.py +++ b/utama_core/analysis/matches.py @@ -2,7 +2,7 @@ A match file's stem is `_vs_` (an evaluate.py round folder, or an old round-robin); evaluate.py runs before 2026-11-12 added `_s`, still read. config_a is the friendly side (yellow) in every run. Shared by `tools/evaluation/explain.py` -and `tools/find_bugs.py`. +and `tools/debug/find_bugs.py`. """ from __future__ import annotations diff --git a/utama_core/analysis/plan_snapshot.py b/utama_core/analysis/plan_snapshot.py index b989c601..3c487cc4 100644 --- a/utama_core/analysis/plan_snapshot.py +++ b/utama_core/analysis/plan_snapshot.py @@ -1,4 +1,4 @@ -"""A picture of what `FastPathPlanner` decided for one robot on one tick (`tools/plan_snapshot.py`). +"""A picture of what `FastPathPlanner` decided for one robot on one tick (`tools/debug/plan_snapshot.py`). Builds the `Game` the planner saw (from a replay frame via `replay.scenario`, or from a hand-made state via `build_game`), runs the planner's own `_path_to`, and draws the pitch around the robot: @@ -40,7 +40,7 @@ from utama_core.replay.scenario import Scenario, scenario_from_replay from utama_core.strategy.catalog import plain_name -# Same ink and palette as tools/figure_style.py (FOR = friendly, AGAINST = enemy). +# Same ink and palette as tools/debug/figure_style.py (FOR = friendly, AGAINST = enemy). INK, INK_2, INK_3, SURFACE, GRID = "#0b0b0b", "#52514e", "#8a8984", "#fcfcfb", "#e4e3df" FOR, AGAINST = "#2a78d6", "#eb6834" CARROT = "#1baf7a" # categorical slot 3: the planner's output, distinct from the team colours diff --git a/utama_core/analysis/plan_trace.py b/utama_core/analysis/plan_trace.py index c1ef3b0d..4694fcd8 100644 --- a/utama_core/analysis/plan_trace.py +++ b/utama_core/analysis/plan_trace.py @@ -1,4 +1,4 @@ -"""The fast-path planner over a time window: how one robot's plan unfolded (`tools/plan_trace.py`). +"""The fast-path planner over a time window: how one robot's plan unfolded (`tools/debug/plan_trace.py`). `plan_snapshot` shows one tick. This runs the same `FastPathPlanner._path_to` on every sampled tick of a window, builds the `Game` each tick saw from a callback (so tests can feed synthetic @@ -60,7 +60,7 @@ # Single-hue ramp (light to dark FOR blue) for time; the carrot dots keep the carrot colour. TIME_CMAP = mcolors.LinearSegmentedColormap.from_list("time", ["#d6e6fa", FOR, "#0f3d7a"]) -# Referee bands: categorical slots from tools/figure_style.py, STOP grey, BALL_PLACEMENT ink. +# Referee bands: categorical slots from tools/debug/figure_style.py, STOP grey, BALL_PLACEMENT ink. REFEREE_COLOURS = { "HALT": "#e4e3df", "STOP": "#e4e3df", diff --git a/utama_core/analysis/restart_picture.py b/utama_core/analysis/restart_picture.py index 178230c4..0f95b462 100644 --- a/utama_core/analysis/restart_picture.py +++ b/utama_core/analysis/restart_picture.py @@ -1,4 +1,4 @@ -"""Picture of where the referee override sends every friendly robot for one restart (`tools/restart_picture.py`). +"""Picture of where the referee override sends every friendly robot for one restart (`tools/debug/restart_picture.py`). For a replay state whose referee command is a restart (STOP, timeouts, kick-offs, penalties, free kicks, ball placement), this runs `RefereeOverride.tick` exactly as the strategy does and records the target diff --git a/utama_core/analysis/robot_calibration.py b/utama_core/analysis/robot_calibration.py index 1c733114..10f1117c 100644 --- a/utama_core/analysis/robot_calibration.py +++ b/utama_core/analysis/robot_calibration.py @@ -27,7 +27,7 @@ ball sensor read on, and whether the ball was still on at the end (`BALL_LOST_M`). A `examples/calibrate_robot.py` run holds, turns and drives with the ball, then kicks it 3 times. - pixi run python tools/robot_calibration.py replays/field/.log [--json OUT] + pixi run python tools/field/robot_calibration.py replays/field/.log [--json OUT] """ from __future__ import annotations diff --git a/utama_core/analysis/stuck_detector.py b/utama_core/analysis/stuck_detector.py index 6febe453..57d40850 100644 --- a/utama_core/analysis/stuck_detector.py +++ b/utama_core/analysis/stuck_detector.py @@ -468,7 +468,7 @@ def find_stuck_windows( `RefereeSidecar`) to reconstruct the command per frame; only if *that* is also unavailable does this check skip entirely, exactly as before — not every replay (a unit-test fixture, a non-refereed - `debug_match.py` run) carries referee state or a sidecar. + `tools/debug/debug_match.py` run) carries referee state or a sidecar. - **Ball possessed.** A window where some robot (either team) has `has_ball=True` for at least `possession_fraction` of its frames is a robot legitimately holding/shielding the ball, not a stall — this is diff --git a/utama_core/dashboard/static/timeline.js b/utama_core/dashboard/static/timeline.js index e751faa0..f58c6190 100644 --- a/utama_core/dashboard/static/timeline.js +++ b/utama_core/dashboard/static/timeline.js @@ -1,5 +1,5 @@ // Match timeline: a window of the match as swimlanes, the dashboard's version of -// tools/match_timeline.py's figure, in the Replay tab around the viewed frame and in the +// tools/debug/match_timeline.py's figure, in the Replay tab around the viewed frame and in the // Live tab up to now. Top to bottom, on one time axis: // - the referee command band (live play, STOP, kickoff, free kick, penalty, placement, HALT); // - possession: whose ball it is, in the team's colour. In a replay, one span per situation diff --git a/utama_core/dashboard/views/demo.py b/utama_core/dashboard/views/demo.py index bcd3e02e..6403c3a2 100644 --- a/utama_core/dashboard/views/demo.py +++ b/utama_core/dashboard/views/demo.py @@ -11,7 +11,7 @@ - settings (`settings`: name -> the values it takes): sent with Run, they apply from the demo it starts (the script sets the examples' config block from them); - the field check (`checks`: real robots only): stops the demo as a switch does, the script runs - `tools/field_check.py`'s check with the radio free (each robot turns on the spot), its lines + `tools/field/field_check.py`'s check with the radio free (each robot turns on the spot), its lines shown under the panel, then starts the same demo again. """ diff --git a/utama_core/motion_planning/pid/pid.py b/utama_core/motion_planning/pid/pid.py index 3604e84c..343b6074 100644 --- a/utama_core/motion_planning/pid/pid.py +++ b/utama_core/motion_planning/pid/pid.py @@ -159,7 +159,7 @@ def set_final_target(self, robot_id: int, final_target: Vector2D | None) -> None flipping sign every few ticks — 6+ reversals — as it repeatedly shot past the target and corrected, until the ball rolled out of play during the oscillation window. Reproduced synthetically too - (`debug_match.py` trace): carrot pinned at `carrot_err≈1.0` while + (`tools/debug/debug_match.py` trace): carrot pinned at `carrot_err≈1.0` while `true_err` closed from >3m to <0.15m at 1.5-2.0 m/s, no deceleration signal reaching the PID until far too late. diff --git a/utama_core/replay/game_log_writer.py b/utama_core/replay/game_log_writer.py index 59b4e96e..897f2a3b 100644 --- a/utama_core/replay/game_log_writer.py +++ b/utama_core/replay/game_log_writer.py @@ -4,7 +4,7 @@ before any filter: every vision packet as received (raw detections with ssl-vision's `t_capture`), the referee's state, and the radio's bytes both ways. `GameLogWriter` writes them in the league's game-log format (`ssl_log.py`), so the tools for official logs read a -field test unchanged: `tools/convert_ssl_log.py` turns it into a replay, and its raw-vision +field test unchanged: `tools/realism/convert_ssl_log.py` turns it into a replay, and its raw-vision sidecar gives our camera's noise. Records: - `VISION_2014`: each `SSL_WrapperPacket`, byte for byte. diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 0668e955..027de900 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -8,7 +8,7 @@ one tick. `scenario_from_replay()` + `apply_scenario()` skip that: read the single nearest frame from the replay, then teleport a freshly-constructed `StrategyRunner` (same two strategies, same profile — see -`repro_from_replay.py`) directly into that field state, so the investigator +`tools/debug/repro_from_replay.py`) directly into that field state, so the investigator can start ticking (with `match_log` tracing on) from just before the stall. Coordinate frame: `GameFrame.friendly_robots`/`enemy_robots`/`ball` store @@ -30,7 +30,7 @@ A replay only ever records one side's perspective (`ReplayWriterConfig`/ `ColumnarReplayWriterConfig.is_my_perspective`, and -`tournament.run_match`/`repro_from_replay.py` both always construct the +`tournament.run_match`/`tools/debug/repro_from_replay.py` both always construct the runner with `my_team_is_yellow=True, my_team_is_right=True` — config_a is always yellow/friendly, and right in the first half; `scenario_from_replay` turns a second-half frame so it is right here too) — so `friendly_robots` in the replay is @@ -134,7 +134,7 @@ class Scenario: `friendly_robots`/`enemy_robots` follow the replay's own perspective (see module docstring): friendly is config_a (yellow/right in every - `tournament.run_match`/`repro_from_replay.py` construction), enemy is + `tournament.run_match`/`tools/debug/repro_from_replay.py` construction), enemy is config_b. """ @@ -176,7 +176,7 @@ def _robot_states(robots: dict, turn: bool = False) -> tuple[RobotState, ...]: def _frame_origin(replay_path: Path) -> float: - """The `ts` of the replay's first frame. Times on the sidecar's and `replay_trace.py`'s + """The `ts` of the replay's first frame. Times on the sidecar's and `tools/debug/replay_trace.py`'s clock (and the `t_seconds` callers pass, from `fouls` or a StallEvent) count from it, not from 0: a frame's `ts` starts at one tick (1/60 s in these replays).""" if replay_path.suffix == ".npz": @@ -319,7 +319,7 @@ def _first_frame_showing(replay_path: Path, t_seconds: float, command: RefereeCo def scenario_from_replay(replay_path, t_seconds: float, *, showing: Optional[RefereeCommand] = None) -> Scenario: """Read the frame nearest `t_seconds` from `replay_path` and build a `Scenario` from it. `t_seconds` counts from the replay's first frame, the clock the sidecar, - `fouls` and `replay_trace.py` use (see `_frame_origin`). It merges in the referee command from + `fouls` and `tools/debug/replay_trace.py` use (see `_frame_origin`). It merges in the referee command from the `.intentions.jsonl` sidecar (frames themselves carry no referee data — see module docstring) and the two strategy config names from the tournament directory's `summary.json`, when available. @@ -433,7 +433,7 @@ def apply_scenario(runner, scenario: Scenario, *, verify: bool = True) -> None: Friendly robots are teleported as `runner.my_team_is_yellow`'s color, enemy robots as the opposite color — matching how the replay was recorded (see module docstring: config_a/friendly is always yellow/right - in `tournament.run_match`/`repro_from_replay.py`, but `apply_scenario` + in `tournament.run_match`/`tools/debug/repro_from_replay.py`, but `apply_scenario` itself just follows whatever `runner.my_team_is_yellow` says, so it also works for a runner built with the opposite orientation). diff --git a/utama_core/replay/ssl_log.py b/utama_core/replay/ssl_log.py index 19954051..7ebd308d 100644 --- a/utama_core/replay/ssl_log.py +++ b/utama_core/replay/ssl_log.py @@ -4,7 +4,7 @@ match, gzipped. `convert_log` turns one into the `.npz` + `.sparse_referee.pkl` pair a round-robin match writes, through `ColumnarReplayWriter`, so `load_columnar_replay`, `render_window`, `scenario_from_replay` and the analyses read a real match like one of ours. -`tools/convert_ssl_log.py` converts files or downloads the published logs. +`tools/realism/convert_ssl_log.py` converts files or downloads the published logs. Log format: the header `SSL_LOG_FILE` and a big-endian int32 version, then records of int64 receive time [ns], int32 message type, int32 size and the serialized message. Types read here: @@ -52,7 +52,7 @@ - `.source.json`: the log, teams, final score, tracker source and field geometry, and under `extras` which of the sidecars below were written. -Sidecars, for measuring physics and vision rather than replaying (`tools/convert_ssl_log.py` +Sidecars, for measuring physics and vision rather than replaying (`tools/realism/convert_ssl_log.py` can add them to a replay already converted). Teams are in kick-off colours like the replay (yellow friendly), positions in metres in field coordinates, times `ts` in seconds on the replay's clock. The arrays are `np.savez_compressed` archives named `.zip`, so a glob for diff --git a/tools/sim_setup.py b/utama_core/run/sim_setup.py similarity index 96% rename from tools/sim_setup.py rename to utama_core/run/sim_setup.py index 27a65db4..43d41abe 100644 --- a/tools/sim_setup.py +++ b/utama_core/run/sim_setup.py @@ -1,6 +1,6 @@ """The one way to load a strategy and to set up a simulated match. Every tool that plays one uses these: -`tools/evaluation/match.py` (round-robin, `evaluate.py`), `repro_from_replay.py`, `moments.py`, -`debug_match.py` and `main.py`. +`tools/evaluation/match.py` (round-robin, `evaluate.py`), `tools/debug/repro_from_replay.py`, `tools/debug/moments.py`, +`tools/debug/debug_match.py` and `main.py`. - `load_side(name)`: a strategy by catalog name, a `.strategy` file by path, or `PATH.py:FUNCTION` (a `build(outfield_robot_ids, motion_controller)` in a scratch file, to try a tactic without a repo change). diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 31982161..3b0b8920 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -245,7 +245,7 @@ class StrategyRunner(SimRecoveryMixin, VisionStreamStatusMixin, LiveStatusMixin) field_bounds (FieldBounds): Bounds of the subset of the full field being used. Defaults to None (ie full field). keep_out (Sequence[FieldBounds]): Rectangles no robot may enter (vision coordinates): each robot's speed into them is capped (`field_fence.py`), and on a camera run one inside - forces HALT (`field_check.py`). Defaults to none. + forces HALT (`tools/field/field_check.py`). Defaults to none. fence_field_lines (bool): On camera runs, fence the touch and goal lines as well as the edges of `field_bounds` inside the field; off by default, as a robot fetching a ball out of play must cross them. On for a run that never needs to (calibration). diff --git a/utama_core/tactics/scripted_moves.py b/utama_core/tactics/scripted_moves.py index c5689040..f2c6389a 100644 --- a/utama_core/tactics/scripted_moves.py +++ b/utama_core/tactics/scripted_moves.py @@ -3,7 +3,7 @@ `ScriptedMovesTactic` sends `CALIBRATION_SCRIPT`'s raw velocity commands, step by step, to the one robot it is given, then stands still. Run with a game log being recorded (`StrategyRunner(game_log_path=...)`), the log holds each command as sent and the robot's -motion as the camera saw it; `tools/robot_calibration.py` turns that into the robot's +motion as the camera saw it; `tools/field/robot_calibration.py` turns that into the robot's numbers (vision noise, delay, speed and turn tracking, acceleration). The ball part of a calibration fetches the ball itself instead (`examples/ball_trials.py`). diff --git a/utama_core/tactics/switch_of_play.py b/utama_core/tactics/switch_of_play.py index 49df210e..7f3d7519 100644 --- a/utama_core/tactics/switch_of_play.py +++ b/utama_core/tactics/switch_of_play.py @@ -457,7 +457,7 @@ def tick( # "Known open bugs") has hand-written a one-off print of exactly this # tuple in a throwaway trace script. Recording it here instead means # any future investigation can get it back for free via - # `debug_match.py --match-log ` + `load_jsonl`, with zero + # `tools/debug/debug_match.py --match-log ` + `load_jsonl`, with zero # runtime cost when match_log is unset (the default for every normal # run/test/tournament). if ctx.match_log is not None: diff --git a/utama_core/tests/analysis/test_field_physics.py b/utama_core/tests/analysis/test_field_physics.py index e012fbff..ddd245d7 100644 --- a/utama_core/tests/analysis/test_field_physics.py +++ b/utama_core/tests/analysis/test_field_physics.py @@ -1,4 +1,4 @@ -"""Unit tests for tools/field_physics.py: the register filter, step delays, ball rolls, agreement. +"""Unit tests for tools/field/field_physics.py: the register filter, step delays, ball rolls, agreement. No real logs and no rsim: the ball roll is checked on a synthetic ball with a known deceleration. """ @@ -10,7 +10,7 @@ import numpy as np import pytest -from tools import field_physics +from tools.field import field_physics def _group(median: float, n: int) -> dict: diff --git a/utama_core/tests/analysis/test_find_bugs.py b/utama_core/tests/analysis/test_find_bugs.py index 8d2fd98d..131231dd 100644 --- a/utama_core/tests/analysis/test_find_bugs.py +++ b/utama_core/tests/analysis/test_find_bugs.py @@ -1,4 +1,4 @@ -"""tools/find_bugs.py without replays: which matches are chosen (each strategy's worst N as config_a, by goal +"""tools/debug/find_bugs.py without replays: which matches are chosen (each strategy's worst N as config_a, by goal difference), the picture ranking and cap, and the index's text. Match files are empty stubs and their scores come from a fake `final_score`, so nothing is simulated or drawn from a real replay.""" @@ -6,7 +6,7 @@ import pytest -from tools import find_bugs +from tools.debug import find_bugs from utama_core.analysis import matches as match_files from utama_core.analysis.findings import Finding diff --git a/utama_core/tests/analysis/test_fouls.py b/utama_core/tests/analysis/test_fouls.py index 0f8ef7c6..5a521ea4 100644 --- a/utama_core/tests/analysis/test_fouls.py +++ b/utama_core/tests/analysis/test_fouls.py @@ -1,5 +1,5 @@ """`utama_core/analysis/fouls.py`: our side's fouls in a run with the referee command active, as -`tools/find_bugs.py --fouls` lists them (moved from `moments.py fouls` on 2026-11-11).""" +`tools/debug/find_bugs.py --fouls` lists them (moved from `tools/debug/moments.py fouls` on 2026-11-11).""" import json @@ -124,7 +124,7 @@ def test_fouls_json_is_the_foul_list_or_the_by_counts_as_rows(): def test_find_bugs_fouls_filters_then_counts(tmp_path): - from tools.find_bugs import fouls_report + from tools.debug.find_bugs import fouls_report run = _run(tmp_path, [_foul(1.0), _foul(2.0, rule="out_of_bounds"), _foul(3.0, rule="crashing")]) assert len(fouls_report(run)) == 2 # out_of_bounds is a stoppage, left out diff --git a/utama_core/tests/analysis/test_match_timeline.py b/utama_core/tests/analysis/test_match_timeline.py index c56d9db9..5e16a9f6 100644 --- a/utama_core/tests/analysis/test_match_timeline.py +++ b/utama_core/tests/analysis/test_match_timeline.py @@ -2,7 +2,7 @@ import numpy as np -from tools.match_timeline import ( +from tools.debug.match_timeline import ( FLIP_BACKS_PER_MIN, FLIP_S, MIN_LIVE_S, diff --git a/utama_core/tests/analysis/test_pitch_maps.py b/utama_core/tests/analysis/test_pitch_maps.py index 3f0d097a..abab892b 100644 --- a/utama_core/tests/analysis/test_pitch_maps.py +++ b/utama_core/tests/analysis/test_pitch_maps.py @@ -1,10 +1,10 @@ -"""`tools/pitch_maps.py` on tiny synthetic replays: the side normalisation, possession and the +"""`tools/debug/pitch_maps.py` on tiny synthetic replays: the side normalisation, possession and the goalkeeper exclusion, and that each figure is written.""" import numpy as np import pytest -from tools import pitch_maps as pm +from tools.debug import pitch_maps as pm from utama_core.engine.match_stats import _POSSESSION_RADIUS_M from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.columnar_reader import ColumnarReplay diff --git a/utama_core/tests/analysis/test_plan_snapshot.py b/utama_core/tests/analysis/test_plan_snapshot.py index 9dc818b1..c19beeb8 100644 --- a/utama_core/tests/analysis/test_plan_snapshot.py +++ b/utama_core/tests/analysis/test_plan_snapshot.py @@ -1,4 +1,4 @@ -"""tools/plan_snapshot.py's drawing function, on the kick-off state of +"""tools/debug/plan_snapshot.py's drawing function, on the kick-off state of test_fpp_inside_ball_keep_out.py (no simulator).""" import math diff --git a/utama_core/tests/analysis/test_plan_trace.py b/utama_core/tests/analysis/test_plan_trace.py index dc1d5415..0e010bdb 100644 --- a/utama_core/tests/analysis/test_plan_trace.py +++ b/utama_core/tests/analysis/test_plan_trace.py @@ -1,4 +1,4 @@ -"""tools/plan_trace.py's trace function on synthetic games over time (no replay, no simulator).""" +"""tools/debug/plan_trace.py's trace function on synthetic games over time (no replay, no simulator).""" import math diff --git a/utama_core/tests/analysis/test_restart_picture.py b/utama_core/tests/analysis/test_restart_picture.py index d941705a..53ae216c 100644 --- a/utama_core/tests/analysis/test_restart_picture.py +++ b/utama_core/tests/analysis/test_restart_picture.py @@ -1,4 +1,4 @@ -"""tools/restart_picture.py's capture of the referee override's commanded targets (no simulator).""" +"""tools/debug/restart_picture.py's capture of the referee override's commanded targets (no simulator).""" import json import math diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index f61d60a5..5449c825 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -37,7 +37,7 @@ _OUTFIELD_IDS = (1, 2, 3, 4, 5) # Every strategy, as round-robins discover them, so a new one is covered without editing this -# file (a strategy branch can't: see tools/check_strategy_branch.py). +# file (a strategy branch can't: see tools/dev/check_strategy_branch.py). _CONFIGS = [pytest.param(name, id=name) for name in catalog.names() if name != "default"] diff --git a/utama_core/tests/engine/test_check_strategy_branch.py b/utama_core/tests/engine/test_check_strategy_branch.py index 282cf80c..e4eb805f 100644 --- a/utama_core/tests/engine/test_check_strategy_branch.py +++ b/utama_core/tests/engine/test_check_strategy_branch.py @@ -1,4 +1,4 @@ -"""`tools/check_strategy_branch.py`: a strategy branch may change strategy code only, may not change +"""`tools/dev/check_strategy_branch.py`: a strategy branch may change strategy code only, may not change its opponents, and its code may not reach outside itself. Lives outside `tests/strategy/` on purpose: that directory is on the allowlist, so a strategy branch @@ -11,7 +11,7 @@ import pytest -from tools.check_strategy_branch import ( +from tools.dev.check_strategy_branch import ( ALLOWED, _load_fingerprint, changed_paths, @@ -43,7 +43,7 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): "utama_core/engine/strategy.py", "utama_core/analysis/goal_sources.py", "tools/evaluation/match.py", - "tools/check_strategy_branch.py", + "tools/dev/check_strategy_branch.py", ".github/workflows/ci.yml", # Prefix matches on whole directory names only. "utama_core/strategy_runner/x.py", diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index 62bd10b8..15400acf 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -6,7 +6,7 @@ import pytest -from tools import pitch_maps as pm +from tools.debug import pitch_maps as pm from tools.evaluation import explain from utama_core.entities.data.referee import RefereeData from utama_core.entities.data.vector import Vector2D, Vector3D diff --git a/utama_core/tests/engine/test_tournament_match_end.py b/utama_core/tests/engine/test_tournament_match_end.py index 04d4937b..62ac2614 100644 --- a/utama_core/tests/engine/test_tournament_match_end.py +++ b/utama_core/tests/engine/test_tournament_match_end.py @@ -5,9 +5,9 @@ from types import SimpleNamespace -from tools import sim_setup from tools.evaluation import match from utama_core.entities.referee.stage import Stage +from utama_core.run import sim_setup class _FakeRunner: diff --git a/utama_core/tests/moments/test_moment_authoring.py b/utama_core/tests/moments/test_moment_authoring.py index 9422d900..ccd223c4 100644 --- a/utama_core/tests/moments/test_moment_authoring.py +++ b/utama_core/tests/moments/test_moment_authoring.py @@ -1,5 +1,5 @@ -"""Pure checks (no rsim) of moments in `tools/moments.py`: loading, saving, the validation errors and -`play --seed`. (Hand-made templates, `moments.py new`, were removed on 2026-11-11: moments are captured +"""Pure checks (no rsim) of moments in `tools/debug/moments.py`: loading, saving, the validation errors and +`play --seed`. (Hand-made templates, `tools/debug/moments.py new`, were removed on 2026-11-11: moments are captured from replays.)""" import dataclasses @@ -7,7 +7,7 @@ import pytest -from tools import moments +from tools.debug import moments PROBE = moments.MOMENTS_DIR / "free_kick_defender_dodges_into_ball.json" diff --git a/utama_core/tests/moments/test_moments.py b/utama_core/tests/moments/test_moments.py index d31cc4ac..73d323f5 100644 --- a/utama_core/tests/moments/test_moments.py +++ b/utama_core/tests/moments/test_moments.py @@ -1,10 +1,10 @@ -"""Every regression moment (`tools/moments.py`, the JSON files beside this one) against every +"""Every regression moment (`tools/debug/moments.py`, the JSON files beside this one) against every strategy it concerns. A moment with a `known_failure` is a strict xfail, so its fix shows as XPASS: then delete the `known_failure`.""" import pytest -from tools import moments +from tools.debug import moments def _cases(): diff --git a/utama_core/tests/moments/test_play_options.py b/utama_core/tests/moments/test_play_options.py index b3813d16..a95a2531 100644 --- a/utama_core/tests/moments/test_play_options.py +++ b/utama_core/tests/moments/test_play_options.py @@ -1,9 +1,9 @@ -"""Pure checks (no rsim) of `play`'s options in `tools/moments.py`: the seed parser, the events +"""Pure checks (no rsim) of `play`'s options in `tools/debug/moments.py`: the seed parser, the events list and the strategy resolver.""" import pytest -from tools import moments +from tools.debug import moments from utama_core.entities.referee.referee_command import RefereeCommand DT = 1 / moments.TICKS_PER_SECOND diff --git a/utama_core/tests/moments/test_requires_and_outcomes.py b/utama_core/tests/moments/test_requires_and_outcomes.py index 671471a8..5f49a359 100644 --- a/utama_core/tests/moments/test_requires_and_outcomes.py +++ b/utama_core/tests/moments/test_requires_and_outcomes.py @@ -1,11 +1,11 @@ -"""Pure checks (no rsim) of the `requires` conditions in `tools/moments.py`: each fires on the case it guards and not on the one it must allow, over +"""Pure checks (no rsim) of the `requires` conditions in `tools/debug/moments.py`: each fires on the case it guards and not on the one it must allow, over synthetic ticks.""" import dataclasses import pytest -from tools import moments +from tools.debug import moments from utama_core.entities.referee.referee_command import RefereeCommand DT = 1 / moments.TICKS_PER_SECOND diff --git a/utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py b/utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py index a966abc3..afd00008 100644 --- a/utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py +++ b/utama_core/tests/motion_planning/implementation/test_trajsampling_correctness.py @@ -561,7 +561,7 @@ def test_try_reuse_ignores_priority_conflict_when_priority_blocking_disabled(): """Pins the restart-formation fix (roadmap "trajsample liveness fixes", session following the recheck-window fix above): even after shrinking the recheck window to 0.5s, a real kickoff still stalled 100% of the time in a live - `debug_match.py` run, traced to a DIFFERENT mechanism than the recheck + `tools/debug/debug_match.py` run, traced to a DIFFERENT mechanism than the recheck window -- priority-blocking itself, not just how far ahead it looks. At a `PREPARE_KICKOFF_YELLOW`/similar restart, every non-keeper teammate diff --git a/utama_core/tests/replay/test_convert_corpus.py b/utama_core/tests/replay/test_convert_corpus.py index d8bc8407..54686a2b 100644 --- a/utama_core/tests/replay/test_convert_corpus.py +++ b/utama_core/tests/replay/test_convert_corpus.py @@ -1,10 +1,10 @@ -"""`tools/convert_ssl_log.py`'s per-log corpus job: what it downloads, converts and keeps.""" +"""`tools/realism/convert_ssl_log.py`'s per-log corpus job: what it downloads, converts and keeps.""" from __future__ import annotations import json -from tools import convert_ssl_log +from tools.realism import convert_ssl_log def _job(tmp_path, keep_raw): @@ -88,7 +88,7 @@ def test_limit_memory_turns_an_oversized_allocation_into_memory_error(): import sys code = ( - "from tools.convert_ssl_log import limit_memory\n" + "from tools.realism.convert_ssl_log import limit_memory\n" "limit_memory(1.5)\n" "try:\n" " bytearray(2 * 2**30)\n" diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 41cd12a5..22b49783 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -346,7 +346,7 @@ def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): # the boundary (then a `.strategy` file must do it in its own process), or `RUNNER_SIDE`? _RUNNER_REACHES_INTO_PLAYER_SIDE = { "tools.evaluation.match": {"utama_core.strategy"}, # the catalog's names - "tools.sim_setup": {"utama_core.engine", "utama_core.strategy"}, # builds the code-named ones (load_side) + "utama_core.run.sim_setup": {"utama_core.engine", "utama_core.strategy"}, # builds the code-named ones (load_side) "utama_core.bundle.strategy_file": {"utama_core.engine"}, "utama_core.run.side_runtime": {"utama_core.engine", "utama_core.motion_planning"}, "utama_core.run.strategy_runner": { diff --git a/utama_core/tests/replay/test_replay_trace_tool.py b/utama_core/tests/replay/test_replay_trace_tool.py index 21be1401..75bd1b73 100644 --- a/utama_core/tests/replay/test_replay_trace_tool.py +++ b/utama_core/tests/replay/test_replay_trace_tool.py @@ -8,7 +8,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand as C -_TOOL = Path(__file__).resolve().parents[3] / "tools" / "replay_trace.py" +_TOOL = Path(__file__).resolve().parents[3] / "tools" / "debug" / "replay_trace.py" _spec = importlib.util.spec_from_file_location("replay_trace", _TOOL) replay_trace = importlib.util.module_from_spec(_spec) _spec.loader.exec_module(replay_trace) diff --git a/utama_core/tests/replay/test_repro_summary.py b/utama_core/tests/replay/test_repro_summary.py index cbe69bc0..5cc1753b 100644 --- a/utama_core/tests/replay/test_repro_summary.py +++ b/utama_core/tests/replay/test_repro_summary.py @@ -1,4 +1,4 @@ -"""`tools/repro_from_replay.py --summary`: per-robot rows from match_log events, and their text.""" +"""`tools/debug/repro_from_replay.py --summary`: per-robot rows from match_log events, and their text.""" import importlib.util from pathlib import Path @@ -6,7 +6,7 @@ import pytest -_TOOL = Path(__file__).resolve().parents[3] / "tools" / "repro_from_replay.py" +_TOOL = Path(__file__).resolve().parents[3] / "tools" / "debug" / "repro_from_replay.py" _spec = importlib.util.spec_from_file_location("repro_from_replay", _TOOL) repro = importlib.util.module_from_spec(_spec) _spec.loader.exec_module(repro) diff --git a/utama_core/tests/replay/test_ssl_log_extras.py b/utama_core/tests/replay/test_ssl_log_extras.py index 21d3f22f..69bb95ce 100644 --- a/utama_core/tests/replay/test_ssl_log_extras.py +++ b/utama_core/tests/replay/test_ssl_log_extras.py @@ -1,6 +1,6 @@ """Tests for the official-log converter's sidecars (`replay/ssl_log.py`): the tracker's kicks, visibility and angular velocity, raw camera detections, and adding them to a replay converted -before they existed (`tools/convert_ssl_log.py --backfill-extras`).""" +before they existed (`tools/realism/convert_ssl_log.py --backfill-extras`).""" from __future__ import annotations @@ -11,7 +11,7 @@ import numpy as np import pytest -from tools import convert_ssl_log +from tools.realism import convert_ssl_log from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.replay.ssl_log import ( diff --git a/utama_core/tests/tools/test_field_check_tool.py b/utama_core/tests/tools/test_field_check_tool.py index 089e1566..da681911 100644 --- a/utama_core/tests/tools/test_field_check_tool.py +++ b/utama_core/tests/tools/test_field_check_tool.py @@ -1,4 +1,4 @@ -"""`tools/field_check.py` flags a slow camera, a missing ball or lids, and no vision at all; the +"""`tools/field/field_check.py` flags a slow camera, a missing ball or lids, and no vision at all; the robots part flags a robot answering few of its commands.""" import collections @@ -8,7 +8,7 @@ from utama_core.team_controller.controllers.real import find_robots as fr spec = importlib.util.spec_from_file_location( - "field_check", Path(__file__).resolve().parents[3] / "tools" / "field_check.py" + "field_check", Path(__file__).resolve().parents[3] / "tools" / "field" / "field_check.py" ) field_check = importlib.util.module_from_spec(spec) spec.loader.exec_module(field_check) diff --git a/utama_core/tests/tools/test_package_graph.py b/utama_core/tests/tools/test_package_graph.py index 85dc806a..1212dfcd 100644 --- a/utama_core/tests/tools/test_package_graph.py +++ b/utama_core/tests/tools/test_package_graph.py @@ -1,9 +1,9 @@ -"""`tools/package_graph.py` on a synthetic `utama_core/` tree: edges, relative imports, skipped tests, the rule.""" +"""`tools/dev/package_graph.py` on a synthetic `utama_core/` tree: edges, relative imports, skipped tests, the rule.""" from collections import Counter from pathlib import Path -from tools.package_graph import edge_counts, render_mermaid, scan, violations +from tools.dev.package_graph import edge_counts, render_mermaid, scan, violations def _write(root: Path, rel: str, text: str) -> None: diff --git a/utama_core/tests/tools/test_package_logs.py b/utama_core/tests/tools/test_package_logs.py index 5d6ba1d6..b6ba9186 100644 --- a/utama_core/tests/tools/test_package_logs.py +++ b/utama_core/tests/tools/test_package_logs.py @@ -1,9 +1,9 @@ -"""Tests for tools/package_logs.py: tournament and field logs packaging.""" +"""Tests for tools/field/package_logs.py: tournament and field logs packaging.""" import tarfile from pathlib import Path -from tools.package_logs import ( +from tools.field.package_logs import ( collect_field_files, collect_tournament_files, compress_log_file, diff --git a/utama_core/tests/tools/test_sim_setup.py b/utama_core/tests/tools/test_sim_setup.py index 1750b6df..5ef84b86 100644 --- a/utama_core/tests/tools/test_sim_setup.py +++ b/utama_core/tests/tools/test_sim_setup.py @@ -1,10 +1,10 @@ -"""`tools/sim_setup.py`: which names load which strategy, and the runner it sets up.""" +"""`utama_core/run/sim_setup.py`: which names load which strategy, and the runner it sets up.""" import pytest -from tools import sim_setup from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.run import sim_setup @pytest.mark.parametrize( diff --git a/utama_core/tests/tools/test_trim_idle_log.py b/utama_core/tests/tools/test_trim_idle_log.py index f6a68951..05841ccc 100644 --- a/utama_core/tests/tools/test_trim_idle_log.py +++ b/utama_core/tests/tools/test_trim_idle_log.py @@ -1,10 +1,10 @@ -"""Tests for tools/trim_idle_log.py: trimming dead/idle time sectors from SSL logs.""" +"""Tests for tools/field/trim_idle_log.py: trimming dead/idle time sectors from SSL logs.""" import gzip import struct from pathlib import Path -from tools.trim_idle_log import find_active_intervals, trim_log +from tools.field.trim_idle_log import find_active_intervals, trim_log from utama_core.replay.game_log_writer import LOG_HEADER, REFEREE, RUN_INFO from utama_core.team_controller.generated_code.ssl_gc_referee_message_pb2 import Referee diff --git a/utama_core/tests/tools/test_vision_check.py b/utama_core/tests/tools/test_vision_check.py index 8dfae104..ed1029a5 100644 --- a/utama_core/tests/tools/test_vision_check.py +++ b/utama_core/tests/tools/test_vision_check.py @@ -1,4 +1,4 @@ -"""The guided check of `tools/vision_check.py`: the spots it asks for and which ball it takes.""" +"""The guided check of `tools/field/vision_check.py`: the spots it asks for and which ball it takes.""" import importlib.util import select @@ -11,7 +11,7 @@ ) spec = importlib.util.spec_from_file_location( - "vision_check", Path(__file__).resolve().parents[3] / "tools" / "vision_check.py" + "vision_check", Path(__file__).resolve().parents[3] / "tools" / "field" / "vision_check.py" ) vision_check = importlib.util.module_from_spec(spec) spec.loader.exec_module(vision_check) From 4238f90e699fa1a2c4062fa90b6e45f28dcc0d6d Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:27:22 +0000 Subject: [PATCH 40/59] examples: move the three field-session scripts to tools/field - examples/calibrate_robot.py, shooting_drill.py, ball_trials.py -> tools/field/ These are the field-day tools (pixi run calibrate, the field test rig), not dashboard demos. Imports of them are now tools.field.; the other examples, demos.py and the tests under utama_core/tests/examples use those paths. ball_trials.py still takes take_ball_facing from examples/pass_receive.py, imported as examples.pass_receive. The moved scripts resolve the repo root one level deeper (parents[2]). Text references and pixi's calibrate task point at the new paths. Co-Authored-By: Claude Haiku 5.5 --- docs/custom_referee_gui.md | 2 +- docs/real_robot_setup.md | 12 ++++---- docs/roadmap.md | 6 ++-- docs/tools.md | 10 +++---- examples/demos.py | 7 ++--- examples/dribble_and_shoot.py | 2 +- examples/pass_receive.py | 11 ++++--- examples/passing_rally.py | 2 +- examples/planner_ab.py | 6 ++-- examples/save_and_counter.py | 5 ++-- examples/score_goal.py | 11 ++++--- examples/teleop.py | 5 ++-- pixi.toml | 2 +- {examples => tools/field}/ball_trials.py | 7 ++--- {examples => tools/field}/calibrate_robot.py | 13 ++++----- {examples => tools/field}/shooting_drill.py | 12 ++++---- utama_core/analysis/robot_calibration.py | 4 +-- utama_core/analysis/tag_calibration.py | 2 +- utama_core/run/field_fence.py | 2 +- utama_core/run/strategy_runner.py | 2 +- utama_core/tactics/scripted_moves.py | 4 +-- utama_core/tests/examples/test_ball_trials.py | 10 ++----- .../tests/examples/test_calibrate_robot.py | 10 ++----- utama_core/tests/examples/test_demos.py | 3 +- .../examples/test_examples_run_as_scripts.py | 29 ++++++++++--------- .../tests/examples/test_shooting_drill.py | 10 ++----- .../test_fpp_inside_ball_keep_out.py | 2 +- .../test_fpp_wall_near_robot.py | 2 +- utama_core/tests/run/test_field_fence.py | 2 +- 29 files changed, 86 insertions(+), 109 deletions(-) rename {examples => tools/field}/ball_trials.py (98%) rename {examples => tools/field}/calibrate_robot.py (98%) rename {examples => tools/field}/shooting_drill.py (97%) diff --git a/docs/custom_referee_gui.md b/docs/custom_referee_gui.md index 30f4a084..41d72470 100644 --- a/docs/custom_referee_gui.md +++ b/docs/custom_referee_gui.md @@ -60,7 +60,7 @@ strategy_view.attach(server, runner, The Live tab then lists the choices per side with a Run button; Run on the one running restarts it. `StrategyRunner.replace_strategy` takes the new strategy at the next tick and only while -halted, so the page refuses otherwise. `examples/shooting_drill.py` offers its attacker +halted, so the page refuses otherwise. `tools/field/shooting_drill.py` offers its attacker and defender tactics this way. ## Commands and what robots do diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index 9ae0656f..b707acb0 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -3,7 +3,7 @@ The procedure for a test day with real robots: ssl-vision on its own Linux laptop sending vision over the network, and our stack on a Windows laptop in WSL with the radio dongle. Each part is checked on its own before anything drives a robot: vision with `tools/field/vision_check.py`, the radio -with teleop, then both together in the field check of `examples/shooting_drill.py`. +with teleop, then both together in the field check of `tools/field/shooting_drill.py`. ``` vision laptop (Linux) robot laptop (Windows + WSL) @@ -131,9 +131,9 @@ radio IDs must differ across all robots on it. ### 4. Both together -Set the "Test-day configuration" block of `examples/shooting_drill.py`: `FIELD`, +Set the "Test-day configuration" block of `tools/field/shooting_drill.py`: `FIELD`, `CAMERA_HALF` (`"full"` when the cameras cover the whole field), each robot's vision and radio -ID and working hardware. Then `pixi run python examples/shooting_drill.py`, open +ID and working hardware. Then `pixi run python tools/field/shooting_drill.py`, open http://localhost:8080 and go through the Live tab's field check ([custom_referee_gui.md](custom_referee_gui.md#field-check-camera-runs)): every row green or amber, each robot under its own ID and colour, a ball in each corner inside the area in play, @@ -187,7 +187,7 @@ robots), and the pattern that turned with it is its lid. It prints radio, lid an profile was calibrated on that lid (a profile's tag offset is its lid's: calibrate again after a swap), and the radios that did not answer and patterns no radio turned. The pairing is saved on this machine (`replays/field/robots_found.json`). The robots an example uses are chosen by radio -(`RADIO_0`, `RADIO_1` in `shooting_drill.py`), one per colour, and no vision ID or colour is +(`RADIO_0`, `RADIO_1` in `tools/field/shooting_drill.py`), one per colour, and no vision ID or colour is written by hand: on real robots an example starts by watching vision for 0.5 s (nothing moves). With each robot's saved lid in view it uses them; otherwise (never run here, a lid missing) it finds those robots again first (`find_robots.confirm`). It cannot tell two robots in use that @@ -205,10 +205,10 @@ pixi run calibrate --radio 0 --check # the new profile against the committ Without both `--robot colour:id` and `--radio` it looks the robot up: with `--radio`, as the examples do; with neither, by `find-robots`. -No dashboard: it runs in the terminal (`examples/calibrate_robot.py`). Once vision sees the robot +No dashboard: it runs in the terminal (`tools/field/calibrate_robot.py`). Once vision sees the robot it asks you to put it near the middle of the camera's view facing +x, with 0.8 m clear ahead, 0.6 m to its left and a ball at rest in view; press Enter. It drives and turns for about 65 s. -Then the ball part (`examples/ball_trials.py`), where **the robot fetches the ball itself**: +Then the ball part (`tools/field/ball_trials.py`), where **the robot fetches the ball itself**: - **Carry ladder**: it carries the ball 0.5 m forward, backward, left and right, and half a turn each way, at rising speeds (0.2 to 1 m/s, 0.5 to 4 rad/s), twice each (`--repeats`), from diff --git a/docs/roadmap.md b/docs/roadmap.md index fbb3f8db..e23e26c0 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -160,7 +160,7 @@ entry by its title, not its number. - *Open, not yet:* one profile per match day vs updated while playing; kick-to-kick spread in the sim (more realistic, but noisier round-robins). - *Measuring, built 2026-10-21:* every camera run records an SSL game log (raw vision, - referee, radio bytes both ways: `GameLogWriter`); `examples/shooting_drill.py + referee, radio bytes both ways: `GameLogWriter`); `tools/field/shooting_drill.py --calibrate` plays fixed moves (`tactics/scripted_moves.py`), and `tools/field/robot_calibration.py` measures loop delay, speed gain, acceleration, vision noise and kick speed from any such log. Checked on a synthetic robot (delay within 10 ms, acceleration within 15 %; turn @@ -168,7 +168,7 @@ entry by its title, not its number. Not yet done: the numbers feed nothing (the sim's latency, the controller), and drift, dribbling, passes and chips are not measured. First real robot 2026-10-27: delay 79 ms, turn gain 1.09, sideways acceleration ~1.8 against ~5 m/s² forward. 2026-10-28: - `pixi run calibrate` (`examples/calibrate_robot.py`) runs it from the terminal, no + `pixi run calibrate` (`tools/field/calibrate_robot.py`) runs it from the terminal, no dashboard: prompts for each set-up, prints each move, DONE, then the analysis and a `.calibration.json`; it now also holds, turns and drives with the ball and kicks 3 times (kick speed and direction off the heading, where the ball sits, ball sensor share, kept or lost). @@ -190,7 +190,7 @@ entry by its title, not its number. 4. **Dribbling**: hold while turning and driving at rising speed until the ball is lost: the fastest turn and drive that keep it. Decides whether a placer may grab a ball from any side and turn with it, instead of going round it first (step 5). Built - 2026-10-29: the carry ladder in `pixi run calibrate` (`examples/ball_trials.py`); not yet + 2026-10-29: the carry ladder in `pixi run calibrate` (`tools/field/ball_trials.py`); not yet run on a real robot, so `CARRY_SPEED` 0.3 / `CARRY_TURN` 1.0 stand. 5. **Receiving and grabbing**: the approach speed at which a robot still traps a ball, driving onto a still ball and receiving a rolling one (passes at a few speeds); whether diff --git a/docs/tools.md b/docs/tools.md index dbcc873a..645d6c3a 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -51,7 +51,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `field-check` | the start of a test day in one command (`tools/field/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([real_robot_setup.md](real_robot_setup.md#each-test-day)) | | `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | | `demos` | every dashboard demo from one command (`examples/demos.py`, `--mode rsim` to rehearse, `--demo` the first): one dashboard stays up and the Live tab's Demo panel switches demo while halted (robots stopped, log saved, radio and vision released, the page reloads by itself), sets the first robot, camera half and rules for the next run, runs the field check, and offers teleop by keyboard ([real_robot_setup.md](real_robot_setup.md#running-the-demos)) | -| `calibrate` | measure one real robot from the terminal and write its profile (`examples/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | +| `calibrate` | measure one real robot from the terminal and write its profile (`tools/field/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | ## Worktrees @@ -156,10 +156,10 @@ the field logs in `replays/field/`. | `examples/demo_exhibition_road.py` | The Exhibition Road festival demo on the 4 m x 3 m field, over rsim | | `examples/demos.py` | `pixi run demos`: shooting drill, pass-receive, save-and-counter and score goal behind one dashboard, switched from the Live tab's Demo panel while halted | | `examples/teleop.py` | Drive either robot by keyboard from the Live tab's Teleop panel (after Force Start; stops on key release, Halt, or the page going quiet); also a demo in `pixi run demos` | -| `examples/calibrate_robot.py` | `pixi run calibrate`: one real robot's profile from the terminal, no dashboard; `--mode rsim --yes` rehearses it | -| `examples/ball_trials.py` | `pixi run calibrate`'s ball part: fetches the ball itself, carries it at rising speeds each way until it loses it, then kicks, each charged; aimed at a target for `--check` | -| `examples/shooting_drill.py` | One robot shoots at a goal the other defends (the keeper feeds the ball back, so it loops) on real robots (or `--mode rsim`/`grsim`): field, camera half, IDs and each robot's working hardware in one config block; the Live tab's field check gates the start. Records every camera run as an SSL game log in `replays/field/`; `--calibrate attacker\|defender` plays fixed moves for measuring that robot | -| `examples/save_and_counter.py` | A 1v1 game where a keeper that saves takes the ball and counterattacks, on real robots (or `--mode rsim`/`grsim`), a goal each: each robot keeps its goal and attacks the other's, reading every tick from the same world whether it attacks or keeps; a keeper's save turns it into the attacker. Field, rules and hardware type from `shooting_drill.py` | +| `tools/field/calibrate_robot.py` | `pixi run calibrate`: one real robot's profile from the terminal, no dashboard; `--mode rsim --yes` rehearses it | +| `tools/field/ball_trials.py` | `pixi run calibrate`'s ball part: fetches the ball itself, carries it at rising speeds each way until it loses it, then kicks, each charged; aimed at a target for `--check` | +| `tools/field/shooting_drill.py` | One robot shoots at a goal the other defends (the keeper feeds the ball back, so it loops) on real robots (or `--mode rsim`/`grsim`): field, camera half, IDs and each robot's working hardware in one config block; the Live tab's field check gates the start. Records every camera run as an SSL game log in `replays/field/`; `--calibrate attacker\|defender` plays fixed moves for measuring that robot | +| `examples/save_and_counter.py` | A 1v1 game where a keeper that saves takes the ball and counterattacks, on real robots (or `--mode rsim`/`grsim`), a goal each: each robot keeps its goal and attacks the other's, reading every tick from the same world whether it attacks or keeps; a keeper's save turns it into the attacker. Field, rules and hardware type from `tools/field/shooting_drill.py` | | `examples/pass_receive.py` | Two robots (one per team, so two colours) pass to each other on real robots (or `--mode rsim`/`grsim`): the robot nearer the ball passes once its partner is still and facing it, the other gets open and receives. The Live tab shows each robot's role | | `examples/score_goal.py` | One robot, no opponent, takes the ball and scores, on a real robot (or `--mode rsim`); also a demo in `pixi run demos` | | `examples/dribble_and_shoot.py` | `score_goal.py`'s robot dribbles a lap of the field, then scores | diff --git a/examples/demos.py b/examples/demos.py index d97a1367..7f7fc6f6 100644 --- a/examples/demos.py +++ b/examples/demos.py @@ -22,7 +22,7 @@ same demo again; - "teleop" (`teleop.py`): drive either robot by keyboard to place robots and the ball. -`planner_ab.py` and `calibrate_robot.py` are not here: they measure, with their own loop and +`planner_ab.py` and `tools/field/calibrate_robot.py` are not here: they measure, with their own loop and terminal prompts, rather than wait on the dashboard. """ @@ -30,19 +30,18 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) -sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tools")) +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) import argparse import signal import traceback -import field_check import pass_receive import save_and_counter import score_goal -import shooting_drill import teleop +from tools.field import field_check, shooting_drill from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import demo as demo_view diff --git a/examples/dribble_and_shoot.py b/examples/dribble_and_shoot.py index b9f52f99..164b1038 100644 --- a/examples/dribble_and_shoot.py +++ b/examples/dribble_and_shoot.py @@ -7,7 +7,7 @@ # the dashboard is at http://localhost:8080: press Force Start to play, Halt to freeze Everything else is `score_goal.py`: the robot set there (`SHOOTER`), the field and camera -view from `shooting_drill.py`, HALT at start, the field check. The robot fetches the +view from `tools/field/shooting_drill.py`, HALT at start, the field check. The robot fetches the ball and dribbles it corner to corner round a rectangle at 55% of the field (`DribbleTactic`, letting go and taking the ball back every 0.8 m, inside the 1 m dribbling rule), and after `LAPS` laps shoots at the goal at +x (`LeadAndSupportTactic`). For another go: Halt, put the diff --git a/examples/pass_receive.py b/examples/pass_receive.py index b56aff28..52b3c13a 100644 --- a/examples/pass_receive.py +++ b/examples/pass_receive.py @@ -15,17 +15,17 @@ collects it and passes again. A ball outside the field (or unseen) holds both robots until the operator puts it back. - Everything to edit for a test day is in the "Test-day configuration" block. The field, the - ball-sensor/kicker profile type and the referee rules are `shooting_drill.py`'s + ball-sensor/kicker profile type and the referee rules are `tools/field/shooting_drill.py`'s (`FIELD`, `TestRobot`, `RULES`), so the examples agree. - Nothing advances on its own: every mode starts in HALT, play starts and stops from the dashboard. Ctrl+C sends stop commands to the robots before exiting. The Live tab's Strategy panel can stand either robot still ("still") or restart it ("pass_receive"), while halted. - The field check on the Live tab must be all green or amber before Force Start, as in - `shooting_drill.py` (docs/real_robot_setup.md, "Each test day"). + `tools/field/shooting_drill.py` (docs/real_robot_setup.md, "Each test day"). Why two teams: the robots wear different pattern colours (yellow 1, blue 0), and a runner team is one colour: there is no way to map a blue pattern into the yellow team. So each robot is its -own team (`strategy` and `opp_strategy`, as in `shooting_drill.py`), and each runs the +own team (`strategy` and `opp_strategy`, as in `tools/field/shooting_drill.py`), and each runs the same `PassReceiveTactic`, which reads the other robot (its only "enemy") as its partner. The two never share state: each decides its role from the same world they both see (who is nearer the ball, where the ball is rolling, whether the partner is set), so the pass needs no new @@ -56,7 +56,7 @@ import time from typing import Optional -from shooting_drill import ( +from tools.field.shooting_drill import ( FIELD, KEEP_OUT, RADIO_0, @@ -67,7 +67,6 @@ _referee_profile, on_field, ) - from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard @@ -101,7 +100,7 @@ MODE = "real" # "real", "rsim" or "grsim"; --mode overrides it -# The part of the field the cameras see (see `shooting_drill.py`); both cameras: "full". +# The part of the field the cameras see (see `tools/field/shooting_drill.py`); both cameras: "full". CAMERA_HALF = "full" # Swapping a robot is a change here only. They must wear different colours (one per team). diff --git a/examples/passing_rally.py b/examples/passing_rally.py index 66f6c05c..5ff7dd4d 100644 --- a/examples/passing_rally.py +++ b/examples/passing_rally.py @@ -19,7 +19,7 @@ the ball back and Force Start. The Live tab shows each robot's role (pass, receive, get_open) under its tactic. - Robots and the readiness checks are `pass_receive.py`'s ("Test-day - configuration" there); the field and the referee rules are `shooting_drill.py`'s. + configuration" there); the field and the referee rules are `tools/field/shooting_drill.py`'s. """ import sys diff --git a/examples/planner_ab.py b/examples/planner_ab.py index c7ba3d7e..be1b59b1 100644 --- a/examples/planner_ab.py +++ b/examples/planner_ab.py @@ -10,7 +10,7 @@ blocks (A B A B ...) so a battery running down or the floor changing over the session falls on both alike. In a block both robots run one planner (`--schemes`, default fpp then trajsample). -The robots are `pass_receive.py`'s pair (one per colour), on `shooting_drill.py`'s field. Each +The robots are `pass_receive.py`'s pair (one per colour), on `tools/field/shooting_drill.py`'s field. Each leg, both drive to a new spot at once, facing where they go, across each other's way: head on (`HEAD_ON`), back, then crossing on the diagonals (`CROSS`), back, and so on. A leg ends once both stand on their spots (within `ARRIVED_M`), or after `LEG_TIMEOUT_S`. Per leg it records how @@ -36,7 +36,8 @@ from typing import Optional from pass_receive import ROBOT_A, ROBOT_B -from shooting_drill import ( + +from tools.field.shooting_drill import ( CAMERA_HALF, FIELD, KEEP_OUT, @@ -45,7 +46,6 @@ no_rules_referee, on_field, ) - from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.engine.context import TickContext from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag diff --git a/examples/save_and_counter.py b/examples/save_and_counter.py index 3c53cbd5..52157d8f 100644 --- a/examples/save_and_counter.py +++ b/examples/save_and_counter.py @@ -21,7 +21,7 @@ - A ball rolling towards a robot's goal (a shot, a clearance) has that robot keeping and the other attacking, so nobody leaves the goal to chase a shot. A ball outside the field (or unseen) holds both robots until the operator puts it back. - - The field, the robot hardware type and the referee rules are `shooting_drill.py`'s + - The field, the robot hardware type and the referee rules are `tools/field/shooting_drill.py`'s (`FIELD`, `TestRobot`, `RULES`): only goals are detected. After a goal play stops; put the ball back and Force Start. Both goals must be in view (`CAMERA_HALF = "full"`). - Every mode starts in HALT; Ctrl+C sends stop commands to the robots before exiting. The Live @@ -40,7 +40,7 @@ import time from typing import Optional -from shooting_drill import ( +from tools.field.shooting_drill import ( FIELD, KEEP_OUT, RADIO_0, @@ -51,7 +51,6 @@ _referee_profile, on_field, ) - from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard diff --git a/examples/score_goal.py b/examples/score_goal.py index a7b6bd0c..8eb52ed3 100644 --- a/examples/score_goal.py +++ b/examples/score_goal.py @@ -5,17 +5,17 @@ pixi run python examples/score_goal.py # real robot pixi run python examples/score_goal.py --mode rsim pixi run python examples/score_goal.py --calibrate # fixed moves from the dashboard; - # pixi run calibrate (examples/calibrate_robot.py) does it from the terminal, with the ball + # pixi run calibrate (tools/field/calibrate_robot.py) does it from the terminal, with the ball # the dashboard is at http://localhost:8080: press Force Start to play, Halt to freeze -The field and the camera's view are `FIELD` and `CAMERA_HALF` in `shooting_drill.py`, +The field and the camera's view are `FIELD` and `CAMERA_HALF` in `tools/field/shooting_drill.py`, so the two examples always agree; the robot is set below. It attacks the goal at +x (the right one in ssl-vision's coordinates) with `LeadAndSupportTactic`: alone, it goes to the ball, turns to the open corner and shoots. It starts in HALT, and the field check gates Force Start as in -`shooting_drill.py`. Put the ball back and Force Start again for the next shot; Halt and +`tools/field/shooting_drill.py`. Put the ball back and Force Start again for the next shot; Halt and Run in the Live tab's Strategy panel restarts the tactic. -`--calibrate` measures the robot alone, as `shooting_drill.py --calibrate` does with two +`--calibrate` measures the robot alone, as `tools/field/shooting_drill.py --calibrate` does with two (that one halts on the second robot it never sees): it plays fixed moves (`tactics/scripted_moves.py`) instead of shooting. Put it near the middle of the camera's view facing +x, with 0.8 m clear ahead and 0.6 m to its left, and a ball at rest in view; Force Start. @@ -31,7 +31,7 @@ import time from typing import Optional -from shooting_drill import ( +from tools.field.shooting_drill import ( CAMERA_HALF, DASHBOARD_PORT, FIELD, @@ -44,7 +44,6 @@ _referee_profile, on_field, ) - from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view diff --git a/examples/teleop.py b/examples/teleop.py index ae2e7fe3..8152c6df 100644 --- a/examples/teleop.py +++ b/examples/teleop.py @@ -10,7 +10,7 @@ Start. W/S forward and back, A/D sideways, Q/E turn, Shift faster, B kicks, F turns the dribbler on and off; Space halts as everywhere on the page. A robot stops when its keys are let go, when the page stops sending (closed, the network gone) and on Halt. No rules, no goals: nothing but -the operator stops play. Robots are `shooting_drill.py`'s (`ROBOT_A`, `ROBOT_B` here), each +the operator stops play. Robots are `tools/field/shooting_drill.py`'s (`ROBOT_A`, `ROBOT_B` here), each kept inside the area in play. """ @@ -22,7 +22,7 @@ import argparse from typing import Optional -from shooting_drill import ( +from tools.field.shooting_drill import ( CAMERA_HALF, DASHBOARD_PORT, FIELD, @@ -34,7 +34,6 @@ _referee_profile, on_field, ) - from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view diff --git a/pixi.toml b/pixi.toml index 691381e1..7e23ecf8 100644 --- a/pixi.toml +++ b/pixi.toml @@ -60,7 +60,7 @@ main = "python -m main" replay = "python -m utama_core.replay.replay_player" runs = "python -m utama_core.analysis.list_runs" debug-robots = "python -m utama_core.team_controller.debug_utils.telop_gui" -calibrate = "python examples/calibrate_robot.py" +calibrate = "python tools/field/calibrate_robot.py" find-robots = "python -m utama_core.team_controller.controllers.real.find_robots" field-check = "python tools/field/field_check.py" demos = "python examples/demos.py" diff --git a/examples/ball_trials.py b/tools/field/ball_trials.py similarity index 98% rename from examples/ball_trials.py rename to tools/field/ball_trials.py index c9c55c19..4ff65c56 100644 --- a/examples/ball_trials.py +++ b/tools/field/ball_trials.py @@ -1,5 +1,5 @@ # ruff: noqa: E402 -"""examples/ball_trials.py — the ball part of `pixi run calibrate`: the robot fetches the ball itself. +"""tools/field/ball_trials.py — the ball part of `pixi run calibrate`: the robot fetches the ball itself. `BallTrialsTactic` measures how fast one robot can carry the ball and how its kicks leave, with no one placing the ball on its dribbler: @@ -27,13 +27,12 @@ import sys from pathlib import Path -sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) import math from typing import NamedTuple, Optional -from pass_receive import take_ball_facing - +from examples.pass_receive import take_ball_facing from utama_core.config.robot_params import REAL_PARAMS from utama_core.engine.context import TickContext from utama_core.engine.tactic import BaseTactic, RobotId, TacticTag diff --git a/examples/calibrate_robot.py b/tools/field/calibrate_robot.py similarity index 98% rename from examples/calibrate_robot.py rename to tools/field/calibrate_robot.py index f604fa8c..65c745ad 100644 --- a/examples/calibrate_robot.py +++ b/tools/field/calibrate_robot.py @@ -1,5 +1,5 @@ # ruff: noqa: E402 -"""examples/calibrate_robot.py — measure one real robot and write its profile: no dashboard. +"""tools/field/calibrate_robot.py — measure one real robot and write its profile: no dashboard. Run: pixi run calibrate # finds the robots on the field; asks which if several @@ -15,7 +15,7 @@ camera's view facing +x (0.8 m clear ahead, 0.6 m to its left) with a ball at rest in view. It plays fixed moves first (`tactics/scripted_moves.py`, `CALIBRATION_SCRIPT`): about 65 s of driving and turning, its turns on the spot also showing where its tag sits. Then the ball part -(`ball_trials.py`), where it fetches the ball itself: +(`tools/field/ball_trials.py`), where it fetches the ball itself: - a carry ladder: forward, backward, sideways and turning with the ball at rising speeds, `--repeats` times each, a direction ending at the first speed that loses the ball; - `--kicks` kicks along the field, each with the kicker charged. @@ -42,7 +42,7 @@ import sys from pathlib import Path -sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) import argparse import json @@ -53,8 +53,8 @@ from dataclasses import replace from typing import Optional -from ball_trials import BallTrialsTactic, at_caps -from shooting_drill import ( +from tools.field.ball_trials import BallTrialsTactic, at_caps +from tools.field.shooting_drill import ( CAMERA_HALF, FIELD, KEEP_OUT, @@ -63,7 +63,6 @@ _one_robot_strategy, no_rules_referee, ) - from utama_core.analysis.robot_calibration import ( FieldLog, ball_noise, @@ -373,7 +372,7 @@ def _analyse(log_path: str, robot: tuple[str, int], radio: int, old: RobotProfil def committed_profile(radio: int) -> Optional[RobotProfile]: """The robot's profile as last committed (`git show HEAD:...`); None if it has none.""" path = profile_path(radio) - rel = path.relative_to(Path(__file__).resolve().parents[1]).as_posix() + rel = path.relative_to(Path(__file__).resolve().parents[2]).as_posix() shown = subprocess.run(["git", "show", f"HEAD:{rel}"], capture_output=True, text=True) return RobotProfile(**json.loads(shown.stdout)["profile"]) if shown.returncode == 0 else None diff --git a/examples/shooting_drill.py b/tools/field/shooting_drill.py similarity index 97% rename from examples/shooting_drill.py rename to tools/field/shooting_drill.py index 774a0569..11c2946e 100644 --- a/examples/shooting_drill.py +++ b/tools/field/shooting_drill.py @@ -1,15 +1,15 @@ # ruff: noqa: E402 -"""examples/shooting_drill.py — one robot shoots at a goal the other defends, on a small field. +"""tools/field/shooting_drill.py — one robot shoots at a goal the other defends, on a small field. The keeper feeds a ball it holds back to the attacker, so the drill loops; it is also where a test day's field, camera half and robot hardware are set (the other examples import them). Run: - pixi run python examples/shooting_drill.py # real robots (MODE below) - pixi run python examples/shooting_drill.py --mode rsim - pixi run python examples/shooting_drill.py --mode grsim # grSim must be running + pixi run python tools/field/shooting_drill.py # real robots (MODE below) + pixi run python tools/field/shooting_drill.py --mode rsim + pixi run python tools/field/shooting_drill.py --mode grsim # grSim must be running # the dashboard is at http://localhost:8080: press Force Start to play, Halt to freeze - pixi run python examples/shooting_drill.py --calibrate attacker # or defender + pixi run python tools/field/shooting_drill.py --calibrate attacker # or defender What it does: - Two robots, one per team, both ours on one radio: the attacker attacks the goal in @@ -58,7 +58,7 @@ from pathlib import Path # Run as `pixi run python examples/.py`: utama_core is not installed, so put the repo on the path. -sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +sys.path.insert(0, str(Path(__file__).resolve().parents[2])) import argparse import dataclasses diff --git a/utama_core/analysis/robot_calibration.py b/utama_core/analysis/robot_calibration.py index 10f1117c..3b1a8886 100644 --- a/utama_core/analysis/robot_calibration.py +++ b/utama_core/analysis/robot_calibration.py @@ -2,7 +2,7 @@ Reads an SSL game log written by `GameLogWriter` (`StrategyRunner(game_log_path=...)`) on real robots: the radio packets as sent and the camera's raw detections, on one clock. Best from a -`--calibrate` run of `examples/shooting_drill.py` (fixed moves, `ScriptedMovesTactic`); +`--calibrate` run of `tools/field/shooting_drill.py` (fixed moves, `ScriptedMovesTactic`); any run works, with fewer clean steps. Per robot that was sent commands: @@ -25,7 +25,7 @@ - **Dribbling**: per constant command held at least `DRIBBLE_MIN_S` with the dribbler on, where the ball sat in the robot's frame (forward of its centre, to its left), how much of the time the ball sensor read on, and whether the ball was still on at the end (`BALL_LOST_M`). A - `examples/calibrate_robot.py` run holds, turns and drives with the ball, then kicks it 3 times. + `tools/field/calibrate_robot.py` run holds, turns and drives with the ball, then kicks it 3 times. pixi run python tools/field/robot_calibration.py replays/field/.log [--json OUT] """ diff --git a/utama_core/analysis/tag_calibration.py b/utama_core/analysis/tag_calibration.py index 10fa9778..e52f83b8 100644 --- a/utama_core/analysis/tag_calibration.py +++ b/utama_core/analysis/tag_calibration.py @@ -2,7 +2,7 @@ centre and how far its heading is off the robot's forward direction. Reads an SSL game log written on real robots (`StrategyRunner(game_log_path=...)`): the turns -and straight drives of an `examples/calibrate_robot.py` run, which writes the offset into the +and straight drives of an `tools/field/calibrate_robot.py` run, which writes the offset into the robot's profile. - **Tag offset**: a robot turning on the spot turns about its own centre, so its tag traces a diff --git a/utama_core/run/field_fence.py b/utama_core/run/field_fence.py index 78dccbf3..9a740247 100644 --- a/utama_core/run/field_fence.py +++ b/utama_core/run/field_fence.py @@ -1,7 +1,7 @@ """Keeps our robots inside the area in play (`field_bounds`, what the camera sees) on camera runs. A tactic chasing a ball that left the camera's half drove its robot after it, out of sight, -where nothing tracks it (a 2026-10-22 grSim test of `examples/shooting_drill.py`: the +where nothing tracks it (a 2026-10-22 grSim test of `tools/field/shooting_drill.py`: the attacker 0.9 m past the half-way line). The field check only halts once a robot is already 0.3 m out. `FencedRobotController` sits under the strategy, like `ProfiledRobotController`, and caps each robot's speed towards each edge of the area to what it can still stop from with its body diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 3b0b8920..21da002f 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -1092,7 +1092,7 @@ def auto_halt(self) -> Optional[str]: def resume_after_auto_halt(self) -> bool: """Force Start once the field check passes again after a HALT it forced, for a run nobody - resumes from the dashboard (`examples/calibrate_robot.py`). True when it resumed.""" + resumes from the dashboard (`tools/field/calibrate_robot.py`). True when it resumed.""" if self._auto_halt is None or self._prev_custom_ref_command != RefereeCommand.HALT: return False if self.field_check.halt_reason(self._field_check_rows) is not None: diff --git a/utama_core/tactics/scripted_moves.py b/utama_core/tactics/scripted_moves.py index f2c6389a..d2db4fcf 100644 --- a/utama_core/tactics/scripted_moves.py +++ b/utama_core/tactics/scripted_moves.py @@ -5,7 +5,7 @@ (`StrategyRunner(game_log_path=...)`), the log holds each command as sent and the robot's motion as the camera saw it; `tools/field/robot_calibration.py` turns that into the robot's numbers (vision noise, delay, speed and turn tracking, acceleration). The ball part of a -calibration fetches the ball itself instead (`examples/ball_trials.py`). +calibration fetches the ball itself instead (`tools/field/ball_trials.py`). Each move goes and comes back (forward then backward, left then right), so the robot ends near where it started; the longest is 0.8 m forward. Pauses (HALT, STOP) do not @@ -17,7 +17,7 @@ (`analysis/robot_calibration.py`), leaves it out. A move with a `prompt` holds the robot still until `proceed()`: the operator sets something up -(a ball on the dribbler) and says so. `examples/calibrate_robot.py` asks in the terminal. +(a ball on the dribbler) and says so. `tools/field/calibrate_robot.py` asks in the terminal. """ from __future__ import annotations diff --git a/utama_core/tests/examples/test_ball_trials.py b/utama_core/tests/examples/test_ball_trials.py index 592d6a3c..bcbc0181 100644 --- a/utama_core/tests/examples/test_ball_trials.py +++ b/utama_core/tests/examples/test_ball_trials.py @@ -1,4 +1,4 @@ -"""`examples/ball_trials.py`, the ball part of `pixi run calibrate`: each carry is the distance it +"""`tools/field/ball_trials.py`, the ball part of `pixi run calibrate`: each carry is the distance it says from standing to standing, runs towards the middle of the field, and the ladder stops a direction at the first speed that loses the ball; every kick comes charged.""" @@ -10,16 +10,10 @@ import pytest +import tools.field.ball_trials as ex from utama_core.entities.data.vector import Vector2D from utama_core.entities.game import FieldBounds -EXAMPLES = Path(__file__).resolve().parents[3] / "examples" -sys.path.insert(0, str(EXAMPLES)) -try: - import ball_trials as ex -finally: - sys.path.remove(str(EXAMPLES)) - BOUNDS = FieldBounds(top_left=(-1.5, 1.125), bottom_right=(1.5, -1.125)) diff --git a/utama_core/tests/examples/test_calibrate_robot.py b/utama_core/tests/examples/test_calibrate_robot.py index 8a21c979..cc47e740 100644 --- a/utama_core/tests/examples/test_calibrate_robot.py +++ b/utama_core/tests/examples/test_calibrate_robot.py @@ -1,4 +1,4 @@ -"""`examples/calibrate_robot.py` writes what a run measured into the robot's profile, keeping +"""`tools/field/calibrate_robot.py` writes what a run measured into the robot's profile, keeping what it did not measure; the profile file reads back as written.""" from __future__ import annotations @@ -8,19 +8,13 @@ import pytest +import tools.field.calibrate_robot as ex from utama_core.team_controller.controllers.common.robot_profile import ( RobotProfile, load_profile, save_profile, ) -EXAMPLES = Path(__file__).resolve().parents[3] / "examples" -sys.path.insert(0, str(EXAMPLES)) -try: - import calibrate_robot as ex -finally: - sys.path.remove(str(EXAMPLES)) - KEPT = { "forward": 1.0, "backward": 0.5, diff --git a/utama_core/tests/examples/test_demos.py b/utama_core/tests/examples/test_demos.py index e4ba4821..9e542bba 100644 --- a/utama_core/tests/examples/test_demos.py +++ b/utama_core/tests/examples/test_demos.py @@ -16,8 +16,9 @@ import pass_receive import save_and_counter import score_goal - import shooting_drill import teleop + + import tools.field.shooting_drill as shooting_drill finally: sys.path.remove(str(EXAMPLES)) diff --git a/utama_core/tests/examples/test_examples_run_as_scripts.py b/utama_core/tests/examples/test_examples_run_as_scripts.py index 20d40917..97d50488 100644 --- a/utama_core/tests/examples/test_examples_run_as_scripts.py +++ b/utama_core/tests/examples/test_examples_run_as_scripts.py @@ -10,28 +10,29 @@ import pytest -EXAMPLES = Path(__file__).resolve().parents[3] / "examples" +REPO = Path(__file__).resolve().parents[3] +EXAMPLES = REPO / "examples" @pytest.mark.parametrize( "name", [ - "shooting_drill.py", - "score_goal.py", - "dribble_and_shoot.py", - "pass_receive.py", - "passing_rally.py", - "save_and_counter.py", - "calibrate_robot.py", - "planner_ab.py", - "demos.py", - "teleop.py", - "demo_referee_feedback_gui.py", + "tools/field/shooting_drill.py", + "examples/score_goal.py", + "examples/dribble_and_shoot.py", + "examples/pass_receive.py", + "examples/passing_rally.py", + "examples/save_and_counter.py", + "tools/field/calibrate_robot.py", + "examples/planner_ab.py", + "examples/demos.py", + "examples/teleop.py", + "examples/demo_referee_feedback_gui.py", ], ) def test_an_example_with_options_prints_its_help_run_by_path(name, tmp_path): done = subprocess.run( - [sys.executable, str(EXAMPLES / name), "--help"], cwd=tmp_path, capture_output=True, text=True, timeout=120 + [sys.executable, str(REPO / name), "--help"], cwd=tmp_path, capture_output=True, text=True, timeout=120 ) assert done.returncode == 0, done.stderr[-2000:] assert "usage:" in done.stdout @@ -42,7 +43,7 @@ def test_the_field_example_holds_while_its_tactic_does_not_apply(): raise, stopping the run the first time the defender played it.""" sys.path.insert(0, str(EXAMPLES)) try: - import shooting_drill as example + import tools.field.shooting_drill as example finally: sys.path.remove(str(EXAMPLES)) robots = frozenset({1}) diff --git a/utama_core/tests/examples/test_shooting_drill.py b/utama_core/tests/examples/test_shooting_drill.py index 3a2ac103..8e3c5d38 100644 --- a/utama_core/tests/examples/test_shooting_drill.py +++ b/utama_core/tests/examples/test_shooting_drill.py @@ -1,4 +1,4 @@ -"""`examples/shooting_drill.py`'s demo keeper: it keeps goal, and a ball it holds goes back +"""`tools/field/shooting_drill.py`'s demo keeper: it keeps goal, and a ball it holds goes back to the attacker, so the demo loops.""" from __future__ import annotations @@ -9,6 +9,7 @@ import pytest +import tools.field.shooting_drill as ex from utama_core.config.enums import Mode from utama_core.engine.context import TickContext from utama_core.entities.data.vector import Vector2D @@ -16,13 +17,6 @@ from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot -EXAMPLES = Path(__file__).resolve().parents[3] / "examples" -sys.path.insert(0, str(EXAMPLES)) -try: - import shooting_drill as ex -finally: - sys.path.remove(str(EXAMPLES)) - @pytest.fixture(autouse=True) def _fresh_possession_state(): diff --git a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py index 23c970be..a14b37a6 100644 --- a/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py +++ b/utama_core/tests/motion_planning/test_fpp_inside_ball_keep_out.py @@ -84,7 +84,7 @@ def test_a_robot_just_inside_the_ball_keep_out_is_sent_out_of_it_not_onto_its_ed assert distance_point_to_segment(np.zeros(2), np.array(us), carrot) >= np.linalg.norm(us) - 1e-6 -# The 3 m x 2.25 m lab field (`examples/shooting_drill.py`'s FIELD). +# The 3 m x 2.25 m lab field (`tools/field/shooting_drill.py`'s FIELD). _LAB = FieldDimensions( full_field_half_length=1.5, full_field_half_width=1.125, diff --git a/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py b/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py index c6f089d8..ec7f82eb 100644 --- a/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py +++ b/utama_core/tests/motion_planning/test_fpp_wall_near_robot.py @@ -16,7 +16,7 @@ from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot -# The lab field: 3 m x 2.25 m (`examples/shooting_drill.py`'s FIELD). +# The lab field: 3 m x 2.25 m (`tools/field/shooting_drill.py`'s FIELD). _LAB = FieldDimensions( full_field_half_length=1.5, full_field_half_width=1.125, diff --git a/utama_core/tests/run/test_field_fence.py b/utama_core/tests/run/test_field_fence.py index 17e7b8e4..4aa28ff8 100644 --- a/utama_core/tests/run/test_field_fence.py +++ b/utama_core/tests/run/test_field_fence.py @@ -141,7 +141,7 @@ def test_no_fence_in_rsim_or_when_the_cameras_see_the_whole_field(mode, bounds): assert _runner(mode, bounds)._fenced(inner, _robot_on_the_half_way_line) is inner -# The lab field's bottom half of its bottom-right quarter (examples/shooting_drill.py, KEEP_OUT). +# The lab field's bottom half of its bottom-right quarter (tools/field/shooting_drill.py, KEEP_OUT). ZONE = FieldBounds(top_left=(0.0, -0.5625), bottom_right=(1.5, -1.125)) From 8a3e0de7b8b4a849c5dea71009b25c2aca6f2aed Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:28:27 +0000 Subject: [PATCH 41/59] dashboard: run as utama_core.dashboard; pixi tasks for evaluate and dashboard - dashboard_server.py -> utama_core/dashboard/__main__.py (python -m utama_core.dashboard). The script imported only utama_core and needed no path logic. - pixi.toml: `evaluate` (python tools/evaluation/evaluate.py, so `pixi run evaluate NAME`) and `dashboard` (python -m utama_core.dashboard), next to `main`. - README, docs/tools.md, docs/first_strategy.md, docs/strategies.md, docs/real_robot_setup.md, change-strategy's SKILL.md, AGENTS.md and the dashboard's live.js comment use the new commands. Co-Authored-By: Claude Haiku 5.5 --- .claude/skills/change-strategy/SKILL.md | 2 +- AGENTS.md | 2 +- README.md | 3 ++- docs/first_strategy.md | 2 +- docs/real_robot_setup.md | 2 +- docs/strategies.md | 4 ++-- docs/tools.md | 6 +++--- pixi.toml | 2 ++ dashboard_server.py => utama_core/dashboard/__main__.py | 4 ++-- utama_core/dashboard/static/live.js | 2 +- 10 files changed, 16 insertions(+), 13 deletions(-) rename dashboard_server.py => utama_core/dashboard/__main__.py (84%) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index 5df01e2d..0020babc 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -42,7 +42,7 @@ to forget. Never start matches without the user's yes. Then: ``` -pixi run python tools/evaluation/evaluate.py NAME [NAME ...] +pixi run evaluate NAME [NAME ...] ``` - Read the first line of each round: "N matches, X from the match results store, M to play". diff --git a/AGENTS.md b/AGENTS.md index cace7e79..023ebc9e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -51,7 +51,7 @@ One term per thing; reuse these instead of coining new ones. the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. -- **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate +- **Evaluation / reference / match results** — `pixi run evaluate NAME` (`tools/evaluation/evaluate.py`): is a candidate stronger than the reference, the champion at the last release (`--at REF` for another release)? A screen on seeds 1-6 only drops; a candidate that survives it is accepted or not on fresh seeds 101-106 (paired t-test). Each round plays under one sim-noise seed in the simulated world and robots diff --git a/README.md b/README.md index 53eb1ab5..df07dea7 100644 --- a/README.md +++ b/README.md @@ -56,7 +56,8 @@ Everything lives under `utama_core/`: - `entities/`, `config/`, `geometry/`: data classes, settings and constants, geometry helpers - `tests/`: all tests -Scripts live in `tools/` (tournaments in `tools/evaluation/`) and `examples/`; see +Scripts live in `tools/` (grouped by who uses them: `debug/`, `field/`, `realism/`, `dev/`; the +strategy evaluation in `tools/evaluation/`) and `examples/`; see [docs/tools.md](docs/tools.md). ## Field conventions diff --git a/docs/first_strategy.md b/docs/first_strategy.md index 846a3fbf..703d19dd 100644 --- a/docs/first_strategy.md +++ b/docs/first_strategy.md @@ -142,7 +142,7 @@ Watching one match is not enough. Football is full of luck. The evaluation plays many matches and tells you if your strategy beats the champion (our best strategy). ``` -pixi run python tools/evaluation/evaluate.py rookie +pixi run evaluate rookie ``` This takes a while: matches play in the background, several at a time. diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index b707acb0..1ea25585 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -275,4 +275,4 @@ far to trust them. An older log is measured again with | `tee: .../usbfs_memory_mb: No such file` | WSL loads USB support only once a device is attached; `/etc/modprobe.d/usbfs.conf` with `options usbcore usbfs_memory_mb=1000` sets it then | | Whole image tinted one colour | White balance stuck at an extreme (2800 K): auto, then lock | | `vision_check` sees nothing | Different networks, Wi-Fi multicast, `.wslconfig` not mirrored, or the firewall rule missing | -| Dashboard: "Address already in use" | Another dashboard (`dashboard_server.py`) holds 8080: stop it | +| Dashboard: "Address already in use" | Another dashboard (`pixi run dashboard`) holds 8080: stop it | diff --git a/docs/strategies.md b/docs/strategies.md index 82af76b5..3ff53d57 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -5,9 +5,9 @@ is core or reserve, and the latest results. Run: -- `pixi run python tools/evaluation/evaluate.py` — one round robin of the core and the champion +- `pixi run evaluate` — one round robin of the core and the champion at the last release: stalls and signals (`--all` plays every strategy). -- `pixi run python tools/evaluation/evaluate.py ` — judges a candidate against the champion +- `pixi run evaluate ` — judges a candidate against the champion at the last release. The way to judge a strategy. `--help` lists the flags. - `pixi run python tools/debug/debug_match.py --strategy --opponent [--dump-ticks PATH]` — one instrumented matchup. diff --git a/docs/tools.md b/docs/tools.md index 645d6c3a..ade0b24f 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -11,8 +11,8 @@ New to the repo? You need only these ([first_strategy.md](first_strategy.md) wal |---|---| | `pixi run main A B` | Watch strategy A (yellow) play strategy B in the simulator | | `pixi run test`, `pixi run lint` | Check nothing broke, before every pull request | -| `pixi run python tools/evaluation/evaluate.py NAME` | Is strategy NAME better than the champion? Read the verdict and the mean diff | -| `pixi run python dashboard_server.py` | Browse recorded replays at http://localhost:8080 | +| `pixi run evaluate NAME` | Is strategy NAME better than the champion? Read the verdict and the mean diff | +| `pixi run dashboard` | Browse recorded replays at http://localhost:8080 | Everything below is for specialists. @@ -70,7 +70,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | | `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `utama_core/run/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | -| `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: recorded replays and run results | +| `utama_core/dashboard/__main__.py` | `pixi run dashboard`: standalone browser dashboard at http://localhost:8080: recorded replays and run results | ## Evaluating strategies diff --git a/pixi.toml b/pixi.toml index 7e23ecf8..a2beb7a8 100644 --- a/pixi.toml +++ b/pixi.toml @@ -57,6 +57,8 @@ lint = "pre-commit run --all-files" test = "pytest utama_core/tests/" build-planner = "cmake -B build/fpp utama_core/motion_planning/fastpathplanning/cpp && cmake --build build/fpp -j" main = "python -m main" +evaluate = "python tools/evaluation/evaluate.py" +dashboard = "python -m utama_core.dashboard" replay = "python -m utama_core.replay.replay_player" runs = "python -m utama_core.analysis.list_runs" debug-robots = "python -m utama_core.team_controller.debug_utils.telop_gui" diff --git a/dashboard_server.py b/utama_core/dashboard/__main__.py similarity index 84% rename from dashboard_server.py rename to utama_core/dashboard/__main__.py index fb42deb4..3cea28f2 100644 --- a/dashboard_server.py +++ b/utama_core/dashboard/__main__.py @@ -1,7 +1,7 @@ -"""dashboard_server.py — standalone dashboard (Replay + Tournament only). +"""utama_core/dashboard/__main__.py — standalone dashboard (Replay + Tournament only). Run: - pixi run python dashboard_server.py + pixi run dashboard (or: python -m utama_core.dashboard) # open http://localhost:8080 in a browser No live match, no CustomReferee, no StrategyRunner — `attach_dashboard()` diff --git a/utama_core/dashboard/static/live.js b/utama_core/dashboard/static/live.js index 5c15518b..7cd86a92 100644 --- a/utama_core/dashboard/static/live.js +++ b/utama_core/dashboard/static/live.js @@ -432,7 +432,7 @@ .then((r) => (r.ok ? r.json() : null)) .then((c) => { if (!c) { - // dashboard_server.py alone serves Replay and Tournament; a live match attaches this view + // `pixi run dashboard` alone serves Replay and Tournament; a live match attaches this view document.getElementById("ref-profile-name").textContent = "No live match attached"; return; } From 70c21387588476a29e5a6b59962abdbc0c32293e Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:29:56 +0000 Subject: [PATCH 42/59] tests: the field scripts moved out of examples/ keep their import check Co-Authored-By: Claude Opus 5.5 --- utama_core/tests/examples/test_examples_run_as_scripts.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/utama_core/tests/examples/test_examples_run_as_scripts.py b/utama_core/tests/examples/test_examples_run_as_scripts.py index 97d50488..50816791 100644 --- a/utama_core/tests/examples/test_examples_run_as_scripts.py +++ b/utama_core/tests/examples/test_examples_run_as_scripts.py @@ -52,7 +52,11 @@ def test_the_field_example_holds_while_its_tactic_does_not_apply(): assert example._play_or_hold(None, frozenset(), None, frozenset({"play", "hold"})) == {} -@pytest.mark.parametrize("path", sorted(EXAMPLES.glob("*.py")), ids=lambda p: p.name) +# the field scripts moved out of examples/ on 2026-11-12 keep the same check +FIELD_SCRIPTS = [REPO / "tools" / "field" / n for n in ("ball_trials.py", "calibrate_robot.py", "shooting_drill.py")] + + +@pytest.mark.parametrize("path", sorted(EXAMPLES.glob("*.py")) + FIELD_SCRIPTS, ids=lambda p: p.name) def test_every_example_imports(path, tmp_path): """Every example's imports resolve. Until 2026-11-11 two demos still imported the removed `utama_core.strategy.kernel_strategy` (gone when strategies became `strategy/.py`) and one From 663ced643405e3be34c73cf7f72613269631454a Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:35:22 +0000 Subject: [PATCH 43/59] structure: custom_referee/ becomes referee/ Co-Authored-By: Claude Haiku 5.5 --- .claude/skills/debug-incident/SKILL.md | 2 +- AGENTS.md | 8 +- README.md | 4 +- docs/README.md | 6 +- docs/STRATEGY_DEVELOPMENT.md | 12 +- docs/architecture.md | 22 +-- docs/img/custom_referee/make_architecture.py | 14 +- docs/img/custom_referee/make_state_machine.py | 6 +- docs/img/sim_realism/make_rsim_tick.py | 6 +- docs/pipeline_method.md | 2 +- docs/pitch_zones.md | 2 +- docs/real_robot_setup.md | 2 +- docs/{custom_referee.md => referee.md} | 8 +- ...cisions.md => referee_design_decisions.md} | 0 .../{custom_referee_gui.md => referee_gui.md} | 2 +- docs/referee_integration.md | 4 +- docs/roadmap.md | 2 +- docs/setup_external.md | 2 +- docs/tactic_model_design_decisions.md | 2 +- examples/demo_custom_referee.py | 2 +- examples/demo_exhibition_road.py | 10 +- examples/demo_referee_feedback_gui.py | 4 +- examples/demo_referee_gui_rsim.py | 4 +- examples/demo_split_shape_match.py | 4 +- examples/pass_receive.py | 2 +- examples/save_and_counter.py | 2 +- examples/score_goal.py | 2 +- examples/teleop.py | 2 +- main.py | 2 +- tools/debug/moments.py | 8 +- tools/field/shooting_drill.py | 18 +-- utama_core/analysis/restart_picture.py | 6 +- utama_core/analysis/stuck_detector.py | 2 +- utama_core/custom_referee/__init__.py | 4 - .../custom_referee/profiles/__init__.py | 3 - utama_core/custom_referee/rules/__init__.py | 14 -- utama_core/dashboard/page.py | 2 +- utama_core/dashboard/server.py | 2 +- utama_core/dashboard/static/live.js | 2 +- utama_core/dashboard/views/referee.py | 6 +- utama_core/dashboard/views/replay.py | 2 +- utama_core/engine/match_stats.py | 2 +- utama_core/engine/referee_override.py | 16 +- utama_core/engine/strategy.py | 2 +- .../fastpathplanning/planner.py | 4 +- utama_core/referee/__init__.py | 4 + .../{custom_referee => referee}/actions.py | 2 +- .../custom_referee.py | 49 +++--- .../{custom_referee => referee}/geometry.py | 0 utama_core/referee/profiles/__init__.py | 3 + .../profiles/human.yaml | 0 .../profiles/profile_loader.py | 0 .../profiles/simulation.yaml | 0 utama_core/referee/rules/__init__.py | 14 ++ .../rules/ball_placement_interference_rule.py | 4 +- .../rules/ball_speed_rule.py | 6 +- .../rules/base_rule.py | 2 +- .../rules/crashing_rule.py | 6 +- .../rules/defense_area_rule.py | 4 +- .../rules/defense_area_stoppage_rule.py | 4 +- .../rules/double_touch_rule.py | 4 +- .../rules/excessive_dribbling_rule.py | 4 +- .../rules/goal_rule.py | 4 +- .../rules/keep_out_rule.py | 4 +- .../rules/keeper_held_ball_rule.py | 4 +- .../rules/last_touch.py | 0 .../rules/no_progress_rule.py | 4 +- .../rules/out_of_bounds_rule.py | 10 +- .../rules/penalty_time_limit_rule.py | 4 +- .../rules/pushing_rule.py | 6 +- .../rules/robot_contact.py | 0 .../rules/robot_stop_speed_rule.py | 4 +- .../state_machine.py | 6 +- utama_core/replay/scenario.py | 2 +- utama_core/replay/ssl_log.py | 2 +- utama_core/run/field_fence.py | 2 +- utama_core/run/live_status.py | 2 +- utama_core/run/referee_source.py | 2 +- utama_core/run/sim_setup.py | 4 +- utama_core/run/strategy_runner.py | 4 +- utama_core/tactics/give_and_go.py | 2 +- .../tests/analysis/test_restart_picture.py | 2 +- .../test_referee_view_serialization.py | 2 +- utama_core/tests/engine/test_ball_roles.py | 12 +- .../test_kernel_strategy_debug_status.py | 7 +- .../test_kickoff_goalkeeper_exemption.py | 6 +- utama_core/tests/engine/test_match_stats.py | 2 +- .../test_referee_overrides_customization.py | 2 +- .../geometry/test_defense_area_rules_off.py | 4 +- .../{custom_referee => referee}/__init__.py | 0 .../{custom_referee => referee}/helpers.py | 0 .../referee_sim.py | 4 +- .../test_aimless_kick.py | 12 +- .../test_ball_contest_deadlock.py | 4 +- .../test_custom_referee.py | 48 +++--- .../test_dribble_placement_stopspeed.py | 12 +- .../test_foul_counter_end_to_end.py | 4 +- .../test_free_kick_taken.py | 2 +- .../test_free_kick_timeout.py | 6 +- .../test_geometry.py | 6 +- .../test_goal_after_non_stopping_foul.py | 4 +- .../test_halt_resume.py | 6 +- .../test_last_touch.py | 8 +- .../test_no_progress_rule.py | 8 +- .../test_out_of_bounds_offender.py | 10 +- .../test_penalty_time_limit_rule.py | 6 +- ...lacement_interference_and_defense_fixes.py | 20 ++- .../test_pushing_crashing.py | 6 +- .../test_referee_rules_integration.py | 2 +- .../test_referee_scan_order.py | 8 +- .../test_referee_unit.py | 140 +++++++++--------- .../test_stage_advance.py | 8 +- .../wandering_strategy.py | 0 utama_core/tests/replay/test_fingerprint.py | 4 +- utama_core/tests/replay/test_scenario.py | 2 +- .../tests/run/test_ball_placement_rsim.py | 2 +- utama_core/tests/run/test_change_of_ends.py | 4 +- utama_core/tests/run/test_field_check.py | 2 +- .../tests/run/test_goalkeeper_stability.py | 4 +- utama_core/tests/run/test_referee_rsim.py | 8 +- utama_core/tests/run/test_replace_strategy.py | 4 +- utama_core/tests/run/test_runner_misconfig.py | 2 +- utama_core/tests/run/test_scenario_hooks.py | 2 +- 123 files changed, 392 insertions(+), 408 deletions(-) rename docs/{custom_referee.md => referee.md} (97%) rename docs/{custom_referee_design_decisions.md => referee_design_decisions.md} (100%) rename docs/{custom_referee_gui.md => referee_gui.md} (99%) delete mode 100644 utama_core/custom_referee/__init__.py delete mode 100644 utama_core/custom_referee/profiles/__init__.py delete mode 100644 utama_core/custom_referee/rules/__init__.py create mode 100644 utama_core/referee/__init__.py rename utama_core/{custom_referee => referee}/actions.py (99%) rename utama_core/{custom_referee => referee}/custom_referee.py (93%) rename utama_core/{custom_referee => referee}/geometry.py (100%) create mode 100644 utama_core/referee/profiles/__init__.py rename utama_core/{custom_referee => referee}/profiles/human.yaml (100%) rename utama_core/{custom_referee => referee}/profiles/profile_loader.py (100%) rename utama_core/{custom_referee => referee}/profiles/simulation.yaml (100%) create mode 100644 utama_core/referee/rules/__init__.py rename utama_core/{custom_referee => referee}/rules/ball_placement_interference_rule.py (97%) rename utama_core/{custom_referee => referee}/rules/ball_speed_rule.py (94%) rename utama_core/{custom_referee => referee}/rules/base_rule.py (98%) rename utama_core/{custom_referee => referee}/rules/crashing_rule.py (97%) rename utama_core/{custom_referee => referee}/rules/defense_area_rule.py (98%) rename utama_core/{custom_referee => referee}/rules/defense_area_stoppage_rule.py (98%) rename utama_core/{custom_referee => referee}/rules/double_touch_rule.py (98%) rename utama_core/{custom_referee => referee}/rules/excessive_dribbling_rule.py (97%) rename utama_core/{custom_referee => referee}/rules/goal_rule.py (96%) rename utama_core/{custom_referee => referee}/rules/keep_out_rule.py (96%) rename utama_core/{custom_referee => referee}/rules/keeper_held_ball_rule.py (97%) rename utama_core/{custom_referee => referee}/rules/last_touch.py (100%) rename utama_core/{custom_referee => referee}/rules/no_progress_rule.py (96%) rename utama_core/{custom_referee => referee}/rules/out_of_bounds_rule.py (98%) rename utama_core/{custom_referee => referee}/rules/penalty_time_limit_rule.py (96%) rename utama_core/{custom_referee => referee}/rules/pushing_rule.py (97%) rename utama_core/{custom_referee => referee}/rules/robot_contact.py (100%) rename utama_core/{custom_referee => referee}/rules/robot_stop_speed_rule.py (97%) rename utama_core/{custom_referee => referee}/state_machine.py (99%) rename utama_core/tests/{custom_referee => referee}/__init__.py (100%) rename utama_core/tests/{custom_referee => referee}/helpers.py (100%) rename utama_core/tests/{custom_referee => referee}/referee_sim.py (97%) rename utama_core/tests/{custom_referee => referee}/test_aimless_kick.py (90%) rename utama_core/tests/{custom_referee => referee}/test_ball_contest_deadlock.py (98%) rename utama_core/tests/{custom_referee => referee}/test_custom_referee.py (97%) rename utama_core/tests/{custom_referee => referee}/test_dribble_placement_stopspeed.py (97%) rename utama_core/tests/{custom_referee => referee}/test_foul_counter_end_to_end.py (98%) rename utama_core/tests/{custom_referee => referee}/test_free_kick_taken.py (97%) rename utama_core/tests/{custom_referee => referee}/test_free_kick_timeout.py (93%) rename utama_core/tests/{custom_referee => referee}/test_geometry.py (98%) rename utama_core/tests/{custom_referee => referee}/test_goal_after_non_stopping_foul.py (94%) rename utama_core/tests/{custom_referee => referee}/test_halt_resume.py (93%) rename utama_core/tests/{custom_referee => referee}/test_last_touch.py (96%) rename utama_core/tests/{custom_referee => referee}/test_no_progress_rule.py (97%) rename utama_core/tests/{custom_referee => referee}/test_out_of_bounds_offender.py (88%) rename utama_core/tests/{custom_referee => referee}/test_penalty_time_limit_rule.py (94%) rename utama_core/tests/{custom_referee => referee}/test_placement_interference_and_defense_fixes.py (96%) rename utama_core/tests/{custom_referee => referee}/test_pushing_crashing.py (98%) rename utama_core/tests/{custom_referee => referee}/test_referee_rules_integration.py (99%) rename utama_core/tests/{custom_referee => referee}/test_referee_scan_order.py (97%) rename utama_core/tests/{custom_referee => referee}/test_referee_unit.py (95%) rename utama_core/tests/{custom_referee => referee}/test_stage_advance.py (97%) rename utama_core/tests/{custom_referee => referee}/wandering_strategy.py (100%) diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md index 70bd44fb..3970b04f 100644 --- a/.claude/skills/debug-incident/SKILL.md +++ b/.claude/skills/debug-incident/SKILL.md @@ -40,7 +40,7 @@ All run as `pixi run python tools/.py ...`. Never conclude from a picture ## 3. Find the cause in the code From the trace: which tactic or override sent the robot there, with which target, waypoint -and obstacles. Then ask whether the rule was really broken (`docs/custom_referee_design_decisions.md`) +and obstacles. Then ask whether the rule was really broken (`docs/referee_design_decisions.md`) and whether the check reads it right. Frame trap: rsim stores y negated; anything written into the sim negates y and heading. diff --git a/AGENTS.md b/AGENTS.md index 023ebc9e..46c9b825 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,7 +18,7 @@ exists yet: say so in your change rather than guessing. |---|---|---|---| | Strategy / tactics | `utama_core/engine/`, `strategy/`, `tactics/`, `skills/` | `docs/STRATEGY_DEVELOPMENT.md` | Engine changes are rare: a new primitive, not a new strategy | | Strategy evaluation | `tools/evaluation/`, `utama_core/replay/`, `utama_core/analysis/` | `docs/STRATEGY_DEVELOPMENT.md`, `docs/signals.md` | Change evaluation and strategy in separate commits, so results stay comparable | -| Referee | `utama_core/custom_referee/` | `docs/custom_referee.md` | | +| Referee | `utama_core/referee/` | `docs/referee.md` | | | Motion planning | `utama_core/motion_planning/`, `tools/motion_planning_benchmark.py` | `docs/motion_planning_comparison.md` | | | Simulation | `utama_core/rsoccer_simulator/`, `vendor/rSim/` | `vendor/rSim/FORK_NOTES.md` | `vendor/rSim` is the C++ physics fork; `rsoccer_simulator` is the Python env on top of it | | Real robots (radio, vision, controllers) | `utama_core/team_controller/`, `utama_core/data_processing/` | `utama_core/team_controller/README.md` (brief) | | @@ -96,7 +96,7 @@ One term per thing; reuse these instead of coining new ones. `PressAndContainTactic`, ...) that strategies compose. - `utama_core/skills/` — lower-level per-robot primitives (`go_to_ball`, `block_attacker`, ...) tactics call directly. -- `utama_core/custom_referee/` — the in-process referee (rules, restart positioning). +- `utama_core/referee/` — the in-process referee (rules, restart positioning). - `utama_core/replay/` — the replay file format (writer, player, columnar reader/writer), scenario rebuilding from a replay, and the match-result cache/fingerprint. - `utama_core/analysis/` — offline analyses of tournament runs and replays (`turnover_breakdown`, @@ -173,10 +173,10 @@ need most: - `docs/STRATEGY_DEVELOPMENT.md` — tactic-kernel model, referee handling, writing a `Tactic`, observability tooling. Read before any strategy-layer change. - `docs/tactic_model_design_decisions.md` — kernel/Tactic/Partitioner design rationale. -- `docs/custom_referee.md` — `CustomReferee` architecture/usage; its "Known gaps" section +- `docs/referee.md` — `CustomReferee` architecture/usage; its "Known gaps" section tracks genuinely open items (don't assume something is missing without checking there first — it may already be resolved and the surrounding doc just stale). -- `docs/custom_referee_design_decisions.md` — referee rule-by-rule design decisions. +- `docs/referee_design_decisions.md` — referee rule-by-rule design decisions. - `docs/roadmap.md` — running list of larger, not-yet-scheduled workstreams; check before assuming a doc's claim about "not yet built" is still accurate — these drift. - `docs/signals.md` — every signal we record about how a strategy plays (stalls, fouls, chances diff --git a/README.md b/README.md index df07dea7..ed48db03 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ real robots are optional ([external setup](docs/setup_external.md)). | Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/strategies.md](docs/strategies.md) | | Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/debug/find_bugs.py RUN_DIR` for a run's worst problems | | Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md) | -| The referee | [docs/custom_referee.md](docs/custom_referee.md) | +| The referee | [docs/referee.md](docs/referee.md) | | Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | | The simulator | [vendor/rSim/FORK_NOTES.md](vendor/rSim/FORK_NOTES.md) | | Real robots, vision, radio | [utama_core/team_controller/README.md](utama_core/team_controller/README.md), [docs/setup_external.md](docs/setup_external.md) | @@ -45,7 +45,7 @@ Everything lives under `utama_core/`: - `strategy/`: the strategies (one module each, named after the strategy) - `tactics/`, `skills/`, `geometry/`: reusable tactics, per-robot skills, and the geometry they share - `engine/`: the tactic-kernel infrastructure (`Strategy`, `Tactic`, `TickContext`, `MatchLog`, referee overrides) -- `custom_referee/`: the in-process referee (rules, state machine, restart positioning, profiles) +- `referee/`: the in-process referee (rules, state machine, restart positioning, profiles) - `motion_planning/`: path planning and motion control - `run/`: the main loop (`StrategyRunner`) - `replay/`: replay files, the match-result cache and code fingerprints diff --git a/docs/README.md b/docs/README.md index 6f60ba51..54024677 100644 --- a/docs/README.md +++ b/docs/README.md @@ -6,8 +6,8 @@ Every doc in this folder, by kind. Docs that code comments cite but that were de - [first_strategy.md](first_strategy.md): start here. Write, watch and evaluate a toy strategy, then let an agent write one. - [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): writing and evaluating strategies and tactics: the tactic-kernel model, referee restarts, lessons from past tactic bugs, round-robins, observability tools. Read before any strategy-layer change. -- [custom_referee.md](custom_referee.md): the in-process `CustomReferee`: architecture, usage, profiles, and its known gaps. -- [custom_referee_gui.md](custom_referee_gui.md): the referee operator panel in the dashboard. +- [referee.md](referee.md): the in-process `CustomReferee`: architecture, usage, profiles, and its known gaps. +- [referee_gui.md](referee_gui.md): the referee operator panel in the dashboard. - [referee_integration.md](referee_integration.md): how referee commands reach robots (`RefereeOverride`) and what each command requires. - [motion_planning_comparison.md](motion_planning_comparison.md): the motion-planning benchmark and how to read it. - [motion_planning_results.md](motion_planning_results.md): its latest full run. @@ -22,7 +22,7 @@ Every doc in this folder, by kind. Docs that code comments cite but that were de - [tactic_model_design_decisions.md](tactic_model_design_decisions.md): why the strategy layer (engine, tactics, strategies) is shaped the way it is, and what was deliberately not built. - [scheduling_math_model.md](scheduling_math_model.md): a mathematical model of tactic scheduling and role allocation, a companion to the above. -- [custom_referee_design_decisions.md](custom_referee_design_decisions.md): rule-by-rule decisions from auditing `CustomReferee` against the SSL rulebook. +- [referee_design_decisions.md](referee_design_decisions.md): rule-by-rule decisions from auditing `CustomReferee` against the SSL rulebook. - [pipeline_method.md](pipeline_method.md): how vision, robot and referee data are refined into one `Game` state, and one tick from state to robot commands. - [architecture.md](architecture.md): the one-tick diagram, and the generated package dependency graph with its import-rule check. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 4614002e..cf8c8917 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -91,11 +91,11 @@ sequenceDiagram ## Referee handling -`CustomReferee` (`utama_core/custom_referee/`) runs in-process and identically across +`CustomReferee` (`utama_core/referee/`) runs in-process and identically across rsim/grsim/real. During a restart, `RefereeOverride` (`engine/referee_override.py`) takes over every outfield robot *before* any `Tactic` ticks, reusing the `*Step` classes in -`custom_referee/actions.py`. Strategies can override a restart formation via -`Strategy(referee_overrides=...)`. See `docs/custom_referee.md`. +`referee/actions.py`. Strategies can override a restart formation via +`Strategy(referee_overrides=...)`. See `docs/referee.md`. To see where the override sends every robot for a restart, run `tools/debug/restart_picture.py` (`REPLAY.npz --t S`, or `--all-restarts` for one small panel per restart command in the replay). It @@ -504,7 +504,7 @@ The picture tools (`tools/debug/match_timeline.py`, `tools/debug/restart_picture ball, while the current planner's carrot from those states is the push-out point 0.85 m from the ball. 3. **Find the cause in the code**, from what the trace shows: which tactic or override sent the robot there, and the target, waypoint and obstacles it used. Ask whether the rule was really - broken (real rules, `docs/custom_referee_design_decisions.md`) and whether the check reads it + broken (real rules, `docs/referee_design_decisions.md`) and whether the check reads it right. 4. **Fix the cause, with a unit test at the boundary** (CLAUDE.md, Testing), e.g. "a computed target is off the field". That test is the protection, and it does not need the foul to @@ -532,7 +532,7 @@ way whatever the strategy. Moments are captured from replays (`capture`); hand-m | Symptom | Looked like | Cause | Fix | Test | |---|---|---|---|---| -| Defender pushed off the pitch during their corner placement | robot leaving the field | override push-out target off the pitch in a corner | `14038121` | `tests/custom_referee/test_referee_unit.py` | +| Defender pushed off the pitch during their corner placement | robot leaving the field | override push-out target off the pitch in a corner | `14038121` | `tests/referee/test_referee_unit.py` | | Defender stuck against their placer | robot ignoring the restart | planner found no path out for a robot inside another's clearance | `c64fc6f9` | `test_fpp_pressed_against_robot.py` | | Defender boxed in a corner closes on the ball | robot driving in | planner detour led back toward the ball; the keep-out guard skipped robots already inside | `935da778` | `test_fpp_inside_ball_keep_out.py` | | Same moment still failing after the fix | robot driving in | `keeps_clear` counted the ball placed onto a robot standing still | `20ca1974` | `test_moments.py` | @@ -542,7 +542,7 @@ way whatever the strategy. Moments are captured from replays (`capture`); hand-m | STOP with the ball just out over the goal line: our robot drives into their keeper (field day 2026-10-27) | robot ignoring a robot | the clear-of-the-ball target, clamped back onto the pitch, was 0.23 m from the keeper standing on its line | field-day-20261027 branch: clearing targets keep `_ROBOT_SPACING_M` (2 robot radii + 10 cm) from every robot, moving on round the ball | `test_referee_unit.py` (TestClearingTargetsKeepOffRobots) | The last row matters on real robots only: in sim matches `StrategyRunner` teleports a placed ball -to its target (`docs/custom_referee_design_decisions.md`, Ball placement), so our placer never +to its target (`docs/referee_design_decisions.md`, Ball placement), so our placer never runs in a round-robin. Its moment was dropped for that reason: check that a moment's behaviour happens in sim matches at all before keeping it. The placer is still slow (about 5 s round the ball, and the carry curves off line), a real-robot item. diff --git a/docs/architecture.md b/docs/architecture.md index b1354f8e..4b2222a7 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -12,7 +12,7 @@ describes the same path in more detail. flowchart TD subgraph input["Input"] vis["Vision frames
data_processing/receivers/vision_receiver.py (real, grSim)
or rsim observations"] - refsrc["Referee data
custom_referee/custom_referee.py (rsim)
or data_processing/receivers/referee_receiver.py"] + refsrc["Referee data
referee/custom_referee.py (rsim)
or data_processing/receivers/referee_receiver.py"] end subgraph world["World model (data_processing/refiners/)"] @@ -27,7 +27,7 @@ flowchart TD strat["Strategy.tick
engine/strategy.py"] restart{"Restart, STOP or TIMEOUT?
engine/referee_override.py"} halt{"HALT?
engine/referee_reset.py"} - ovr["RefereeOverride.tick
engine/referee_override.py
custom_referee/actions.py"] + ovr["RefereeOverride.tick
engine/referee_override.py
referee/actions.py"] part["Partitioner (robots per tactic)
engine/strategy.py, strategy/*.py"] tac["Tactic.tick
tactics/*.py"] skill["Skills
skills/*.py"] @@ -96,14 +96,14 @@ flowchart LR p_analysis["analysis"] -->|8| p_replay["replay"] p_analysis["analysis"] -->|1| p_rsoccer_simulator["rsoccer_simulator"] p_config["config"] -->|1| p_geometry["geometry"] - p_custom_referee["custom_referee"] -->|20| p_config["config"] - p_custom_referee["custom_referee"] -->|48| p_entities["entities"] - p_custom_referee["custom_referee"] -->|2| p_geometry["geometry"] - p_custom_referee["custom_referee"] -->|1| p_geometry["geometry"] - p_custom_referee["custom_referee"] -->|1| p_skills["skills"] + p_referee["referee"] -->|20| p_config["config"] + p_referee["referee"] -->|48| p_entities["entities"] + p_referee["referee"] -->|2| p_geometry["geometry"] + p_referee["referee"] -->|1| p_geometry["geometry"] + p_referee["referee"] -->|1| p_skills["skills"] p_dashboard["dashboard"] -->|1| p_analysis["analysis"] p_dashboard["dashboard"] -->|3| p_config["config"] - p_dashboard["dashboard"] -->|3| p_custom_referee["custom_referee"] + p_dashboard["dashboard"] -->|3| p_referee["referee"] p_dashboard["dashboard"] -->|1| p_engine["engine"] p_dashboard["dashboard"] -->|2| p_entities["entities"] p_dashboard["dashboard"] -->|2| p_replay["replay"] @@ -112,7 +112,7 @@ flowchart LR p_data_processing["data_processing"] -->|2| p_geometry["geometry"] p_data_processing["data_processing"] -->|4| p_team_controller["team_controller"] p_engine["engine"] -->|3| p_config["config"] - p_engine["engine"] -->|2| p_custom_referee["custom_referee"] + p_engine["engine"] -->|2| p_referee["referee"] p_engine["engine"] -->|17| p_entities["entities"] p_engine["engine"] -->|1| p_geometry["geometry"] p_engine["engine"] -->|3| p_motion_planning["motion_planning"] @@ -128,7 +128,7 @@ flowchart LR p_motion_planning["motion_planning"] -->|3| p_geometry["geometry"] p_motion_planning["motion_planning"] -->|8| p_rsoccer_simulator["rsoccer_simulator"] p_replay["replay"] -->|6| p_config["config"] - p_replay["replay"] -->|1| p_custom_referee["custom_referee"] + p_replay["replay"] -->|1| p_referee["referee"] p_replay["replay"] -->|1| p_data_processing["data_processing"] p_replay["replay"] -->|20| p_entities["entities"] p_replay["replay"] -->|2| p_geometry["geometry"] @@ -138,7 +138,7 @@ flowchart LR p_rsoccer_simulator["rsoccer_simulator"] -->|3| p_entities["entities"] p_rsoccer_simulator["rsoccer_simulator"] -->|2| p_geometry["geometry"] p_run["run"] -->|8| p_config["config"] - p_run["run"] -->|4| p_custom_referee["custom_referee"] + p_run["run"] -->|4| p_referee["referee"] p_run["run"] -->|4| p_data_processing["data_processing"] p_run["run"] -->|4| p_engine["engine"] p_run["run"] -->|12| p_entities["entities"] diff --git a/docs/img/custom_referee/make_architecture.py b/docs/img/custom_referee/make_architecture.py index 10084048..9a38032b 100644 --- a/docs/img/custom_referee/make_architecture.py +++ b/docs/img/custom_referee/make_architecture.py @@ -1,4 +1,4 @@ -"""Draws architecture.png for docs/custom_referee.md ("## Architecture"): one tick of CustomReferee, from the +"""Draws architecture.png for docs/referee.md ("## Architecture"): one tick of CustomReferee, from the GameFrame through the rule checks and the game state machine to the strategy layer and the simulator. pixi run python docs/img/custom_referee/make_architecture.py @@ -25,9 +25,9 @@ "MatchStats", "_disallowed_goal", "_TRANSITION_COOLDOWN", - "utama_core/custom_referee/custom_referee.py", - "utama_core/custom_referee/state_machine.py", - "utama_core/custom_referee/rules", + "utama_core/referee/custom_referee.py", + "utama_core/referee/state_machine.py", + "utama_core/referee/rules", "utama_core/entities/game/game_frame.py", "utama_core/engine/strategy.py", "utama_core/tactics", @@ -37,7 +37,7 @@ 150, 128, "CustomReferee, one tick", - "custom_referee/custom_referee.py steps on each GameFrame. The result reaches the strategy through the " + "referee/custom_referee.py steps on each GameFrame. The result reaches the strategy through the " "same buffer as a real referee.", figsize=(14, 12), ) @@ -73,7 +73,7 @@ 62, 13, "Stopping rules: the first violation wins", - "custom_referee/rules/, in priority order: goal, out of bounds, double touch,\n" + "referee/rules/, in priority order: goal, out of bounds, double touch,\n" "defense area, pushing, keeper held ball, excessive dribbling, no progress,\n" "penalty time limit, defense area stoppage (2nd foul: HALT)", kind="decision", @@ -106,7 +106,7 @@ 62, 13, "GameStateMachine.step", - "custom_referee/state_machine.py\n" + "referee/state_machine.py\n" "0.3 s cooldown (_TRANSITION_COOLDOWN), then the violation\n" "(a stopping foul or goal changes the command), then auto-advance", kind="decision", diff --git a/docs/img/custom_referee/make_state_machine.py b/docs/img/custom_referee/make_state_machine.py index 3fc5fbe5..e40fe6fb 100644 --- a/docs/img/custom_referee/make_state_machine.py +++ b/docs/img/custom_referee/make_state_machine.py @@ -1,4 +1,4 @@ -"""Draws state_machine.png for docs/custom_referee.md ("## State machine and auto-advance"): the referee +"""Draws state_machine.png for docs/referee.md ("## State machine and auto-advance"): the referee commands GameStateMachine moves between, with the trigger or timer on each transition. The blue line is the live-play cycle: STOP, a free kick, NORMAL_START, and a stopping foul or goal back to STOP. @@ -17,14 +17,14 @@ NAMES = [ "GameStateMachine", "RefereeCommand", - "utama_core/custom_referee/state_machine.py", + "utama_core/referee/state_machine.py", ] d = Diagram( 200, 138, "Referee commands and their transitions", - "custom_referee/state_machine.py, GameStateMachine. A box is a RefereeCommand (* = the team); each arrow is " + "referee/state_machine.py, GameStateMachine. A box is a RefereeCommand (* = the team); each arrow is " "its trigger or timer.", figsize=(16, 11.5), ) diff --git a/docs/img/sim_realism/make_rsim_tick.py b/docs/img/sim_realism/make_rsim_tick.py index deb8d386..d2c8183e 100644 --- a/docs/img/sim_realism/make_rsim_tick.py +++ b/docs/img/sim_realism/make_rsim_tick.py @@ -28,7 +28,7 @@ "_frame_to_observations", "vision_rng", "utama_core/run/strategy_runner.py", - "utama_core/custom_referee/custom_referee.py", + "utama_core/referee/custom_referee.py", "utama_core/team_controller/controllers/sim/rsim_controller.py", "utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py", "utama_core/rsoccer_simulator/Utils/sim_noise.py", @@ -58,9 +58,7 @@ "one RobotCommand per robot,\nsent through RSimController", kind="decision", ) -d.box( - 24, 22, 36, 14, "CustomReferee", "custom_referee/custom_referee.py\nstepped in process each tick", kind="decision" -) +d.box(24, 22, 36, 14, "CustomReferee", "referee/custom_referee.py\nstepped in process each tick", kind="decision") d.arrow((18, 45), (18, 29), "frames", lx=-1.0, ha="right") d.arrow((30, 29), (30, 45), "referee data", lx=1.0) diff --git a/docs/pipeline_method.md b/docs/pipeline_method.md index be05697c..7ff0c305 100644 --- a/docs/pipeline_method.md +++ b/docs/pipeline_method.md @@ -13,7 +13,7 @@ state into robot commands. Everything below runs inside `StrategyRunner` The referee is one of three sources (`run/referee_source.py`): none, the official GameController over the network, or `CustomReferee`, which runs in the same process and is what -rsim matches and tournaments use (`docs/custom_referee.md`). +rsim matches and tournaments use (`docs/referee.md`). **Problem.** Combining new data with prior knowledge (e.g. a Kalman filter) kept bloating `GameFrame` with new functions, and access to past and current state wasn't uniform. diff --git a/docs/pitch_zones.md b/docs/pitch_zones.md index 7266d611..86763c46 100644 --- a/docs/pitch_zones.md +++ b/docs/pitch_zones.md @@ -51,7 +51,7 @@ A third and a strip together name one of nine cells: "attacking left wing", "def - **The box**: the defense area, 1 m deep and 2 m wide in front of each goal. At most one defender (the goalkeeper) may be inside its own box, and attackers may not enter the - opponent's (`custom_referee/rules/defense_area_rule.py`). "Our box" and "their box" are from + opponent's (`referee/rules/defense_area_rule.py`). "Our box" and "their box" are from the team's point of view. Code calls it the defense area (`FieldDimensions.right_defense_area`). - **The goal**: 1 m wide. - **The centre circle**: 0.5 m radius; it matters at kickoffs. diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index 1ea25585..4021446e 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -135,7 +135,7 @@ Set the "Test-day configuration" block of `tools/field/shooting_drill.py`: `FIEL `CAMERA_HALF` (`"full"` when the cameras cover the whole field), each robot's vision and radio ID and working hardware. Then `pixi run python tools/field/shooting_drill.py`, open http://localhost:8080 and go through the Live tab's field check -([custom_referee_gui.md](custom_referee_gui.md#field-check-camera-runs)): every row green or +([referee_gui.md](referee_gui.md#field-check-camera-runs)): every row green or amber, each robot under its own ID and colour, a ball in each corner inside the area in play, and a robot pushed by hand across the cameras' overlap moving smoothly (a jump there means the two calibrations disagree). Only then Force Start. diff --git a/docs/custom_referee.md b/docs/referee.md similarity index 97% rename from docs/custom_referee.md rename to docs/referee.md index e4e4f121..2aa245b0 100644 --- a/docs/custom_referee.md +++ b/docs/referee.md @@ -1,6 +1,6 @@ # Custom Referee -`CustomReferee` (`utama_core/custom_referee/`) is an in-process referee: it steps +`CustomReferee` (`utama_core/referee/`) is an in-process referee: it steps synchronously on `GameFrame`s and produces `RefereeData`, which `RefereeOverride` (`engine/referee_override.py`) reads each tick via `game.referee`. No network, no AutoReferee process, no simulator-specific code — identical in RSim, grSim and Real. @@ -49,7 +49,7 @@ Built in `_build_active_rules` (`custom_referee.py`), in this priority order; de | `KeepOutRule` | `DIRECT_FREE_*`, `PREPARE_KICKOFF_*` | Defending team within 0.5m for 30 consecutive frames: non-stopping, 2 s re-raise, restarts the free kick's 10 s clock (§8.4.3). Not during bare `STOP` or penalties, nor once a free kick is taken (stage 3 of the state machine: the ball moved 0.05m, so it is live). | | `PenaltyTimeLimitRule` | `NORMAL_START`/`FORCE_START` after `PREPARE_PENALTY_*` | Penalty still in play 10 s after its normal start: goal kick for the defenders (§5.3.5). | | `NoProgressRule` | live play | Ball hasn't moved 0.05 m in 10 s: `STOP` then `FORCE_START` where it lies, moved out of the opponent's defense area if it is inside it (`legal_restart_position`, §8.1). The clock waits for the ball to be in play (a `NORMAL_START` restart: 0.05 m of movement or the 10 s auto-in-play) and is held while the ball is inside either defense area. Last in the list, so a real foul on the same tick wins. | -| `PushingRule`, `KeeperHeldBallRule`, `ExcessiveDribblingRule`, `RobotStopSpeedRule`, `CrashingRule`, `DefenseAreaStoppageRule`, `BallPlacementInterferenceRule` | see each rule file | SSL §8.3/8.4 audit (`434ab29`). Rationale per rule: `custom_referee_design_decisions.md`. | +| `PushingRule`, `KeeperHeldBallRule`, `ExcessiveDribblingRule`, `RobotStopSpeedRule`, `CrashingRule`, `DefenseAreaStoppageRule`, `BallPlacementInterferenceRule` | see each rule file | SSL §8.3/8.4 audit (`434ab29`). Rationale per rule: `referee_design_decisions.md`. | ## State machine and auto-advance @@ -146,7 +146,7 @@ ball speed, full-episode reset, teams changing ends at half-time, ## Running ```bash -pixi run pytest utama_core/tests/custom_referee/ --headless +pixi run pytest utama_core/tests/referee/ --headless pixi run python examples/demo_custom_referee.py # pygame, 6 scripted rule scenes; SPACE pause, R restart, ←/→ skip -pixi run python examples/demo_referee_gui_rsim.py # RSim + dashboard referee tab, see custom_referee_gui.md +pixi run python examples/demo_referee_gui_rsim.py # RSim + dashboard referee tab, see referee_gui.md ``` diff --git a/docs/custom_referee_design_decisions.md b/docs/referee_design_decisions.md similarity index 100% rename from docs/custom_referee_design_decisions.md rename to docs/referee_design_decisions.md diff --git a/docs/custom_referee_gui.md b/docs/referee_gui.md similarity index 99% rename from docs/custom_referee_gui.md rename to docs/referee_gui.md index 41d72470..33bd72ef 100644 --- a/docs/custom_referee_gui.md +++ b/docs/referee_gui.md @@ -82,4 +82,4 @@ after a goal the referee stays in `STOP` until the operator acts. For a physical field, keep every `auto_advance` flag false so robots never start moving until the operator presses a button. Profile keys, auto-advance triggers and making a custom profile: -`custom_referee.md`. +`referee.md`. diff --git a/docs/referee_integration.md b/docs/referee_integration.md index 6d7f06d5..116b0849 100644 --- a/docs/referee_integration.md +++ b/docs/referee_integration.md @@ -4,8 +4,8 @@ How referee commands reach robots, and what each command requires. The original integration is gone (BT removed in `087ee4b`, `960662c`, `48affd6`); the current mechanism is `RefereeOverride` (`utama_core/engine/referee_override.py`, design: §13 of `tactic_model_design_decisions.md`) driving the `*Step` classes in -`utama_core/custom_referee/actions.py`. For the in-process referee itself see -`custom_referee.md`. +`utama_core/referee/actions.py`. For the in-process referee itself see +`referee.md`. ## Data path diff --git a/docs/roadmap.md b/docs/roadmap.md index e23e26c0..0109f77f 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -12,7 +12,7 @@ entry by its title, not its number. - **BT/py_trees removal** — `AbstractStrategy` rewritten kernel-native — `087ee4b`, `960662c`, `48affd6`. - **Tournament scoreless-draw debugging** — rSim kick direction, `FastPathPlanner`, `SwitchOfPlayTactic`, `DefenseTactic` foul loop, `TwoDPID` braking — `27fd36f`, `e11094a`, `78fce73`. - **Motion-controller discontinuity handling** — PID auto-reset on orientation target jump — `91100ff`, `87cf250`, `036077c`. -- **CustomReferee gaps** — double touch, ball speed, full-episode `reset()`, `set_debug_status` rename (see `docs/custom_referee.md`). +- **CustomReferee gaps** — double touch, ball speed, full-episode `reset()`, `set_debug_status` rename (see `docs/referee.md`). - **Strategy-computation perf pass** — ~3x end-to-end — `3086337`, `0cf1e17`, `679e8cd`, `b79b863`, `b98cd29`, `4493002`. - **Goalkeeper overshoot** — `a4df59e`, `ba59c9e`. - **Stuck-match root causes** — `PressAndContainTactic` loose ball, `GiveAndGoTactic` hop timeout — `d6b3ff1`. diff --git a/docs/setup_external.md b/docs/setup_external.md index fcb63d6d..42f84072 100644 --- a/docs/setup_external.md +++ b/docs/setup_external.md @@ -1,7 +1,7 @@ # External setup: grSim, GameController, AutoReferee, SSL Vision None of this is needed for everyday work: rsim and the in-process -[`CustomReferee`](custom_referee.md) run everything headless with no external process, and +[`CustomReferee`](referee.md) run everything headless with no external process, and behave the same across rsim, grSim and real mode. Set these up only to run against grSim, the official competition software, or real robots. diff --git a/docs/tactic_model_design_decisions.md b/docs/tactic_model_design_decisions.md index 81029b95..997c9646 100644 --- a/docs/tactic_model_design_decisions.md +++ b/docs/tactic_model_design_decisions.md @@ -92,7 +92,7 @@ controller but not `game`. **§13. Referee restarts are handled before any Tactic ticks** (`engine/referee_override.py`). For `STOP`, `TIMEOUT_*` and every restart command, `RefereeOverride` computes every outfield -robot's command from the long-lived `*Step` classes in `custom_referee/actions.py` (reused, +robot's command from the long-lived `*Step` classes in `referee/actions.py` (reused, not reimplemented — keep-out geometry has one home). Steps are driven through a three-attribute shim (`game`, `motion_controller`, `cmd_map`). The goalkeeper's pinned tactic ticks only if the override produced no command for it (kickoff steps exempt the keeper). A restart arriving diff --git a/examples/demo_custom_referee.py b/examples/demo_custom_referee.py index f894f2b0..9770ce5b 100644 --- a/examples/demo_custom_referee.py +++ b/examples/demo_custom_referee.py @@ -40,12 +40,12 @@ import pygame from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee import CustomReferee, RefereeGeometry from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee, RefereeGeometry from utama_core.rsoccer_simulator.Render import COLORS, SSLRenderField from utama_core.rsoccer_simulator.Render.ball import RenderBall from utama_core.rsoccer_simulator.Render.overlay import ( diff --git a/examples/demo_exhibition_road.py b/examples/demo_exhibition_road.py index 44d6364a..320d07bc 100644 --- a/examples/demo_exhibition_road.py +++ b/examples/demo_exhibition_road.py @@ -35,8 +35,10 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1])) from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import ( +from utama_core.dashboard import attach_dashboard +from utama_core.dashboard.views import referee as referee_view +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import ( AutoAdvanceConfig, DefenseAreaConfig, GameConfig, @@ -46,10 +48,8 @@ RefereeProfile, RulesConfig, ) -from utama_core.dashboard import attach_dashboard -from utama_core.dashboard.views import referee as referee_view from utama_core.run import StrategyRunner -from utama_core.tests.custom_referee.wandering_strategy import wandering_strategy +from utama_core.tests.referee.wandering_strategy import wandering_strategy # --------------------------------------------------------------------------- # Configuration diff --git a/examples/demo_referee_feedback_gui.py b/examples/demo_referee_feedback_gui.py index 1d43be03..5a8cd881 100644 --- a/examples/demo_referee_feedback_gui.py +++ b/examples/demo_referee_feedback_gui.py @@ -22,8 +22,6 @@ import math import time -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.entities.data.vector import Vector2D, Vector3D @@ -31,6 +29,8 @@ from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile def _robot( diff --git a/examples/demo_referee_gui_rsim.py b/examples/demo_referee_gui_rsim.py index 43e9a6c6..36682f9c 100644 --- a/examples/demo_referee_gui_rsim.py +++ b/examples/demo_referee_gui_rsim.py @@ -33,11 +33,11 @@ # Run as `pixi run python examples/.py`: utama_core is not installed, so put the repo on the path. sys.path.insert(0, str(Path(__file__).resolve().parents[1])) -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run import StrategyRunner from utama_core.strategy.catalog import builder diff --git a/examples/demo_split_shape_match.py b/examples/demo_split_shape_match.py index 888d71a3..e50986be 100644 --- a/examples/demo_split_shape_match.py +++ b/examples/demo_split_shape_match.py @@ -23,11 +23,11 @@ import time -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run import StrategyRunner from utama_core.strategy.catalog import builder diff --git a/examples/pass_receive.py b/examples/pass_receive.py index 52b3c13a..2ff9f29f 100644 --- a/examples/pass_receive.py +++ b/examples/pass_receive.py @@ -68,7 +68,6 @@ on_field, ) from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS -from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.dashboard.views import strategy as strategy_view @@ -90,6 +89,7 @@ kick_bend, oriented_towards, ) +from utama_core.referee import CustomReferee from utama_core.run import StrategyRunner from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot from utama_core.tactics.scripted_moves import ScriptedMovesTactic diff --git a/examples/save_and_counter.py b/examples/save_and_counter.py index 52157d8f..66053e50 100644 --- a/examples/save_and_counter.py +++ b/examples/save_and_counter.py @@ -52,7 +52,6 @@ on_field, ) from utama_core.config.physical_constants import ROBOT_RADIUS -from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.dashboard.views import strategy as strategy_view @@ -67,6 +66,7 @@ has_ball, oriented_towards, ) +from utama_core.referee import CustomReferee from utama_core.run import StrategyRunner from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.utils.move_utils import empty_command, move, turn_on_spot diff --git a/examples/score_goal.py b/examples/score_goal.py index 8eb52ed3..cf851e84 100644 --- a/examples/score_goal.py +++ b/examples/score_goal.py @@ -44,11 +44,11 @@ _referee_profile, on_field, ) -from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.dashboard.views import strategy as strategy_view from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee from utama_core.run import StrategyRunner from utama_core.tactics.lead_and_support import LeadAndSupportTactic from utama_core.tactics.scripted_moves import ScriptedMovesTactic diff --git a/examples/teleop.py b/examples/teleop.py index 8152c6df..268d1f0d 100644 --- a/examples/teleop.py +++ b/examples/teleop.py @@ -34,11 +34,11 @@ _referee_profile, on_field, ) -from utama_core.custom_referee import CustomReferee from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.dashboard.views import teleop as teleop_view from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee from utama_core.run import StrategyRunner from utama_core.tactics.teleop import TeleopDrive, TeleopTactic diff --git a/main.py b/main.py index d59996c4..060a0adc 100644 --- a/main.py +++ b/main.py @@ -13,10 +13,10 @@ import argparse -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run.sim_setup import UnknownStrategy, load_side, sim_referee, sim_runner diff --git a/tools/debug/moments.py b/tools/debug/moments.py index 8bb8c8e6..777d276d 100644 --- a/tools/debug/moments.py +++ b/tools/debug/moments.py @@ -10,7 +10,7 @@ "strategy": "all" or one strategy, "opponent": the other side (default pendulum), "seconds": how long to play (default 3), "checks": names from `CHECKS` below, or referee rule names our side must not break - (`custom_referee/rules/`, "*" for any), + (`referee/rules/`, "*" for any), "requires": names from `REQUIRES` below: conditions that must hold during the play, so a moment whose situation never arose fails ("did not arise: ...") instead of passing, "known_failure": null, or why it still fails (the test is then a strict xfail), @@ -90,7 +90,7 @@ DEFAULT_OPPONENT = "pendulum" DEFAULT_SECONDS = 3.0 -# Rulebook distances (`custom_referee/rules/keep_out_rule.py`, `robot_stop_speed_rule.py`). +# Rulebook distances (`referee/rules/keep_out_rule.py`, `robot_stop_speed_rule.py`). KEEP_OUT_M = 0.5 STOP_SPEED_MPS = 1.5 # A robot inside the keep-out circle may drift with noise, never drive in: closer by more than @@ -253,11 +253,11 @@ class MomentError(ValueError): def referee_rule_names() -> set[str]: - """The `rule_name=` literals of the referee's rules, read from `custom_referee/` (rules and state machine).""" + """The `rule_name=` literals of the referee's rules, read from `referee/` (rules and state machine).""" import ast names = set() - for path in (REPO_ROOT / "utama_core" / "custom_referee").rglob("*.py"): + for path in (REPO_ROOT / "utama_core" / "referee").rglob("*.py"): for node in ast.walk(ast.parse(path.read_text())): if isinstance(node, ast.Call): for kw in node.keywords: diff --git a/tools/field/shooting_drill.py b/tools/field/shooting_drill.py index 11c2946e..29bafe33 100644 --- a/tools/field/shooting_drill.py +++ b/tools/field/shooting_drill.py @@ -24,7 +24,7 @@ On the dashboard's Live tab, the field check must be all green or amber before Force Start: a red row (robot not seen, outside the camera half, radio lost, wrong field size) halts the -robots at once. See docs/custom_referee_gui.md, "Field check". +robots at once. See docs/referee_gui.md, "Field check". Measuring a robot (`--calibrate attacker|defender`): that robot plays fixed moves instead (`tactics/scripted_moves.py`, about 70 s: 10 s still, steps forward and back at 0.3, 0.6 and @@ -66,14 +66,6 @@ from typing import NamedTuple, Optional from utama_core.config.field_params import FieldBounds, FieldDimensions -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import ( - AutoAdvanceConfig, - GameConfig, - RefereeProfile, - RulesConfig, - load_profile, -) from utama_core.dashboard import DashboardServer, attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.dashboard.views import strategy as strategy_view @@ -83,6 +75,14 @@ from utama_core.engine.tactic import BaseTactic, TacticTag from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.geometry.pass_and_score_geometry import has_ball, oriented_towards +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import ( + AutoAdvanceConfig, + GameConfig, + RefereeProfile, + RulesConfig, + load_profile, +) from utama_core.run import StrategyRunner from utama_core.skills.utils.move_utils import kick, turn_on_spot from utama_core.tactics.defense import DefenseTactic diff --git a/utama_core/analysis/restart_picture.py b/utama_core/analysis/restart_picture.py index 0f95b462..063185b8 100644 --- a/utama_core/analysis/restart_picture.py +++ b/utama_core/analysis/restart_picture.py @@ -3,7 +3,7 @@ For a replay state whose referee command is a restart (STOP, timeouts, kick-offs, penalties, free kicks, ball placement), this runs `RefereeOverride.tick` exactly as the strategy does and records the target each robot is commanded to. The `*Step` classes only produce velocity commands through `move` and -`turn_on_spot`, so `_recording_steps` swaps those two names in `custom_referee.actions` for recorders for +`turn_on_spot`, so `_recording_steps` swaps those two names in `referee.actions` for recorders for the duration of the call (and restores them): the commanded target is what is captured, and no engine or planner code changes. A detour waypoint is captured as the target, as commanded. @@ -54,7 +54,6 @@ BALL_KEEP_OUT_DISTANCE, OPPONENT_DEFENSE_AREA_KEEP_DISTANCE, ) -from utama_core.custom_referee import actions as _actions from utama_core.engine.referee_override import RefereeOverride, is_override_command from utama_core.entities.data.referee import RefereeData from utama_core.entities.data.vector import Vector2D @@ -62,6 +61,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage +from utama_core.referee import actions as _actions from utama_core.replay.columnar_reader import load_columnar_replay from utama_core.replay.scenario import Scenario, scenario_from_replay @@ -112,7 +112,7 @@ def flagged(self) -> tuple[RobotPlan, ...]: @contextmanager def _recording_steps() -> Iterator[dict[int, CommandedTarget]]: - """Swap `move` and `turn_on_spot` in `custom_referee.actions` for recorders, then restore them.""" + """Swap `move` and `turn_on_spot` in `referee.actions` for recorders, then restore them.""" recorded: dict[int, CommandedTarget] = {} real_move, real_turn = _actions.move, _actions.turn_on_spot diff --git a/utama_core/analysis/stuck_detector.py b/utama_core/analysis/stuck_detector.py index 57d40850..8fecd9ac 100644 --- a/utama_core/analysis/stuck_detector.py +++ b/utama_core/analysis/stuck_detector.py @@ -2,7 +2,7 @@ robot oscillates instead of making progress, or a restart command stuck in effect far longer than any legal restart ceremony takes. -This is a prototype analysis tool, not a live `custom_referee` rule (see +This is a prototype analysis tool, not a live `referee` rule (see `docs/testing_gaps.md` gap #11) — it runs after a match, over a recorded `.pkl`/`.npz` replay, and reports candidate windows for a human/agent to look at with `render_window()`. It intentionally does not (and should not, diff --git a/utama_core/custom_referee/__init__.py b/utama_core/custom_referee/__init__.py deleted file mode 100644 index 6b08039e..00000000 --- a/utama_core/custom_referee/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from utama_core.custom_referee.custom_referee import CustomReferee -from utama_core.custom_referee.geometry import RefereeGeometry - -__all__ = ["CustomReferee", "RefereeGeometry"] diff --git a/utama_core/custom_referee/profiles/__init__.py b/utama_core/custom_referee/profiles/__init__.py deleted file mode 100644 index 5b9edc28..00000000 --- a/utama_core/custom_referee/profiles/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from utama_core.custom_referee.profiles.profile_loader import load_profile - -__all__ = ["load_profile"] diff --git a/utama_core/custom_referee/rules/__init__.py b/utama_core/custom_referee/rules/__init__.py deleted file mode 100644 index 7a6548f0..00000000 --- a/utama_core/custom_referee/rules/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.defense_area_rule import DefenseAreaRule -from utama_core.custom_referee.rules.goal_rule import GoalRule -from utama_core.custom_referee.rules.keep_out_rule import KeepOutRule -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule - -__all__ = [ - "BaseRule", - "RuleViolation", - "GoalRule", - "OutOfBoundsRule", - "DefenseAreaRule", - "KeepOutRule", -] diff --git a/utama_core/dashboard/page.py b/utama_core/dashboard/page.py index 7e4da940..5e6b4103 100644 --- a/utama_core/dashboard/page.py +++ b/utama_core/dashboard/page.py @@ -1,7 +1,7 @@ """Assembles the dashboard's single-page shell by inlining `static/*` files. Kept dependency-free and build-step-free on purpose (same constraint -`custom_referee/gui.py` operated under): one HTML string, served by the +`referee/gui.py` operated under): one HTML string, served by the stdlib HTTP server, no bundler, no separate static file route. """ diff --git a/utama_core/dashboard/server.py b/utama_core/dashboard/server.py index bf2c6252..3604d30a 100644 --- a/utama_core/dashboard/server.py +++ b/utama_core/dashboard/server.py @@ -7,7 +7,7 @@ handler for the path. Each `views/*.py` module owns its own state shape and registers itself against a running server — this module just moves bytes. -Extracted from `custom_referee/gui.py`'s `_RefereeGUIServer`, which used to +Extracted from `referee/gui.py`'s `_RefereeGUIServer`, which used to run one server per referee instance with a single hardcoded SSE channel and a single hardcoded `/command` handler. Multiple views sharing one server means one browser tab, one port, one process — not a GUI per concern. diff --git a/utama_core/dashboard/static/live.js b/utama_core/dashboard/static/live.js index 7cd86a92..bfe8db17 100644 --- a/utama_core/dashboard/static/live.js +++ b/utama_core/dashboard/static/live.js @@ -1,5 +1,5 @@ // Live view: field canvas + referee command buttons + profile config readout. -// Successor to custom_referee/gui.py's single-page HTML/JS — same behavior, +// Successor to referee/gui.py's single-page HTML/JS — same behavior, // registered as one tab against the shared dashboard server. Named "Live" // (not "Referee") because it's the one view for watching+controlling a // running match — a tactic-assignment panel lives here too, not in a diff --git a/utama_core/dashboard/views/referee.py b/utama_core/dashboard/views/referee.py index dfe74649..40367082 100644 --- a/utama_core/dashboard/views/referee.py +++ b/utama_core/dashboard/views/referee.py @@ -1,6 +1,6 @@ """Referee view — attaches `CustomReferee` state/commands to a `DashboardServer`. -This is the direct successor to `custom_referee/gui.py`'s `_RefereeGUIServer`: +This is the direct successor to `referee/gui.py`'s `_RefereeGUIServer`: same state shape pushed over SSE, same `/command` semantics, but registered as one channel/route pair on a shared server instead of owning a private HTTP server. `CustomReferee.step()` still calls `notify()` on every tick — @@ -18,8 +18,8 @@ from utama_core.entities.referee.referee_command import RefereeCommand if TYPE_CHECKING: - from utama_core.custom_referee import CustomReferee - from utama_core.custom_referee.profiles.profile_loader import RefereeProfile + from utama_core.referee import CustomReferee + from utama_core.referee.profiles.profile_loader import RefereeProfile CHANNEL = "referee" diff --git a/utama_core/dashboard/views/replay.py b/utama_core/dashboard/views/replay.py index 9fcf96b1..ab6f8729 100644 --- a/utama_core/dashboard/views/replay.py +++ b/utama_core/dashboard/views/replay.py @@ -55,7 +55,6 @@ from utama_core.analysis.turnover_breakdown import analyse_match, is_real from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.settings import REPLAY_BASE_PATH -from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.dashboard.server import DashboardServer from utama_core.dashboard.views.referee import _serialise_ball, _serialise_robots from utama_core.engine.match_log import ( @@ -65,6 +64,7 @@ load_jsonl, ) from utama_core.entities.game.game_frame import GameFrame +from utama_core.referee.geometry import RefereeGeometry from utama_core.replay.columnar_reader import load_columnar_replay from utama_core.replay.replay_player import _load_replay diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index b7684469..cbe6f33e 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -65,11 +65,11 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.physical_constants import ROBOT_RADIUS -from utama_core.custom_referee.rules.base_rule import RuleViolation from utama_core.entities.data.vector import Vector2D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.rules.base_rule import RuleViolation # Pitch is bucketed into thirds along x, from the recording side's own goal # (defensive) to the opponent's goal (attacking), independent of which diff --git a/utama_core/engine/referee_override.py b/utama_core/engine/referee_override.py index 872517af..a0e10ed6 100644 --- a/utama_core/engine/referee_override.py +++ b/utama_core/engine/referee_override.py @@ -10,7 +10,7 @@ This module matches the current `RefereeCommand` and, when it is a restart, takes over every friendly robot's command for that tick, bypassing tactics entirely. It reuses the `*Step` classes in -`utama_core/custom_referee/actions.py` rather than reimplementing +`utama_core/referee/actions.py` rather than reimplementing keep-out-distance geometry — those classes only ever touch `blackboard.game`, `blackboard.motion_controller`, and `blackboard.cmd_map` (verified: no other blackboard key is read), so a @@ -26,7 +26,7 @@ together under "just freeze", which was wrong for the other two: - STOP's actual rule is stricter than a freeze: "stop in place, AND stay - >= 0.5m from the ball" (`docs/custom_referee_gui.md`). A robot already + >= 0.5m from the ball" (`docs/referee_gui.md`). A robot already inside that keep-out radius at the exact instant STOP is entered (e.g. a carrier mid-dribble, or `goalkeep.py`'s own retrieval branch driving the keeper up to a loose ball) has no way to comply by freezing — it is @@ -55,7 +55,12 @@ from dataclasses import dataclass, field from typing import Callable, Optional -from utama_core.custom_referee.actions import ( +from utama_core.engine.tactic import RobotId +from utama_core.entities.data.command import RobotCommand +from utama_core.entities.game import Game +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.referee.actions import ( BallPlacementOursStep, BallPlacementTheirsStep, DirectFreeOursStep, @@ -66,11 +71,6 @@ PreparePenaltyTheirsStep, StopStep, ) -from utama_core.engine.tactic import RobotId -from utama_core.entities.data.command import RobotCommand -from utama_core.entities.game import Game -from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.motion_planning.common.motion_controller import MotionController # Commands requiring a legal-position override: every stoppage/restart except # HALT, which `Strategy.tick()`'s `is_paused` check already handles by issuing diff --git a/utama_core/engine/strategy.py b/utama_core/engine/strategy.py index 8dacec2b..d53a2666 100644 --- a/utama_core/engine/strategy.py +++ b/utama_core/engine/strategy.py @@ -24,7 +24,7 @@ Referee restarts (kickoff/ball-placement/free-kick/penalty) are handled before any tactic ticks at all, not by a tactic: `engine.referee_override` -reuses the `custom_referee/actions.py` Step classes (keep-out-distance +reuses the `referee/actions.py` Step classes (keep-out-distance geometry, formation positions) to take over every outfield robot's command for the duration of the restart. See `_OVERRIDE_COMMANDS` there and `referee_reset.py` for how this fits with the barrier-reset/pause tiers. diff --git a/utama_core/motion_planning/fastpathplanning/planner.py b/utama_core/motion_planning/fastpathplanning/planner.py index bf2d4038..2f4a8eda 100644 --- a/utama_core/motion_planning/fastpathplanning/planner.py +++ b/utama_core/motion_planning/fastpathplanning/planner.py @@ -77,7 +77,7 @@ def _perp_rotation(subgoal_direction: int) -> Tuple[float, float]: return rot -# Same set `DefenseAreaRule` (custom_referee/rules/defense_area_rule.py) uses to +# Same set `DefenseAreaRule` (referee/rules/defense_area_rule.py) uses to # decide when defense-area encroachment is actually a foul — entry is legal # outside these commands (e.g. during a DIRECT_FREE_*/BALL_PLACEMENT_* restart # where the ball itself has come to rest in the opponent's box and a robot must @@ -375,7 +375,7 @@ def _enemy_defense_area_retrieval_exempt(self, game: Game, robot_id: Optional[in genuine ball-in-the-box retrieval or carry-to-place is exempted. Without this, `DIRECT_FREE_OURS`/`BALL_PLACEMENT_OURS` - (`custom_referee/actions.py`) can correctly choose to approach the + (`referee/actions.py`) can correctly choose to approach the ball (or, once carrying it, drive toward `designated_position`), but the planner refuses to route anywhere inside the rectangle at all — the kicker/placer converges to just outside diff --git a/utama_core/referee/__init__.py b/utama_core/referee/__init__.py new file mode 100644 index 00000000..3f0231aa --- /dev/null +++ b/utama_core/referee/__init__.py @@ -0,0 +1,4 @@ +from utama_core.referee.custom_referee import CustomReferee +from utama_core.referee.geometry import RefereeGeometry + +__all__ = ["CustomReferee", "RefereeGeometry"] diff --git a/utama_core/custom_referee/actions.py b/utama_core/referee/actions.py similarity index 99% rename from utama_core/custom_referee/actions.py rename to utama_core/referee/actions.py index 043c68f4..9cd505ac 100644 --- a/utama_core/custom_referee/actions.py +++ b/utama_core/referee/actions.py @@ -23,7 +23,6 @@ PENALTY_LINE_Y_STEP_RATIO, PENALTY_MARK_HALF_FIELD_RATIO, ) -from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.entities.data.command import RobotCommand from utama_core.entities.data.vector import Vector2D from utama_core.entities.referee.referee_command import RefereeCommand @@ -40,6 +39,7 @@ restart_support, ) from utama_core.geometry.tolerance import Sticky +from utama_core.referee.geometry import RefereeGeometry from utama_core.skills.man_mark import mark_target from utama_core.skills.utils.move_utils import empty_command, kick, move, turn_on_spot diff --git a/utama_core/custom_referee/custom_referee.py b/utama_core/referee/custom_referee.py similarity index 93% rename from utama_core/custom_referee/custom_referee.py rename to utama_core/referee/custom_referee.py index 4fc33cdc..4a5836f4 100644 --- a/utama_core/custom_referee/custom_referee.py +++ b/utama_core/referee/custom_referee.py @@ -6,37 +6,30 @@ from typing import List, Optional from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.profiles.profile_loader import ( - RefereeProfile, - load_profile, -) -from utama_core.custom_referee.rules.ball_placement_interference_rule import ( - BallPlacementInterferenceRule, -) -from utama_core.custom_referee.rules.ball_speed_rule import BallSpeedRule -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.crashing_rule import CrashingRule -from utama_core.custom_referee.rules.defense_area_rule import DefenseAreaRule -from utama_core.custom_referee.rules.defense_area_stoppage_rule import ( - DefenseAreaStoppageRule, -) -from utama_core.custom_referee.rules.double_touch_rule import DoubleTouchRule -from utama_core.custom_referee.rules.excessive_dribbling_rule import ( - ExcessiveDribblingRule, -) -from utama_core.custom_referee.rules.goal_rule import GoalRule -from utama_core.custom_referee.rules.keep_out_rule import KeepOutRule -from utama_core.custom_referee.rules.keeper_held_ball_rule import KeeperHeldBallRule -from utama_core.custom_referee.rules.no_progress_rule import NoProgressRule -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule -from utama_core.custom_referee.rules.penalty_time_limit_rule import PenaltyTimeLimitRule -from utama_core.custom_referee.rules.pushing_rule import PushingRule -from utama_core.custom_referee.rules.robot_stop_speed_rule import RobotStopSpeedRule -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.referee import RefereeData from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.profiles.profile_loader import RefereeProfile, load_profile +from utama_core.referee.rules.ball_placement_interference_rule import ( + BallPlacementInterferenceRule, +) +from utama_core.referee.rules.ball_speed_rule import BallSpeedRule +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.crashing_rule import CrashingRule +from utama_core.referee.rules.defense_area_rule import DefenseAreaRule +from utama_core.referee.rules.defense_area_stoppage_rule import DefenseAreaStoppageRule +from utama_core.referee.rules.double_touch_rule import DoubleTouchRule +from utama_core.referee.rules.excessive_dribbling_rule import ExcessiveDribblingRule +from utama_core.referee.rules.goal_rule import GoalRule +from utama_core.referee.rules.keep_out_rule import KeepOutRule +from utama_core.referee.rules.keeper_held_ball_rule import KeeperHeldBallRule +from utama_core.referee.rules.no_progress_rule import NoProgressRule +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.referee.rules.penalty_time_limit_rule import PenaltyTimeLimitRule +from utama_core.referee.rules.pushing_rule import PushingRule +from utama_core.referee.rules.robot_stop_speed_rule import RobotStopSpeedRule +from utama_core.referee.state_machine import GameStateMachine # SSL rulebook §7: no goal if the scoring team committed a non-stopping foul # in the last two seconds before the ball entered the goal. diff --git a/utama_core/custom_referee/geometry.py b/utama_core/referee/geometry.py similarity index 100% rename from utama_core/custom_referee/geometry.py rename to utama_core/referee/geometry.py diff --git a/utama_core/referee/profiles/__init__.py b/utama_core/referee/profiles/__init__.py new file mode 100644 index 00000000..363d3f83 --- /dev/null +++ b/utama_core/referee/profiles/__init__.py @@ -0,0 +1,3 @@ +from utama_core.referee.profiles.profile_loader import load_profile + +__all__ = ["load_profile"] diff --git a/utama_core/custom_referee/profiles/human.yaml b/utama_core/referee/profiles/human.yaml similarity index 100% rename from utama_core/custom_referee/profiles/human.yaml rename to utama_core/referee/profiles/human.yaml diff --git a/utama_core/custom_referee/profiles/profile_loader.py b/utama_core/referee/profiles/profile_loader.py similarity index 100% rename from utama_core/custom_referee/profiles/profile_loader.py rename to utama_core/referee/profiles/profile_loader.py diff --git a/utama_core/custom_referee/profiles/simulation.yaml b/utama_core/referee/profiles/simulation.yaml similarity index 100% rename from utama_core/custom_referee/profiles/simulation.yaml rename to utama_core/referee/profiles/simulation.yaml diff --git a/utama_core/referee/rules/__init__.py b/utama_core/referee/rules/__init__.py new file mode 100644 index 00000000..6cc236cf --- /dev/null +++ b/utama_core/referee/rules/__init__.py @@ -0,0 +1,14 @@ +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.defense_area_rule import DefenseAreaRule +from utama_core.referee.rules.goal_rule import GoalRule +from utama_core.referee.rules.keep_out_rule import KeepOutRule +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule + +__all__ = [ + "BaseRule", + "RuleViolation", + "GoalRule", + "OutOfBoundsRule", + "DefenseAreaRule", + "KeepOutRule", +] diff --git a/utama_core/custom_referee/rules/ball_placement_interference_rule.py b/utama_core/referee/rules/ball_placement_interference_rule.py similarity index 97% rename from utama_core/custom_referee/rules/ball_placement_interference_rule.py rename to utama_core/referee/rules/ball_placement_interference_rule.py index 5ac9a1f2..0070cefe 100644 --- a/utama_core/custom_referee/rules/ball_placement_interference_rule.py +++ b/utama_core/referee/rules/ball_placement_interference_rule.py @@ -26,11 +26,11 @@ from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.geometry.math_utils import distance_point_to_segment +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation _BALL_PLACEMENT_COMMANDS = { RefereeCommand.BALL_PLACEMENT_YELLOW, diff --git a/utama_core/custom_referee/rules/ball_speed_rule.py b/utama_core/referee/rules/ball_speed_rule.py similarity index 94% rename from utama_core/custom_referee/rules/ball_speed_rule.py rename to utama_core/referee/rules/ball_speed_rule.py index 42f822b2..edeca87b 100644 --- a/utama_core/custom_referee/rules/ball_speed_rule.py +++ b/utama_core/referee/rules/ball_speed_rule.py @@ -5,11 +5,11 @@ import math from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.last_touch import infer_last_touch_team from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.last_touch import infer_last_touch_team # Frames in a row over the limit before it counts. 67-91% of the calls in the round-robins of # 2026-11-09 were one frame, up to 39 m/s, with the robot's kick at a median 5.3 m/s: vision noise diff --git a/utama_core/custom_referee/rules/base_rule.py b/utama_core/referee/rules/base_rule.py similarity index 98% rename from utama_core/custom_referee/rules/base_rule.py rename to utama_core/referee/rules/base_rule.py index dd118676..43927271 100644 --- a/utama_core/custom_referee/rules/base_rule.py +++ b/utama_core/referee/rules/base_rule.py @@ -6,9 +6,9 @@ from dataclasses import dataclass from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry @dataclass(frozen=True) diff --git a/utama_core/custom_referee/rules/crashing_rule.py b/utama_core/referee/rules/crashing_rule.py similarity index 97% rename from utama_core/custom_referee/rules/crashing_rule.py rename to utama_core/referee/rules/crashing_rule.py index cb359b6c..b9b52e04 100644 --- a/utama_core/custom_referee/rules/crashing_rule.py +++ b/utama_core/referee/rules/crashing_rule.py @@ -33,11 +33,11 @@ import math from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.robot_contact import find_robot_pair_contacts from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.robot_contact import find_robot_pair_contacts _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/defense_area_rule.py b/utama_core/referee/rules/defense_area_rule.py similarity index 98% rename from utama_core/custom_referee/rules/defense_area_rule.py rename to utama_core/referee/rules/defense_area_rule.py index 1c9127b3..f618359e 100644 --- a/utama_core/custom_referee/rules/defense_area_rule.py +++ b/utama_core/referee/rules/defense_area_rule.py @@ -7,11 +7,11 @@ from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.config.referee_constants import PENALTY_MARK_HALF_FIELD_RATIO -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # Contact distance for "this defender is the one who touched the ball" — diff --git a/utama_core/custom_referee/rules/defense_area_stoppage_rule.py b/utama_core/referee/rules/defense_area_stoppage_rule.py similarity index 98% rename from utama_core/custom_referee/rules/defense_area_stoppage_rule.py rename to utama_core/referee/rules/defense_area_stoppage_rule.py index 87101caf..ac1eea5e 100644 --- a/utama_core/custom_referee/rules/defense_area_stoppage_rule.py +++ b/utama_core/referee/rules/defense_area_stoppage_rule.py @@ -24,10 +24,10 @@ from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # "Before the ball has entered play" — STOP itself, plus a free kick that # hasn't yet transitioned to NORMAL_START. Kickoff/penalty prepare commands diff --git a/utama_core/custom_referee/rules/double_touch_rule.py b/utama_core/referee/rules/double_touch_rule.py similarity index 98% rename from utama_core/custom_referee/rules/double_touch_rule.py rename to utama_core/referee/rules/double_touch_rule.py index 6a1ecd38..71d822f9 100644 --- a/utama_core/custom_referee/rules/double_touch_rule.py +++ b/utama_core/referee/rules/double_touch_rule.py @@ -15,10 +15,10 @@ from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # Commands whose transition into NORMAL_START starts a restart-kick window. _RESTART_COMMANDS = frozenset( diff --git a/utama_core/custom_referee/rules/excessive_dribbling_rule.py b/utama_core/referee/rules/excessive_dribbling_rule.py similarity index 97% rename from utama_core/custom_referee/rules/excessive_dribbling_rule.py rename to utama_core/referee/rules/excessive_dribbling_rule.py index 6d2af57b..a0dcec2a 100644 --- a/utama_core/custom_referee/rules/excessive_dribbling_rule.py +++ b/utama_core/referee/rules/excessive_dribbling_rule.py @@ -21,10 +21,10 @@ from typing import Optional from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/goal_rule.py b/utama_core/referee/rules/goal_rule.py similarity index 96% rename from utama_core/custom_referee/rules/goal_rule.py rename to utama_core/referee/rules/goal_rule.py index 932e8345..aecea0ea 100644 --- a/utama_core/custom_referee/rules/goal_rule.py +++ b/utama_core/referee/rules/goal_rule.py @@ -5,10 +5,10 @@ import math from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # Commands that represent active play — goal detection is only relevant here. _ACTIVE_PLAY_COMMANDS = { diff --git a/utama_core/custom_referee/rules/keep_out_rule.py b/utama_core/referee/rules/keep_out_rule.py similarity index 96% rename from utama_core/custom_referee/rules/keep_out_rule.py rename to utama_core/referee/rules/keep_out_rule.py index f87d6094..864df776 100644 --- a/utama_core/custom_referee/rules/keep_out_rule.py +++ b/utama_core/referee/rules/keep_out_rule.py @@ -5,10 +5,10 @@ import math from typing import Optional # used by BaseRule.check return type -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # §8.4.3 applies "during an opponent kick-off or free kick" only. STOP carries # "no automatic sanction" for being too close, and a robot out of position at a diff --git a/utama_core/custom_referee/rules/keeper_held_ball_rule.py b/utama_core/referee/rules/keeper_held_ball_rule.py similarity index 97% rename from utama_core/custom_referee/rules/keeper_held_ball_rule.py rename to utama_core/referee/rules/keeper_held_ball_rule.py index a8114243..6d45b458 100644 --- a/utama_core/custom_referee/rules/keeper_held_ball_rule.py +++ b/utama_core/referee/rules/keeper_held_ball_rule.py @@ -15,10 +15,10 @@ from typing import Optional from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/last_touch.py b/utama_core/referee/rules/last_touch.py similarity index 100% rename from utama_core/custom_referee/rules/last_touch.py rename to utama_core/referee/rules/last_touch.py diff --git a/utama_core/custom_referee/rules/no_progress_rule.py b/utama_core/referee/rules/no_progress_rule.py similarity index 96% rename from utama_core/custom_referee/rules/no_progress_rule.py rename to utama_core/referee/rules/no_progress_rule.py index 3a1af1ea..d8eff43b 100644 --- a/utama_core/custom_referee/rules/no_progress_rule.py +++ b/utama_core/referee/rules/no_progress_rule.py @@ -21,10 +21,10 @@ from typing import Optional from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/out_of_bounds_rule.py b/utama_core/referee/rules/out_of_bounds_rule.py similarity index 98% rename from utama_core/custom_referee/rules/out_of_bounds_rule.py rename to utama_core/referee/rules/out_of_bounds_rule.py index e78049f4..03c03946 100644 --- a/utama_core/custom_referee/rules/out_of_bounds_rule.py +++ b/utama_core/referee/rules/out_of_bounds_rule.py @@ -6,15 +6,15 @@ from typing import Optional from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import CORNER_INFIELD_OFFSET, RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.last_touch import ( +from utama_core.entities.game.game_frame import GameFrame +from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import CORNER_INFIELD_OFFSET, RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.last_touch import ( infer_last_touch_team, touching_robot, touching_team, ) -from utama_core.entities.game.game_frame import GameFrame -from utama_core.entities.referee.referee_command import RefereeCommand _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/penalty_time_limit_rule.py b/utama_core/referee/rules/penalty_time_limit_rule.py similarity index 96% rename from utama_core/custom_referee/rules/penalty_time_limit_rule.py rename to utama_core/referee/rules/penalty_time_limit_rule.py index 93ae04cf..e86c96a6 100644 --- a/utama_core/custom_referee/rules/penalty_time_limit_rule.py +++ b/utama_core/referee/rules/penalty_time_limit_rule.py @@ -10,10 +10,10 @@ from typing import Optional -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/pushing_rule.py b/utama_core/referee/rules/pushing_rule.py similarity index 97% rename from utama_core/custom_referee/rules/pushing_rule.py rename to utama_core/referee/rules/pushing_rule.py index 238b8aba..78a1779d 100644 --- a/utama_core/custom_referee/rules/pushing_rule.py +++ b/utama_core/referee/rules/pushing_rule.py @@ -17,11 +17,11 @@ from typing import Optional from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation -from utama_core.custom_referee.rules.robot_contact import find_robot_pair_contacts from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation +from utama_core.referee.rules.robot_contact import find_robot_pair_contacts _ACTIVE_PLAY_COMMANDS = { RefereeCommand.NORMAL_START, diff --git a/utama_core/custom_referee/rules/robot_contact.py b/utama_core/referee/rules/robot_contact.py similarity index 100% rename from utama_core/custom_referee/rules/robot_contact.py rename to utama_core/referee/rules/robot_contact.py diff --git a/utama_core/custom_referee/rules/robot_stop_speed_rule.py b/utama_core/referee/rules/robot_stop_speed_rule.py similarity index 97% rename from utama_core/custom_referee/rules/robot_stop_speed_rule.py rename to utama_core/referee/rules/robot_stop_speed_rule.py index ebacd669..c1caa76f 100644 --- a/utama_core/custom_referee/rules/robot_stop_speed_rule.py +++ b/utama_core/referee/rules/robot_stop_speed_rule.py @@ -29,10 +29,10 @@ from typing import Optional from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation class RobotStopSpeedRule(BaseRule): diff --git a/utama_core/custom_referee/state_machine.py b/utama_core/referee/state_machine.py similarity index 99% rename from utama_core/custom_referee/state_machine.py rename to utama_core/referee/state_machine.py index 874bb5b1..d46b9b42 100644 --- a/utama_core/custom_referee/state_machine.py +++ b/utama_core/referee/state_machine.py @@ -10,14 +10,14 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.physical_constants import ROBOT_RADIUS from utama_core.config.referee_constants import PENALTY_MARK_HALF_FIELD_RATIO -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.profiles.profile_loader import AutoAdvanceConfig -from utama_core.custom_referee.rules.base_rule import RuleViolation from utama_core.entities.data.referee import RefereeData from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import CLOCK_RUNS, RefereeCommand from utama_core.entities.referee.stage import Stage +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.profiles.profile_loader import AutoAdvanceConfig +from utama_core.referee.rules.base_rule import RuleViolation logger = logging.getLogger(__name__) diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 027de900..8d5348cc 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -466,7 +466,7 @@ def apply_scenario(runner, scenario: Scenario, *, verify: bool = True) -> None: robot teleported near the goal line, confirmed against a real replay, 2026-09-03). """ - from utama_core.custom_referee import CustomReferee + from utama_core.referee import CustomReferee sim_controller = runner.sim_controller if sim_controller is None: diff --git a/utama_core/replay/ssl_log.py b/utama_core/replay/ssl_log.py index 7ebd308d..b71ca7a3 100644 --- a/utama_core/replay/ssl_log.py +++ b/utama_core/replay/ssl_log.py @@ -613,7 +613,7 @@ def free_kick_taken(command: np.ndarray, counter: np.ndarray, ball_xy: np.ndarra The game controller keeps `DIRECT_FREE_*` through the play that follows, until the next stoppage. Our referee switches to `NORMAL_START` before the kick instead (its advance 3, see - `docs/custom_referee.md`), and the analyses count live play as `NORMAL_START`/`FORCE_START`, + `docs/referee.md`), and the analyses count live play as `NORMAL_START`/`FORCE_START`, so a converted replay says `NORMAL_START` from the kick on.""" taken = np.zeros(len(command), dtype=bool) in_kick = np.isin(command, list(FREE_KICKS)) diff --git a/utama_core/run/field_fence.py b/utama_core/run/field_fence.py index 9a740247..caaef2c1 100644 --- a/utama_core/run/field_fence.py +++ b/utama_core/run/field_fence.py @@ -12,7 +12,7 @@ Only edges inside the field are fenced (the half-way line on a half-field run): a robot must cross the touch and goal lines to fetch a ball out of play, or a restart never completes -(`custom_referee/actions.py`, `_clamp_to_field_or_ball`), and the cameras see past them. +(`referee/actions.py`, `_clamp_to_field_or_ball`), and the cameras see past them. Keep-out zones (`StrategyRunner(keep_out=...)`) are rectangles no robot may enter, in every mode: the speed into each is capped the same way, on the sides a robot could reach before it stops. A diff --git a/utama_core/run/live_status.py b/utama_core/run/live_status.py index e4a7be7d..e0d11fc2 100644 --- a/utama_core/run/live_status.py +++ b/utama_core/run/live_status.py @@ -6,7 +6,7 @@ from rich.text import Text from utama_core.config.settings import FPS_PRINT_INTERVAL -from utama_core.custom_referee import CustomReferee +from utama_core.referee import CustomReferee from utama_core.run.referee_source import OfficialReferee diff --git a/utama_core/run/referee_source.py b/utama_core/run/referee_source.py index b2283696..dd244d06 100644 --- a/utama_core/run/referee_source.py +++ b/utama_core/run/referee_source.py @@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Union if TYPE_CHECKING: - from utama_core.custom_referee import CustomReferee + from utama_core.referee import CustomReferee @dataclass(frozen=True) diff --git a/utama_core/run/sim_setup.py b/utama_core/run/sim_setup.py index 43d41abe..957ecce7 100644 --- a/utama_core/run/sim_setup.py +++ b/utama_core/run/sim_setup.py @@ -21,10 +21,10 @@ from typing import Callable, Optional from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner from utama_core.strategy import catalog diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index 21da002f..da82033d 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -26,7 +26,6 @@ ROBOT_FEEDBACK_CONNECTION_TIMEOUT_SECONDS, TIMESTEP, ) -from utama_core.custom_referee import CustomReferee from utama_core.data_processing.receivers import RefereeMessageReceiver, VisionReceiver from utama_core.data_processing.refiners import ( PositionRefiner, @@ -51,6 +50,7 @@ from utama_core.geometry.pass_and_score_geometry import reset_possession_state from utama_core.motion_planning.common.control_schemes import get_control_scheme from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.referee import CustomReferee from utama_core.replay.columnar_writer import ( ColumnarReplayWriter, ColumnarReplayWriterConfig, @@ -406,7 +406,7 @@ def __init__( self._vision_stream_renderer: Optional[GameFrameRenderer] = None if isinstance(self.referee, CustomReferee): - from utama_core.custom_referee.geometry import RefereeGeometry + from utama_core.referee.geometry import RefereeGeometry self.referee.override_geometry(RefereeGeometry.from_field_dims(self.full_field_dims)) diff --git a/utama_core/tactics/give_and_go.py b/utama_core/tactics/give_and_go.py index 5c6d8694..d6060e4a 100644 --- a/utama_core/tactics/give_and_go.py +++ b/utama_core/tactics/give_and_go.py @@ -86,7 +86,7 @@ # field corner locked a receiver_id and then held the ball motionless for # the rest of a 600s match — `is_committed()` returns True whenever # receiver_id is not None, so nothing ever reassigns these robots either, -# and no custom_referee rule catches a legally-dribbling, barely-moving +# and no referee rule catches a legally-dribbling, barely-moving # ball outside a defense area (keeper_held_ball only watches the defense # area; excessive_dribbling only watches distance carried, not hold time). # Abandoning a hop that's taken too long and forcing the fallback shoot/ diff --git a/utama_core/tests/analysis/test_restart_picture.py b/utama_core/tests/analysis/test_restart_picture.py index 53ae216c..1b58a682 100644 --- a/utama_core/tests/analysis/test_restart_picture.py +++ b/utama_core/tests/analysis/test_restart_picture.py @@ -14,11 +14,11 @@ render_restart, ) from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE -from utama_core.custom_referee import actions from utama_core.entities.data.referee import RefereeData from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage +from utama_core.referee import actions from utama_core.tests.fixtures.game_builder import build_game, make_ball, make_robot diff --git a/utama_core/tests/dashboard/test_referee_view_serialization.py b/utama_core/tests/dashboard/test_referee_view_serialization.py index 33b2662f..dc66a493 100644 --- a/utama_core/tests/dashboard/test_referee_view_serialization.py +++ b/utama_core/tests/dashboard/test_referee_view_serialization.py @@ -119,12 +119,12 @@ def test_a_command_from_the_page_is_stamped_on_the_referees_clock_not_the_wall_c """In rsim the referee runs on sim time; a wall-clock stamp put its match clock 1.8e9 s out.""" from types import SimpleNamespace - from utama_core.custom_referee import CustomReferee from utama_core.dashboard.views import referee as referee_view from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand + from utama_core.referee import CustomReferee handlers = {} server = SimpleNamespace( diff --git a/utama_core/tests/engine/test_ball_roles.py b/utama_core/tests/engine/test_ball_roles.py index 3bc75229..fe0d4eef 100644 --- a/utama_core/tests/engine/test_ball_roles.py +++ b/utama_core/tests/engine/test_ball_roles.py @@ -7,12 +7,6 @@ import pytest from utama_core.config.physical_constants import ROBOT_RADIUS -from utama_core.custom_referee.actions import ( - _WALL_FROM_BALL_M, - _is_in_own_defense_area, - _next_is_their_free_kick, - their_free_kick_targets, -) from utama_core.engine.ball_roles import COVER_M, ON_BALL_SWITCH_MARGIN_M, BallRoles from utama_core.engine.context import TickContext from utama_core.entities.data.command import RobotCommand @@ -27,6 +21,12 @@ receiver_of_rolling_ball, segment_blocked, ) +from utama_core.referee.actions import ( + _WALL_FROM_BALL_M, + _is_in_own_defense_area, + _next_is_their_free_kick, + their_free_kick_targets, +) from utama_core.skills.man_mark import MARK_STANDOFF, mark_target from utama_core.tactics.give_and_go import _relocate_target diff --git a/utama_core/tests/engine/test_kernel_strategy_debug_status.py b/utama_core/tests/engine/test_kernel_strategy_debug_status.py index cfc06c37..3d923b99 100644 --- a/utama_core/tests/engine/test_kernel_strategy_debug_status.py +++ b/utama_core/tests/engine/test_kernel_strategy_debug_status.py @@ -99,7 +99,7 @@ def test_debug_status_leaves_out_a_goalkeeper_whose_robot_is_not_on_the_field(): def _refereed_runner(command, notifier=None): """`pendulum` under our own referee, seeded with `command`; `notifier` stands in for a dashboard.""" - from utama_core.custom_referee import CustomReferee + from utama_core.referee import CustomReferee from utama_core.run.strategy_runner import StrategyRunner referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=6, n_robots_blue=3) @@ -147,11 +147,8 @@ def test_in_live_play_no_robot_shows_the_referee(): def test_the_placer_and_the_free_kick_taker_are_named(): - from utama_core.custom_referee.actions import ( - BallPlacementOursStep, - DirectFreeOursStep, - ) from utama_core.engine.referee_override import _job + from utama_core.referee.actions import BallPlacementOursStep, DirectFreeOursStep placement = BallPlacementOursStep() placement._placer_id = 2 diff --git a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py index 41a3a1f2..fdbba440 100644 --- a/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py +++ b/utama_core/tests/engine/test_kickoff_goalkeeper_exemption.py @@ -279,7 +279,7 @@ def test_our_kickoff_with_only_keeper_present_does_not_raise(nonzero_keeper_runn keeper). Exercised directly against the Step class with a minimal object, since reproducing "rsim spawned only one robot" isn't practical through the fixture — this only needs to prove the early-return guard fires.""" - from utama_core.custom_referee.actions import PrepareKickoffOursStep + from utama_core.referee.actions import PrepareKickoffOursStep class _FakeRef: designated_position = None @@ -318,8 +318,8 @@ def test_their_kickoff_from_the_wrong_half_goes_round_the_centre_circle(pendulum on the circle in the wrong half (the old push-out left a robot a hair inside the edge, "encroaching", its target its own position).""" from utama_core.config.field_params import STANDARD_FIELD_DIMS - from utama_core.custom_referee.geometry import RefereeGeometry - from utama_core.custom_referee.rules.keep_out_rule import KeepOutRule + from utama_core.referee.geometry import RefereeGeometry + from utama_core.referee.rules.keep_out_rule import KeepOutRule runner = pendulum_runner game = runner.my.game diff --git a/utama_core/tests/engine/test_match_stats.py b/utama_core/tests/engine/test_match_stats.py index acb14eb4..2665ac79 100644 --- a/utama_core/tests/engine/test_match_stats.py +++ b/utama_core/tests/engine/test_match_stats.py @@ -6,7 +6,6 @@ import pytest -from utama_core.custom_referee.rules.base_rule import RuleViolation from utama_core.engine.match_stats import MatchStatsAccumulator from utama_core.entities.data.referee import RefereeData from utama_core.entities.data.vector import Vector2D, Vector3D @@ -16,6 +15,7 @@ from utama_core.entities.game.team_info import TeamInfo from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage +from utama_core.referee.rules.base_rule import RuleViolation def _robot(rid: int, x: float, y: float, is_friendly: bool) -> Robot: diff --git a/utama_core/tests/engine/test_referee_overrides_customization.py b/utama_core/tests/engine/test_referee_overrides_customization.py index 1f1184c9..4c3ac4a9 100644 --- a/utama_core/tests/engine/test_referee_overrides_customization.py +++ b/utama_core/tests/engine/test_referee_overrides_customization.py @@ -3,7 +3,7 @@ `RefereeOverride.overrides` (set via `AbstractStrategy(..., referee_overrides=...)` or `Strategy.referee_overrides = ...`) lets a strategy replace the built-in `*Step` formation for one specific `RefereeCommand` with its own callable, -without touching `custom_referee/actions.py` itself. This file covers: +without touching `referee/actions.py` itself. This file covers: - a registered override actually runs instead of the built-in Step (`test_registered_override_replaces_built_in_step`) diff --git a/utama_core/tests/geometry/test_defense_area_rules_off.py b/utama_core/tests/geometry/test_defense_area_rules_off.py index f173104b..2d0a4b0b 100644 --- a/utama_core/tests/geometry/test_defense_area_rules_off.py +++ b/utama_core/tests/geometry/test_defense_area_rules_off.py @@ -7,7 +7,6 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee import actions from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.field import Field @@ -24,6 +23,7 @@ ) from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner +from utama_core.referee import actions # We are on the right: our box spans x >= 3.5, the opponent's x <= -3.5 (standard field). _ENEMY_BOX = Vector2D(-4.0, 0.0) @@ -77,7 +77,7 @@ def test_the_planners_route_through_the_opponents_box_in_open_play_without_the_r @pytest.mark.parametrize("profile, rules", [("simulation", True), ("human", False)]) def test_the_runner_takes_the_box_rules_from_the_referee_profile(profile, rules): """`human` (and the real examples, built on it) has no defense-area rule, so robots ignore the boxes.""" - from utama_core.custom_referee import CustomReferee + from utama_core.referee import CustomReferee from utama_core.run.strategy_runner import StrategyRunner runner = SimpleNamespace(referee=CustomReferee.from_profile_name(profile)) diff --git a/utama_core/tests/custom_referee/__init__.py b/utama_core/tests/referee/__init__.py similarity index 100% rename from utama_core/tests/custom_referee/__init__.py rename to utama_core/tests/referee/__init__.py diff --git a/utama_core/tests/custom_referee/helpers.py b/utama_core/tests/referee/helpers.py similarity index 100% rename from utama_core/tests/custom_referee/helpers.py rename to utama_core/tests/referee/helpers.py diff --git a/utama_core/tests/custom_referee/referee_sim.py b/utama_core/tests/referee/referee_sim.py similarity index 97% rename from utama_core/tests/custom_referee/referee_sim.py rename to utama_core/tests/referee/referee_sim.py index f357748f..b3f440c4 100644 --- a/utama_core/tests/custom_referee/referee_sim.py +++ b/utama_core/tests/referee/referee_sim.py @@ -1,7 +1,7 @@ """Visual RSim simulation for verifying referee command behaviour. Run with: - pixi run python utama_core/tests/custom_referee/referee_sim.py + pixi run python utama_core/tests/referee/referee_sim.py What it does: - Starts a 3v3 RSim with WanderingTactic as the base strategy. @@ -31,7 +31,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.run import StrategyRunner -from utama_core.tests.custom_referee.wandering_strategy import wandering_strategy +from utama_core.tests.referee.wandering_strategy import wandering_strategy # --------------------------------------------------------------------------- # Configuration diff --git a/utama_core/tests/custom_referee/test_aimless_kick.py b/utama_core/tests/referee/test_aimless_kick.py similarity index 90% rename from utama_core/tests/custom_referee/test_aimless_kick.py rename to utama_core/tests/referee/test_aimless_kick.py index 79e35bf6..8978b383 100644 --- a/utama_core/tests/custom_referee/test_aimless_kick.py +++ b/utama_core/tests/referee/test_aimless_kick.py @@ -10,13 +10,13 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.profiles.profile_loader import load_profile -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import ball as _ball -from utama_core.tests.custom_referee.helpers import frame as _frame -from utama_core.tests.custom_referee.helpers import robot as _robot +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.profiles.profile_loader import load_profile +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.tests.referee.helpers import ball as _ball +from utama_core.tests.referee.helpers import frame as _frame +from utama_core.tests.referee.helpers import robot as _robot GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) # Yellow (friendly) defends the left goal, so it attacks the right goal line. diff --git a/utama_core/tests/custom_referee/test_ball_contest_deadlock.py b/utama_core/tests/referee/test_ball_contest_deadlock.py similarity index 98% rename from utama_core/tests/custom_referee/test_ball_contest_deadlock.py rename to utama_core/tests/referee/test_ball_contest_deadlock.py index f563e501..e43332a4 100644 --- a/utama_core/tests/custom_referee/test_ball_contest_deadlock.py +++ b/utama_core/tests/referee/test_ball_contest_deadlock.py @@ -27,13 +27,13 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE -from utama_core.custom_referee.custom_referee import CustomReferee from utama_core.engine.referee_override import RefereeOverride from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.custom_referee import CustomReferee # Robots placed exactly at PushingRule's contact distance (2*ROBOT_RADIUS + # 0.03 = 0.18m) along the x-axis, ball trapped exactly between their fronts — @@ -162,7 +162,7 @@ def _fake_move(game, motion_controller, robot_id, target_coords, target_oren, dr local_forward_vel=0.0, local_left_vel=0.0, angular_vel=0.0, kick=False, chip=False, dribble=False ) - import utama_core.custom_referee.actions as referee_actions + import utama_core.referee.actions as referee_actions original_move = referee_actions.move referee_actions.move = _fake_move diff --git a/utama_core/tests/custom_referee/test_custom_referee.py b/utama_core/tests/referee/test_custom_referee.py similarity index 97% rename from utama_core/tests/custom_referee/test_custom_referee.py rename to utama_core/tests/referee/test_custom_referee.py index 22bd7dee..c4b21abd 100644 --- a/utama_core/tests/custom_referee/test_custom_referee.py +++ b/utama_core/tests/referee/test_custom_referee.py @@ -8,23 +8,23 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.custom_referee import CustomReferee -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.profiles.profile_loader import load_profile -from utama_core.custom_referee.rules.ball_speed_rule import BallSpeedRule -from utama_core.custom_referee.rules.defense_area_rule import DefenseAreaRule -from utama_core.custom_referee.rules.double_touch_rule import DoubleTouchRule -from utama_core.custom_referee.rules.goal_rule import GoalRule -from utama_core.custom_referee.rules.keep_out_rule import KeepOutRule -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.referee import RefereeData from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.tests.custom_referee.helpers import ball as _ball -from utama_core.tests.custom_referee.helpers import frame as _frame -from utama_core.tests.custom_referee.helpers import robot as _robot +from utama_core.referee.custom_referee import CustomReferee +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.profiles.profile_loader import load_profile +from utama_core.referee.rules.ball_speed_rule import BallSpeedRule +from utama_core.referee.rules.defense_area_rule import DefenseAreaRule +from utama_core.referee.rules.double_touch_rule import DoubleTouchRule +from utama_core.referee.rules.goal_rule import GoalRule +from utama_core.referee.rules.keep_out_rule import KeepOutRule +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.referee.state_machine import GameStateMachine +from utama_core.tests.referee.helpers import ball as _ball +from utama_core.tests.referee.helpers import frame as _frame +from utama_core.tests.referee.helpers import robot as _robot # --------------------------------------------------------------------------- # Helpers @@ -840,7 +840,7 @@ def test_no_automatic_sanction_during_a_penalty_or_stop(self, command): class TestGameStateMachine: def test_goal_increments_yellow_score(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -856,7 +856,7 @@ def test_goal_increments_yellow_score(self): assert data.next_command == RefereeCommand.BALL_PLACEMENT_BLUE def test_goal_increments_blue_score(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -870,7 +870,7 @@ def test_goal_increments_blue_score(self): assert sm.yellow_team.score == 0 def test_transition_cooldown_suppresses_duplicate(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -887,7 +887,7 @@ def test_transition_cooldown_suppresses_duplicate(self): assert sm.yellow_team.score == 1 # still 1 def test_goal_sets_designated_position_to_centre(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -900,7 +900,7 @@ def test_goal_sets_designated_position_to_centre(self): assert data.designated_position == (0.0, 0.0) def test_goal_status_message_is_propagated_into_referee_data(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -927,7 +927,7 @@ def test_halt_escalation_mid_goal_restart_preserves_kickoff_and_ball_target(self match. _handle_foul must preserve next_command/ball_placement_target when the escalating violation doesn't provide its own. """ - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() goal = RuleViolation( @@ -959,7 +959,7 @@ def test_halt_escalation_with_its_own_restart_still_overrides(self): (e.g. a genuinely new stopping foul) must still take effect as before -- the preservation above only guards against an escalation with nothing of its own to give.""" - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() goal = RuleViolation( @@ -985,7 +985,7 @@ def test_halt_escalation_with_its_own_restart_still_overrides(self): assert data.designated_position == (1.5, 2.0) def test_manual_command_clears_status_message(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -1038,7 +1038,7 @@ def test_manual_penalty_auto_advances_from_stop_and_then_to_normal_start(self): assert data.next_command is None def test_reset_restores_score_command_and_stage(self): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() violation = RuleViolation( @@ -1224,7 +1224,7 @@ def test_simulation_stop_advances_after_timeout_even_if_a_robot_never_clears(sel must force the advance through regardless once enough time has passed, the same way a real GC operator eventually would. """ - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() stuck_ball = _ball(0.0, 0.0) @@ -1263,7 +1263,7 @@ def test_simulation_stop_still_advances_immediately_when_robots_clear_normally(s clear the ball, STOP still advances immediately rather than waiting out the new timeout -- the timeout is a fallback, not a new floor on every restart's latency.""" - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _state_machine() clear_frame = _frame( diff --git a/utama_core/tests/custom_referee/test_dribble_placement_stopspeed.py b/utama_core/tests/referee/test_dribble_placement_stopspeed.py similarity index 97% rename from utama_core/tests/custom_referee/test_dribble_placement_stopspeed.py rename to utama_core/tests/referee/test_dribble_placement_stopspeed.py index 0be2a852..939661a5 100644 --- a/utama_core/tests/custom_referee/test_dribble_placement_stopspeed.py +++ b/utama_core/tests/referee/test_dribble_placement_stopspeed.py @@ -6,18 +6,16 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.excessive_dribbling_rule import ( - ExcessiveDribblingRule, -) -from utama_core.custom_referee.rules.keeper_held_ball_rule import KeeperHeldBallRule -from utama_core.custom_referee.rules.robot_stop_speed_rule import RobotStopSpeedRule from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import frame as _frame +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.excessive_dribbling_rule import ExcessiveDribblingRule +from utama_core.referee.rules.keeper_held_ball_rule import KeeperHeldBallRule +from utama_core.referee.rules.robot_stop_speed_rule import RobotStopSpeedRule +from utama_core.tests.referee.helpers import frame as _frame GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) diff --git a/utama_core/tests/custom_referee/test_foul_counter_end_to_end.py b/utama_core/tests/referee/test_foul_counter_end_to_end.py similarity index 98% rename from utama_core/tests/custom_referee/test_foul_counter_end_to_end.py rename to utama_core/tests/referee/test_foul_counter_end_to_end.py index 601b5d67..76a6607f 100644 --- a/utama_core/tests/custom_referee/test_foul_counter_end_to_end.py +++ b/utama_core/tests/referee/test_foul_counter_end_to_end.py @@ -15,9 +15,9 @@ from __future__ import annotations -from utama_core.custom_referee.rules.base_rule import RuleViolation -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.rules.base_rule import RuleViolation +from utama_core.referee.state_machine import GameStateMachine # GameStateMachine._TRANSITION_COOLDOWN is 0.3s — a stopping foul's # transition is suppressed if it arrives sooner than that after the last diff --git a/utama_core/tests/custom_referee/test_free_kick_taken.py b/utama_core/tests/referee/test_free_kick_taken.py similarity index 97% rename from utama_core/tests/custom_referee/test_free_kick_taken.py rename to utama_core/tests/referee/test_free_kick_taken.py index 8367dc89..2adf9f94 100644 --- a/utama_core/tests/custom_referee/test_free_kick_taken.py +++ b/utama_core/tests/referee/test_free_kick_taken.py @@ -3,11 +3,11 @@ auto-advance, so a defender the ball rolled onto was still charged with keep_out. """ -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.state_machine import GameStateMachine def _frame(ts: float, ball_xy: tuple[float, float]) -> GameFrame: diff --git a/utama_core/tests/custom_referee/test_free_kick_timeout.py b/utama_core/tests/referee/test_free_kick_timeout.py similarity index 93% rename from utama_core/tests/custom_referee/test_free_kick_timeout.py rename to utama_core/tests/referee/test_free_kick_timeout.py index 163fc0c4..0f0a2318 100644 --- a/utama_core/tests/custom_referee/test_free_kick_timeout.py +++ b/utama_core/tests/referee/test_free_kick_timeout.py @@ -3,11 +3,11 @@ with no limit, so a free kick nobody took held the game forever. """ -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.state_machine import GameStateMachine def _frame(ts: float) -> GameFrame: @@ -34,7 +34,7 @@ def test_untaken_free_kick_is_in_play_after_ten_seconds(): def test_defender_too_close_restarts_the_free_kick_clock(): """§8.4.3: on a Defender Too Close foul "the timer of the opponent team for bringing the ball into play is reset".""" - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = GameStateMachine(half_duration_seconds=300.0, kickoff_team="yellow", n_robots_yellow=3, n_robots_blue=3) sm.seed_clock(0.0) @@ -55,7 +55,7 @@ def test_defender_too_close_restarts_the_free_kick_clock(): def test_only_the_first_defender_too_close_foul_restarts_the_free_kick_clock(): """A defender parked inside 0.5 m re-raises keep_out every 2 s; when each foul restarted the clock, the free kick was never forced and held the rest of a match.""" - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = GameStateMachine(half_duration_seconds=300.0, kickoff_team="yellow", n_robots_yellow=3, n_robots_blue=3) sm.seed_clock(0.0) diff --git a/utama_core/tests/custom_referee/test_geometry.py b/utama_core/tests/referee/test_geometry.py similarity index 98% rename from utama_core/tests/custom_referee/test_geometry.py rename to utama_core/tests/referee/test_geometry.py index 1b82052e..97a713f8 100644 --- a/utama_core/tests/custom_referee/test_geometry.py +++ b/utama_core/tests/referee/test_geometry.py @@ -26,8 +26,8 @@ from utama_core.config.field_params import STANDARD_FIELD_DIMS from utama_core.config.referee_constants import OPPONENT_DEFENSE_AREA_KEEP_DISTANCE -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.out_of_bounds_rule import ( +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.out_of_bounds_rule import ( _CORNER_INFIELD_OFFSET, OutOfBoundsRule, ) @@ -262,7 +262,7 @@ def test_a_restart_near_the_box_leaves_room_for_the_kickers_approach(x: float, y towards the box whenever the kick points away from it; that spot has to clear the planner's ring too. A free kick at (-4.25, -1.54), 0.54 m from the side edge, held its kicker 1.3 m away for 20 s (tournament_20260927_230330).""" - from utama_core.custom_referee.actions import DirectFreeOursStep + from utama_core.referee.actions import DirectFreeOursStep px, py = GEO.legal_restart_position(x, y, OPPONENT_DEFENSE_AREA_KEEP_DISTANCE) inner_x = GEO.half_length - 2.0 * GEO.half_defense_depth diff --git a/utama_core/tests/custom_referee/test_goal_after_non_stopping_foul.py b/utama_core/tests/referee/test_goal_after_non_stopping_foul.py similarity index 94% rename from utama_core/tests/custom_referee/test_goal_after_non_stopping_foul.py rename to utama_core/tests/referee/test_goal_after_non_stopping_foul.py index a0bfde48..f8867894 100644 --- a/utama_core/tests/custom_referee/test_goal_after_non_stopping_foul.py +++ b/utama_core/tests/referee/test_goal_after_non_stopping_foul.py @@ -6,12 +6,12 @@ import pytest -from utama_core.custom_referee.custom_referee import CustomReferee -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.custom_referee import CustomReferee +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation class _FoulOnce(BaseRule): diff --git a/utama_core/tests/custom_referee/test_halt_resume.py b/utama_core/tests/referee/test_halt_resume.py similarity index 93% rename from utama_core/tests/custom_referee/test_halt_resume.py rename to utama_core/tests/referee/test_halt_resume.py index f5d46d26..856e7eeb 100644 --- a/utama_core/tests/custom_referee/test_halt_resume.py +++ b/utama_core/tests/referee/test_halt_resume.py @@ -9,10 +9,10 @@ from __future__ import annotations -from utama_core.custom_referee.rules.base_rule import RuleViolation -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import ball, frame +from utama_core.referee.rules.base_rule import RuleViolation +from utama_core.referee.state_machine import GameStateMachine +from utama_core.tests.referee.helpers import ball, frame _HALT = RuleViolation( rule_name="defense_area_stoppage", diff --git a/utama_core/tests/custom_referee/test_last_touch.py b/utama_core/tests/referee/test_last_touch.py similarity index 96% rename from utama_core/tests/custom_referee/test_last_touch.py rename to utama_core/tests/referee/test_last_touch.py index 8347bc6c..30fbc8ef 100644 --- a/utama_core/tests/custom_referee/test_last_touch.py +++ b/utama_core/tests/referee/test_last_touch.py @@ -10,14 +10,14 @@ from __future__ import annotations from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.last_touch import infer_last_touch_team -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import robot as _robot +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.last_touch import infer_last_touch_team +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.tests.referee.helpers import robot as _robot def _ball(x: float, y: float) -> Ball: diff --git a/utama_core/tests/custom_referee/test_no_progress_rule.py b/utama_core/tests/referee/test_no_progress_rule.py similarity index 97% rename from utama_core/tests/custom_referee/test_no_progress_rule.py rename to utama_core/tests/referee/test_no_progress_rule.py index 7941952a..6cff44f4 100644 --- a/utama_core/tests/custom_referee/test_no_progress_rule.py +++ b/utama_core/tests/referee/test_no_progress_rule.py @@ -9,14 +9,14 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.no_progress_rule import NoProgressRule -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.no_progress_rule import NoProgressRule +from utama_core.referee.state_machine import GameStateMachine GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) @@ -87,7 +87,7 @@ def test_state_machine_continues_with_force_start_once_robots_clear(): def test_simulation_profile_stops_a_frozen_game(): - from utama_core.custom_referee.custom_referee import CustomReferee + from utama_core.referee.custom_referee import CustomReferee referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=1, n_robots_blue=1) referee.seed_clock(0.0, initial_command=RefereeCommand.FORCE_START) diff --git a/utama_core/tests/custom_referee/test_out_of_bounds_offender.py b/utama_core/tests/referee/test_out_of_bounds_offender.py similarity index 88% rename from utama_core/tests/custom_referee/test_out_of_bounds_offender.py rename to utama_core/tests/referee/test_out_of_bounds_offender.py index b2505cf5..7e4f335e 100644 --- a/utama_core/tests/custom_referee/test_out_of_bounds_offender.py +++ b/utama_core/tests/referee/test_out_of_bounds_offender.py @@ -7,13 +7,13 @@ """ from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.engine.match_stats import MatchStatsAccumulator from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import ball as _ball -from utama_core.tests.custom_referee.helpers import frame as _frame -from utama_core.tests.custom_referee.helpers import robot as _robot +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.tests.referee.helpers import ball as _ball +from utama_core.tests.referee.helpers import frame as _frame +from utama_core.tests.referee.helpers import robot as _robot GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) _OVER_THE_TOUCH_LINE = (1.0, GEO.half_width + 0.05) diff --git a/utama_core/tests/custom_referee/test_penalty_time_limit_rule.py b/utama_core/tests/referee/test_penalty_time_limit_rule.py similarity index 94% rename from utama_core/tests/custom_referee/test_penalty_time_limit_rule.py rename to utama_core/tests/referee/test_penalty_time_limit_rule.py index 8e05e060..b367ede6 100644 --- a/utama_core/tests/custom_referee/test_penalty_time_limit_rule.py +++ b/utama_core/tests/referee/test_penalty_time_limit_rule.py @@ -8,12 +8,12 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.penalty_time_limit_rule import PenaltyTimeLimitRule from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.penalty_time_limit_rule import PenaltyTimeLimitRule GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) @@ -79,7 +79,7 @@ def test_ordinary_kickoff_has_no_time_limit(): def test_simulation_profile_stops_a_penalty_after_ten_seconds(): - from utama_core.custom_referee.custom_referee import CustomReferee + from utama_core.referee.custom_referee import CustomReferee referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=1, n_robots_blue=1) referee.seed_clock(0.0, initial_command=RefereeCommand.FORCE_START) diff --git a/utama_core/tests/custom_referee/test_placement_interference_and_defense_fixes.py b/utama_core/tests/referee/test_placement_interference_and_defense_fixes.py similarity index 96% rename from utama_core/tests/custom_referee/test_placement_interference_and_defense_fixes.py rename to utama_core/tests/referee/test_placement_interference_and_defense_fixes.py index 31dc217f..1e421f25 100644 --- a/utama_core/tests/custom_referee/test_placement_interference_and_defense_fixes.py +++ b/utama_core/tests/referee/test_placement_interference_and_defense_fixes.py @@ -7,20 +7,18 @@ import pytest from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.ball_placement_interference_rule import ( - BallPlacementInterferenceRule, -) -from utama_core.custom_referee.rules.defense_area_rule import DefenseAreaRule -from utama_core.custom_referee.rules.defense_area_stoppage_rule import ( - DefenseAreaStoppageRule, -) -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.entities.data.vector import Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.tests.custom_referee.helpers import frame as _frame -from utama_core.tests.custom_referee.helpers import robot as _robot +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.ball_placement_interference_rule import ( + BallPlacementInterferenceRule, +) +from utama_core.referee.rules.defense_area_rule import DefenseAreaRule +from utama_core.referee.rules.defense_area_stoppage_rule import DefenseAreaStoppageRule +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule +from utama_core.tests.referee.helpers import frame as _frame +from utama_core.tests.referee.helpers import robot as _robot GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) diff --git a/utama_core/tests/custom_referee/test_pushing_crashing.py b/utama_core/tests/referee/test_pushing_crashing.py similarity index 98% rename from utama_core/tests/custom_referee/test_pushing_crashing.py rename to utama_core/tests/referee/test_pushing_crashing.py index 1bf38fdd..26db7388 100644 --- a/utama_core/tests/custom_referee/test_pushing_crashing.py +++ b/utama_core/tests/referee/test_pushing_crashing.py @@ -3,14 +3,14 @@ from __future__ import annotations from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.crashing_rule import CrashingRule -from utama_core.custom_referee.rules.pushing_rule import PushingRule from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.crashing_rule import CrashingRule +from utama_core.referee.rules.pushing_rule import PushingRule GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) diff --git a/utama_core/tests/custom_referee/test_referee_rules_integration.py b/utama_core/tests/referee/test_referee_rules_integration.py similarity index 99% rename from utama_core/tests/custom_referee/test_referee_rules_integration.py rename to utama_core/tests/referee/test_referee_rules_integration.py index b1681208..d0d999fa 100644 --- a/utama_core/tests/custom_referee/test_referee_rules_integration.py +++ b/utama_core/tests/referee/test_referee_rules_integration.py @@ -13,12 +13,12 @@ from __future__ import annotations -from utama_core.custom_referee.custom_referee import CustomReferee from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.custom_referee import CustomReferee def _ball(x: float = 0.0, y: float = 0.0, vx: float = 0.0, vy: float = 0.0) -> Ball: diff --git a/utama_core/tests/custom_referee/test_referee_scan_order.py b/utama_core/tests/referee/test_referee_scan_order.py similarity index 97% rename from utama_core/tests/custom_referee/test_referee_scan_order.py rename to utama_core/tests/referee/test_referee_scan_order.py index f027198a..be428df1 100644 --- a/utama_core/tests/custom_referee/test_referee_scan_order.py +++ b/utama_core/tests/referee/test_referee_scan_order.py @@ -30,14 +30,14 @@ from typing import Optional -from utama_core.custom_referee.custom_referee import CustomReferee -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.base_rule import BaseRule, RuleViolation from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game.ball import Ball from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee.custom_referee import CustomReferee +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.base_rule import BaseRule, RuleViolation # Robots at PushingRule/CrashingRule's contact distance (2*ROBOT_RADIUS+0.03 = # 0.18m), same convention as test_pushing_crashing.py. @@ -148,7 +148,7 @@ def test_first_stopping_rule_in_priority_order_wins_and_later_rules_are_never_co # check() with a call counter, in place, so the rest of # CustomReferee's internals (the same self._rules list _step() # iterates) are completely untouched. - from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule + from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule oob_rule = next(r for r in referee._rules if isinstance(r, OutOfBoundsRule)) call_count = 0 diff --git a/utama_core/tests/custom_referee/test_referee_unit.py b/utama_core/tests/referee/test_referee_unit.py similarity index 95% rename from utama_core/tests/custom_referee/test_referee_unit.py rename to utama_core/tests/referee/test_referee_unit.py index 3f70d8e3..c6e43412 100644 --- a/utama_core/tests/custom_referee/test_referee_unit.py +++ b/utama_core/tests/referee/test_referee_unit.py @@ -316,7 +316,7 @@ def _run_step(self, step_class, game: Game) -> dict: return cmd_map def test_halt_writes_to_all_robots(self): - from utama_core.custom_referee.actions import HaltStep + from utama_core.referee.actions import HaltStep robots = {0: _robot(0), 1: _robot(1)} game = _make_game(friendly_robots=robots, referee=_make_referee_data()) @@ -326,7 +326,7 @@ def test_halt_writes_to_all_robots(self): assert cmd_map[rid] is not None def test_stop_writes_to_all_robots(self): - from utama_core.custom_referee.actions import StopStep + from utama_core.referee.actions import StopStep robots = {0: _robot(0), 1: _robot(1), 2: _robot(2)} game = _make_game(friendly_robots=robots, referee=_make_referee_data()) @@ -341,7 +341,7 @@ def test_stop_writes_to_all_robots(self): class TestBallPlacementOursStep: def test_robot_without_ball_moves_to_ball_first(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -412,7 +412,7 @@ def test_robot_without_ball_approaches_an_out_of_bounds_ball_with_offset(self, m whatever tick sees the ball still out of bounds (e.g. the one tick before that teleport lands). """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -481,7 +481,7 @@ def test_placer_choice_is_sticky_across_near_tied_distances(self, monkeypatch): placer choice via `Sticky` across ticks (the instance persists across ticks -- constructed once in `RefereeOverride.__init__`). """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured_placer_ids = [] @@ -538,7 +538,7 @@ def test_placer_reassigns_when_a_robot_is_clearly_closer(self, monkeypatch): """The sticky placer choice must still yield to a genuinely closer robot -- hysteresis should suppress noise-level flips, not freeze the assignment forever.""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured_placer_ids = [] @@ -592,7 +592,7 @@ def test_teammate_parked_on_the_spot_is_cleared_off_the_ball_path(self, monkeypa (7 of 441 placements in that run). Teammates now keep off the ball's path to the spot, as the other team already must.""" from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -635,7 +635,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri def test_robot_with_ball_moves_to_designated_position(self, monkeypatch): import math - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions move_captured = [] turn_captured = [] @@ -712,7 +712,7 @@ def test_release_withheld_while_ball_still_moving_fast_near_target(self, monkeyp must keep driving the placer (move(), not empty_command()) rather than starting the release countdown. """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions move_captured = [] @@ -772,7 +772,7 @@ def test_release_starts_once_ball_is_close_and_settled(self, monkeypatch): """Companion to the fast-ball case above: once the ball is both within BALL_PLACEMENT_DONE_DISTANCE and slow (<= _SETTLED_SPEED_MPS), the release countdown must actually start.""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **k: ("move", a[2])) @@ -818,7 +818,7 @@ def test_release_starts_once_ball_is_close_and_settled(self, monkeypatch): assert node._release_started_at == 0.0 def test_non_placing_teammate_clears_from_ball(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -877,8 +877,8 @@ def _tick(self, monkeypatch, node, ts, has_ball, ball_x=0.09, ball_v=0.0, full_s Returns (where it was sent, the command it got).""" import dataclasses - from utama_core.custom_referee import actions as referee_actions from utama_core.entities.data.command import RobotCommand + from utama_core.referee import actions as referee_actions sent = {} @@ -909,13 +909,13 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri @pytest.mark.parametrize("full_speed", [0.49, 0.51, 1.0]) def test_the_carry_is_capped_at_carry_speed(self, monkeypatch, full_speed): - from utama_core.custom_referee.actions import BallPlacementOursStep as Step + from utama_core.referee.actions import BallPlacementOursStep as Step _, cmd = self._tick(monkeypatch, Step(), 0.0, True, full_speed=full_speed) assert cmd.local_forward_vel == pytest.approx(min(full_speed, Step._CARRY_SPEED_MPS)) def test_the_carry_slows_to_stop_at_the_spot(self, monkeypatch): - from utama_core.custom_referee.actions import BallPlacementOursStep as Step + from utama_core.referee.actions import BallPlacementOursStep as Step # Still rolling 0.08 m from the spot (not settled): no faster than braking at the carry rate allows. _, cmd = self._tick(monkeypatch, Step(), 0.0, True, ball_x=self.DESIGNATED[0] - 0.08, ball_v=0.4) @@ -938,7 +938,7 @@ class TestBallPlacementOursApproachAroundBall: def _placer_move(self, monkeypatch, robot_xy, ball_v=(0.0, 0.0)): """(target, orientation) the placer at `robot_xy` is sent to.""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1015,7 +1015,7 @@ def test_placer_meets_a_rolling_ball_on_its_path_facing_it(self, monkeypatch, sp placer's back to it, heading for a point behind it facing the spot, and never caught. Rolling faster than `_SETTLED_SPEED_MPS`, the placer goes to where it will meet the ball, ahead on its path, facing back along it.""" - from utama_core.custom_referee.actions import BallPlacementOursStep as step + from utama_core.referee.actions import BallPlacementOursStep as step assert step._SETTLED_SPEED_MPS == 0.3 start = (-2.0, -2.0) @@ -1040,7 +1040,7 @@ def test_placer_parked_at_the_approach_point_creeps_onto_the_ball(self, monkeypa """Field test 2026-10-27: real placers parked 0.10-0.11 m from the ball, ~1 cm short of dribbler contact, for 15-20 s. Lined up within _CREEP_RANGE_M of the approach point without the ball, the target moves _CREEP_M further along the carry direction.""" - from utama_core.custom_referee.actions import BallPlacementOursStep as step + from utama_core.referee.actions import BallPlacementOursStep as step at_edge = (self.APPROACH[0] - step._CREEP_RANGE_M, self.APPROACH[1]) target = self._placer_target(monkeypatch, at_edge) @@ -1048,7 +1048,7 @@ def test_placer_parked_at_the_approach_point_creeps_onto_the_ball(self, monkeypa assert (target.x, target.y) == pytest.approx((self.APPROACH[0] + step._CREEP_M, self.APPROACH[1])) def test_placer_short_of_the_creep_range_aims_at_the_approach_point(self, monkeypatch): - from utama_core.custom_referee.actions import BallPlacementOursStep as step + from utama_core.referee.actions import BallPlacementOursStep as step target = self._placer_target(monkeypatch, (self.APPROACH[0] - step._CREEP_RANGE_M - 0.001, self.APPROACH[1])) @@ -1062,7 +1062,7 @@ def test_placer_short_of_the_creep_range_aims_at_the_approach_point(self, monkey class TestRefereeKeepOutRetreat: def test_stop_moves_only_robots_inside_keep_out_radius(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1089,7 +1089,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert cmd_map[1] is not None def test_stop_clears_robot_from_opponent_defense_area(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1133,7 +1133,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(-3.25, 0.0) def test_direct_free_theirs_clears_robot_from_opponent_defense_area(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1177,7 +1177,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(-3.25, 0.0) def test_direct_free_theirs_evicts_excess_defenders_from_own_defense_area(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1221,7 +1221,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(3.27, 0.2) def test_ball_placement_theirs_clears_robot_from_opponent_defense_area(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1265,7 +1265,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(-3.25, 0.0) def test_ball_placement_theirs_clears_encroaching_robot(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1292,7 +1292,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(0.8, 0.0) def test_ball_placement_theirs_clears_robot_from_designated_position(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1337,7 +1337,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured[0][1] == Vector2D(1.8, 1.0) def test_direct_free_theirs_clears_encroaching_robot(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1366,7 +1366,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri class TestPenaltyPositioning: def test_prepare_penalty_ours_kicker_stays_on_attacking_half(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1397,7 +1397,7 @@ def test_prepare_penalty_ours_kicker_waits_behind_the_ball_not_on_it(self, monke # decoy_and_overload_vs_score_aware_zone_flow (2026-09-28): the kicker was # sent to the mark itself, i.e. onto the placed ball, shoved it away at # 1.5 m/s before NORMAL_START, and keep-out voided the penalty. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1428,7 +1428,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert (kicker_target - mark).mag() <= KICKER_READY_DISTANCE def test_prepare_penalty_theirs_support_robots_stay_on_our_half(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1467,7 +1467,7 @@ def test_prepare_penalty_theirs_support_robots_stand_outside_the_keep_out_circle # decoy_and_overload_vs_low_block (2026-09-28): the line 0.4 m behind the # mark put a defender 0.44 m from the ball, KeepOutRule (0.5 m) fired # 1 s into every PREPARE_PENALTY, and the penalty was never taken. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1494,7 +1494,7 @@ def test_prepare_penalty_theirs_goal_side_defender_walks_round_the_ball(self, mo # decoy_and_overload_vs_low_block (2026-09-28): a defender starting between # the mark and its own goal drove straight through the ball to the line # behind it, 0.30 m from the ball for 0.5 s -- keep-out voided the penalty. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1528,7 +1528,7 @@ def test_prepare_penalty_ours_goal_side_teammate_walks_round_the_ball(self, monk # Mirror of the defender case: a non-kicker of ours left goal-side of the # mark drove straight through the placed ball to its line 1 m behind it, # knocking the ball off the mark before the kick. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1561,7 +1561,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri def test_prepare_penalty_ours_goalkeeper_stays_on_own_goal_line(self, monkeypatch): # PreparePenaltyOursStep must keep the friendly goalkeeper on our own goal line, # not displace it into the opponent's half behind the penalty mark. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1594,7 +1594,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri def test_prepare_penalty_line_formation_centered_symmetrically(self, monkeypatch): # Penalty support robots on the line behind the mark must be centered # symmetrically around y=0. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1627,7 +1627,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri def test_prepare_penalty_theirs_clears_extra_defender_from_own_defense_area(self, monkeypatch): # PreparePenaltyTheirsStep must clear any outfield defender beyond the keeper # out of own defense area (clear_own_defense_area=True). - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1657,7 +1657,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri def test_prepare_penalty_ours_clears_teammate_from_opp_defense_area(self, monkeypatch): # PreparePenaltyOursStep must clear teammates from opponent defense area # (clear_opp_defense_area=True). - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1694,7 +1694,7 @@ def test_point_inside_circle_near_boundary_is_projected_onto_circle(self): # inside the keep-out circle. _reachable_on_circle must not return the # unprojected inside-the-circle point; it must return a point at radius # distance from center that is inside the pitch boundaries. - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions game = _make_game(my_team_is_yellow=True, my_team_is_right=False) center = Vector2D(1.79, 2.75) # ball near top sideline (y = 3.0) @@ -1710,7 +1710,7 @@ def test_point_inside_circle_near_boundary_is_projected_onto_circle(self): class TestVariableFieldScaling: def test_prepare_kickoff_ours_scales_support_positions_with_field_bounds(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1755,7 +1755,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert support_target.distance_to(Vector2D(0.0, 0.0)) >= 0.5 def test_prepare_kickoff_ours_uses_own_half_when_defending_left(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1796,7 +1796,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert support_target.x < 0.0, "support robot must stay on own half (defending left)" def test_prepare_penalty_ours_scales_penalty_mark_with_field_bounds(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1838,7 +1838,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri class TestPrepareKickoffTheirsStep: def test_all_robots_placed_on_own_half_right(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1866,7 +1866,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert target.x > 0.0, f"Expected positive-x (own half right), got {target}" def test_all_robots_placed_on_own_half_left(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -1896,7 +1896,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert target.x < 0.0, f"Expected negative-x (own half left), got {target}" def test_positions_outside_centre_circle(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1920,7 +1920,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert dist >= 0.5, f"Target {target} inside centre circle" def test_scales_with_custom_field_bounds(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -1979,7 +1979,7 @@ def _at_the_ball(friendly_robots, enemy_robots=None): field_bounds=STANDARD_FIELD_DIMS.full_field_bounds, ), ) - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions node = referee_actions.DirectFreeOursStep() node.blackboard = _make_blackboard(game, _make_cmd_map(game)) @@ -2000,8 +2000,8 @@ def test_the_taker_kicks_only_with_the_ball_on_the_kicker(self): assert node.blackboard.cmd_map[0].kick == 0 def test_the_taker_waits_for_the_teammate_to_face_the_ball_and_it_turns(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions from utama_core.entities.data.command import RobotCommand + from utama_core.referee import actions as referee_actions turning = RobotCommand(local_forward_vel=0, local_left_vel=0, angular_vel=2.0, kick=0, chip=0, dribble=0) monkeypatch.setattr(referee_actions, "turn_on_spot", lambda *a, **k: turning) @@ -2013,7 +2013,7 @@ def test_the_taker_waits_for_the_teammate_to_face_the_ball_and_it_turns(self, mo @pytest.mark.parametrize("from_ball, turns", [(0.799, True), (0.751, True), (0.749, False)]) def test_a_receiver_on_the_keep_out_edge_turns_instead_of_being_cleared(self, monkeypatch, from_ball, turns): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions turning = object() cleared = object() @@ -2040,7 +2040,7 @@ def test_the_kick_target_is_kept_while_lanes_open_and_shut(self): assert node._kick_target(game, 0, Vector2D(1.06, 0.0))[0] == 1 def test_with_nobody_in_range_the_nearest_teammate_comes_and_the_taker_waits(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **k: ("move", a[2], a[3])) far = dataclasses.replace(_robot(1, -3.0, 2.5), orientation=0.0) @@ -2072,7 +2072,7 @@ def test_the_taker_kicks_when_the_called_teammate_has_arrived(self): assert node.blackboard.cmd_map[0].kick == 1 def test_kicker_is_closest_robot_to_ball(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2142,7 +2142,7 @@ def test_approach_point_stays_reachable_when_ball_is_near_opponent_box(self, mon enemy id=1 southeast of the ball so `_kick_target_enemy` picks the same kick direction traced live. """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2196,7 +2196,7 @@ def test_kicker_goes_round_the_ball_to_an_approach_point_on_its_far_side(self, m kick placed 0.25 m inside the goal line back onto the line, where the first touch put it out: 90 of 478 free kicks, tournament_20260927_223257.""" from utama_core.config.physical_constants import BALL_RADIUS, ROBOT_RADIUS - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2238,7 +2238,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert closest >= ROBOT_RADIUS + BALL_RADIUS + 0.05 # 5 cm between robot and ball (2026-10-27) def test_kicker_moves_toward_ball(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2283,7 +2283,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert target.distance_to(ball_pos) < robot_start.distance_to(ball_pos) def test_non_kicker_robots_get_stop_command(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **kw: ("move",)) @@ -2311,7 +2311,7 @@ def test_non_kicker_robots_get_stop_command(self, monkeypatch): assert cmd_map[2] != ("move", 2) def test_writes_command_for_every_robot(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **kw: ("move",)) @@ -2340,7 +2340,7 @@ def test_kicker_choice_is_sticky_across_near_tied_distances(self, monkeypatch): reuse the same instance across ticks (it does — constructed once in `RefereeOverride.__init__`) and hold its choice via `Sticky`. """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured_kicker_ids = [] @@ -2377,7 +2377,7 @@ def test_kicker_reassigns_when_a_robot_is_clearly_closer(self, monkeypatch): """The sticky kicker choice must still yield to a genuinely closer robot — hysteresis should suppress noise-level flips, not freeze the assignment forever.""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured_kicker_ids = [] @@ -2409,7 +2409,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert captured_kicker_ids[-1] == 3 def test_direct_free_ours_clears_non_kicker_from_opponent_defense_area(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2453,7 +2453,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert r0_moves[0][1] == Vector2D(-3.25, 0.0) def test_direct_free_ours_clears_non_kicker_from_ball_keep_out(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2503,7 +2503,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri class TestDirectFreeTheirsStep: def test_robot_outside_keep_out_stays_put(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **kw: ("move",)) @@ -2521,7 +2521,7 @@ def test_robot_outside_keep_out_stays_put(self, monkeypatch): assert cmd_map[0] != ("move", 0) def test_encroaching_robot_clears_and_the_nearest_other_takes_the_wall(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2551,7 +2551,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri assert cmd_map[2] is not None def test_encroaching_robot_projected_to_keep_out_boundary(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2580,7 +2580,7 @@ def test_robot_one_centimetre_short_of_keep_out_boundary_is_commanded_to_boundar Before the fix, dx * dx + dy * dy < 1e-4 treated it as already at target and issued empty_command(False), leaving it stranded at 0.795 m inside the keep-out. """ - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2607,7 +2607,7 @@ def test_robot_between_ball_and_opponent_box_clears_round_the_ball(self, monkeyp """A free kick 1 m in front of the opponent box (inner edge x = -3.5 here): straight out from the ball is (-3.3, 0), where the planner's box margin stopped the robot 0.48 m from the ball, a Defender Too Close foul.""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] monkeypatch.setattr( @@ -2630,7 +2630,7 @@ def test_robot_by_a_ball_in_the_corner_clears_round_the_ball_onto_the_pitch(self """Ball at (4.0, 2.5): straight out from it the robot's spot is off the pitch, and clamped back on (x <= 4.4) it was 0.48 m from the ball, so the robot never left (moment placement_in_corner_traps_defender).""" - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] monkeypatch.setattr( @@ -2650,7 +2650,7 @@ def test_robot_by_a_ball_in_the_corner_clears_round_the_ball_onto_the_pitch(self assert referee_actions._clamp_to_field(target, game) == target def test_all_robots_get_commands(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions monkeypatch.setattr(referee_actions, "move", lambda *a, **kw: ("move",)) @@ -2668,7 +2668,7 @@ def test_all_robots_get_commands(self, monkeypatch): assert v is not None def test_clear_to_legal_positions_touchline_clamping_preserves_keep_out(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = [] @@ -2733,8 +2733,8 @@ def test_robot_between_ball_and_spot_is_sent_clear_of_both(self, monkeypatch, st import dataclasses from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE - from utama_core.custom_referee import actions as referee_actions from utama_core.geometry.math_utils import distance_point_to_segment + from utama_core.referee import actions as referee_actions captured = {} @@ -2769,7 +2769,7 @@ class TestClearingTargetsKeepOffRobots: START = (4.70, -0.68) def _stop_target(self, monkeypatch, keeper=KEEPER): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions captured = {} @@ -2806,7 +2806,7 @@ def fake_move(game, motion_controller, robot_id, target_coords, target_oren, dri return game, captured[1] def test_a_robot_cleared_from_the_ball_is_not_sent_onto_another_robot(self, monkeypatch): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions game, target = self._stop_target(monkeypatch) assert target.distance_to(Vector2D(*self.KEEPER)) >= referee_actions._ROBOT_SPACING_M @@ -2820,7 +2820,7 @@ def test_with_no_robot_near_it_keeps_its_nearest_spot(self, monkeypatch): @pytest.mark.parametrize("gap", [-0.001, 0.001]) def test_robot_spacing_boundary(self, gap): - from utama_core.custom_referee import actions as referee_actions + from utama_core.referee import actions as referee_actions game = _make_game(friendly_robots={0: _robot(0, 0.0, 0.0), 1: _robot(1, 3.0, 0.0)}) point = Vector2D(referee_actions._ROBOT_SPACING_M + gap, 0.0) diff --git a/utama_core/tests/custom_referee/test_stage_advance.py b/utama_core/tests/referee/test_stage_advance.py similarity index 97% rename from utama_core/tests/custom_referee/test_stage_advance.py rename to utama_core/tests/referee/test_stage_advance.py index 6ececfd8..3c72dcd4 100644 --- a/utama_core/tests/custom_referee/test_stage_advance.py +++ b/utama_core/tests/referee/test_stage_advance.py @@ -4,12 +4,12 @@ half, and score-aware strategies (strategy.pickers.is_late_in_half) never saw one. """ -from utama_core.custom_referee.state_machine import GameStateMachine from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, GameFrame, Robot from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage -from utama_core.tests.custom_referee.test_free_kick_timeout import _frame +from utama_core.referee.state_machine import GameStateMachine +from utama_core.tests.referee.test_free_kick_timeout import _frame def _machine() -> GameStateMachine: @@ -143,7 +143,7 @@ def test_the_second_half_starts_with_its_kick_off_and_ends_the_match(): def test_after_full_time_no_violation_restarts_play(): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sm = _machine() _playing(sm, 10.0) @@ -164,7 +164,7 @@ def test_after_full_time_no_violation_restarts_play(): def test_an_operator_profile_ends_no_half_itself(): - from utama_core.custom_referee.profiles.profile_loader import AutoAdvanceConfig + from utama_core.referee.profiles.profile_loader import AutoAdvanceConfig sm = GameStateMachine( half_duration_seconds=300.0, diff --git a/utama_core/tests/custom_referee/wandering_strategy.py b/utama_core/tests/referee/wandering_strategy.py similarity index 100% rename from utama_core/tests/custom_referee/wandering_strategy.py rename to utama_core/tests/referee/wandering_strategy.py diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 22b49783..aba698c4 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -383,7 +383,7 @@ def test_the_tactics_are_outside_the_base(graph): def test_the_base_holds_the_sim_script_and_referee_profiles(graph): base = graph.base_modules([MATCH_ENTRY]) assert set(fp.SUBPROCESS_SCRIPTS) <= base - assert any("custom_referee/profiles/simulation.yaml" in row for row in graph.data_files(base)) + assert any("referee/profiles/simulation.yaml" in row for row in graph.data_files(base)) # Every place the code a match runs reaches outside the import graph, and how each is @@ -425,7 +425,7 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "opens files": [ "utama_core.bundle.archive", "utama_core.bundle.strategy_file", - "utama_core.custom_referee.profiles.profile_loader", + "utama_core.referee.profiles.profile_loader", "utama_core.engine.match_log", "utama_core.engine.match_stats", "utama_core.replay.columnar_reader", diff --git a/utama_core/tests/replay/test_scenario.py b/utama_core/tests/replay/test_scenario.py index 157d543f..64a34643 100644 --- a/utama_core/tests/replay/test_scenario.py +++ b/utama_core/tests/replay/test_scenario.py @@ -370,7 +370,7 @@ def _replay_runner(frame): """What `apply_scenario` touches of a runner, with the referee `_build_runner` gives it.""" from types import SimpleNamespace - from utama_core.custom_referee import CustomReferee + from utama_core.referee import CustomReferee referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=6, n_robots_blue=6) referee.seed_clock(frame.ts, RefereeCommand.PREPARE_KICKOFF_YELLOW) diff --git a/utama_core/tests/run/test_ball_placement_rsim.py b/utama_core/tests/run/test_ball_placement_rsim.py index 196d6b50..5d4ba222 100644 --- a/utama_core/tests/run/test_ball_placement_rsim.py +++ b/utama_core/tests/run/test_ball_placement_rsim.py @@ -53,10 +53,10 @@ from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS from utama_core.config.referee_constants import BALL_KEEP_OUT_DISTANCE -from utama_core.custom_referee import CustomReferee from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee from utama_core.run.strategy_runner import StrategyRunner from utama_core.strategy.catalog import builder from utama_core.team_controller.controllers import AbstractSimController diff --git a/utama_core/tests/run/test_change_of_ends.py b/utama_core/tests/run/test_change_of_ends.py index 8c2df333..78d5db2e 100644 --- a/utama_core/tests/run/test_change_of_ends.py +++ b/utama_core/tests/run/test_change_of_ends.py @@ -7,8 +7,6 @@ import dataclasses -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.data.vector import Vector2D from utama_core.entities.game.field import FieldBounds @@ -16,6 +14,8 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.geometry.math_utils import in_field_bounds +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run import StrategyRunner from utama_core.run.strategy_runner import _turned from utama_core.strategy.catalog import builder diff --git a/utama_core/tests/run/test_field_check.py b/utama_core/tests/run/test_field_check.py index 84a8059b..a4a950ca 100644 --- a/utama_core/tests/run/test_field_check.py +++ b/utama_core/tests/run/test_field_check.py @@ -10,9 +10,9 @@ from utama_core.config.enums import Mode from utama_core.config.field_params import FieldBounds, FieldDimensions -from utama_core.custom_referee import CustomReferee from utama_core.entities.data.raw_vision import RawBallData, RawRobotData, RawVisionData from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee from utama_core.run.field_check import ( CAMERA_SILENT_S, OUT_OF_BOUNDS_MARGIN_M, diff --git a/utama_core/tests/run/test_goalkeeper_stability.py b/utama_core/tests/run/test_goalkeeper_stability.py index 933ff5a5..1381349f 100644 --- a/utama_core/tests/run/test_goalkeeper_stability.py +++ b/utama_core/tests/run/test_goalkeeper_stability.py @@ -22,10 +22,10 @@ import dataclasses -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run import StrategyRunner from utama_core.strategy.catalog import builder diff --git a/utama_core/tests/run/test_referee_rsim.py b/utama_core/tests/run/test_referee_rsim.py index e1be987b..b09723c4 100644 --- a/utama_core/tests/run/test_referee_rsim.py +++ b/utama_core/tests/run/test_referee_rsim.py @@ -41,9 +41,6 @@ BALL_KEEP_OUT_DISTANCE, OPPONENT_DEFENSE_AREA_KEEP_DISTANCE, ) -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.engine import ball_release from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.context import TickContext @@ -53,6 +50,9 @@ from utama_core.entities.game import Game from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.motion_planning.common.motion_controller import MotionController +from utama_core.referee import CustomReferee +from utama_core.referee.geometry import RefereeGeometry +from utama_core.referee.rules.out_of_bounds_rule import OutOfBoundsRule from utama_core.run.strategy_runner import StrategyRunner from utama_core.skills.go_to_ball import go_to_ball from utama_core.skills.utils.move_utils import empty_command @@ -556,7 +556,7 @@ def __init__(self, referee: CustomReferee): self.after_halt: list[RefereeCommand] = [] def reset_field(self, sim_controller: AbstractSimController, game: Game): - from utama_core.custom_referee.rules.base_rule import RuleViolation + from utama_core.referee.rules.base_rule import RuleViolation sim_controller.teleport_ball(0.5, 0.5) self._referee.set_command( diff --git a/utama_core/tests/run/test_replace_strategy.py b/utama_core/tests/run/test_replace_strategy.py index 37c595b5..11de0195 100644 --- a/utama_core/tests/run/test_replace_strategy.py +++ b/utama_core/tests/run/test_replace_strategy.py @@ -5,13 +5,13 @@ import pytest -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.engine.context import TickContext from utama_core.engine.match_log import MatchLog from utama_core.engine.strategy import Strategy from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee +from utama_core.referee.profiles.profile_loader import load_profile from utama_core.run import StrategyRunner from utama_core.tactics.defense import DefenseTactic diff --git a/utama_core/tests/run/test_runner_misconfig.py b/utama_core/tests/run/test_runner_misconfig.py index 5a3e517e..52266827 100644 --- a/utama_core/tests/run/test_runner_misconfig.py +++ b/utama_core/tests/run/test_runner_misconfig.py @@ -9,8 +9,8 @@ GREAT_EXHIBITION_FIELD_DIMS, STANDARD_FIELD_DIMS, ) -from utama_core.custom_referee import CustomReferee from utama_core.entities.game.field import FieldBounds +from utama_core.referee import CustomReferee from utama_core.run.referee_source import OfficialReferee from utama_core.run.strategy_runner import StrategyRunner from utama_core.tests.run.strat_runner_test_utils import DummyStrategy diff --git a/utama_core/tests/run/test_scenario_hooks.py b/utama_core/tests/run/test_scenario_hooks.py index a77658ed..fd273aec 100644 --- a/utama_core/tests/run/test_scenario_hooks.py +++ b/utama_core/tests/run/test_scenario_hooks.py @@ -1,8 +1,8 @@ from unittest.mock import Mock -from utama_core.custom_referee import CustomReferee from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand +from utama_core.referee import CustomReferee from utama_core.rsoccer_simulator.ssl import ssl_gym_base from utama_core.run.strategy_runner import StrategyRunner From 0aee61e1e3cad26e589175cad6c9c5ee755b042e Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:36:45 +0000 Subject: [PATCH 44/59] structure: rsoccer_simulator/ becomes simulator/, subpackages lowercase Co-Authored-By: Claude Haiku 5.5 --- AGENTS.md | 6 +++--- README.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 2 +- docs/architecture.md | 20 +++++++++---------- docs/img/sim_realism/make_rsim_tick.py | 10 +++++----- docs/sim_realism.md | 2 +- examples/demo_custom_referee.py | 8 ++++---- tools/debug/moments.py | 4 ++-- tools/debug/repro_from_replay.py | 2 +- tools/dev/setup_worktree.sh | 2 +- tools/evaluation/evaluate.py | 2 +- tools/evaluation/match.py | 8 +++----- tools/evaluation/sim_settings.py | 2 +- utama_core/analysis/render_window.py | 2 +- utama_core/engine/abstract_strategy.py | 2 +- .../common/motion_controller.py | 2 +- .../controllers/dwa_controller.py | 2 +- .../controllers/fastpathplanning.py | 2 +- .../controllers/pid_controller.py | 2 +- .../controllers/trajsampling.py | 2 +- utama_core/motion_planning/dwa/planner.py | 2 +- .../dwa/translation_controller.py | 2 +- .../fastpathplanning/planner.py | 2 +- utama_core/replay/fingerprint.py | 2 +- utama_core/replay/replay_player.py | 10 +++++----- utama_core/replay/scenario.py | 2 +- .../rsoccer_simulator/Entities/__init__.py | 4 ---- .../rsoccer_simulator/Render/__init__.py | 13 ------------ .../rsoccer_simulator/Utils/__init__.py | 1 - .../rsoccer_simulator/ssl/envs/__init__.py | 1 - utama_core/run/game_gater.py | 2 +- utama_core/run/sim_setup.py | 2 +- utama_core/run/strategy_runner.py | 8 ++++---- utama_core/run/vision_stream.py | 8 ++------ .../.gitignore | 0 .../{rsoccer_simulator => simulator}/LICENSE | 0 .../README.md | 2 +- .../__init__.py | 0 .../Entities => simulator/entities}/Ball.py | 2 +- .../Entities => simulator/entities}/Field.py | 0 .../Entities => simulator/entities}/Frame.py | 4 ++-- .../Entities => simulator/entities}/Robot.py | 0 utama_core/simulator/entities/__init__.py | 4 ++++ utama_core/simulator/render/__init__.py | 13 ++++++++++++ .../Render => simulator/render}/ball.py | 2 +- .../Render => simulator/render}/field.py | 2 +- .../Render => simulator/render}/overlay.py | 2 +- .../Render => simulator/render}/robot.py | 2 +- .../Render => simulator/render}/utils.py | 0 .../simulators}/__init__.py | 0 .../simulators}/robosim/robosim_subprocess.py | 0 .../simulators}/robosim/robosim_wrapper.py | 0 .../simulators}/rsim.py | 4 ++-- .../ssl/__init__.py | 0 utama_core/simulator/ssl/envs/__init__.py | 1 + .../ssl/envs/standard_ssl.py | 10 +++++----- .../ssl/ssl_gym_base.py | 8 ++++---- utama_core/simulator/utils/__init__.py | 1 + .../utils}/gaussian_noise.py | 0 .../Utils => simulator/utils}/kdtree.py | 0 .../Utils => simulator/utils}/sim_noise.py | 2 +- .../controllers/sim/rsim_controller.py | 2 +- .../controllers/sim/rsim_robot_controller.py | 2 +- utama_core/tests/engine/test_evaluate.py | 4 ++-- utama_core/tests/replay/test_fingerprint.py | 12 +++++------ utama_core/tests/replay/test_repro_summary.py | 4 ++-- utama_core/tests/run/test_scenario_hooks.py | 2 +- utama_core/tests/run/test_sim_pose_ahead.py | 2 +- .../test_dribble_with_friction.py | 4 ++-- .../test_render_overlay.py | 2 +- .../test_robosim_wrapper.py | 6 +++--- .../test_sim_noise.py | 10 +++------- .../test_sim_physics_knobs.py | 6 +++--- vendor/rSim/FORK_NOTES.md | 2 +- 74 files changed, 125 insertions(+), 135 deletions(-) delete mode 100644 utama_core/rsoccer_simulator/Entities/__init__.py delete mode 100644 utama_core/rsoccer_simulator/Render/__init__.py delete mode 100644 utama_core/rsoccer_simulator/Utils/__init__.py delete mode 100644 utama_core/rsoccer_simulator/ssl/envs/__init__.py rename utama_core/{rsoccer_simulator => simulator}/.gitignore (100%) rename utama_core/{rsoccer_simulator => simulator}/LICENSE (100%) rename utama_core/{rsoccer_simulator => simulator}/README.md (98%) rename utama_core/{rsoccer_simulator => simulator}/__init__.py (100%) rename utama_core/{rsoccer_simulator/Entities => simulator/entities}/Ball.py (73%) rename utama_core/{rsoccer_simulator/Entities => simulator/entities}/Field.py (100%) rename utama_core/{rsoccer_simulator/Entities => simulator/entities}/Frame.py (96%) rename utama_core/{rsoccer_simulator/Entities => simulator/entities}/Robot.py (100%) create mode 100644 utama_core/simulator/entities/__init__.py create mode 100644 utama_core/simulator/render/__init__.py rename utama_core/{rsoccer_simulator/Render => simulator/render}/ball.py (88%) rename utama_core/{rsoccer_simulator/Render => simulator/render}/field.py (99%) rename utama_core/{rsoccer_simulator/Render => simulator/render}/overlay.py (95%) rename utama_core/{rsoccer_simulator/Render => simulator/render}/robot.py (98%) rename utama_core/{rsoccer_simulator/Render => simulator/render}/utils.py (100%) rename utama_core/{rsoccer_simulator/Simulators => simulator/simulators}/__init__.py (100%) rename utama_core/{rsoccer_simulator/Simulators => simulator/simulators}/robosim/robosim_subprocess.py (100%) rename utama_core/{rsoccer_simulator/Simulators => simulator/simulators}/robosim/robosim_wrapper.py (100%) rename utama_core/{rsoccer_simulator/Simulators => simulator/simulators}/rsim.py (97%) rename utama_core/{rsoccer_simulator => simulator}/ssl/__init__.py (100%) create mode 100644 utama_core/simulator/ssl/envs/__init__.py rename utama_core/{rsoccer_simulator => simulator}/ssl/envs/standard_ssl.py (98%) rename utama_core/{rsoccer_simulator => simulator}/ssl/ssl_gym_base.py (97%) create mode 100644 utama_core/simulator/utils/__init__.py rename utama_core/{rsoccer_simulator/Utils => simulator/utils}/gaussian_noise.py (100%) rename utama_core/{rsoccer_simulator/Utils => simulator/utils}/kdtree.py (100%) rename utama_core/{rsoccer_simulator/Utils => simulator/utils}/sim_noise.py (99%) rename utama_core/tests/{rsoccer_simulator => simulator}/test_dribble_with_friction.py (96%) rename utama_core/tests/{rsoccer_simulator => simulator}/test_render_overlay.py (96%) rename utama_core/tests/{rsoccer_simulator => simulator}/test_robosim_wrapper.py (96%) rename utama_core/tests/{rsoccer_simulator => simulator}/test_sim_noise.py (95%) rename utama_core/tests/{rsoccer_simulator => simulator}/test_sim_physics_knobs.py (98%) diff --git a/AGENTS.md b/AGENTS.md index 46c9b825..0763de8d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -5,7 +5,7 @@ Durable context for any coding agent (not just Claude) working in this repo. ## What this repo is Utama-Core is the RoboCup SSL (Small Size League) team's robot-control stack: vision -ingestion, motion planning, robot control, a simulator (`rsoccer_simulator`, "rsim"), and +ingestion, motion planning, robot control, a simulator (`utama_core/simulator`, "rsim"), and the strategy layer that decides what each robot does. `Utama-Strategy` is a sibling repo and is stale — all active strategy work happens here, on top of the tactic-kernel model. @@ -20,7 +20,7 @@ exists yet: say so in your change rather than guessing. | Strategy evaluation | `tools/evaluation/`, `utama_core/replay/`, `utama_core/analysis/` | `docs/STRATEGY_DEVELOPMENT.md`, `docs/signals.md` | Change evaluation and strategy in separate commits, so results stay comparable | | Referee | `utama_core/referee/` | `docs/referee.md` | | | Motion planning | `utama_core/motion_planning/`, `tools/motion_planning_benchmark.py` | `docs/motion_planning_comparison.md` | | -| Simulation | `utama_core/rsoccer_simulator/`, `vendor/rSim/` | `vendor/rSim/FORK_NOTES.md` | `vendor/rSim` is the C++ physics fork; `rsoccer_simulator` is the Python env on top of it | +| Simulation | `utama_core/simulator/`, `vendor/rSim/` | `vendor/rSim/FORK_NOTES.md` | `vendor/rSim` is the C++ physics fork; `utama_core/simulator` is the Python env on top of it | | Real robots (radio, vision, controllers) | `utama_core/team_controller/`, `utama_core/data_processing/` | `utama_core/team_controller/README.md` (brief) | | ## Glossary @@ -102,7 +102,7 @@ One term per thing; reuse these instead of coining new ones. - `utama_core/analysis/` — offline analyses of tournament runs and replays (`turnover_breakdown`, `restart_outcomes`, `stuck_detector`, `render_window`, `render_clip`, `list_runs`). Imports `replay/`; `replay/` never imports it. -- Everything else (`motion_planning/`, `rsoccer_simulator/`, `team_controller/`, +- Everything else (`motion_planning/`, `simulator/`, `team_controller/`, `data_processing/`, `entities/`, `geometry/`) is infrastructure the strategy layer sits on top of. Writing a strategy rarely needs to change it, but it is the main work area for planner, simulator, vision and hardware work: see the Work areas table above. diff --git a/README.md b/README.md index ed48db03..ee5e70c3 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,7 @@ Everything lives under `utama_core/`: - `run/`: the main loop (`StrategyRunner`) - `replay/`: replay files, the match-result cache and code fingerprints - `analysis/`: offline analyses of tournament runs and replays (ball losses, chances, restarts, stalls) -- `rsoccer_simulator/`: the Python simulator environment over the rSim physics fork in `vendor/rSim/` +- `simulator/`: the Python simulator environment over the rSim physics fork in `vendor/rSim/` - `team_controller/`, `data_processing/`: vision, robot radio and referee input - `dashboard/`: the browser dashboard - `entities/`, `config/`, `geometry/`: data classes, settings and constants, geometry helpers diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index cf8c8917..88bcd469 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -428,7 +428,7 @@ whoever runs it. `diagnosis` (ball in goal / past a line, taker not closing on the ball, taker at the ball but not kicking). The tournament prints a STALLS section, and writes it to `summary.json`; a possession-pinned backstop flags what the watchdog misses. -- **Sim noise** (`rsoccer_simulator/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded +- **Sim noise** (`simulator/utils/sim_noise.py`, `--sim-noise JSON`) — seeded command latency per robot, kick speed and direction noise (a per-robot offset plus kick-to-kick spread), two-phase ball friction (slide after a kick, then roll), per-robot speed and braking limits applied to the commands the sim acts on (hardware caps, the 4 m/s^2 command cap, no per-match acceleration draw, diff --git a/docs/architecture.md b/docs/architecture.md index 4b2222a7..0c5bcf0b 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -39,7 +39,7 @@ flowchart TD subgraph output["Output (team_controller/)"] ctrl["RobotController.send_robot_commands
team_controller/controllers/"] - rsim["rsim
rsoccer_simulator/ (sim/rsim_robot_controller.py)"] + rsim["rsim
simulator/ (sim/rsim_robot_controller.py)"] grsim["grSim over UDP
sim/grsim_robot_controller.py"] real["Real robots over radio
real/real_robot_controller.py"] end @@ -94,7 +94,7 @@ flowchart LR p_analysis["analysis"] -->|3| p_engine["engine"] p_analysis["analysis"] -->|11| p_entities["entities"] p_analysis["analysis"] -->|8| p_replay["replay"] - p_analysis["analysis"] -->|1| p_rsoccer_simulator["rsoccer_simulator"] + p_analysis["analysis"] -->|1| p_simulator["simulator"] p_config["config"] -->|1| p_geometry["geometry"] p_referee["referee"] -->|20| p_config["config"] p_referee["referee"] -->|48| p_entities["entities"] @@ -116,7 +116,7 @@ flowchart LR p_engine["engine"] -->|17| p_entities["entities"] p_engine["engine"] -->|1| p_geometry["geometry"] p_engine["engine"] -->|3| p_motion_planning["motion_planning"] - p_engine["engine"] -->|1| p_rsoccer_simulator["rsoccer_simulator"] + p_engine["engine"] -->|1| p_simulator["simulator"] p_engine["engine"] -->|1| p_skills["skills"] p_engine["engine"] -->|1| p_tactics["tactics"] p_engine["engine"] -->|1| p_team_controller["team_controller"] @@ -126,17 +126,17 @@ flowchart LR p_motion_planning["motion_planning"] -->|23| p_config["config"] p_motion_planning["motion_planning"] -->|23| p_entities["entities"] p_motion_planning["motion_planning"] -->|3| p_geometry["geometry"] - p_motion_planning["motion_planning"] -->|8| p_rsoccer_simulator["rsoccer_simulator"] + p_motion_planning["motion_planning"] -->|8| p_simulator["simulator"] p_replay["replay"] -->|6| p_config["config"] p_replay["replay"] -->|1| p_referee["referee"] p_replay["replay"] -->|1| p_data_processing["data_processing"] p_replay["replay"] -->|20| p_entities["entities"] p_replay["replay"] -->|2| p_geometry["geometry"] - p_replay["replay"] -->|5| p_rsoccer_simulator["rsoccer_simulator"] + p_replay["replay"] -->|5| p_simulator["simulator"] p_replay["replay"] -->|3| p_team_controller["team_controller"] - p_rsoccer_simulator["rsoccer_simulator"] -->|4| p_config["config"] - p_rsoccer_simulator["rsoccer_simulator"] -->|3| p_entities["entities"] - p_rsoccer_simulator["rsoccer_simulator"] -->|2| p_geometry["geometry"] + p_simulator["simulator"] -->|4| p_config["config"] + p_simulator["simulator"] -->|3| p_entities["entities"] + p_simulator["simulator"] -->|2| p_geometry["geometry"] p_run["run"] -->|8| p_config["config"] p_run["run"] -->|4| p_referee["referee"] p_run["run"] -->|4| p_data_processing["data_processing"] @@ -145,7 +145,7 @@ flowchart LR p_run["run"] -->|2| p_geometry["geometry"] p_run["run"] -->|2| p_motion_planning["motion_planning"] p_run["run"] -->|2| p_replay["replay"] - p_run["run"] -->|6| p_rsoccer_simulator["rsoccer_simulator"] + p_run["run"] -->|6| p_simulator["simulator"] p_run["run"] -->|1| p_geometry["geometry"] p_run["run"] -->|1| p_skills["skills"] p_run["run"] -->|1| p_team_controller["team_controller"] @@ -174,7 +174,7 @@ flowchart LR p_team_controller["team_controller"] -->|10| p_config["config"] p_team_controller["team_controller"] -->|7| p_entities["entities"] p_team_controller["team_controller"] -->|1| p_geometry["geometry"] - p_team_controller["team_controller"] -->|2| p_rsoccer_simulator["rsoccer_simulator"] + p_team_controller["team_controller"] -->|2| p_simulator["simulator"] p_team_controller["team_controller"] -->|1| p_skills["skills"] ``` diff --git a/docs/img/sim_realism/make_rsim_tick.py b/docs/img/sim_realism/make_rsim_tick.py index d2c8183e..7cdb6da8 100644 --- a/docs/img/sim_realism/make_rsim_tick.py +++ b/docs/img/sim_realism/make_rsim_tick.py @@ -30,11 +30,11 @@ "utama_core/run/strategy_runner.py", "utama_core/referee/custom_referee.py", "utama_core/team_controller/controllers/sim/rsim_controller.py", - "utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py", - "utama_core/rsoccer_simulator/Utils/sim_noise.py", - "utama_core/rsoccer_simulator/Simulators/rsim.py", - "utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py", - "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py", + "utama_core/simulator/ssl/envs/standard_ssl.py", + "utama_core/simulator/utils/sim_noise.py", + "utama_core/simulator/simulators/rsim.py", + "utama_core/simulator/simulators/robosim/robosim_wrapper.py", + "utama_core/simulator/simulators/robosim/robosim_subprocess.py", "vendor/rSim/src/robosim", ] diff --git a/docs/sim_realism.md b/docs/sim_realism.md index 24a53501..9d9f0265 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -467,7 +467,7 @@ Removed 2026-11-09: simulation models the measured world and assumes robots work A robot's calibrated profile now drives its kick in rsim when a run gives the profile (the examples do): ball speed `kick_speed` (yellow 0 2.19 m/s, blue 0 1.31, the medians of 2026-10-28's kicks), direction bias + bend × ball offset + normal scatter of `kick_spread_deg` -(`utama_core/rsoccer_simulator/Utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than +(`utama_core/simulator/utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than the kick speed commanded, at 1 to 5 m/s, so the command adds that back. The strategy evaluation passes no profiles, so its matches are unchanged: whether evaluation should use our kick is the Phase 4 / roadmap 2a decision, not this one. Latency is not in this kick profile: rsim's latency is `SimNoise`'s (`reference/world.json`), and real robots predict their diff --git a/examples/demo_custom_referee.py b/examples/demo_custom_referee.py index 9770ce5b..26d84e1f 100644 --- a/examples/demo_custom_referee.py +++ b/examples/demo_custom_referee.py @@ -46,14 +46,14 @@ from utama_core.entities.game.robot import Robot from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.referee import CustomReferee, RefereeGeometry -from utama_core.rsoccer_simulator.Render import COLORS, SSLRenderField -from utama_core.rsoccer_simulator.Render.ball import RenderBall -from utama_core.rsoccer_simulator.Render.overlay import ( +from utama_core.simulator.render import COLORS, SSLRenderField +from utama_core.simulator.render.ball import RenderBall +from utama_core.simulator.render.overlay import ( OverlayObject, OverlayType, RenderOverlay, ) -from utama_core.rsoccer_simulator.Render.robot import RenderSSLRobot +from utama_core.simulator.render.robot import RenderSSLRobot # --------------------------------------------------------------------------- # Scene definition diff --git a/tools/debug/moments.py b/tools/debug/moments.py index 777d276d..05ed243d 100644 --- a/tools/debug/moments.py +++ b/tools/debug/moments.py @@ -109,7 +109,7 @@ AGAINST_DIR = REPO_ROOT.parent / f"{REPO_ROOT.name}-moments-against" BUILD_ARTIFACTS = ( "utama_core/motion_planning/fastpathplanning/_fastpathplanner.cpython-*.so", - "utama_core/rsoccer_simulator/Simulators/robosim/_robosim.cpython-*.so", + "utama_core/simulator/simulators/robosim/_robosim.cpython-*.so", ) @@ -525,7 +525,7 @@ def label(name: str) -> str: def play(m: Moment, strategy: str) -> list[Tick]: """Play `m` with `strategy` on our side (yellow) for `m.seconds`.""" from utama_core.replay.scenario import apply_scenario - from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise + from utama_core.simulator.utils.sim_noise import SimNoise def side(name: str): try: diff --git a/tools/debug/repro_from_replay.py b/tools/debug/repro_from_replay.py index 13c92713..048b64a9 100644 --- a/tools/debug/repro_from_replay.py +++ b/tools/debug/repro_from_replay.py @@ -97,8 +97,8 @@ class name (e.g. "DecoyOverloadTactic"), on a release why, else null. Written wh from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.replay.columnar_reader import load_sim_noise from utama_core.replay.scenario import Scenario, apply_scenario, scenario_from_replay -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run.sim_setup import load_side, sim_runner +from utama_core.simulator.utils.sim_noise import SimNoise from utama_core.strategy import catalog _STILL_STALLED_WINDOW_S = 10.0 diff --git a/tools/dev/setup_worktree.sh b/tools/dev/setup_worktree.sh index 758c4c8d..7d42bf6c 100755 --- a/tools/dev/setup_worktree.sh +++ b/tools/dev/setup_worktree.sh @@ -32,7 +32,7 @@ fi for rel in \ utama_core/motion_planning/fastpathplanning \ - utama_core/rsoccer_simulator/Simulators/robosim; do + utama_core/simulator/simulators/robosim; do for src in "$main_root/$rel"/_*.cpython-*.so; do [ -e "$src" ] || continue name="$(basename "$src")" diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 5f035f70..4bf770da 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -57,7 +57,7 @@ from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 from utama_core.replay import match_results # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise # noqa: E402 +from utama_core.simulator.utils.sim_noise import SimNoise # noqa: E402 from utama_core.strategy import catalog # noqa: E402 CONFIRM_SEED = 101 # the confirm stage's first seed: never one the screen plays diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index 1dda4d01..1a367e9a 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -29,10 +29,6 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.replay.columnar_writer import ColumnarReplayWriterConfig -from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( - enable_sim_reuse, -) -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run.sim_setup import ( # noqa: F401 -- re-exported N_OUTFIELD, OUTFIELD_ROBOT_IDS, @@ -40,6 +36,8 @@ sim_referee, sim_runner, ) +from utama_core.simulator.simulators.robosim.robosim_wrapper import enable_sim_reuse +from utama_core.simulator.utils.sim_noise import SimNoise from utama_core.strategy import catalog from utama_core.strategy.catalog import plain_name @@ -165,7 +163,7 @@ def run_match( Both sides use the fpp planner (`tools/motion_planning_benchmark.py` compares planners). `sim_noise`, if set, plays the match with seeded latency, kick speed noise and vision noise - (`utama_core/rsoccer_simulator/Utils/sim_noise.py`, `docs/sim_realism.md`). The draws + (`utama_core/simulator/utils/sim_noise.py`, `docs/sim_realism.md`). The draws depend on the seed, team colour and robot id only, so the same `sim_noise` gives every pairing the same physics. """ diff --git a/tools/evaluation/sim_settings.py b/tools/evaluation/sim_settings.py index 44f02bed..fc4bde8a 100644 --- a/tools/evaluation/sim_settings.py +++ b/tools/evaluation/sim_settings.py @@ -11,7 +11,7 @@ import json from pathlib import Path -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise +from utama_core.simulator.utils.sim_noise import SimNoise REFERENCE_DIR = Path(__file__).with_name("reference") DEFAULT_PLAYERS = REFERENCE_DIR / "players.json" diff --git a/utama_core/analysis/render_window.py b/utama_core/analysis/render_window.py index aeb86f2f..b7452a95 100644 --- a/utama_core/analysis/render_window.py +++ b/utama_core/analysis/render_window.py @@ -32,7 +32,7 @@ from utama_core.engine.match_log import load_jsonl from utama_core.entities.game import GameFrame from utama_core.replay.replay_player import load_frames_in_range -from utama_core.rsoccer_simulator.Render.utils import COLORS +from utama_core.simulator.render.utils import COLORS _FRIENDLY_COLOR = tuple(c / 255 for c in COLORS["YELLOW"]) _ENEMY_COLOR = tuple(c / 255 for c in COLORS["BLUE"]) diff --git a/utama_core/engine/abstract_strategy.py b/utama_core/engine/abstract_strategy.py index 58fd003f..ce0b20d9 100644 --- a/utama_core/engine/abstract_strategy.py +++ b/utama_core/engine/abstract_strategy.py @@ -28,7 +28,7 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.geometry.math_utils import assert_contains, assert_valid_bounding_box from utama_core.motion_planning.common.motion_controller import MotionController -from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.simulator.ssl.ssl_gym_base import SSLBaseEnv from utama_core.skills.utils.move_utils import empty_command from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, diff --git a/utama_core/motion_planning/common/motion_controller.py b/utama_core/motion_planning/common/motion_controller.py index 4b062780..5cd06270 100644 --- a/utama_core/motion_planning/common/motion_controller.py +++ b/utama_core/motion_planning/common/motion_controller.py @@ -8,7 +8,7 @@ PoseAhead, control_latency_s, ) -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv class MotionController(ABC): diff --git a/utama_core/motion_planning/controllers/dwa_controller.py b/utama_core/motion_planning/controllers/dwa_controller.py index 5e1b46f5..023343a9 100644 --- a/utama_core/motion_planning/controllers/dwa_controller.py +++ b/utama_core/motion_planning/controllers/dwa_controller.py @@ -7,7 +7,7 @@ DWATranslationController, ) from utama_core.motion_planning.pid import PID, get_pids -from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv +from utama_core.simulator.ssl.envs.standard_ssl import SSLStandardEnv class DWAController(MotionController): diff --git a/utama_core/motion_planning/controllers/fastpathplanning.py b/utama_core/motion_planning/controllers/fastpathplanning.py index 9917ce64..e083230b 100644 --- a/utama_core/motion_planning/controllers/fastpathplanning.py +++ b/utama_core/motion_planning/controllers/fastpathplanning.py @@ -4,7 +4,7 @@ from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.motion_planning.fastpathplanning.planner import FastPathPlanner from utama_core.motion_planning.pid.pid import get_pids -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv class FastPathPlanningController(MotionController): diff --git a/utama_core/motion_planning/controllers/pid_controller.py b/utama_core/motion_planning/controllers/pid_controller.py index ee5970c1..c30191a7 100644 --- a/utama_core/motion_planning/controllers/pid_controller.py +++ b/utama_core/motion_planning/controllers/pid_controller.py @@ -5,7 +5,7 @@ from utama_core.entities.game import Game from utama_core.motion_planning.common.motion_controller import MotionController from utama_core.motion_planning.pid.pid import get_pids -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv class PIDController(MotionController): diff --git a/utama_core/motion_planning/controllers/trajsampling.py b/utama_core/motion_planning/controllers/trajsampling.py index a89c48dc..b837a476 100644 --- a/utama_core/motion_planning/controllers/trajsampling.py +++ b/utama_core/motion_planning/controllers/trajsampling.py @@ -43,7 +43,7 @@ class of bug `TwoDPID.set_final_target` works around for FPP's carrot. from utama_core.motion_planning.pid.pid import get_pids from utama_core.motion_planning.trajsampling.config import trajsamplingconfig as config from utama_core.motion_planning.trajsampling.planner import TrajectorySamplingPlanner -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv _PARAMS_BY_MODE = {Mode.RSIM: RSIM_PARAMS, Mode.GRSIM: GRSIM_PARAMS, Mode.REAL: REAL_PARAMS} diff --git a/utama_core/motion_planning/dwa/planner.py b/utama_core/motion_planning/dwa/planner.py index 25df6fbe..a698119c 100644 --- a/utama_core/motion_planning/dwa/planner.py +++ b/utama_core/motion_planning/dwa/planner.py @@ -14,7 +14,7 @@ point_segment_distance, ) from utama_core.motion_planning.planning.obstacles import ObstacleRegion, to_rectangles -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv class DynamicWindowPlanner: diff --git a/utama_core/motion_planning/dwa/translation_controller.py b/utama_core/motion_planning/dwa/translation_controller.py index 07cd0c89..de9282f3 100644 --- a/utama_core/motion_planning/dwa/translation_controller.py +++ b/utama_core/motion_planning/dwa/translation_controller.py @@ -5,7 +5,7 @@ from utama_core.entities.game import Game from utama_core.motion_planning.common.acceleration_limiter import AccelerationLimiter from utama_core.motion_planning.dwa.config import DynamicWindowConfig -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.ssl.envs import SSLStandardEnv from .planner import DynamicWindowPlanner diff --git a/utama_core/motion_planning/fastpathplanning/planner.py b/utama_core/motion_planning/fastpathplanning/planner.py index 2f4a8eda..e08c56d8 100644 --- a/utama_core/motion_planning/fastpathplanning/planner.py +++ b/utama_core/motion_planning/fastpathplanning/planner.py @@ -33,7 +33,7 @@ scan_collides_nb, scan_find_subgoal_nb, ) -from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv +from utama_core.simulator.ssl.envs.standard_ssl import SSLStandardEnv try: from utama_core.motion_planning.fastpathplanning import _fastpathplanner diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index 4aa78765..f0cce7c6 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -70,7 +70,7 @@ # Code that runs but is not imported: `robosim_wrapper.py` starts it as a script in the # `robosim` pixi environment. -SUBPROCESS_SCRIPTS = ("utama_core.rsoccer_simulator.Simulators.robosim.robosim_subprocess",) +SUBPROCESS_SCRIPTS = ("utama_core.simulator.simulators.robosim.robosim_subprocess",) # Environment variables that change play: UTAMA_EXACT_MATH (`config/settings.py`) and the # thread/JIT knobs of numba and the BLAS numpy links against. diff --git a/utama_core/replay/replay_player.py b/utama_core/replay/replay_player.py index 39f962b3..953d0ce9 100644 --- a/utama_core/replay/replay_player.py +++ b/utama_core/replay/replay_player.py @@ -15,11 +15,11 @@ from utama_core.entities.game.mapping_utils import map_friendly_enemy_to_colors from utama_core.geometry.math_utils import rad_to_deg from utama_core.replay.entities import ReplayMetadata -from utama_core.rsoccer_simulator.Entities import Ball as RSoccerBall -from utama_core.rsoccer_simulator.Entities import Frame as RSoccerFrame -from utama_core.rsoccer_simulator.Entities import FrameSSL -from utama_core.rsoccer_simulator.Entities import Robot as RSoccerRobot -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.entities import Ball as RSoccerBall +from utama_core.simulator.entities import Frame as RSoccerFrame +from utama_core.simulator.entities import FrameSSL +from utama_core.simulator.entities import Robot as RSoccerRobot +from utama_core.simulator.ssl.envs import SSLStandardEnv logger = logging.getLogger(__name__) diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 8d5348cc..28383637 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -14,7 +14,7 @@ Coordinate frame: `GameFrame.friendly_robots`/`enemy_robots`/`ball` store positions in plain pitch-frame metres — the same frame `AbstractSimController.teleport_ball`/`teleport_robot` take directly (see -`utama_core/rsoccer_simulator/ssl/ssl_gym_base.py`'s `teleport_ball`/ +`utama_core/simulator/ssl/ssl_gym_base.py`'s `teleport_ball`/ `teleport_robot`, which do the y-flip into rsim's internal frame themselves; callers, including the teleport accuracy test in `utama_core/tests/run/test_teleport_position_accuracy.py`, pass diff --git a/utama_core/rsoccer_simulator/Entities/__init__.py b/utama_core/rsoccer_simulator/Entities/__init__.py deleted file mode 100644 index 7fea65bd..00000000 --- a/utama_core/rsoccer_simulator/Entities/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from utama_core.rsoccer_simulator.Entities.Ball import Ball -from utama_core.rsoccer_simulator.Entities.Field import Field -from utama_core.rsoccer_simulator.Entities.Frame import Frame, FrameSSL, FrameVSS -from utama_core.rsoccer_simulator.Entities.Robot import Robot diff --git a/utama_core/rsoccer_simulator/Render/__init__.py b/utama_core/rsoccer_simulator/Render/__init__.py deleted file mode 100644 index 95376852..00000000 --- a/utama_core/rsoccer_simulator/Render/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -from utama_core.rsoccer_simulator.Render.ball import RenderBall -from utama_core.rsoccer_simulator.Render.field import ( - Sim2DRenderField, - SSLRenderField, - VSSRenderField, -) -from utama_core.rsoccer_simulator.Render.overlay import RenderOverlay -from utama_core.rsoccer_simulator.Render.robot import ( - RenderSim2DRobot, - RenderSSLRobot, - RenderVSSRobot, -) -from utama_core.rsoccer_simulator.Render.utils import COLORS diff --git a/utama_core/rsoccer_simulator/Utils/__init__.py b/utama_core/rsoccer_simulator/Utils/__init__.py deleted file mode 100644 index bd0b51c1..00000000 --- a/utama_core/rsoccer_simulator/Utils/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from utama_core.rsoccer_simulator.Utils.kdtree import KDTree diff --git a/utama_core/rsoccer_simulator/ssl/envs/__init__.py b/utama_core/rsoccer_simulator/ssl/envs/__init__.py deleted file mode 100644 index 0770ac16..00000000 --- a/utama_core/rsoccer_simulator/ssl/envs/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from utama_core.rsoccer_simulator.ssl.envs.standard_ssl import SSLStandardEnv diff --git a/utama_core/run/game_gater.py b/utama_core/run/game_gater.py index 7441c77b..27c1f685 100644 --- a/utama_core/run/game_gater.py +++ b/utama_core/run/game_gater.py @@ -4,7 +4,7 @@ from utama_core.data_processing.refiners import PositionRefiner from utama_core.entities.data.raw_vision import RawVisionData from utama_core.entities.game.game_frame import GameFrame -from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.simulator.ssl.ssl_gym_base import SSLBaseEnv class GameGater: diff --git a/utama_core/run/sim_setup.py b/utama_core/run/sim_setup.py index 957ecce7..834a4122 100644 --- a/utama_core/run/sim_setup.py +++ b/utama_core/run/sim_setup.py @@ -25,8 +25,8 @@ from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.referee import CustomReferee from utama_core.referee.profiles.profile_loader import load_profile -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner +from utama_core.simulator.utils.sim_noise import SimNoise from utama_core.strategy import catalog N_OUTFIELD = 5 # + 1 goalkeeper per side diff --git a/utama_core/run/strategy_runner.py b/utama_core/run/strategy_runner.py index da82033d..9797ae96 100644 --- a/utama_core/run/strategy_runner.py +++ b/utama_core/run/strategy_runner.py @@ -57,9 +57,6 @@ ) from utama_core.replay.game_log_writer import GameLogWriter, code_version from utama_core.replay.replay_writer import ReplayWriter, ReplayWriterConfig -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run import GameGater from utama_core.run.field_check import LOOP_STALL_S, FieldCheck from utama_core.run.field_fence import FencedRobotController, inner_edges @@ -75,6 +72,9 @@ ) from utama_core.run.vision_stream import GameFrameRenderer, RSimVisionStreamServer from utama_core.run.vision_stream_status import VisionStreamStatusMixin +from utama_core.simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.utils.gaussian_noise import RsimGaussianNoise +from utama_core.simulator.utils.sim_noise import SimNoise from utama_core.skills.shielding import reset_shield_state from utama_core.strategy.pickers import reset_closer_to_ball_state from utama_core.team_controller.controllers import ( @@ -281,7 +281,7 @@ class StrategyRunner(SimRecoveryMixin, VisionStreamStatusMixin, LiveStatusMixin) Defaults to 0. sim_noise (SimNoise, optional): When running in rsim, seeded latency, kick and ball physics, motion limits and vision noise - (`utama_core/rsoccer_simulator/Utils/sim_noise.py`); replaces `rsim_noise` and `rsim_vanishing`. + (`utama_core/simulator/utils/sim_noise.py`); replaces `rsim_noise` and `rsim_vanishing`. Recorded in a columnar replay. Defaults to None (off). filtering (bool, optional): Turn on Kalman smoothing and vanished-robot imputation. Defaults to True. referee (RefereeSource, optional): Referee source. Pass a ``CustomReferee`` diff --git a/utama_core/run/vision_stream.py b/utama_core/run/vision_stream.py index c61f36d6..5a0dea8f 100644 --- a/utama_core/run/vision_stream.py +++ b/utama_core/run/vision_stream.py @@ -36,7 +36,7 @@ class GameFrameRenderer: def __init__(self, field_dims, scale: float = 100.0) -> None: import pygame - from utama_core.rsoccer_simulator.Render import SSLRenderField + from utama_core.simulator.render import SSLRenderField self._pygame = pygame self._field_renderer = SSLRenderField( @@ -61,11 +61,7 @@ def __init__(self, field_dims, scale: float = 100.0) -> None: def render(self, game_frame, friendly_color=None, enemy_color=None) -> np.ndarray: """Render a `GameFrame` into an RGB numpy array.""" - from utama_core.rsoccer_simulator.Render import ( - COLORS, - RenderBall, - RenderSSLRobot, - ) + from utama_core.simulator.render import COLORS, RenderBall, RenderSSLRobot if friendly_color is None: friendly_color = COLORS["YELLOW"] if game_frame.my_team_is_yellow else COLORS["BLUE"] diff --git a/utama_core/rsoccer_simulator/.gitignore b/utama_core/simulator/.gitignore similarity index 100% rename from utama_core/rsoccer_simulator/.gitignore rename to utama_core/simulator/.gitignore diff --git a/utama_core/rsoccer_simulator/LICENSE b/utama_core/simulator/LICENSE similarity index 100% rename from utama_core/rsoccer_simulator/LICENSE rename to utama_core/simulator/LICENSE diff --git a/utama_core/rsoccer_simulator/README.md b/utama_core/simulator/README.md similarity index 98% rename from utama_core/rsoccer_simulator/README.md rename to utama_core/simulator/README.md index 744a8d3c..6804c4e6 100644 --- a/utama_core/rsoccer_simulator/README.md +++ b/utama_core/simulator/README.md @@ -87,7 +87,7 @@ def teleport_robot( Functions used to draw points/lines/polygons of interest. Used for visualisation and debugging. Note that these are also sent together with robot commands ONLY at the end of the frame. -For the list of available colours, see `rsoccer_simulator/Render/utils.py`. +For the list of available colours, see `simulator/render/utils.py`. #### Draw Point diff --git a/utama_core/rsoccer_simulator/__init__.py b/utama_core/simulator/__init__.py similarity index 100% rename from utama_core/rsoccer_simulator/__init__.py rename to utama_core/simulator/__init__.py diff --git a/utama_core/rsoccer_simulator/Entities/Ball.py b/utama_core/simulator/entities/Ball.py similarity index 73% rename from utama_core/rsoccer_simulator/Entities/Ball.py rename to utama_core/simulator/entities/Ball.py index f1db504a..b680cde6 100644 --- a/utama_core/rsoccer_simulator/Entities/Ball.py +++ b/utama_core/simulator/entities/Ball.py @@ -2,7 +2,7 @@ from numpy.random import normal -from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.simulator.utils.gaussian_noise import RsimGaussianNoise @dataclass() diff --git a/utama_core/rsoccer_simulator/Entities/Field.py b/utama_core/simulator/entities/Field.py similarity index 100% rename from utama_core/rsoccer_simulator/Entities/Field.py rename to utama_core/simulator/entities/Field.py diff --git a/utama_core/rsoccer_simulator/Entities/Frame.py b/utama_core/simulator/entities/Frame.py similarity index 96% rename from utama_core/rsoccer_simulator/Entities/Frame.py rename to utama_core/simulator/entities/Frame.py index ef29e261..b7f4701a 100644 --- a/utama_core/rsoccer_simulator/Entities/Frame.py +++ b/utama_core/simulator/entities/Frame.py @@ -1,7 +1,7 @@ from typing import Dict -from utama_core.rsoccer_simulator.Entities.Ball import Ball -from utama_core.rsoccer_simulator.Entities.Robot import Robot +from utama_core.simulator.entities.Ball import Ball +from utama_core.simulator.entities.Robot import Robot class Frame: diff --git a/utama_core/rsoccer_simulator/Entities/Robot.py b/utama_core/simulator/entities/Robot.py similarity index 100% rename from utama_core/rsoccer_simulator/Entities/Robot.py rename to utama_core/simulator/entities/Robot.py diff --git a/utama_core/simulator/entities/__init__.py b/utama_core/simulator/entities/__init__.py new file mode 100644 index 00000000..d1f074dd --- /dev/null +++ b/utama_core/simulator/entities/__init__.py @@ -0,0 +1,4 @@ +from utama_core.simulator.entities.Ball import Ball +from utama_core.simulator.entities.Field import Field +from utama_core.simulator.entities.Frame import Frame, FrameSSL, FrameVSS +from utama_core.simulator.entities.Robot import Robot diff --git a/utama_core/simulator/render/__init__.py b/utama_core/simulator/render/__init__.py new file mode 100644 index 00000000..716b5b5e --- /dev/null +++ b/utama_core/simulator/render/__init__.py @@ -0,0 +1,13 @@ +from utama_core.simulator.render.ball import RenderBall +from utama_core.simulator.render.field import ( + Sim2DRenderField, + SSLRenderField, + VSSRenderField, +) +from utama_core.simulator.render.overlay import RenderOverlay +from utama_core.simulator.render.robot import ( + RenderSim2DRobot, + RenderSSLRobot, + RenderVSSRobot, +) +from utama_core.simulator.render.utils import COLORS diff --git a/utama_core/rsoccer_simulator/Render/ball.py b/utama_core/simulator/render/ball.py similarity index 88% rename from utama_core/rsoccer_simulator/Render/ball.py rename to utama_core/simulator/render/ball.py index 7cbc3f42..ad0dcb4a 100644 --- a/utama_core/rsoccer_simulator/Render/ball.py +++ b/utama_core/simulator/render/ball.py @@ -1,6 +1,6 @@ import pygame -from utama_core.rsoccer_simulator.Render.utils import COLORS +from utama_core.simulator.render.utils import COLORS class RenderBall: diff --git a/utama_core/rsoccer_simulator/Render/field.py b/utama_core/simulator/render/field.py similarity index 99% rename from utama_core/rsoccer_simulator/Render/field.py rename to utama_core/simulator/render/field.py index 5a5dbf5a..95feeba3 100644 --- a/utama_core/rsoccer_simulator/Render/field.py +++ b/utama_core/simulator/render/field.py @@ -1,6 +1,6 @@ import pygame -from utama_core.rsoccer_simulator.Render.utils import COLORS +from utama_core.simulator.render.utils import COLORS class RenderField: diff --git a/utama_core/rsoccer_simulator/Render/overlay.py b/utama_core/simulator/render/overlay.py similarity index 95% rename from utama_core/rsoccer_simulator/Render/overlay.py rename to utama_core/simulator/render/overlay.py index d20982a2..53bd358b 100644 --- a/utama_core/rsoccer_simulator/Render/overlay.py +++ b/utama_core/simulator/render/overlay.py @@ -3,7 +3,7 @@ import pygame -from utama_core.rsoccer_simulator.Render.utils import COLORS +from utama_core.simulator.render.utils import COLORS class OverlayType(Enum): diff --git a/utama_core/rsoccer_simulator/Render/robot.py b/utama_core/simulator/render/robot.py similarity index 98% rename from utama_core/rsoccer_simulator/Render/robot.py rename to utama_core/simulator/render/robot.py index 91c6bd9d..65a3b08b 100644 --- a/utama_core/rsoccer_simulator/Render/robot.py +++ b/utama_core/simulator/render/robot.py @@ -1,7 +1,7 @@ import numpy as np import pygame -from utama_core.rsoccer_simulator.Render.utils import COLORS, TAG_ID_COLORS +from utama_core.simulator.render.utils import COLORS, TAG_ID_COLORS class RenderRobot: diff --git a/utama_core/rsoccer_simulator/Render/utils.py b/utama_core/simulator/render/utils.py similarity index 100% rename from utama_core/rsoccer_simulator/Render/utils.py rename to utama_core/simulator/render/utils.py diff --git a/utama_core/rsoccer_simulator/Simulators/__init__.py b/utama_core/simulator/simulators/__init__.py similarity index 100% rename from utama_core/rsoccer_simulator/Simulators/__init__.py rename to utama_core/simulator/simulators/__init__.py diff --git a/utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py b/utama_core/simulator/simulators/robosim/robosim_subprocess.py similarity index 100% rename from utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py rename to utama_core/simulator/simulators/robosim/robosim_subprocess.py diff --git a/utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py b/utama_core/simulator/simulators/robosim/robosim_wrapper.py similarity index 100% rename from utama_core/rsoccer_simulator/Simulators/robosim/robosim_wrapper.py rename to utama_core/simulator/simulators/robosim/robosim_wrapper.py diff --git a/utama_core/rsoccer_simulator/Simulators/rsim.py b/utama_core/simulator/simulators/rsim.py similarity index 97% rename from utama_core/rsoccer_simulator/Simulators/rsim.py rename to utama_core/simulator/simulators/rsim.py index 07d1a0d1..79ddc502 100644 --- a/utama_core/rsoccer_simulator/Simulators/rsim.py +++ b/utama_core/simulator/simulators/rsim.py @@ -2,8 +2,8 @@ import numpy as np -from utama_core.rsoccer_simulator.Entities import Field, Frame, FrameSSL -from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( +from utama_core.simulator.entities import Field, Frame, FrameSSL +from utama_core.simulator.simulators.robosim.robosim_wrapper import ( RSimSubprocessWrapper, acquire_simulator, ) diff --git a/utama_core/rsoccer_simulator/ssl/__init__.py b/utama_core/simulator/ssl/__init__.py similarity index 100% rename from utama_core/rsoccer_simulator/ssl/__init__.py rename to utama_core/simulator/ssl/__init__.py diff --git a/utama_core/simulator/ssl/envs/__init__.py b/utama_core/simulator/ssl/envs/__init__.py new file mode 100644 index 00000000..5e819123 --- /dev/null +++ b/utama_core/simulator/ssl/envs/__init__.py @@ -0,0 +1 @@ +from utama_core.simulator.ssl.envs.standard_ssl import SSLStandardEnv diff --git a/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py b/utama_core/simulator/ssl/envs/standard_ssl.py similarity index 98% rename from utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py rename to utama_core/simulator/ssl/envs/standard_ssl.py index 08dcc940..97c8affb 100644 --- a/utama_core/rsoccer_simulator/ssl/envs/standard_ssl.py +++ b/utama_core/simulator/ssl/envs/standard_ssl.py @@ -17,11 +17,11 @@ from utama_core.entities.data.raw_vision import RawBallData, RawRobotData, RawVisionData from utama_core.entities.data.referee import RefereeData from utama_core.geometry.math_utils import deg_to_rad, normalise_heading_deg, rad_to_deg -from utama_core.rsoccer_simulator.Entities import Ball, Frame, Robot -from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv -from utama_core.rsoccer_simulator.Utils import KDTree -from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.Utils.sim_noise import ( +from utama_core.simulator.entities import Ball, Frame, Robot +from utama_core.simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.simulator.utils import KDTree +from utama_core.simulator.utils.gaussian_noise import RsimGaussianNoise +from utama_core.simulator.utils.sim_noise import ( CommandDelay, KickAngleNoise, KickSpeedNoise, diff --git a/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py b/utama_core/simulator/ssl/ssl_gym_base.py similarity index 97% rename from utama_core/rsoccer_simulator/ssl/ssl_gym_base.py rename to utama_core/simulator/ssl/ssl_gym_base.py index 4dc5e948..22cae4f4 100644 --- a/utama_core/rsoccer_simulator/ssl/ssl_gym_base.py +++ b/utama_core/simulator/ssl/ssl_gym_base.py @@ -11,19 +11,19 @@ import pygame from utama_core.geometry.math_utils import rad_to_deg -from utama_core.rsoccer_simulator.Entities import Ball, Field, Frame, Robot -from utama_core.rsoccer_simulator.Render import ( +from utama_core.simulator.entities import Ball, Field, Frame, Robot +from utama_core.simulator.render import ( COLORS, RenderBall, RenderSSLRobot, SSLRenderField, ) -from utama_core.rsoccer_simulator.Render.overlay import ( +from utama_core.simulator.render.overlay import ( OverlayObject, OverlayType, RenderOverlay, ) -from utama_core.rsoccer_simulator.Simulators.rsim import RSimSSL +from utama_core.simulator.simulators.rsim import RSimSSL class SSLBaseEnv: diff --git a/utama_core/simulator/utils/__init__.py b/utama_core/simulator/utils/__init__.py new file mode 100644 index 00000000..49192db1 --- /dev/null +++ b/utama_core/simulator/utils/__init__.py @@ -0,0 +1 @@ +from utama_core.simulator.utils.kdtree import KDTree diff --git a/utama_core/rsoccer_simulator/Utils/gaussian_noise.py b/utama_core/simulator/utils/gaussian_noise.py similarity index 100% rename from utama_core/rsoccer_simulator/Utils/gaussian_noise.py rename to utama_core/simulator/utils/gaussian_noise.py diff --git a/utama_core/rsoccer_simulator/Utils/kdtree.py b/utama_core/simulator/utils/kdtree.py similarity index 100% rename from utama_core/rsoccer_simulator/Utils/kdtree.py rename to utama_core/simulator/utils/kdtree.py diff --git a/utama_core/rsoccer_simulator/Utils/sim_noise.py b/utama_core/simulator/utils/sim_noise.py similarity index 99% rename from utama_core/rsoccer_simulator/Utils/sim_noise.py rename to utama_core/simulator/utils/sim_noise.py index 1a94d59c..18d547ef 100644 --- a/utama_core/rsoccer_simulator/Utils/sim_noise.py +++ b/utama_core/simulator/utils/sim_noise.py @@ -26,7 +26,7 @@ import numpy as np -from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise +from utama_core.simulator.utils.gaussian_noise import RsimGaussianNoise COLOURS = ("team_blue", "team_yellow") diff --git a/utama_core/team_controller/controllers/sim/rsim_controller.py b/utama_core/team_controller/controllers/sim/rsim_controller.py index ded588c9..296ec482 100644 --- a/utama_core/team_controller/controllers/sim/rsim_controller.py +++ b/utama_core/team_controller/controllers/sim/rsim_controller.py @@ -2,7 +2,7 @@ from utama_core.config.settings import ADD_Y_COORD, REMOVAL_Y_COORD, TELEPORT_X_COORDS from utama_core.entities.game.field import FieldBounds -from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.simulator.ssl.ssl_gym_base import SSLBaseEnv from utama_core.team_controller.controllers.common.sim_controller_abstract import ( AbstractSimController, ) diff --git a/utama_core/team_controller/controllers/sim/rsim_robot_controller.py b/utama_core/team_controller/controllers/sim/rsim_robot_controller.py index 2c09d39a..f6b7aaf3 100644 --- a/utama_core/team_controller/controllers/sim/rsim_robot_controller.py +++ b/utama_core/team_controller/controllers/sim/rsim_robot_controller.py @@ -5,7 +5,7 @@ from numpy.typing import NDArray from utama_core.entities.data.command import RobotCommand, RobotResponse -from utama_core.rsoccer_simulator.ssl.ssl_gym_base import SSLBaseEnv +from utama_core.simulator.ssl.ssl_gym_base import SSLBaseEnv from utama_core.team_controller.controllers.common.robot_controller_abstract import ( AbstractRobotController, ) diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 013ff3bd..b161d526 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -83,7 +83,7 @@ def test_the_players_load_and_the_core_is_in_the_catalog(): def test_the_reference_world_and_robots_make_one_valid_sim_noise(): from tools.evaluation.sim_settings import reference_noise - from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise + from utama_core.simulator.utils.sim_noise import SimNoise noise = SimNoise.from_dict(reference_noise(seed=3)) assert noise.seed == 3 @@ -103,7 +103,7 @@ def test_every_reference_setting_names_its_source(): def test_the_reference_sim_does_not_draw_robot_motor_limits(): """Acceleration is the command cap; a per-match draw would be a robot capability as noise.""" from tools.evaluation.sim_settings import reference_noise - from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise + from utama_core.simulator.utils.sim_noise import SimNoise assert not SimNoise.from_dict(reference_noise()).motion_limits diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index aba698c4..ae295ad6 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -93,7 +93,7 @@ def c(ids): "utama_core/skills/aim.py": "def aim():\n return 0\n", "utama_core/tactics/defend.py": "class DefendTactic:\n pass\n", "utama_core/tactics/unused.py": 'class UnusedTactic:\n pass\n\n\nif __name__ == "__main__":\n print(1)\n', - "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py": "import json\n", + "utama_core/simulator/simulators/robosim/robosim_subprocess.py": "import json\n", } CONFIGS = ["a", "b", "c"] @@ -104,7 +104,7 @@ def repo(tmp_path: Path) -> Path: path = tmp_path / rel path.parent.mkdir(parents=True, exist_ok=True) path.write_text(text) - for pkg in ("utama_core/rsoccer_simulator", "utama_core/rsoccer_simulator"): + for pkg in ("utama_core/simulator", "utama_core/simulator"): (tmp_path / pkg / "__init__.py").write_text("") return tmp_path @@ -238,7 +238,7 @@ def test_a_compiled_planner_counts_for_the_players_that_load_it_and_not_the_base def test_the_rsim_subprocess_script_and_data_files_are_in_the_base(repo): - rel = "utama_core/rsoccer_simulator/Simulators/robosim/robosim_subprocess.py" + rel = "utama_core/simulator/simulators/robosim/robosim_subprocess.py" assert _changed_after(repo, rel, "import json", "import json, struct") == {"base"} assert _changed_after(repo, "utama_core/profiles/sim.yaml", "speed: 1", "speed: 2") == {"base"} @@ -412,12 +412,12 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "utama_core.bundle.archive", "utama_core.bundle.strategy_file", "utama_core.config.settings", - "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", + "utama_core.simulator.simulators.robosim.robosim_wrapper", ], "dynamic import": ["utama_core.strategy.catalog"], "module-level state": [ "utama_core.motion_planning.fastpathplanning.planner", - "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", + "utama_core.simulator.simulators.robosim.robosim_wrapper", "utama_core.geometry.pass_and_score_geometry", "utama_core.skills.shielding", "utama_core.strategy.pickers", @@ -438,7 +438,7 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): "subprocess": [ "utama_core.bundle.strategy_file", "utama_core.replay.game_log_writer", - "utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper", + "utama_core.simulator.simulators.robosim.robosim_wrapper", ], } diff --git a/utama_core/tests/replay/test_repro_summary.py b/utama_core/tests/replay/test_repro_summary.py index 5cc1753b..4bfe2bf4 100644 --- a/utama_core/tests/replay/test_repro_summary.py +++ b/utama_core/tests/replay/test_repro_summary.py @@ -79,7 +79,7 @@ def test_format_caps_the_lines_and_counts_the_rest(): def test_resolve_sim_noise_uses_the_replays_own_settings_by_default(): - from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise + from utama_core.simulator.utils.sim_noise import SimNoise settings = SimNoise(seed=2, latency_s=(0.03, 0.15), kick_speed_sd=0.45).to_dict() noise, line = repro.resolve_sim_noise(None, {"settings": settings, "draw": {}}) @@ -109,7 +109,7 @@ def test_the_replays_stored_settings_redraw_the_same_robots(): """The repro's draw is `SimNoise.draw` on the stored settings, so with the same robot counts and time step it is the match's own draw: latency ticks and kick offsets per robot, exactly.""" from utama_core.config.settings import TIMESTEP - from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise + from utama_core.simulator.utils.sim_noise import SimNoise noise = SimNoise(seed=2, latency_s=(0.03, 0.15), kick_speed_offset_sd=0.2, max_accel=(1.5, 3.5)) counts = {"team_blue": 6, "team_yellow": 6} diff --git a/utama_core/tests/run/test_scenario_hooks.py b/utama_core/tests/run/test_scenario_hooks.py index fd273aec..d227f19d 100644 --- a/utama_core/tests/run/test_scenario_hooks.py +++ b/utama_core/tests/run/test_scenario_hooks.py @@ -3,8 +3,8 @@ from utama_core.entities.game.game_frame import GameFrame from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.referee import CustomReferee -from utama_core.rsoccer_simulator.ssl import ssl_gym_base from utama_core.run.strategy_runner import StrategyRunner +from utama_core.simulator.ssl import ssl_gym_base def test_strategy_runner_step_once_delegates_to_single_step_loop(): diff --git a/utama_core/tests/run/test_sim_pose_ahead.py b/utama_core/tests/run/test_sim_pose_ahead.py index 8199899d..1ecc61dc 100644 --- a/utama_core/tests/run/test_sim_pose_ahead.py +++ b/utama_core/tests/run/test_sim_pose_ahead.py @@ -9,8 +9,8 @@ from utama_core.motion_planning.controllers.fastpathplanning import ( FastPathPlanningController, ) -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise from utama_core.run.strategy_runner import StrategyRunner +from utama_core.simulator.utils.sim_noise import SimNoise TEAM = SimpleNamespace(motion_controller=FastPathPlanningController) diff --git a/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py b/utama_core/tests/simulator/test_dribble_with_friction.py similarity index 96% rename from utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py rename to utama_core/tests/simulator/test_dribble_with_friction.py index 9e08a5d3..34fd5f50 100644 --- a/utama_core/tests/rsoccer_simulator/test_dribble_with_friction.py +++ b/utama_core/tests/simulator/test_dribble_with_friction.py @@ -14,8 +14,8 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.Utils.sim_noise import SimNoise +from utama_core.simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.utils.sim_noise import SimNoise TICK = 1 / 60 FRONT = 0.1 # the ball's centre, this far in front of the robot's centre, is in the kicker diff --git a/utama_core/tests/rsoccer_simulator/test_render_overlay.py b/utama_core/tests/simulator/test_render_overlay.py similarity index 96% rename from utama_core/tests/rsoccer_simulator/test_render_overlay.py rename to utama_core/tests/simulator/test_render_overlay.py index 52faceaf..98276f77 100644 --- a/utama_core/tests/rsoccer_simulator/test_render_overlay.py +++ b/utama_core/tests/simulator/test_render_overlay.py @@ -1,6 +1,6 @@ from unittest.mock import patch -from utama_core.rsoccer_simulator.Render.overlay import ( +from utama_core.simulator.render.overlay import ( OverlayObject, OverlayType, RenderOverlay, diff --git a/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py b/utama_core/tests/simulator/test_robosim_wrapper.py similarity index 96% rename from utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py rename to utama_core/tests/simulator/test_robosim_wrapper.py index 889f604b..b07afab7 100644 --- a/utama_core/tests/rsoccer_simulator/test_robosim_wrapper.py +++ b/utama_core/tests/simulator/test_robosim_wrapper.py @@ -3,7 +3,7 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.Simulators.robosim.robosim_wrapper import ( +from utama_core.simulator.simulators.robosim.robosim_wrapper import ( RSimSubprocessWrapper, ) @@ -131,7 +131,7 @@ def test_reused_sim_plays_exactly_as_a_fresh_one(monkeypatch): """With reuse on, closing a sim parks its subprocess and the next `acquire` hands it back with a new native world: a play after a different, messy play (ball kicked away, robots fast and turned, dribblers spinning) must be bit-identical to the same play in a fresh subprocess.""" - from utama_core.rsoccer_simulator.Simulators.robosim import robosim_wrapper as rw + from utama_core.simulator.simulators.robosim import robosim_wrapper as rw monkeypatch.setattr(rw, "_reuse_sims", True) monkeypatch.setattr(rw, "_idle_sims", {}) @@ -160,7 +160,7 @@ def test_reused_sim_plays_exactly_as_a_fresh_one(monkeypatch): def test_sim_whose_request_failed_is_not_parked_for_reuse(monkeypatch): """A request that failed part-way may have left the pipe out of step, so that sim is terminated.""" - from utama_core.rsoccer_simulator.Simulators.robosim import robosim_wrapper as rw + from utama_core.simulator.simulators.robosim import robosim_wrapper as rw monkeypatch.setattr(rw, "_reuse_sims", True) monkeypatch.setattr(rw, "_idle_sims", {}) diff --git a/utama_core/tests/rsoccer_simulator/test_sim_noise.py b/utama_core/tests/simulator/test_sim_noise.py similarity index 95% rename from utama_core/tests/rsoccer_simulator/test_sim_noise.py rename to utama_core/tests/simulator/test_sim_noise.py index 4ab5b41b..bf6463cc 100644 --- a/utama_core/tests/rsoccer_simulator/test_sim_noise.py +++ b/utama_core/tests/simulator/test_sim_noise.py @@ -3,13 +3,9 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.Utils.gaussian_noise import RsimGaussianNoise -from utama_core.rsoccer_simulator.Utils.sim_noise import ( - CommandDelay, - KickSpeedNoise, - SimNoise, -) +from utama_core.simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.utils.gaussian_noise import RsimGaussianNoise +from utama_core.simulator.utils.sim_noise import CommandDelay, KickSpeedNoise, SimNoise N = {"team_blue": 2, "team_yellow": 2} TICK = 1 / 60 diff --git a/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py b/utama_core/tests/simulator/test_sim_physics_knobs.py similarity index 98% rename from utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py rename to utama_core/tests/simulator/test_sim_physics_knobs.py index 16eb75a5..6e6d9a77 100644 --- a/utama_core/tests/rsoccer_simulator/test_sim_physics_knobs.py +++ b/utama_core/tests/simulator/test_sim_physics_knobs.py @@ -11,9 +11,9 @@ import numpy as np import pytest -from utama_core.rsoccer_simulator.Entities import Robot -from utama_core.rsoccer_simulator.ssl.envs import SSLStandardEnv -from utama_core.rsoccer_simulator.Utils.sim_noise import ( +from utama_core.simulator.entities import Robot +from utama_core.simulator.ssl.envs import SSLStandardEnv +from utama_core.simulator.utils.sim_noise import ( KickAngleNoise, MotionLimits, SimDraw, diff --git a/vendor/rSim/FORK_NOTES.md b/vendor/rSim/FORK_NOTES.md index d4700af9..25b1506f 100644 --- a/vendor/rSim/FORK_NOTES.md +++ b/vendor/rSim/FORK_NOTES.md @@ -246,7 +246,7 @@ cmake --build build/rsim-py310 -j2 mkdir -p build/rsim-override/robosim echo "from ._robosim import SSL, VSS" > build/rsim-override/robosim/__init__.py ln -s $(pwd)/build/rsim-py310/_robosim.cpython-310-x86_64-linux-gnu.so build/rsim-override/robosim/ -PYTHONPATH=$(pwd)/build/rsim-override pixi run pytest utama_core/tests/rsoccer_simulator --headless +PYTHONPATH=$(pwd)/build/rsim-override pixi run pytest utama_core/tests/simulator --headless ``` Installing for everyone is then a copy of that `.so` over From e6e517ac970b42d7dd36b124a8391d2f1aee49c7 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:37:15 +0000 Subject: [PATCH 45/59] docs: stale script references; demo_pendulum_match Co-Authored-By: Claude Haiku 5.5 --- docs/field_log_replay.md | 2 +- docs/field_logs.md | 2 +- examples/demo_exhibition_road.py | 2 +- examples/{demo_split_shape_match.py => demo_pendulum_match.py} | 2 +- utama_core/engine/match_stats.py | 2 ++ 5 files changed, 6 insertions(+), 4 deletions(-) rename examples/{demo_split_shape_match.py => demo_pendulum_match.py} (97%) diff --git a/docs/field_log_replay.md b/docs/field_log_replay.md index 203aeaab..053846ec 100644 --- a/docs/field_log_replay.md +++ b/docs/field_log_replay.md @@ -32,7 +32,7 @@ Missing: - a per-tick view that sets the raw camera, the refined world and the command side by side; - rerunning the decision code on the recorded inputs. -## The tool: `tools/field_replay.py` +## The tool (not built yet) Three subcommands, each one step of the loop. diff --git a/docs/field_logs.md b/docs/field_logs.md index 1d806211..3f5afdc2 100644 --- a/docs/field_logs.md +++ b/docs/field_logs.md @@ -45,7 +45,7 @@ pixi run python tools/field/robot_calibration.py replays/field/.log.gz - **Dribbler Retention**: Sustained carry velocity and turn rate caps before the ball escapes (0.3 m/s, 0.6 rad/s). - **Output**: Writes `.calibration.json`. -### Tag Alignment Calibration (`tools/tag_calibration.py`) +### Tag Alignment Calibration (`utama_core/analysis/tag_calibration.py`) Measures optical tag placement relative to the chassis center: ```bash pixi run python -m utama_core.analysis.tag_calibration replays/field/.log.gz diff --git a/examples/demo_exhibition_road.py b/examples/demo_exhibition_road.py index 320d07bc..c9581418 100644 --- a/examples/demo_exhibition_road.py +++ b/examples/demo_exhibition_road.py @@ -8,7 +8,7 @@ What it does: - Uses GREAT_EXHIBITION_FIELD_DIMS (4 m × 3 m) — the compact field sized for the Exhibition Road festival venue. - - Builds a custom RefereeProfile inline (same style as Utama-Strategy/main.py) + - Builds a custom RefereeProfile inline (same style as `main.py`, run with `pixi run main` in this repo) with all rules enabled and human-operator auto-advance settings so a festival steward can control the game from the browser GUI. - 2v2 format: two yellow robots vs two blue robots, matching the small field. diff --git a/examples/demo_split_shape_match.py b/examples/demo_pendulum_match.py similarity index 97% rename from examples/demo_split_shape_match.py rename to examples/demo_pendulum_match.py index e50986be..ba34e0b9 100644 --- a/examples/demo_split_shape_match.py +++ b/examples/demo_pendulum_match.py @@ -1,5 +1,5 @@ # ruff: noqa: E402 -"""Visible grsim 6v6: both teams run the split-shape kernel Strategy against each other. +"""Visible grsim 6v6: both teams run the pendulum Strategy against each other. Not a test — a manual/visual smoke run for reviewing LeadAndSupportTactic / ShadowAndMarkTactic / the possession-split picker actually contesting an diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index cbe6f33e..170cab9d 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -53,6 +53,8 @@ gives post-match tooling that signal directly from `MatchStats` without a replay re-trace. See `MatchStats.pass_distances_m`'s docstring for the exact definitions and `_record_pass_quality` for where they're computed. + +`tools/metric_correlation.py`, cited below, was deleted on 2026-11-12; it is in git history. """ from __future__ import annotations From 5e3022b86c715c298866698b4fd70617c7d1433f Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 20:53:29 +0000 Subject: [PATCH 46/59] dashboard: the Tournament tab becomes the Strategies tab Every catalog strategy with its description, file, role, tactics, verdicts, per-match signals beside the other strategies' average, and its matches with replay links; every evaluation run with its verdicts first, then the health check and the matches per round. Standings are gone: the verdict is the only ranking. Frozen .strategy files and pre-rename names show as the catalog name. Co-Authored-By: Claude Opus 5.5 --- docs/first_strategy.md | 4 + docs/roadmap.md | 2 +- docs/tools.md | 4 +- utama_core/dashboard/__main__.py | 6 +- utama_core/dashboard/page.py | 2 +- utama_core/dashboard/server.py | 8 +- utama_core/dashboard/static/app.css | 20 + utama_core/dashboard/static/app.js | 4 +- utama_core/dashboard/static/index.html | 8 +- utama_core/dashboard/static/replay.js | 2 +- utama_core/dashboard/static/strategies.js | 353 ++++++++++++++++ utama_core/dashboard/static/tournament.js | 397 ------------------ utama_core/dashboard/views/strategies.py | 306 ++++++++++++++ utama_core/dashboard/views/tournament.py | 68 --- .../tests/dashboard/test_strategies_view.py | 136 ++++++ .../tests/dashboard/test_tournament_view.py | 52 --- 16 files changed, 837 insertions(+), 535 deletions(-) create mode 100644 utama_core/dashboard/static/strategies.js delete mode 100644 utama_core/dashboard/static/tournament.js create mode 100644 utama_core/dashboard/views/strategies.py delete mode 100644 utama_core/dashboard/views/tournament.py create mode 100644 utama_core/tests/dashboard/test_strategies_view.py delete mode 100644 utama_core/tests/dashboard/test_tournament_view.py diff --git a/docs/first_strategy.md b/docs/first_strategy.md index 703d19dd..b2128f60 100644 --- a/docs/first_strategy.md +++ b/docs/first_strategy.md @@ -165,6 +165,10 @@ Read two things: Ignore everything else in the output for now. +To see it all in a browser, run `pixi run dashboard` and open http://localhost:8080. +The **Strategies** tab shows every strategy: what it does, its verdicts, how it plays and its matches. +Click ▶ on a match to watch its replay. + ## 9. Now let an agent write one You know how a strategy works now. A coding agent (like Claude Code) can write and test new ones diff --git a/docs/roadmap.md b/docs/roadmap.md index 0109f77f..e650adb7 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -17,7 +17,7 @@ entry by its title, not its number. - **Goalkeeper overshoot** — `a4df59e`, `ba59c9e`. - **Stuck-match root causes** — `PressAndContainTactic` loose ball, `GiveAndGoTactic` hop timeout — `d6b3ff1`. - **Defense-area retrieval stall** — `7a8e717`; trajsample equivalent in `TrajectorySamplingPlanner._enemy_defense_area_retrieval_exempt`. -- **Dashboard rebuild** — Live/Replay/Tournament views — `c3c389e`. +- **Dashboard rebuild** — Live/Replay/Tournament views — `c3c389e`. The Tournament tab became the Strategies tab on 2026-11-12 (catalog, verdicts, signals, matches; no standings). - **Touchline avoidance + placement-into-defense-area stall** — `3513c59`. - **SSL §8.3/8.4 audit + 7 referee rules** — `434ab29`. - **Restart formations read real goalkeeper id; `referee_overrides` hook** — `7cd1f61`. diff --git a/docs/tools.md b/docs/tools.md index ade0b24f..52e4ca69 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -12,7 +12,7 @@ New to the repo? You need only these ([first_strategy.md](first_strategy.md) wal | `pixi run main A B` | Watch strategy A (yellow) play strategy B in the simulator | | `pixi run test`, `pixi run lint` | Check nothing broke, before every pull request | | `pixi run evaluate NAME` | Is strategy NAME better than the champion? Read the verdict and the mean diff | -| `pixi run dashboard` | Browse recorded replays at http://localhost:8080 | +| `pixi run dashboard` | http://localhost:8080: the Strategies tab (every strategy, its tactics, verdicts, signals and matches; every evaluation run) and recorded replays | Everything below is for specialists. @@ -70,7 +70,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | | `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `utama_core/run/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | -| `utama_core/dashboard/__main__.py` | `pixi run dashboard`: standalone browser dashboard at http://localhost:8080: recorded replays and run results | +| `utama_core/dashboard/__main__.py` | `pixi run dashboard`: standalone browser dashboard at http://localhost:8080: Strategies tab (`dashboard/views/strategies.py`) and Replay tab | ## Evaluating strategies diff --git a/utama_core/dashboard/__main__.py b/utama_core/dashboard/__main__.py index 3cea28f2..306a62b4 100644 --- a/utama_core/dashboard/__main__.py +++ b/utama_core/dashboard/__main__.py @@ -1,17 +1,17 @@ -"""utama_core/dashboard/__main__.py — standalone dashboard (Replay + Tournament only). +"""utama_core/dashboard/__main__.py — standalone dashboard (Replay + Strategies only). Run: pixi run dashboard (or: python -m utama_core.dashboard) # open http://localhost:8080 in a browser No live match, no CustomReferee, no StrategyRunner — `attach_dashboard()` -already wires up Replay and Tournament unconditionally (both are stateless +already wires up Replay and Strategies unconditionally (both are stateless readers of `replays/*/summary.json` and `*.pkl` files on disk), so this script's only job is to start the HTTP server and keep the process alive. Live/Referee views need a running match to attach to and so are still opt-in — see `examples/demo_referee_gui_rsim.py` for a script that starts one. -Use this when you just want to browse recorded replays or tournament +Use this when you just want to browse recorded replays or evaluation standings without also starting a live rsim match. """ diff --git a/utama_core/dashboard/page.py b/utama_core/dashboard/page.py index 5e6b4103..d6d1c68f 100644 --- a/utama_core/dashboard/page.py +++ b/utama_core/dashboard/page.py @@ -22,5 +22,5 @@ def build_page() -> str: .replace("__LIVE_JS__", (_STATIC_DIR / "live.js").read_text()) .replace("__TIMELINE_JS__", (_STATIC_DIR / "timeline.js").read_text()) .replace("__REPLAY_JS__", (_STATIC_DIR / "replay.js").read_text()) - .replace("__TOURNAMENT_JS__", (_STATIC_DIR / "tournament.js").read_text()) + .replace("__STRATEGIES_JS__", (_STATIC_DIR / "strategies.js").read_text()) ) diff --git a/utama_core/dashboard/server.py b/utama_core/dashboard/server.py index 3604d30a..e5f5e63d 100644 --- a/utama_core/dashboard/server.py +++ b/utama_core/dashboard/server.py @@ -56,7 +56,7 @@ def send(self, data: bytes) -> bool: def attach_dashboard(port: int = 8080) -> "DashboardServer": """Start the dashboard's HTTP server in a background daemon thread. - Tournament and Replay views are attached automatically — both are + Strategies and Replay views are attached automatically — both are stateless readers of files on disk (`replays/*/summary.json`, `*.pkl`), so every dashboard instance gets them working with no per-script wiring. The Referee and Live views depend on a specific running match/referee @@ -65,11 +65,11 @@ def attach_dashboard(port: int = 8080) -> "DashboardServer": """ from utama_core.dashboard.page import build_page from utama_core.dashboard.views import replay as replay_view - from utama_core.dashboard.views import tournament as tournament_view + from utama_core.dashboard.views import strategies as strategies_view server = DashboardServer(port) server.set_page(build_page()) - tournament_view.attach(server) + strategies_view.attach(server) replay_view.attach(server) server.start() print(f"Dashboard → http://localhost:{port}") @@ -83,7 +83,7 @@ class DashboardServer(threading.Thread): that channel receives it as one `data:` frame. Views register POST handlers with `add_command_handler(path, handler)` and static payload getters with `add_route(path, getter)` for simple `GET -> JSON` endpoints - (e.g. tournament summaries, replay frame lists). + (e.g. evaluation summaries, replay frame lists). """ def __init__(self, port: int) -> None: diff --git a/utama_core/dashboard/static/app.css b/utama_core/dashboard/static/app.css index f79759c3..6041d8e3 100644 --- a/utama_core/dashboard/static/app.css +++ b/utama_core/dashboard/static/app.css @@ -239,3 +239,23 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } padding: 16px 24px; font-size: 1rem; background: var(--halt); color: #fff; } } + +/* Strategies tab (strategies.js) */ +.subtab.active { border-color: var(--accent); color: var(--accent); } +.strategies-layout { display: flex; gap: 8px; width: 100%; min-height: 0; align-items: flex-start; } +.strategy-list { width: 280px; flex-shrink: 0; max-height: calc(100vh - 110px); overflow-y: auto; } +.strategy-item { padding: 8px 10px; border-bottom: 1px solid var(--border); border-left: 3px solid transparent; cursor: pointer; } +.strategy-item:hover { background: var(--surface-2); } +.strategy-item.active { border-left-color: var(--accent); background: var(--surface-2); } +.strategy-summary { font-size: .72rem; margin-top: 2px; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; } +.strategy-doc { font-size: .75rem; margin-top: 6px; white-space: pre-wrap; } +.signal-row { display: grid; grid-template-columns: 170px 1fr 56px 56px; gap: 8px; align-items: center; font-size: .75rem; padding: 2px 0; } +.signal-bar { position: relative; height: 10px; background: var(--surface-2); border-radius: 2px; } +.signal-fill { height: 100%; background: var(--accent); border-radius: 2px; } +.signal-field { position: absolute; top: -2px; width: 2px; height: 14px; margin-left: -1px; background: var(--text); } +.verdict-card { padding: 8px 10px; margin-bottom: 6px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--surface-2); } +@media (max-width: 720px) { + .strategies-layout { flex-direction: column; } + .strategy-list { width: 100%; max-height: 40vh; } + .signal-row { grid-template-columns: 110px 1fr 44px 44px; } +} diff --git a/utama_core/dashboard/static/app.js b/utama_core/dashboard/static/app.js index ad1ae52a..d5fa69eb 100644 --- a/utama_core/dashboard/static/app.js +++ b/utama_core/dashboard/static/app.js @@ -1,4 +1,4 @@ -// Tab shell. Each view module (referee.js, live.js, replay.js, tournament.js) +// Tab shell. Each view module (referee.js, live.js, replay.js, strategies.js) // registers itself via `Dashboard.registerView(name, { mount, onShow })`. // `mount` runs once; `onShow` runs each time the tab becomes active (views // that poll on an interval only should start when visible). @@ -30,7 +30,7 @@ const Dashboard = (() => { } // Cross-view command: switch to the Replay tab and preload a specific - // path (used by the Tournament tab's "view replay" links). `replay.js` + // path (used by the Strategies tab's "view replay" links). `replay.js` // registers this itself, since only it knows how to load a replay — this // is just the addressable hook other views call into. let _showReplay = null; diff --git a/utama_core/dashboard/static/index.html b/utama_core/dashboard/static/index.html index f091d7fe..066f107d 100644 --- a/utama_core/dashboard/static/index.html +++ b/utama_core/dashboard/static/index.html @@ -11,7 +11,7 @@
- +
@@ -162,8 +162,8 @@
-
-
+
+
@@ -172,7 +172,7 @@ - + diff --git a/utama_core/dashboard/static/replay.js b/utama_core/dashboard/static/replay.js index 4d8bce3f..3ada7ebd 100644 --- a/utama_core/dashboard/static/replay.js +++ b/utama_core/dashboard/static/replay.js @@ -481,7 +481,7 @@ function framesFromColumns(c) { } function loadReplayByPath(path, atTime) { - // Entry point for other views (Tournament's "view replay" links) via + // Entry point for other views (the Strategies tab's "view replay" links) via // Dashboard.showReplay(path) — same load, but also syncs the dropdown. // The dropdown's options are only populated once loadList()'s fetch // resolves, so the value must be set inside that callback, not after diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js new file mode 100644 index 00000000..6b6fe6b3 --- /dev/null +++ b/utama_core/dashboard/static/strategies.js @@ -0,0 +1,353 @@ +// Strategies tab: every strategy in the catalog (what it is, the tactics it uses, its verdicts, how it +// plays, its matches with their replays), and every evaluation run, verdicts first. +// Data: GET /strategies and /strategies/runs (dashboard/views/strategies.py), read from replays/. +// There are no standings: the verdict (goals, paired against the champion) is the only ranking, and +// signals are shown beside the other strategies' average to explain how a strategy plays, never to +// rank it (docs/signals.md). + +(function () { + let data = null; // /strategies + let runs = null; // /strategies/runs, loaded when the Runs page is first opened + let page = "strategies"; // "strategies" | "runs" + let selected = null; // strategy name + let showAllMatches = false; + const expandedRun = {}; // run_id -> bool; the newest starts open + const expandedRound = {}; // "run_id:k" -> bool + + const esc = (s) => + String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]); + const pct = (x) => Math.round((x || 0) * 1000) / 10 + "%"; + const num = (x, d = 2) => (x == null ? "—" : Number(x).toFixed(d)); + const signed = (x, d = 2) => (x == null ? "—" : (x > 0 ? "+" : "") + Number(x).toFixed(d)); + + const VERDICT_COLOUR = { better: "check-ok", dropped: "check-fail", undecided: "check-warn" }; + function verdictBadge(v) { + return `${esc(v)}`; + } + function roleBadge(role) { + const label = role === "champion" ? "★ champion" : role; + const colour = role === "champion" ? "accent" : role === "core" ? "" : "muted"; + return `${label}`; + } + function replayButton(path, atTime, label) { + if (!path) return `no replay`; + const at = atTime != null ? ` data-at="${atTime}"` : ""; + return ``; + } + function testLine(t) { + if (!t) return ""; + return `mean diff ${signed(t.mean)} ± ${num(t.se)} goals/match (n ${t.n ?? "—"}, p ${num(t.p, 3)})`; + } + + // --- the strategy list and one strategy --------------------------------------------------------- + + function renderList() { + const order = { champion: 0, core: 1, reserve: 2 }; + const rows = [...data.strategies].sort((a, b) => order[a.role] - order[b.role] || a.name.localeCompare(b.name)); + return rows + .map((s) => { + const last = s.verdicts[0]; + return ( + `
` + + `
${esc(s.name)}${roleBadge(s.role)}
` + + `
${esc(s.summary) || "no description"}
` + + (last ? `
${verdictBadge(last.verdict)} ${esc(last.date || "")}
` : "") + + `
` + ); + }) + .join(""); + } + + function renderTactics(s) { + if (!s.tactics.length) return '
No tactics imported from utama_core/tactics (it defines its own).
'; + return s.tactics + .map((t) => `
${esc(t.name)} ${esc(t.file)}
` + + (t.description ? `
${esc(t.description)}
` : "")) + .join(""); + } + + function renderVerdicts(s) { + if (!s.verdicts.length) { + return `
Never evaluated. Run pixi run evaluate ${esc(s.name)} to see if it beats the champion.
`; + } + return s.verdicts + .map((v) => + `
${verdictBadge(v.verdict)} in the ${esc(v.decided_in)} after ${v.rounds} round(s) · ` + + `${testLine(v)} · vs ${esc(v.reference)}${esc(v.date || v.run_id)}
`) + .join(""); + } + + function renderSignals(s) { + const sig = s.signals; + if (!sig) return '
No round with this strategy yet.
'; + const max = (r) => Math.max(Math.abs(r.value || 0), Math.abs(r.field || 0)) || 1; + const fmt = (r, x) => (x == null ? "—" : r.key.endsWith("_share") || r.key === "stalled" ? pct(x) : num(x, r.key === "pass_progress_m" ? 2 : 1)); + const rows = sig.rows + .map((r) => { + const m = max(r); + const w = r.value == null ? 0 : (Math.abs(r.value) / m) * 100; + const fw = r.field == null ? null : (Math.abs(r.field) / m) * 100; + const tick = fw == null ? "" : `
`; + return ( + `
${esc(r.label)}` + + `
${tick}
` + + `${fmt(r, r.value)}${fmt(r, r.field)}
` + ); + }) + .join(""); + return ( + `
Per match, ${sig.matches} matches in ${esc(sig.run_id)} ` + + `(${esc(sig.date || "")}). The tick and the grey number: the other strategies' average in that round. ` + + `More is not better: these explain how it plays (docs/signals.md).
` + + `
thisothers
` + + rows + ); + } + + function renderMatchList(s) { + if (!s.matches.length) return '
No recorded matches.
'; + const shown = showAllMatches ? s.matches : s.matches.slice(0, 30); + const rows = shown + .map((m) => { + const [f, a] = m.score; + const res = f > a ? "check-ok" : f < a ? "check-fail" : "muted"; + return ( + `vs ${esc(m.opponent)}${f} – ${a}` + + `${m.seed ?? "—"}${esc(m.date || "")}` + + `${m.stalled ? 'stalled' : ""}` + + `${replayButton(m.replay)}` + ); + }) + .join(""); + const more = + s.matches.length > shown.length + ? `` + : ""; + return ( + `` + + `${rows}
OpponentScoreSeedDate
${more}` + ); + } + + function renderStrategy(s) { + const old = s.old_names.length ? ` (was ${s.old_names.map(esc).join(", ")})` : ""; + const rest = s.description.split("\n\n").slice(1).join("\n\n"); + return ` +
+
+

${esc(s.name)}${old}

${roleBadge(s.role)}
+
${esc(s.summary)}
+ ${rest ? `
${esc(rest)}
` : ""} +
${esc(s.file)} · watch it: pixi run main ${esc(s.name)} wolfpack
+
+
Tactics it uses
${renderTactics(s)}
+
Verdicts (against the champion)
${renderVerdicts(s)}
+
How it plays
${renderSignals(s)}
+
Matches (${s.matches.length})
${renderMatchList(s)}
+
`; + } + + function renderStrategiesPage() { + if (!data) return '
Loading…
'; + if (!selected || !data.strategies.find((s) => s.name === selected)) selected = data.champion || data.strategies[0]?.name; + const s = data.strategies.find((x) => x.name === selected); + return ` +
+
${renderList()}
+
${s ? renderStrategy(s) : ""}
+
`; + } + + // --- runs --------------------------------------------------------------------------------------- + + function renderVerdictCards(run) { + const cands = Object.entries((run.report || {}).candidates || {}); + if (!run.report) { + return run.run_id.startsWith("eval_") + ? '
No report.json: the run did not finish.
' + : '
An older round robin: no verdicts.
'; + } + if (!cands.length) return '
No candidate: a health check of the field only.
'; + return cands + .map(([name, r]) => { + const decided = r[r.decided_in] || {}; + const h2h = r.vs_todays_champion; + return ( + `
${esc(name)}${verdictBadge(r.verdict)}
` + + `
in the ${esc(r.decided_in)} after ${r.rounds} round(s) · ${testLine(decided)}
` + + `
against ${esc(run.reference)} (the champion at the last release)` + + (h2h ? `; against today's ${esc(h2h.name)}: ${signed(h2h.mean)} ± ${num(h2h.se)}` : "") + + `
` + ); + }) + .join(""); + } + + // Find the replay of the match named "
_vs_" (how stall incidents name matches). + function replayOfMatch(round, stem) { + const r = (round.results || []).find((x) => x.replay && x.replay.split("/").pop().startsWith(stem + ".")); + return r ? r.replay : null; + } + + function renderHealth(round) { + const parts = []; + const incidents = round.stall_incidents || []; + if (round.stall_incidents) { + const rows = incidents + .map( + (inc) => + `
stall${esc(inc.kind)} at ${inc.sim_time.toFixed(1)}s ` + + `for ${inc.duration_s.toFixed(0)}s` + + inc.matches.map((m) => replayButton(replayOfMatch(round, m), inc.sim_time, m)).join("") + + `
` + ) + .join(""); + parts.push(`
Stalls: ${incidents.length} incidents
` + (rows || '
none
')); + } + const rs = round.restarts; + if (rs && rs.restarts) { + parts.push( + `
Restarts: ${rs.reached_normal_start}/${rs.restarts} reached NORMAL_START (${pct(rs.reached_normal_start / rs.restarts)})
` + ); + } + if (round.fouls) { + const byRule = Object.entries(round.fouls) + .map(([rule, f]) => [rule, f.total]) + .sort((a, b) => b[1] - a[1]) + .map(([rule, n]) => `${n} ${rule.replace(/_/g, " ")}`) + .join(", "); + parts.push(`
Fouls
${byRule || "none"}
`); + } + if ((round.failed || []).length) { + parts.push(`
${round.failed.length} match(es) crashed
`); + } + return parts.join("") || '
No health data in this round.
'; + } + + function renderRoundMatches(round) { + const rows = (round.results || []) + .map((r) => { + const stalled = ((r.stats || {}).stall_events || []).length || r.possession_backstop; + return ( + `${esc(r.display_a)} (yellow) vs ${esc(r.display_b)}` + + `${r.score_a} – ${r.score_b}` + + `${stalled ? 'stalled' : ""}${r.reused ? 'from store' : ""}` + + `${replayButton(r.replay)}` + ); + }) + .join(""); + return `${rows}
`; + } + + function renderRun(run) { + const meta = (run.report || {}).run || {}; + const commit = meta.git_commit ? ` · ${esc(meta.git_commit.slice(0, 8))}${meta.git_dirty ? " (dirty)" : ""}` : ""; + const nMatches = run.rounds.reduce((n, s) => n + (s.results || []).length, 0); + const open = expandedRun[run.run_id]; + const header = + `
${open ? "▼" : "▶"} ` + + `${esc(run.run_id)} · ${run.rounds.length} round(s) · ${nMatches} matches${commit}
`; + if (!open) return `
${header}
`; + const rounds = run.rounds + .map((round) => { + const key = `${run.run_id}:${round.round ?? 1}`; + const o = expandedRound[key]; + return ( + `
${o ? "▼" : "▶"} ` + + `Round ${round.round ?? 1}${round.seed != null ? ` (seed ${round.seed})` : ""} · ${(round.results || []).length} matches
` + + (o ? renderRoundMatches(round) : "") + ); + }) + .join(""); + return ` +
+ ${header} +
+
Verdicts
${renderVerdictCards(run)}
+
Health check (round 1)
${run.rounds[0] ? renderHealth(run.rounds[0]) : ""}
+
Matches
${rounds}
+
+
`; + } + + function renderRunsPage() { + if (!runs) return '
Loading…
'; + if (!runs.length) return '
No runs yet. Start one with pixi run evaluate NAME.
'; + return runs.map(renderRun).join(""); + } + + // --- shell -------------------------------------------------------------------------------------- + + function render() { + const root = document.getElementById("strategies-root"); + if (!root) return; + const tab = (p, label) => ``; + root.innerHTML = + `
${tab("strategies", "Strategies")}${tab("runs", "Evaluation runs")}
` + + (page === "strategies" ? renderStrategiesPage() : renderRunsPage()); + + for (const b of root.querySelectorAll(".subtab")) { + b.addEventListener("click", () => { + page = b.dataset.page; + if (page === "runs" && !runs) loadRuns(); + render(); + }); + } + for (const el of root.querySelectorAll(".strategy-item")) { + el.addEventListener("click", () => { + selected = el.dataset.name; + showAllMatches = false; + render(); + }); + } + for (const b of root.querySelectorAll(".show-all-matches")) { + b.addEventListener("click", () => { + showAllMatches = true; + render(); + }); + } + for (const h of root.querySelectorAll(".run-header")) { + h.addEventListener("click", () => { + expandedRun[h.dataset.runId] = !expandedRun[h.dataset.runId]; + render(); + }); + } + for (const h of root.querySelectorAll(".round-header")) { + h.addEventListener("click", () => { + expandedRound[h.dataset.key] = !expandedRound[h.dataset.key]; + render(); + }); + } + for (const btn of root.querySelectorAll(".view-replay-btn")) { + btn.addEventListener("click", (e) => { + e.stopPropagation(); + const at = btn.dataset.at != null ? Number(btn.dataset.at) : undefined; + Dashboard.showReplay(btn.dataset.path, at); + }); + } + } + + function load() { + fetch("/strategies") + .then((r) => r.json()) + .then((d) => { + data = d; + render(); + }) + .catch((err) => console.error("strategies fetch error:", err)); + if (page === "runs") loadRuns(); + } + + function loadRuns() { + fetch("/strategies/runs") + .then((r) => r.json()) + .then((d) => { + runs = d; + if (runs.length && !Object.keys(expandedRun).length) expandedRun[runs[0].run_id] = true; + render(); + }) + .catch((err) => console.error("runs fetch error:", err)); + } + + Dashboard.registerView("strategies", { mount: render, onShow: load }); +})(); diff --git a/utama_core/dashboard/static/tournament.js b/utama_core/dashboard/static/tournament.js deleted file mode 100644 index 81a64b32..00000000 --- a/utama_core/dashboard/static/tournament.js +++ /dev/null @@ -1,397 +0,0 @@ -// Tournament view: standings + per-match results, sortable/expandable. -// Successor concern to hand-reading round-robin log output — -// reads replays//summary.json via the tournament view's Python side. -// A round summary (`evaluate.py`, or an older round_robin.py run) also carries a per-strategy table, stall -// incidents, restart outcomes and fouls (docs/STRATEGY_DEVELOPMENT.md -// "Reading a tournament run"); those are shown when present. Each result's -// `replay` is the path of its replay file, or null (added server-side). -// `evaluate.py` (like the older round_robin.py) writes `winner` as the literal string "draw" on -// a tie (never null), and `standings` only carries wins/draws per config — -// losses/GF/GA/win% are derived here from `results`, not shipped precomputed. - -(function () { - let runs = []; - let sortKey = { column: "wins", dir: -1 }; - let expandedMatch = {}; // "runIndex:matchIndex" -> bool - let expandedRun = {}; // run_id -> bool; only the newest run starts open - - function short(name) { - return name.replace(/^build_/, "").replace(/_kernel_strategy$/, ""); - } - - function pct(x) { - return Math.round((x || 0) * 1000) / 10 + "%"; - } - - // Derive losses/games/GF/GA/win% per config from `results`, since - // `standings` in summary.json only ever carries wins/draws. - function standingsRows(run) { - if (run.strategies) return sortRows(strategyRows(run)); - const base = {}; - for (const name of run.config_names || []) { - base[name] = { name, wins: 0, draws: 0, losses: 0, games: 0, gf: 0, ga: 0 }; - } - for (const r of run.results || []) { - const a = base[r.config_a] || (base[r.config_a] = { name: r.config_a, wins: 0, draws: 0, losses: 0, games: 0, gf: 0, ga: 0 }); - const b = base[r.config_b] || (base[r.config_b] = { name: r.config_b, wins: 0, draws: 0, losses: 0, games: 0, gf: 0, ga: 0 }); - a.games++; - b.games++; - a.gf += r.score_a; - a.ga += r.score_b; - b.gf += r.score_b; - b.ga += r.score_a; - if (r.winner === "draw") { - a.draws++; - b.draws++; - } else if (r.winner === r.config_a) { - a.wins++; - b.losses++; - } else if (r.winner === r.config_b) { - b.wins++; - a.losses++; - } - } - const rows = Object.values(base).map((s) => ({ - ...s, - gd: s.gf - s.ga, - winPct: s.games ? s.wins / s.games : 0, - })); - return sortRows(rows); - } - - function sortRows(rows) { - const { column, dir } = sortKey; - rows.sort((x, y) => ((x[column] ?? 0) - (y[column] ?? 0)) * dir); - return rows; - } - - // a round's per-strategy table (summary.json `strategies`). - function strategyRows(run) { - return Object.entries(run.strategies).map(([name, s]) => ({ - name, - wins: s.wins, - draws: s.draws, - losses: s.losses, - games: s.matches, - gf: s.goals_for, - ga: s.goals_against, - gd: s.goals_for - s.goals_against, - winPct: s.matches ? s.wins / s.matches : 0, - shots: s.shots, - passes: s.completed_passes, - entries: s.attacking_third_entries, - fouls: s.fouls, - realLosses: s.real_losses_as_a, - stalled: s.stalled, - })); - } - - function renderStandings(run, runIndex) { - const rows = standingsRows(run); - const arrow = (col) => (sortKey.column === col ? (sortKey.dir === -1 ? " ▼" : " ▲") : ""); - const cols = [ - ["wins", "W"], - ["draws", "D"], - ["losses", "L"], - ["games", "Games"], - ["gf", "GF"], - ["ga", "GA"], - ["gd", "GD"], - ["winPct", "Win%"], - ]; - if (run.strategies) { - cols.push( - ["shots", "Shots"], - ["passes", "Passes"], - ["entries", "Entries"], - ["fouls", "Fouls"], - ["realLosses", "Losses as A"], - ["stalled", "Stalled"] - ); - } - const cell = (r, col) => { - if (col === "gd") return `${r.gd > 0 ? "+" : ""}${r.gd}`; - if (col === "winPct") return pct(r.winPct); - return r[col] ?? "—"; - }; - const trs = rows - .map((r) => `${short(r.name)}` + cols.map(([col]) => `${cell(r, col)}`).join("") + ``) - .join(""); - const ths = cols - .map(([col, label]) => `${label}${arrow(col)}`) - .join(""); - return ` - - ${ths} - ${trs} -
Config
`; - } - - function replayButton(path, atTime, label) { - if (!path) return `no replay file`; - const at = atTime != null ? ` data-at="${atTime}"` : ""; - return ``; - } - - function teamAvg(perRobot, prefix) { - const vals = Object.entries(perRobot || {}) - .filter(([k]) => k.startsWith(prefix)) - .map(([, v]) => v); - if (!vals.length) return null; - return vals.reduce((a, b) => a + b, 0) / vals.length; - } - - function renderMatchDetail(r) { - const stats = r.stats || {}; - const rec = stats.rule_event_counts || {}; - const recParts = Object.entries(rec).map(([k, v]) => `${v} ${k.replace(/_/g, " ")}`); - const shots = stats.shots || {}; - const friendlyMotion = teamAvg(stats.robot_motion_pct, "friendly_"); - const enemyMotion = teamAvg(stats.robot_motion_pct, "enemy_"); - - return ` -
-
Rule events${recParts.length ? recParts.join(", ") : "none"}
-
Shots${shots.friendly ?? 0} - ${shots.enemy ?? 0}
-
Ball travel${stats.ball_travel_m != null ? stats.ball_travel_m.toFixed(1) + " m" : "—"}
-
Avg motion${friendlyMotion != null ? pct(friendlyMotion) : "—"} - ${enemyMotion != null ? pct(enemyMotion) : "—"}
-
${replayButton(r.replay)}
-
`; - } - - // Fixed, predictable ordering for the 4 side x kickoff cells within a - // pair's group — (a_is_right, a_kicks_off) in this order — rather than - // whatever order concurrent workers happened to finish in. - const CELL_ORDER = [ - [true, true], - [true, false], - [false, true], - [false, false], - ]; - - function cellLabel(r, pairA) { - // a round plays each pair once, config_a as yellow - if (r.a_is_right === undefined) return `${short(r.config_a)} (yellow) vs ${short(r.config_b)}`; - // r.config_a may be either physical config depending on which side of - // the 4-cell product ran; re-express relative to pairA (the group's - // canonical/alphabetically-first config) so labels read consistently - // within a group regardless of which config was "a" for this row. - const aIsPairA = r.config_a === pairA; - const isRight = aIsPairA ? r.a_is_right : !r.a_is_right; - const kicksOff = aIsPairA ? r.a_kicks_off : !r.a_kicks_off; - return `${short(pairA)} ${isRight ? "right" : "left"}, ${kicksOff ? short(pairA) : "opponent"} kicks off`; - } - - // Group flat `results` into one entry per unordered {config_a, config_b} - // pair, each holding up to 4 cell rows ordered by CELL_ORDER. Groups are - // ordered alphabetically by the pair's sorted names for a stable render - // independent of match-completion order. - function groupedMatches(run) { - const groups = {}; // "confA|confB" (sorted) -> { pairA, pairB, rows: [] } - (run.results || []).forEach((r, i) => { - const [pairA, pairB] = [r.config_a, r.config_b].sort(); - const key = pairA + "|" + pairB; - if (!groups[key]) groups[key] = { pairA, pairB, rows: [] }; - groups[key].rows.push({ r, resultIndex: i }); - }); - - return Object.keys(groups) - .sort() - .map((key) => { - const g = groups[key]; - g.rows.sort((x, y) => { - const cellOf = (row) => { - const aIsPairA = row.r.config_a === g.pairA; - const isRight = aIsPairA ? row.r.a_is_right : !row.r.a_is_right; - const kicksOff = aIsPairA ? row.r.a_kicks_off : !row.r.a_kicks_off; - return CELL_ORDER.findIndex(([r_, k_]) => r_ === isRight && k_ === kicksOff); - }; - return cellOf(x) - cellOf(y); - }); - return g; - }); - } - - function renderMatches(run, runIndex) { - const groups = groupedMatches(run); - const rows = groups - .map((g) => { - const groupHeader = - `` + - `${short(g.pairA)} vs ${short(g.pairB)}`; - const matchRows = g.rows - .map(({ r, resultIndex }) => { - const key = runIndex + ":" + resultIndex; - const isDraw = r.winner === "draw"; - const winnerLabel = isDraw ? "draw" : short(r.winner); - const poss = (r.stats || {}).possession_pct; - const possLabel = poss ? `${pct(poss.friendly)} - ${pct(poss.enemy)}` : "—"; - const expanded = !!expandedMatch[key]; - const detailRow = expanded - ? `${renderMatchDetail(r)}` - : ""; - return ( - `` + - `${cellLabel(r, g.pairA)}` + - `${r.score_a} - ${r.score_b}` + - `${winnerLabel}${((r.stats || {}).stall_events || []).length ? ' stalled' : ""}` + - `${possLabel}` + - `${expanded ? "▲" : "▼"}` + - `${detailRow}` - ); - }) - .join(""); - return groupHeader + matchRows; - }) - .join(""); - - return ` -
- - - - - ${rows} -
CellScoreWinnerPossession
-
`; - } - - // Find the replay of the match named "
_vs_" (how stall incidents name matches). - function replayOfMatch(run, stem) { - const r = (run.results || []).find((x) => x.replay && x.replay.split("/").pop().startsWith(stem + ".")); - return r ? r.replay : null; - } - - function renderDiagnostics(run) { - const parts = []; - const incidents = run.stall_incidents || []; - if (run.stall_incidents) { - const rows = incidents - .map( - (inc) => - `
stall${inc.kind} at ${inc.sim_time.toFixed(1)}s ` + - `for ${inc.duration_s.toFixed(0)}s` + - inc.matches.map((m) => replayButton(replayOfMatch(run, m), inc.sim_time, m)).join("") + - `
` - ) - .join(""); - parts.push( - `
Stalls: ${run.stalled_match_count ?? incidents.length} matches, ${incidents.length} incidents
` + - (rows || '
none
') - ); - } - const rs = run.restarts; - if (rs && rs.restarts) { - const kinds = Object.entries(rs.by_kind || {}) - .map(([kind, k]) => { - const bad = Object.entries(k.outcomes || {}) - .filter(([o]) => o !== "taken") - .map(([o, n]) => `${n} ${o.replace(/_/g, " ")}`) - .join(", "); - return `
${kind.replace(/_/g, " ").toLowerCase()}` + - `${k.reached_normal_start}/${k.n} reached NORMAL_START${bad ? " (" + bad + ")" : ""}
`; - }) - .join(""); - parts.push( - `
Restarts: ${rs.reached_normal_start}/${rs.restarts} reached NORMAL_START (${pct(rs.reached_normal_start / rs.restarts)})
` + - kinds - ); - } - if (run.fouls) { - const byRule = Object.entries(run.fouls) - .map(([rule, f]) => [rule, f.total]) - .sort((a, b) => b[1] - a[1]) - .map(([rule, n]) => `${n} ${rule.replace(/_/g, " ")}`) - .join(", "); - parts.push(`
Fouls
${byRule || "none"}
`); - } - return parts.length ? `
${parts.join("")}
` : ""; - } - - function renderRunHeader(run) { - const meta = run.run || {}; - const commit = meta.git_commit ? ` · ${meta.git_commit.slice(0, 8)}${meta.git_dirty ? " (dirty)" : ""}` : ""; - const argv = meta.argv && meta.argv.length ? ` · ${meta.argv.join(" ")}` : ""; - const open = expandedRun[run.run_id]; - return `
${open ? "▼" : "▶"} ${run.run_id} · ` + - `${(run.config_names || []).length} configs · ${(run.results || []).length} matches${commit}${argv}
`; - } - - function renderRun(run, index) { - if (!expandedRun[run.run_id]) return `
${renderRunHeader(run)}
`; - return ` -
- ${renderRunHeader(run)} -
${renderStandings(run, index)}
- ${renderDiagnostics(run)} -
Matches
- ${renderMatches(run, index)} -
`; - } - - function render() { - const container = document.getElementById("tournament-runs"); - if (!container) return; - if (!runs.length) { - container.innerHTML = '
No tournament runs found.
'; - return; - } - container.innerHTML = runs.map(renderRun).join(""); - - for (const th of container.querySelectorAll("th.sortable")) { - th.addEventListener("click", () => { - const col = th.dataset.col; - if (sortKey.column === col) { - sortKey.dir *= -1; - } else { - sortKey = { column: col, dir: -1 }; - } - render(); - }); - } - for (const header of container.querySelectorAll(".run-header")) { - header.addEventListener("click", () => { - const id = header.dataset.runId; - expandedRun[id] = !expandedRun[id]; - render(); - }); - } - for (const row of container.querySelectorAll("tr.match-row")) { - row.addEventListener("click", (e) => { - if (e.target.closest(".view-replay-btn")) return; - const key = row.dataset.key; - expandedMatch[key] = !expandedMatch[key]; - render(); - }); - } - for (const btn of container.querySelectorAll(".view-replay-btn")) { - btn.addEventListener("click", (e) => { - e.stopPropagation(); - const path = btn.dataset.path; - const at = btn.dataset.at != null ? Number(btn.dataset.at) : undefined; - Dashboard.showReplay(path, at); - }); - } - } - - function load() { - fetch("/tournament/runs") - .then((r) => r.json()) - .then((data) => { - runs = data; - if (runs.length && !Object.keys(expandedRun).length) expandedRun[runs[0].run_id] = true; - render(); - }) - .catch((err) => console.error("tournament fetch error:", err)); - } - - function mount() { - load(); - } - - function onShow() { - load(); - } - - Dashboard.registerView("tournament", { mount, onShow }); -})(); diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py new file mode 100644 index 00000000..7f9e6979 --- /dev/null +++ b/utama_core/dashboard/views/strategies.py @@ -0,0 +1,306 @@ +"""Strategies view: every strategy in the catalog, with what it is and what we know about it, and +every evaluation run, verdicts first. Reads only what is already on disk; records nothing. + + GET /strategies {"champion", "core", "strategies": [...]} one entry per catalog strategy + GET /strategies/runs every run under `replays/`, newest first + +A strategy's entry: its description (the module docstring), file, role (champion / core / reserve, +`tools/evaluation/reference/players.json`), the tactics it imports, its verdicts (from each +`eval_*/report.json` it was a candidate in), how it plays (per-match signals in the newest round it +played, beside the average of the other strategies in that round) and its matches, each with its +replay. Names are shown as the catalog calls them today: a `.strategy` file (`name@commit.strategy`) +and a pre-rename name both show as the strategy's name, so frozen files never appear as strategies of +their own. Matches played under an older name or older code keep their date, which is how to tell. +""" + +from __future__ import annotations + +import ast +import json +import re +from pathlib import Path +from typing import Iterable, Optional + +from utama_core.config.settings import REPLAY_BASE_PATH +from utama_core.dashboard.server import DashboardServer +from utama_core.strategy import catalog + +REPO = Path(__file__).resolve().parents[3] +PLAYERS = REPO / "tools" / "evaluation" / "reference" / "players.json" +STRATEGY_DIR = REPO / "utama_core" / "strategy" +TACTICS_PACKAGE = "utama_core.tactics" + +# The signals shown per strategy, as (key, label, per): `per` is "match" (divide the round total by +# matches), "match_as_a" (real losses are measured on config_a's side only) or None (already a rate). +SIGNALS = [ + ("goals_for", "goals scored", "match"), + ("goals_against", "goals conceded", "match"), + ("shots", "shots", "match"), + ("attacking_third_entries", "attacking-third entries", "match"), + ("completed_passes", "completed passes", "match"), + ("forward_pass_share", "forward pass share", None), + ("pass_progress_m", "metres gained per pass", None), + ("real_losses_as_a", "real ball losses", "match_as_a"), + ("fouls", "fouls", "match"), + ("stalled", "stalled matches (share)", "match"), +] + + +def attach(server: DashboardServer) -> None: + server.add_route("/strategies", lambda: json.dumps(load_strategies()).encode()) + server.add_route("/strategies/runs", lambda: json.dumps(load_runs()).encode()) + + +# --- names ------------------------------------------------------------------------------------ + + +def display_name(config: str) -> str: + """`config` as the catalog calls it today: `replays/eval/frozen/pendulum@ab12.strategy` and + `build_split_shape_kernel_strategy` both become a plain catalog name.""" + if config.endswith(".strategy"): + config = Path(config).stem.split("@")[0] + return catalog.current_name(config) + + +def run_date(run_id: str) -> Optional[str]: + m = re.search(r"(\d{4})(\d{2})(\d{2})", run_id) + return f"{m[1]}-{m[2]}-{m[3]}" if m else None + + +# --- reading the disk ------------------------------------------------------------------------- + + +def _read_json(path: Path) -> Optional[dict]: + try: + return json.loads(path.read_text()) + except (OSError, json.JSONDecodeError): + return None + + +def _summary_paths(base: Path) -> list[Path]: + # older round robins: /summary.json; evaluate.py: eval_/round_/summary.json + return [*base.glob("*/summary.json"), *base.glob("eval_*/round_*/summary.json")] + + +def _summaries(base: Path) -> list[tuple[Path, dict]]: + out = [] + for path in _summary_paths(base): + summary = _read_json(path) + if summary is not None: + for result in summary.get("results", []): + result["replay"] = _replay_path(base, path.parent, result) + out.append((path, summary)) + out.sort(key=lambda ps: ps[1].get("run_id", ""), reverse=True) + return out + + +def _replay_path(base: Path, run_dir: Path, result: dict) -> Optional[str]: + """The result's replay, relative to `base`: `evaluate.py` writes `
_vs_.npz`. Older runs + (the retired `ladder.py`, `full_match_tournament.py`) wrote side and kickoff tags, + `_vs__` (as `.pkl` for the latter).""" + stem = f"{catalog.plain_name(result['config_a'])}_vs_{catalog.plain_name(result['config_b'])}" + names = [f"{stem}.npz", f"{stem}.pkl"] + if "a_is_right" in result: + names.insert(0, f"{stem}_{'R' if result['a_is_right'] else 'L'}{'K' if result.get('a_kicks_off') else 'k'}.pkl") + for name in names: + if (run_dir / name).exists(): + return str((run_dir / name).relative_to(base)) + return None + + +def _reports(base: Path) -> list[dict]: + reports = [r for p in base.glob("eval_*/report.json") if (r := _read_json(p)) is not None] + return sorted(reports, key=lambda r: r.get("run_id", ""), reverse=True) + + +# --- one strategy ----------------------------------------------------------------------------- + + +def _docstring(path: Path) -> str: + try: + return ast.get_docstring(ast.parse(path.read_text())) or "" + except (OSError, SyntaxError): + return "" + + +def _first_line(text: str) -> str: + return text.strip().split("\n\n")[0].replace("\n", " ") if text else "" + + +def tactics_of(path: Path) -> list[dict]: + """The tactics a strategy file imports from `utama_core.tactics`, each with its module's first + docstring paragraph. Read from source: importing would run the module.""" + try: + tree = ast.parse(path.read_text()) + except (OSError, SyntaxError): + return [] + found: dict[str, dict] = {} + for node in ast.walk(tree): + if isinstance(node, ast.ImportFrom) and node.module and node.module.startswith(TACTICS_PACKAGE): + module = REPO / Path(*node.module.split(".")) + file = module.with_suffix(".py") if module.with_suffix(".py").exists() else module / "__init__.py" + for alias in node.names: + if alias.name[:1].isupper() and alias.name not in found: + found[alias.name] = { + "name": alias.name, + "file": str(file.relative_to(REPO)), + "description": _first_line(_docstring(file)), + } + return list(found.values()) + + +def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict]: + out = [] + for _, summary in summaries: + run_id = summary.get("run_id", "") + for r in summary.get("results", []): + a, b = display_name(r["config_a"]), display_name(r["config_b"]) + # a match reused from the store is listed under the run that played it + if name not in (a, b) or a == b or r.get("reused"): + continue + mine, theirs, opponent = (r["score_a"], r["score_b"], b) if a == name else (r["score_b"], r["score_a"], a) + stats = r.get("stats") or {} + out.append( + { + "opponent": opponent, + "score": [mine, theirs], + "seed": r.get("seed"), + "run_id": run_id, + "date": run_date(run_id), + "stalled": bool(stats.get("stall_events") or r.get("possession_backstop")), + "replay": r.get("replay"), + } + ) + return out + + +def _rate(row: dict, key: str, per: Optional[str]) -> Optional[float]: + value = row.get(key) + if value is None: + return None + if per == "match": + n = row.get("matches") or 0 + elif per == "match_as_a": + n = row.get("matches_as_a") or 0 + else: + return float(value) + return value / n if n else None + + +def signals_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> Optional[dict]: + """Per-match signals in the newest round with a strategy table that `name` played in, beside the + mean of the other strategies there. A comparison with the field, not a ranking.""" + for _, summary in summaries: + table = {display_name(k): v for k, v in (summary.get("strategies") or {}).items()} + if name not in table: + continue + others = [row for n, row in table.items() if n != name] + rows = [] + for key, label, per in SIGNALS: + value = _rate(table[name], key, per) + field = [v for row in others if (v := _rate(row, key, per)) is not None] + rows.append( + { + "key": key, + "label": label, + "value": value, + "field": sum(field) / len(field) if field else None, + } + ) + run_id = summary.get("run_id", "") + return { + "run_id": run_id, + "date": run_date(run_id), + "matches": table[name].get("matches"), + "rows": rows, + } + return None + + +def _verdicts_of(name: str, reports: Iterable[dict]) -> list[dict]: + out = [] + for report in reports: + for candidate, r in (report.get("candidates") or {}).items(): + if display_name(candidate) != name or "verdict" not in r: + continue + decided = r.get(r.get("decided_in", ""), {}) + out.append( + { + "run_id": report.get("run_id"), + "date": run_date(report.get("run_id", "")), + "verdict": r["verdict"], + "decided_in": r.get("decided_in"), + "rounds": r.get("rounds"), + "mean": decided.get("mean"), + "se": decided.get("se"), + "p": decided.get("p"), + "n": decided.get("n"), + "reference": display_name(report.get("reference", "")), + } + ) + return out + + +def load_strategies(base: Optional[Path] = None) -> dict: + base = Path(base or REPLAY_BASE_PATH) + players = _read_json(PLAYERS) or {} + champion, core = players.get("champion"), players.get("core", []) + summaries = _summaries(base) if base.exists() else [] + reports = _reports(base) if base.exists() else [] + strategies = [] + for name in catalog.names(): + path = STRATEGY_DIR / f"{name}.py" + doc = _docstring(path) + strategies.append( + { + "name": name, + "role": "champion" if name == champion else "core" if name in core else "reserve", + "summary": _first_line(doc), + "description": doc, + "file": str(path.relative_to(REPO)), + "old_names": sorted(old for old, new in catalog.RENAMED.items() if new == name), + "tactics": tactics_of(path), + "verdicts": _verdicts_of(name, reports), + "signals": signals_of(name, summaries), + "matches": _matches_of(name, summaries), + } + ) + return {"champion": champion, "core": core, "strategies": strategies} + + +# --- runs ------------------------------------------------------------------------------------- + + +def load_runs(base: Optional[Path] = None) -> list[dict]: + """Every run, newest first: an `evaluate.py` run is its report (if it finished) and its rounds; + an older round robin is one round. Names in results stay as recorded; the page shows them through + the same mapping as `/strategies` does on the server (`display` on each result).""" + base = Path(base or REPLAY_BASE_PATH) + if not base.exists(): + return [] + runs: dict[str, dict] = {} + for path, summary in _summaries(base): + for r in summary.get("results", []): + r["display_a"], r["display_b"] = display_name(r["config_a"]), display_name(r["config_b"]) + run_dir = path.parent.parent if path.parent.name.startswith("round_") else path.parent + run = runs.setdefault( + run_dir.name, {"run_id": run_dir.name, "date": run_date(run_dir.name), "report": None, "rounds": []} + ) + run["rounds"].append(summary) + for report in _reports(base): + run = runs.get(report.get("run_id")) + if run is None: + continue + run["reference"] = display_name(report.get("reference", "")) + run["report"] = { + "run": report.get("run"), + "rule": report.get("rule"), + "failed": report.get("failed", []), + "candidates": { + display_name(c): {k: v for k, v in r.items() if k != "stalls"} + for c, r in (report.get("candidates") or {}).items() + }, + } + for run in runs.values(): + run["rounds"].sort(key=lambda s: s.get("round", 0)) + return sorted(runs.values(), key=lambda r: r["run_id"], reverse=True) diff --git a/utama_core/dashboard/views/tournament.py b/utama_core/dashboard/views/tournament.py deleted file mode 100644 index d14202b5..00000000 --- a/utama_core/dashboard/views/tournament.py +++ /dev/null @@ -1,68 +0,0 @@ -"""Tournament view — reads `replays//summary.json` written by -`evaluate.py` and exposes it to the dashboard. - -Fully standalone: no coupling to a running match or `StrategyRunner`. Just a -`GET /tournament/runs` route returning every run's full summary inline -(newest first), since the run count is small and this avoids needing a -second dynamic-path route on `DashboardServer`. Each result gains `replay`: -its replay's path under `REPLAY_BASE_PATH`, or None when there is no file, so -the page links only to replays that exist. -""" - -from __future__ import annotations - -import json -from pathlib import Path -from typing import List, Optional - -from utama_core.config.settings import REPLAY_BASE_PATH -from utama_core.dashboard.server import DashboardServer -from utama_core.strategy.catalog import plain_name - - -def attach(server: DashboardServer) -> None: - server.add_route("/tournament/runs", _runs_bytes) - - -def _runs_bytes() -> bytes: - return json.dumps(_load_runs()).encode() - - -def _load_runs() -> List[dict]: - if not REPLAY_BASE_PATH.exists(): - return [] - - summaries = [] - # Older round-robins: replays/tournament_/summary.json; evaluate.py: one per round, - # replays/eval_/round_/summary.json. - paths = [*REPLAY_BASE_PATH.glob("*/summary.json"), *REPLAY_BASE_PATH.glob("eval_*/round_*/summary.json")] - for summary_path in paths: - try: - with open(summary_path) as f: - summary = json.load(f) - except (json.JSONDecodeError, OSError): - continue - for result in summary.get("results", []): - result["replay"] = _replay_path(summary_path.parent, result) - summaries.append(summary) - - summaries.sort(key=lambda s: s.get("run_id", ""), reverse=True) - return summaries - - -def _short(config: str) -> str: - return plain_name(config) - - -def _replay_path(run_dir: Path, result: dict) -> Optional[str]: - """The result's replay, relative to `REPLAY_BASE_PATH`: `evaluate.py` writes - `_vs_.npz`. Older runs (the retired `ladder.py`, `full_match_tournament.py`) wrote - side and kickoff tags, `_vs__` (as `.pkl` for the latter).""" - stem = f"{_short(result['config_a'])}_vs_{_short(result['config_b'])}" - names = [f"{stem}.npz", f"{stem}.pkl"] - if "a_is_right" in result: - names.insert(0, f"{stem}_{'R' if result['a_is_right'] else 'L'}{'K' if result.get('a_kicks_off') else 'k'}.pkl") - for name in names: - if (run_dir / name).exists(): - return str((run_dir / name).relative_to(REPLAY_BASE_PATH)) - return None diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py new file mode 100644 index 00000000..9f0d7997 --- /dev/null +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -0,0 +1,136 @@ +"""`utama_core.dashboard.views.strategies`: the Strategies tab's payloads, from a small fake `replays/`.""" + +from __future__ import annotations + +import json + +import pytest + +from utama_core.dashboard.views import strategies as view + + +def _write(path, payload): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload)) + + +def _row(a, b, score_a, score_b, **extra): + return {"config_a": a, "config_b": b, "score_a": score_a, "score_b": score_b, "seed": 1, **extra} + + +@pytest.fixture +def replays(tmp_path): + """One finished evaluate.py run: mirage the candidate (dropped), the reference a frozen pendulum.""" + run = tmp_path / "eval_20261112_100000" + frozen = "replays/eval/frozen/pendulum@ab12cd34.strategy" + _write( + run / "round_1" / "summary.json", + { + "run_id": "eval_20261112_100000/round_1", + "round": 1, + "seed": 1, + "results": [ + _row("mirage", "wolfpack", 3, 1), + _row(frozen, "mirage", 2, 0), + _row("wolfpack", "mirage", 1, 1, reused=True), # played by an earlier run + ], + "strategies": { + "mirage": {"matches": 2, "goals_for": 3, "shots": 10, "stalled": 1}, + "wolfpack": {"matches": 1, "goals_for": 1, "shots": 4, "stalled": 0}, + frozen: {"matches": 1, "goals_for": 2, "shots": 8, "stalled": 0}, + }, + }, + ) + (run / "round_1" / "mirage_vs_wolfpack.npz").write_bytes(b"") + _write( + run / "report.json", + { + "run_id": "eval_20261112_100000", + "reference": frozen, + "candidates": { + "mirage": { + "verdict": "dropped", + "decided_in": "screen", + "rounds": 2, + "screen": {"n": 8, "mean": -1.2, "se": 0.4, "p": 0.99}, + "stalls": {"too": "big"}, + } + }, + }, + ) + return tmp_path + + +def _strategy(payload, name): + (s,) = [s for s in payload["strategies"] if s["name"] == name] + return s + + +def test_frozen_files_and_old_names_show_as_the_catalog_name(): + assert view.display_name("replays/eval/frozen/pendulum@ab12cd34.strategy") == "pendulum" + assert view.display_name("build_split_shape_kernel_strategy") == "pendulum" + assert view.display_name("high_press") == "wolfpack" + + +def test_every_catalog_strategy_is_listed_once_with_its_role(replays): + payload = view.load_strategies(replays) + names = [s["name"] for s in payload["strategies"]] + assert sorted(names) == sorted(set(names)) and "pendulum" in names + assert _strategy(payload, payload["champion"])["role"] == "champion" + assert {_strategy(payload, n)["role"] for n in payload["core"] if n != payload["champion"]} == {"core"} + assert not any(n.endswith(".strategy") for n in names) + + +def test_a_strategy_carries_its_description_file_and_tactics(replays): + wolfpack = _strategy(view.load_strategies(replays), "wolfpack") + assert wolfpack["summary"] and wolfpack["file"] == "utama_core/strategy/wolfpack.py" + assert {"GiveAndGoTactic", "PressAndContainTactic"} <= {t["name"] for t in wolfpack["tactics"]} + assert "high_press" in wolfpack["old_names"] + + +def test_a_candidates_verdict_is_shown_against_the_champion_by_name(replays): + (v,) = _strategy(view.load_strategies(replays), "mirage")["verdicts"] + assert (v["verdict"], v["decided_in"], v["rounds"], v["mean"], v["n"]) == ("dropped", "screen", 2, -1.2, 8) + assert v["reference"] == "pendulum" and v["date"] == "2026-11-12" + + +def test_matches_are_from_the_strategys_side_with_their_replays_and_reused_ones_once(replays): + matches = _strategy(view.load_strategies(replays), "mirage")["matches"] + assert sorted((m["opponent"], tuple(m["score"])) for m in matches) == [("pendulum", (0, 2)), ("wolfpack", (3, 1))] + by_opponent = {m["opponent"]: m["replay"] for m in matches} + assert by_opponent["wolfpack"] == "eval_20261112_100000/round_1/mirage_vs_wolfpack.npz" + assert by_opponent["pendulum"] is None + + +def test_signals_are_per_match_beside_the_other_strategies_average(replays): + sig = _strategy(view.load_strategies(replays), "mirage")["signals"] + rows = {r["key"]: r for r in sig["rows"]} + assert rows["shots"]["value"] == 5.0 # 10 shots in 2 matches + assert rows["shots"]["field"] == 6.0 # wolfpack 4, pendulum 8 + assert rows["stalled"]["value"] == 0.5 + assert rows["fouls"]["value"] is None # not in this round's table + + +def test_a_run_groups_its_rounds_and_its_report_without_the_bulky_stalls(replays): + (run,) = view.load_runs(replays) + assert run["run_id"] == "eval_20261112_100000" and run["reference"] == "pendulum" + assert run["report"]["candidates"]["mirage"]["verdict"] == "dropped" + assert "stalls" not in run["report"]["candidates"]["mirage"] + assert [r["display_a"] for r in run["rounds"][0]["results"]] == ["mirage", "pendulum", "wolfpack"] + + +def test_an_older_round_robin_is_one_round_and_finds_side_tagged_replays(tmp_path): + run = tmp_path / "tournament_1" + _write( + run / "summary.json", + {"run_id": "tournament_1", "results": [_row("a", "b", 1, 0, a_is_right=False, a_kicks_off=True)]}, + ) + (run / "a_vs_b_LK.pkl").write_bytes(b"") + (loaded,) = view.load_runs(tmp_path) + assert loaded["report"] is None + assert loaded["rounds"][0]["results"][0]["replay"] == "tournament_1/a_vs_b_LK.pkl" + + +def test_no_replays_folder_gives_empty_pages(tmp_path): + assert view.load_runs(tmp_path / "missing") == [] + assert all(not s["matches"] for s in view.load_strategies(tmp_path / "missing")["strategies"]) diff --git a/utama_core/tests/dashboard/test_tournament_view.py b/utama_core/tests/dashboard/test_tournament_view.py deleted file mode 100644 index f9f1e04d..00000000 --- a/utama_core/tests/dashboard/test_tournament_view.py +++ /dev/null @@ -1,52 +0,0 @@ -"""Tests for `utama_core.dashboard.views.tournament`'s `/tournament/runs` payload.""" - -from __future__ import annotations - -import json - -from utama_core.dashboard.views import tournament as tournament_view - - -def _write_run(root, results): - run = root / "tournament_1" - run.mkdir() - (run / "summary.json").write_text(json.dumps({"run_id": "tournament_1", "results": results})) - return run - - -def test_each_match_carries_the_path_of_its_replay_when_the_file_exists(tmp_path, monkeypatch): - # evaluate.py names a replay "_vs_.npz"; the dashboard must not guess - # another runner's naming and link to a file that isn't there - run = _write_run( - tmp_path, - [ - {"config_a": "low_block", "config_b": "three_slot"}, - {"config_a": "tiki_taka", "config_b": "riptide"}, - ], - ) - (run / "low_block_vs_three_slot.npz").write_bytes(b"") - monkeypatch.setattr(tournament_view, "REPLAY_BASE_PATH", tmp_path) - - (loaded,) = tournament_view._load_runs() - - assert [r["replay"] for r in loaded["results"]] == ["tournament_1/low_block_vs_three_slot.npz", None] - - -def test_replays_with_side_and_kickoff_tags_are_found(tmp_path, monkeypatch): - run = _write_run( - tmp_path, - [ - { - "config_a": "a", - "config_b": "b", - "a_is_right": False, - "a_kicks_off": True, - } - ], - ) - (run / "a_vs_b_LK.pkl").write_bytes(b"") - monkeypatch.setattr(tournament_view, "REPLAY_BASE_PATH", tmp_path) - - (loaded,) = tournament_view._load_runs() - - assert loaded["results"][0]["replay"] == "tournament_1/a_vs_b_LK.pkl" From 026d9b47f67b04d0308f12fc6e4f60da2500ce6e Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 22:18:01 +0000 Subject: [PATCH 47/59] dashboard: runs send each match's stall flag, not its full stats (12 MB to 0.7 MB) Co-Authored-By: Claude Opus 5.5 --- utama_core/dashboard/static/strategies.js | 3 +-- utama_core/dashboard/views/strategies.py | 14 ++++++++++---- utama_core/tests/dashboard/test_strategies_view.py | 8 ++++++-- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js index 6b6fe6b3..5cce2ec7 100644 --- a/utama_core/dashboard/static/strategies.js +++ b/utama_core/dashboard/static/strategies.js @@ -227,11 +227,10 @@ function renderRoundMatches(round) { const rows = (round.results || []) .map((r) => { - const stalled = ((r.stats || {}).stall_events || []).length || r.possession_backstop; return ( `${esc(r.display_a)} (yellow) vs ${esc(r.display_b)}` + `${r.score_a} – ${r.score_b}` + - `${stalled ? 'stalled' : ""}${r.reused ? 'from store' : ""}` + + `${r.stalled ? 'stalled' : ""}${r.reused ? 'from store' : ""}` + `${replayButton(r.replay)}` ); }) diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py index 7f9e6979..ec81bb55 100644 --- a/utama_core/dashboard/views/strategies.py +++ b/utama_core/dashboard/views/strategies.py @@ -149,6 +149,10 @@ def tactics_of(path: Path) -> list[dict]: return list(found.values()) +def _stalled(result: dict) -> bool: + return bool((result.get("stats") or {}).get("stall_events") or result.get("possession_backstop")) + + def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict]: out = [] for _, summary in summaries: @@ -159,7 +163,6 @@ def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict] if name not in (a, b) or a == b or r.get("reused"): continue mine, theirs, opponent = (r["score_a"], r["score_b"], b) if a == name else (r["score_b"], r["score_a"], a) - stats = r.get("stats") or {} out.append( { "opponent": opponent, @@ -167,7 +170,7 @@ def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict] "seed": r.get("seed"), "run_id": run_id, "date": run_date(run_id), - "stalled": bool(stats.get("stall_events") or r.get("possession_backstop")), + "stalled": _stalled(r), "replay": r.get("replay"), } ) @@ -273,8 +276,8 @@ def load_strategies(base: Optional[Path] = None) -> dict: def load_runs(base: Optional[Path] = None) -> list[dict]: """Every run, newest first: an `evaluate.py` run is its report (if it finished) and its rounds; - an older round robin is one round. Names in results stay as recorded; the page shows them through - the same mapping as `/strategies` does on the server (`display` on each result).""" + an older round robin is one round. Names in results stay as recorded, with `display_a`/`display_b` + the catalog names; each result's `stats` is replaced by `stalled`.""" base = Path(base or REPLAY_BASE_PATH) if not base.exists(): return [] @@ -282,6 +285,9 @@ def load_runs(base: Optional[Path] = None) -> list[dict]: for path, summary in _summaries(base): for r in summary.get("results", []): r["display_a"], r["display_b"] = display_name(r["config_a"]), display_name(r["config_b"]) + # the page needs only whether it stalled; the full stats are ~95% of the payload + r["stalled"] = _stalled(r) + r.pop("stats", None) run_dir = path.parent.parent if path.parent.name.startswith("round_") else path.parent run = runs.setdefault( run_dir.name, {"run_id": run_dir.name, "date": run_date(run_dir.name), "report": None, "rounds": []} diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py index 9f0d7997..6401b426 100644 --- a/utama_core/tests/dashboard/test_strategies_view.py +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -30,7 +30,7 @@ def replays(tmp_path): "round": 1, "seed": 1, "results": [ - _row("mirage", "wolfpack", 3, 1), + _row("mirage", "wolfpack", 3, 1, stats={"stall_events": [{"t": 40.0}], "shots": 9}), _row(frozen, "mirage", 2, 0), _row("wolfpack", "mirage", 1, 1, reused=True), # played by an earlier run ], @@ -116,7 +116,11 @@ def test_a_run_groups_its_rounds_and_its_report_without_the_bulky_stalls(replays assert run["run_id"] == "eval_20261112_100000" and run["reference"] == "pendulum" assert run["report"]["candidates"]["mirage"]["verdict"] == "dropped" assert "stalls" not in run["report"]["candidates"]["mirage"] - assert [r["display_a"] for r in run["rounds"][0]["results"]] == ["mirage", "pendulum", "wolfpack"] + results = run["rounds"][0]["results"] + assert [r["display_a"] for r in results] == ["mirage", "pendulum", "wolfpack"] + # only the stall flag of each match's stats is sent: the full stats are megabytes over all runs + assert [r["stalled"] for r in results] == [True, False, False] + assert not any("stats" in r for r in results) def test_an_older_round_robin_is_one_round_and_finds_side_tagged_replays(tmp_path): From 43c70a8a410a972dfb4babb11975ee6204e773bc Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 22:27:25 +0000 Subject: [PATCH 48/59] fix: paths one folder off after dropping src/; colours by seed; stale tests - robot_profile, find_robots, robosim_wrapper counted folders up from where they sat before the src/ layer went: profiles loaded blank (no kick bend or carry caps on real robots), the robot pairing and the robosim build env pointed outside the repo - evaluate.py: colours follow the seed, not the round, so a confirm seed has the same colours whatever ROUNDS was; identical at ROUNDS=6, so no stored match changes - tests: explain's helper deleted with the research tools; fingerprint audit re-sorted after the renames Co-Authored-By: Claude Opus 5.5 --- docs/STRATEGY_DEVELOPMENT.md | 2 +- tools/evaluation/evaluate.py | 7 ++++--- .../simulator/simulators/robosim/robosim_wrapper.py | 2 +- .../controllers/common/robot_profile.py | 2 +- .../team_controller/controllers/real/find_robots.py | 2 +- utama_core/tests/engine/test_evaluate.py | 10 +++++++--- utama_core/tests/engine/test_explain.py | 3 +-- utama_core/tests/replay/test_fingerprint.py | 4 ++-- utama_core/tests/team_controller/test_find_robots.py | 9 +++++++++ 9 files changed, 27 insertions(+), 14 deletions(-) diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 88bcd469..d592b0e2 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -302,7 +302,7 @@ flowchart TD - **Rounds.** Every round is the same round robin, every pair of players once, under noise seed k; after round 1 only the candidates not yet decided stay. The match results store makes it cheap: a match whose code is unchanged is never played again, so a run plays only the matches of edited strategies - (and of a seed never played before). The candidate (then the reference) is config_a in odd rounds + (and of a seed never played before). The candidate (then the reference) is config_a under odd seeds and config_b in even ones, so both meet each opponent in the same colour under the same noise (the noise is drawn per colour and robot, so one seed can favour a colour by half a goal). - **The decision** (`analysis/ratings.py`) is on diffs: the candidate's goal difference against an diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 4bf770da..68978c8c 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -78,12 +78,13 @@ def round_fixtures( under `seed` (k by default). The store holds every match whose code is unchanged, so only the matches of edited strategies, or of a seed not played before, are actually played. The earlier of the two in (candidates, - reference, opponents) order is config_a in odd rounds, so candidates and reference face each - opponent with the same colour.""" + reference, opponents) order is config_a under an odd seed, so candidates and reference face each + opponent with the same colour, and a seed always has the same colours whichever round plays it + (a confirm seed's round depends on `ratings.ROUNDS`).""" seed = k if seed is None else seed order = list(dict.fromkeys([*candidates, reference, *opponents])) pairs = itertools.combinations(order, 2) - return [(x, y, seed) if k % 2 else (y, x, seed) for x, y in pairs] + return [(x, y, seed) if seed % 2 else (y, x, seed) for x, y in pairs] def seed_of(k: int) -> int: diff --git a/utama_core/simulator/simulators/robosim/robosim_wrapper.py b/utama_core/simulator/simulators/robosim/robosim_wrapper.py index da53582c..f94f6660 100644 --- a/utama_core/simulator/simulators/robosim/robosim_wrapper.py +++ b/utama_core/simulator/simulators/robosim/robosim_wrapper.py @@ -188,7 +188,7 @@ def __init__(self, sim_type, n_blue, n_yellow, field_type, time_step_ms): # Ensure rc-robosim's scikit-build uses a compatible CMake policy level. env["CMAKE_ARGS"] = f"{env.get('CMAKE_ARGS', '')} {cmake_policy_flag}".strip() env["SKBUILD_CMAKE_ARGS"] = f"{env.get('SKBUILD_CMAKE_ARGS', '')} {cmake_policy_flag}".strip() - project_root = Path(__file__).resolve().parents[5] + project_root = Path(__file__).resolve().parents[4] robosim_env = project_root / ".pixi" / "envs" / "robosim" robosim_python = robosim_env / "bin" / "python" include_dir = robosim_env / "include" diff --git a/utama_core/team_controller/controllers/common/robot_profile.py b/utama_core/team_controller/controllers/common/robot_profile.py index 279e3183..0c3831b3 100644 --- a/utama_core/team_controller/controllers/common/robot_profile.py +++ b/utama_core/team_controller/controllers/common/robot_profile.py @@ -84,7 +84,7 @@ class RobotProfile: # One file per robot, by radio ID: `pixi run calibrate` writes it, every script reads it. -PROFILE_DIR = Path(__file__).resolve().parents[4] / "config" / "robots" +PROFILE_DIR = Path(__file__).resolve().parents[3] / "config" / "robots" def profile_path(radio_id: int, directory: Path = PROFILE_DIR) -> Path: diff --git a/utama_core/team_controller/controllers/real/find_robots.py b/utama_core/team_controller/controllers/real/find_robots.py index d3988648..3df4fe98 100644 --- a/utama_core/team_controller/controllers/real/find_robots.py +++ b/utama_core/team_controller/controllers/real/find_robots.py @@ -38,7 +38,7 @@ SSL_WrapperPacket, ) -FOUND_PATH = Path(__file__).resolve().parents[5] / "replays" / "field" / "robots_found.json" +FOUND_PATH = Path(__file__).resolve().parents[4] / "replays" / "field" / "robots_found.json" RADIOS = tuple(range(8)) TICK_S = 1 / 60 ANSWER_S = 0.3 # still, listening for the radio's answer and the lids' headings before the turn diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index b161d526..21828d2b 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -67,9 +67,13 @@ def test_a_decision_uses_its_stages_seeds_only(): assert list(evaluate._with_seeds(ledger, {101})) == ["101"] -def test_a_rounds_seed_can_differ_from_its_number_but_colours_follow_the_round(): - fixtures = evaluate.round_fixtures(1, ["c"], "ref", ["o"], seed=101) - assert ("c", "o", 101) in fixtures and ("ref", "o", 101) in fixtures +def test_colours_follow_the_seed_not_the_round(): + # a confirm seed is played in round ROUNDS+1 or later, so a run with another ROUNDS plays it in a + # round of the other parity: the store would then hold it in both colours, and the verdict would + # count both (test_the_verdict_does_not_depend_on_other_seeds_already_in_the_store) + for k in (1, 2, 7, 8): + assert ("c", "o", 101) in evaluate.round_fixtures(k, ["c"], "ref", ["o"], seed=101) + assert ("o", "c", 102) in evaluate.round_fixtures(k, ["c"], "ref", ["o"], seed=102) def test_the_players_load_and_the_core_is_in_the_catalog(): diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index 15400acf..1143a7fc 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -6,7 +6,6 @@ import pytest -from tools.debug import pitch_maps as pm from tools.evaluation import explain from utama_core.entities.data.referee import RefereeData from utama_core.entities.data.vector import Vector2D, Vector3D @@ -56,7 +55,7 @@ def _referee(score_yellow, score_blue): def _write_match(run_dir, a, b, score_a, score_b, seed=None): """A three-tick match, config_a (yellow, friendly) scoring `score_a`; the team with the ball is always the friendly one. Written the way `evaluate.py` names their files.""" - stem = f"{pm.sr.short(a)}_vs_{pm.sr.short(b)}" + ("" if seed is None else f"_s{seed}") + stem = f"{explain._short_name(a)}_vs_{explain._short_name(b)}" + ("" if seed is None else f"_s{seed}") path = run_dir / f"{stem}.npz" cfg = ColumnarReplayWriterConfig(replay_name=stem, overwrite_existing=True, checkpoint_every_s=0) writer = ColumnarReplayWriter(cfg, my_team_is_yellow=True, exp_friendly=3, exp_enemy=3, path=path) diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index ae295ad6..cf3dee45 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -416,18 +416,18 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): ], "dynamic import": ["utama_core.strategy.catalog"], "module-level state": [ + "utama_core.geometry.pass_and_score_geometry", "utama_core.motion_planning.fastpathplanning.planner", "utama_core.simulator.simulators.robosim.robosim_wrapper", - "utama_core.geometry.pass_and_score_geometry", "utama_core.skills.shielding", "utama_core.strategy.pickers", ], "opens files": [ "utama_core.bundle.archive", "utama_core.bundle.strategy_file", - "utama_core.referee.profiles.profile_loader", "utama_core.engine.match_log", "utama_core.engine.match_stats", + "utama_core.referee.profiles.profile_loader", "utama_core.replay.columnar_reader", "utama_core.replay.columnar_writer", "utama_core.replay.game_log_writer", diff --git a/utama_core/tests/team_controller/test_find_robots.py b/utama_core/tests/team_controller/test_find_robots.py index 6fdf91e7..03326418 100644 --- a/utama_core/tests/team_controller/test_find_robots.py +++ b/utama_core/tests/team_controller/test_find_robots.py @@ -135,3 +135,12 @@ def test_confirm_finds_again_when_a_saved_lid_is_not_in_view_or_it_never_ran(tmp def test_confirm_stops_when_a_radio_is_not_found(tmp_path, field): with pytest.raises(SystemExit, match="Radio 2 not found"): fr.confirm([0, 2], tmp_path / "found.json", look=set, finder=_finder(field)) + + +def test_the_pairing_and_the_profiles_live_inside_the_repo(): + # both paths count folders up from their module, and moving the module once pointed them + # outside the repo (profiles then loaded blank, with no error) + repo = fr.PROFILE_DIR.parents[2] + assert (repo / "pixi.toml").exists() + assert fr.PROFILE_DIR == repo / "utama_core" / "config" / "robots" + assert fr.FOUND_PATH == repo / "replays" / "field" / "robots_found.json" From 3b318674e159fc88a8cccd2670bc7a520e5175d9 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 22:52:11 +0000 Subject: [PATCH 49/59] docs: regenerate the package graph and data-flow picture after the renames Co-Authored-By: Claude Opus 5.5 --- docs/architecture.md | 132 ++++++++++++---------- docs/img/architecture/match_data_flow.png | Bin 143692 -> 143328 bytes 2 files changed, 72 insertions(+), 60 deletions(-) diff --git a/docs/architecture.md b/docs/architecture.md index 0c5bcf0b..17ed4970 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -90,89 +90,101 @@ The rule the script checks: `replay/` never imports `analysis/` (see [AGENTS.md] ```mermaid flowchart LR - p_analysis["analysis"] -->|11| p_config["config"] - p_analysis["analysis"] -->|3| p_engine["engine"] - p_analysis["analysis"] -->|11| p_entities["entities"] - p_analysis["analysis"] -->|8| p_replay["replay"] + p_analysis["analysis"] -->|20| p_config["config"] + p_analysis["analysis"] -->|4| p_engine["engine"] + p_analysis["analysis"] -->|26| p_entities["entities"] + p_analysis["analysis"] -->|2| p_motion_planning["motion_planning"] + p_analysis["analysis"] -->|1| p_referee["referee"] + p_analysis["analysis"] -->|16| p_replay["replay"] p_analysis["analysis"] -->|1| p_simulator["simulator"] + p_analysis["analysis"] -->|6| p_strategy["strategy"] + p_analysis["analysis"] -->|2| p_team_controller["team_controller"] + p_bundle["bundle"] -->|3| p_config["config"] + p_bundle["bundle"] -->|5| p_engine["engine"] + p_bundle["bundle"] -->|7| p_entities["entities"] + p_bundle["bundle"] -->|1| p_motion_planning["motion_planning"] + p_bundle["bundle"] -->|2| p_strategy["strategy"] p_config["config"] -->|1| p_geometry["geometry"] - p_referee["referee"] -->|20| p_config["config"] - p_referee["referee"] -->|48| p_entities["entities"] - p_referee["referee"] -->|2| p_geometry["geometry"] - p_referee["referee"] -->|1| p_geometry["geometry"] - p_referee["referee"] -->|1| p_skills["skills"] - p_dashboard["dashboard"] -->|1| p_analysis["analysis"] + p_dashboard["dashboard"] -->|2| p_analysis["analysis"] p_dashboard["dashboard"] -->|3| p_config["config"] - p_dashboard["dashboard"] -->|3| p_referee["referee"] - p_dashboard["dashboard"] -->|1| p_engine["engine"] + p_dashboard["dashboard"] -->|2| p_engine["engine"] p_dashboard["dashboard"] -->|2| p_entities["entities"] + p_dashboard["dashboard"] -->|3| p_referee["referee"] p_dashboard["dashboard"] -->|2| p_replay["replay"] - p_data_processing["data_processing"] -->|6| p_config["config"] - p_data_processing["data_processing"] -->|26| p_entities["entities"] - p_data_processing["data_processing"] -->|2| p_geometry["geometry"] + p_dashboard["dashboard"] -->|2| p_run["run"] + p_dashboard["dashboard"] -->|1| p_strategy["strategy"] + p_dashboard["dashboard"] -->|1| p_tactics["tactics"] + p_data_processing["data_processing"] -->|7| p_config["config"] + p_data_processing["data_processing"] -->|27| p_entities["entities"] + p_data_processing["data_processing"] -->|1| p_geometry["geometry"] p_data_processing["data_processing"] -->|4| p_team_controller["team_controller"] p_engine["engine"] -->|3| p_config["config"] - p_engine["engine"] -->|2| p_referee["referee"] - p_engine["engine"] -->|17| p_entities["entities"] - p_engine["engine"] -->|1| p_geometry["geometry"] + p_engine["engine"] -->|25| p_entities["entities"] + p_engine["engine"] -->|3| p_geometry["geometry"] p_engine["engine"] -->|3| p_motion_planning["motion_planning"] + p_engine["engine"] -->|2| p_referee["referee"] p_engine["engine"] -->|1| p_simulator["simulator"] - p_engine["engine"] -->|1| p_skills["skills"] + p_engine["engine"] -->|3| p_skills["skills"] + p_engine["engine"] -->|1| p_strategy["strategy"] p_engine["engine"] -->|1| p_tactics["tactics"] - p_engine["engine"] -->|1| p_team_controller["team_controller"] + p_engine["engine"] -->|2| p_team_controller["team_controller"] p_entities["entities"] -->|1| p_config["config"] - p_geometry["geometry"] -->|1| p_config["config"] - p_geometry["geometry"] -->|2| p_entities["entities"] - p_motion_planning["motion_planning"] -->|23| p_config["config"] - p_motion_planning["motion_planning"] -->|23| p_entities["entities"] + p_geometry["geometry"] -->|4| p_config["config"] + p_geometry["geometry"] -->|6| p_entities["entities"] + p_geometry["geometry"] -->|1| p_motion_planning["motion_planning"] + p_geometry["geometry"] -->|1| p_skills["skills"] + p_motion_planning["motion_planning"] -->|25| p_config["config"] + p_motion_planning["motion_planning"] -->|25| p_entities["entities"] p_motion_planning["motion_planning"] -->|3| p_geometry["geometry"] p_motion_planning["motion_planning"] -->|8| p_simulator["simulator"] - p_replay["replay"] -->|6| p_config["config"] - p_replay["replay"] -->|1| p_referee["referee"] + p_referee["referee"] -->|20| p_config["config"] + p_referee["referee"] -->|47| p_entities["entities"] + p_referee["referee"] -->|4| p_geometry["geometry"] + p_referee["referee"] -->|2| p_skills["skills"] + p_replay["replay"] -->|1| p_bundle["bundle"] + p_replay["replay"] -->|4| p_config["config"] p_replay["replay"] -->|1| p_data_processing["data_processing"] - p_replay["replay"] -->|20| p_entities["entities"] - p_replay["replay"] -->|2| p_geometry["geometry"] + p_replay["replay"] -->|22| p_entities["entities"] + p_replay["replay"] -->|1| p_geometry["geometry"] + p_replay["replay"] -->|1| p_referee["referee"] p_replay["replay"] -->|5| p_simulator["simulator"] - p_replay["replay"] -->|3| p_team_controller["team_controller"] - p_simulator["simulator"] -->|4| p_config["config"] - p_simulator["simulator"] -->|3| p_entities["entities"] - p_simulator["simulator"] -->|2| p_geometry["geometry"] - p_run["run"] -->|8| p_config["config"] - p_run["run"] -->|4| p_referee["referee"] + p_replay["replay"] -->|1| p_strategy["strategy"] + p_replay["replay"] -->|4| p_team_controller["team_controller"] + p_run["run"] -->|1| p_bundle["bundle"] + p_run["run"] -->|9| p_config["config"] p_run["run"] -->|4| p_data_processing["data_processing"] - p_run["run"] -->|4| p_engine["engine"] - p_run["run"] -->|12| p_entities["entities"] + p_run["run"] -->|5| p_engine["engine"] + p_run["run"] -->|18| p_entities["entities"] p_run["run"] -->|2| p_geometry["geometry"] - p_run["run"] -->|2| p_motion_planning["motion_planning"] - p_run["run"] -->|2| p_replay["replay"] - p_run["run"] -->|6| p_simulator["simulator"] - p_run["run"] -->|1| p_geometry["geometry"] + p_run["run"] -->|3| p_motion_planning["motion_planning"] + p_run["run"] -->|6| p_referee["referee"] + p_run["run"] -->|3| p_replay["replay"] + p_run["run"] -->|7| p_simulator["simulator"] p_run["run"] -->|1| p_skills["skills"] - p_run["run"] -->|1| p_team_controller["team_controller"] + p_run["run"] -->|2| p_strategy["strategy"] + p_run["run"] -->|2| p_team_controller["team_controller"] p_run["run"] -->|1| p_tests["tests"] - p_geometry["geometry"] -->|3| p_config["config"] - p_geometry["geometry"] -->|4| p_entities["entities"] - p_geometry["geometry"] -->|1| p_motion_planning["motion_planning"] - p_geometry["geometry"] -->|1| p_skills["skills"] - p_skills["skills"] -->|6| p_config["config"] + p_simulator["simulator"] -->|4| p_config["config"] + p_simulator["simulator"] -->|3| p_entities["entities"] + p_simulator["simulator"] -->|2| p_geometry["geometry"] + p_skills["skills"] -->|7| p_config["config"] p_skills["skills"] -->|2| p_data_processing["data_processing"] - p_skills["skills"] -->|1| p_engine["engine"] - p_skills["skills"] -->|26| p_entities["entities"] - p_skills["skills"] -->|2| p_geometry["geometry"] + p_skills["skills"] -->|2| p_engine["engine"] + p_skills["skills"] -->|25| p_entities["entities"] + p_skills["skills"] -->|5| p_geometry["geometry"] p_skills["skills"] -->|8| p_motion_planning["motion_planning"] - p_skills["skills"] -->|3| p_geometry["geometry"] - p_strategy["strategy"] -->|65| p_engine["engine"] - p_strategy["strategy"] -->|22| p_entities["entities"] - p_strategy["strategy"] -->|23| p_motion_planning["motion_planning"] - p_strategy["strategy"] -->|63| p_tactics["tactics"] - p_tactics["tactics"] -->|6| p_config["config"] - p_tactics["tactics"] -->|25| p_engine["engine"] - p_tactics["tactics"] -->|40| p_entities["entities"] + p_strategy["strategy"] -->|36| p_engine["engine"] + p_strategy["strategy"] -->|12| p_entities["entities"] + p_strategy["strategy"] -->|13| p_motion_planning["motion_planning"] + p_strategy["strategy"] -->|36| p_tactics["tactics"] + p_tactics["tactics"] -->|7| p_config["config"] + p_tactics["tactics"] -->|29| p_engine["engine"] + p_tactics["tactics"] -->|43| p_entities["entities"] + p_tactics["tactics"] -->|16| p_geometry["geometry"] p_tactics["tactics"] -->|1| p_motion_planning["motion_planning"] - p_tactics["tactics"] -->|15| p_geometry["geometry"] p_tactics["tactics"] -->|36| p_skills["skills"] - p_team_controller["team_controller"] -->|10| p_config["config"] - p_team_controller["team_controller"] -->|7| p_entities["entities"] + p_team_controller["team_controller"] -->|12| p_config["config"] + p_team_controller["team_controller"] -->|12| p_entities["entities"] p_team_controller["team_controller"] -->|1| p_geometry["geometry"] p_team_controller["team_controller"] -->|2| p_simulator["simulator"] p_team_controller["team_controller"] -->|1| p_skills["skills"] diff --git a/docs/img/architecture/match_data_flow.png b/docs/img/architecture/match_data_flow.png index bd3dbe6cc2b44de3c906b2dbaf46ad6d104eb5b5..6e9983ad154bc916f9dbe3ec87bb1b52be392648 100644 GIT binary patch delta 51453 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 delta 51934 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 Date: Thu, 12 Nov 2026 22:53:58 +0000 Subject: [PATCH 50/59] dashboard: a strategy page with less text The summary without the name and boilerplate, tactics as chips, verdict and code on one line each (details on hover), signals from a real round not an exhibition match, matches of the newest run only. Co-Authored-By: Claude Opus 5.5 --- utama_core/dashboard/static/app.css | 6 ++- utama_core/dashboard/static/strategies.js | 53 ++++++++++--------- utama_core/dashboard/views/strategies.py | 35 +++++++++--- .../tests/dashboard/test_strategies_view.py | 16 ++++++ 4 files changed, 77 insertions(+), 33 deletions(-) diff --git a/utama_core/dashboard/static/app.css b/utama_core/dashboard/static/app.css index 6041d8e3..03ed6e83 100644 --- a/utama_core/dashboard/static/app.css +++ b/utama_core/dashboard/static/app.css @@ -248,7 +248,6 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } .strategy-item:hover { background: var(--surface-2); } .strategy-item.active { border-left-color: var(--accent); background: var(--surface-2); } .strategy-summary { font-size: .72rem; margin-top: 2px; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; } -.strategy-doc { font-size: .75rem; margin-top: 6px; white-space: pre-wrap; } .signal-row { display: grid; grid-template-columns: 170px 1fr 56px 56px; gap: 8px; align-items: center; font-size: .75rem; padding: 2px 0; } .signal-bar { position: relative; height: 10px; background: var(--surface-2); border-radius: 2px; } .signal-fill { height: 100%; background: var(--accent); border-radius: 2px; } @@ -259,3 +258,8 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } .strategy-list { width: 100%; max-height: 40vh; } .signal-row { grid-template-columns: 110px 1fr 44px 44px; } } + +.strategy-facts { display: grid; grid-template-columns: max-content 1fr; gap: 6px 14px; align-items: baseline; } +.strategy-facts .ref-section-title { margin: 0; } +.tactic-chip { display: inline-block; padding: 1px 8px; border: 1px solid var(--border, #333); border-radius: 10px; font-size: .74rem; cursor: help; } +.strategy-summary { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js index 5cce2ec7..d955e78d 100644 --- a/utama_core/dashboard/static/strategies.js +++ b/utama_core/dashboard/static/strategies.js @@ -30,7 +30,7 @@ return `${label}`; } function replayButton(path, atTime, label) { - if (!path) return `no replay`; + if (!path) return ""; const at = atTime != null ? ` data-at="${atTime}"` : ""; return ``; } @@ -59,21 +59,22 @@ } function renderTactics(s) { - if (!s.tactics.length) return '

No tactics imported from utama_core/tactics (it defines its own).
'; + if (!s.tactics.length) return 'its own'; + // one chip per tactic; what it does and its file on hover return s.tactics - .map((t) => `
${esc(t.name)} ${esc(t.file)}
` + - (t.description ? `
${esc(t.description)}
` : "")) - .join(""); + .map((t) => `${esc(t.name.replace(/Tactic$/, ""))}`) + .join(" "); } function renderVerdicts(s) { if (!s.verdicts.length) { - return `
Never evaluated. Run pixi run evaluate ${esc(s.name)} to see if it beats the champion.
`; + return `not evaluated`; } return s.verdicts .map((v) => - `
${verdictBadge(v.verdict)} in the ${esc(v.decided_in)} after ${v.rounds} round(s) · ` + - `${testLine(v)} · vs ${esc(v.reference)}${esc(v.date || v.run_id)}
`) + `
` + + `${verdictBadge(v.verdict)} ${signed(v.mean)} ± ${num(v.se)} goals/match vs ${esc(v.reference)} ` + + `${esc(v.date || v.run_id)}
`) .join(""); } @@ -95,25 +96,26 @@ ); }) .join(""); + const title = `${sig.matches} matches in ${sig.run_id}. More is not better: these explain how it plays (docs/signals.md).`; return ( - `
Per match, ${sig.matches} matches in ${esc(sig.run_id)} ` + - `(${esc(sig.date || "")}). The tick and the grey number: the other strategies' average in that round. ` + - `More is not better: these explain how it plays (docs/signals.md).
` + - `
thisothers
` + + `
per match, ${esc(sig.date || "")}` + + `thisothers
` + rows ); } function renderMatchList(s) { - if (!s.matches.length) return '
No recorded matches.
'; - const shown = showAllMatches ? s.matches : s.matches.slice(0, 30); + if (!s.matches.length) return '
None yet.
'; + // the newest run's matches; older ones (older code, maybe older names) on request + const newest = s.matches[0].run_id; + const shown = showAllMatches ? s.matches : s.matches.filter((m) => m.run_id === newest); const rows = shown .map((m) => { const [f, a] = m.score; const res = f > a ? "check-ok" : f < a ? "check-fail" : "muted"; return ( `vs ${esc(m.opponent)}${f} – ${a}` + - `${m.seed ?? "—"}${esc(m.date || "")}` + + `${esc(m.date || "")}` + `${m.stalled ? 'stalled' : ""}` + `${replayButton(m.replay)}` ); @@ -121,29 +123,30 @@ .join(""); const more = s.matches.length > shown.length - ? `` + ? `` : ""; return ( - `` + - `${rows}
OpponentScoreSeedDate
${more}` + `` + + `${rows}
${more}` ); } function renderStrategy(s) { const old = s.old_names.length ? ` (was ${s.old_names.map(esc).join(", ")})` : ""; - const rest = s.description.split("\n\n").slice(1).join("\n\n"); + const facts = [ + ["Tactics", renderTactics(s)], + ["Verdict", renderVerdicts(s)], + ["Code", `${esc(s.file)}`], + ]; return ` -
+

${esc(s.name)}${old}

${roleBadge(s.role)}
${esc(s.summary)}
- ${rest ? `
${esc(rest)}
` : ""} -
${esc(s.file)} · watch it: pixi run main ${esc(s.name)} wolfpack
-
Tactics it uses
${renderTactics(s)}
-
Verdicts (against the champion)
${renderVerdicts(s)}
+
${facts.map(([k, v]) => `${k}
${v}
`).join("")}
How it plays
${renderSignals(s)}
-
Matches (${s.matches.length})
${renderMatchList(s)}
+
Matches
${renderMatchList(s)}
`; } diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py index ec81bb55..e60793e1 100644 --- a/utama_core/dashboard/views/strategies.py +++ b/utama_core/dashboard/views/strategies.py @@ -127,6 +127,20 @@ def _first_line(text: str) -> str: return text.strip().split("\n\n")[0].replace("\n", " ") if text else "" +# a strategy docstring opens "`name` (until `old`): what it does. The pickers only it uses are +# here."; the page already shows the name and old names +_NAME_PREFIX = re.compile(r"^`[^`]+`(\s*\(until [^)]*\))?:\s*") +_BOILERPLATE = re.compile(r"\s*[^.]*\bpickers only it uses\b[^.]*\.?") + + +def summary_of(doc: str) -> str: + """What the strategy does, in one line, without its name or the docstring's boilerplate.""" + line = _BOILERPLATE.sub("", _NAME_PREFIX.sub("", _first_line(doc))).strip() + if not line.startswith("`"): # a strategy's name stays lower case + line = line[:1].upper() + line[1:] + return line.replace("`", "") + + def tactics_of(path: Path) -> list[dict]: """The tactics a strategy file imports from `utama_core.tactics`, each with its module's first docstring paragraph. Read from source: importing would run the module.""" @@ -190,13 +204,20 @@ def _rate(row: dict, key: str, per: Optional[str]) -> Optional[float]: return value / n if n else None +MIN_SIGNAL_MATCHES = 3 # fewer is an exhibition match, not a round: its averages say little + + def signals_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> Optional[dict]: - """Per-match signals in the newest round with a strategy table that `name` played in, beside the - mean of the other strategies there. A comparison with the field, not a ranking.""" - for _, summary in summaries: - table = {display_name(k): v for k, v in (summary.get("strategies") or {}).items()} - if name not in table: - continue + """Per-match signals in the newest round with a strategy table that `name` played at least + `MIN_SIGNAL_MATCHES` in (else the newest it played in at all), beside the mean of the other + strategies there. A comparison with the field, not a ranking.""" + tables = [ + (summary, {display_name(k): v for k, v in (summary.get("strategies") or {}).items()}) + for _, summary in summaries + ] + tables = [(summary, t) for summary, t in tables if name in t] + full = [(summary, t) for summary, t in tables if (t[name].get("matches") or 0) >= MIN_SIGNAL_MATCHES] + for summary, table in (full or tables)[:1]: others = [row for n, row in table.items() if n != name] rows = [] for key, label, per in SIGNALS: @@ -258,7 +279,7 @@ def load_strategies(base: Optional[Path] = None) -> dict: { "name": name, "role": "champion" if name == champion else "core" if name in core else "reserve", - "summary": _first_line(doc), + "summary": summary_of(doc), "description": doc, "file": str(path.relative_to(REPO)), "old_names": sorted(old for old, new in catalog.RENAMED.items() if new == name), diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py index 6401b426..b7752925 100644 --- a/utama_core/tests/dashboard/test_strategies_view.py +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -72,6 +72,22 @@ def test_frozen_files_and_old_names_show_as_the_catalog_name(): assert view.display_name("high_press") == "wolfpack" +def test_the_summary_drops_the_name_and_the_boilerplate(): + doc = "`wolfpack` (until 2026-11-12 `high_press`): hunts the ball high up. The pickers only it uses are here." + assert view.summary_of(doc) == "Hunts the ball high up." + assert view.summary_of("Helpers shared by more than one strategy.") == "Helpers shared by more than one strategy." + + +def test_signals_come_from_a_real_round_not_a_newer_exhibition_match(replays, monkeypatch): + monkeypatch.setattr(view, "MIN_SIGNAL_MATCHES", 2) # mirage plays 2 in the fixture's round + _write( + replays / "tournament_20261113_000000" / "summary.json", + {"run_id": "tournament_20261113_000000", "results": [], "strategies": {"mirage": {"matches": 1, "shots": 99}}}, + ) + sig = _strategy(view.load_strategies(replays), "mirage")["signals"] + assert sig["run_id"] == "eval_20261112_100000/round_1" + + def test_every_catalog_strategy_is_listed_once_with_its_role(replays): payload = view.load_strategies(replays) names = [s["name"] for s in payload["strategies"]] From 26681d0ee1d5c22f039311b9b836a49f6bfee7f5 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 23:14:47 +0000 Subject: [PATCH 51/59] dashboard: runs newest first by date; the frozen reference as 'name (last release)' Runs were sorted by id, so every tournament_ run came before any eval_ run and a strategy's page showed old signals and matches. evaluate.py records the reference as name@commit: now mapped to its catalog name, marked in match lists and kept out of the signals' comparison. Co-Authored-By: Claude Opus 5.5 --- utama_core/dashboard/views/strategies.py | 28 ++++++++++++++----- .../tests/dashboard/test_strategies_view.py | 15 ++++++++-- 2 files changed, 33 insertions(+), 10 deletions(-) diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py index e60793e1..c195c8ad 100644 --- a/utama_core/dashboard/views/strategies.py +++ b/utama_core/dashboard/views/strategies.py @@ -54,14 +54,25 @@ def attach(server: DashboardServer) -> None: # --- names ------------------------------------------------------------------------------------ +def is_frozen(config: str) -> bool: + """A player from a `.strategy` file: recorded as its path or as `name@commit`.""" + return config.endswith(".strategy") or "@" in config + + def display_name(config: str) -> str: - """`config` as the catalog calls it today: `replays/eval/frozen/pendulum@ab12.strategy` and - `build_split_shape_kernel_strategy` both become a plain catalog name.""" - if config.endswith(".strategy"): - config = Path(config).stem.split("@")[0] + """`config` as the catalog calls it today: `replays/eval/frozen/pendulum@ab12.strategy`, + `split_shape@ab12` and `build_split_shape_kernel_strategy` all become a plain catalog name.""" + if is_frozen(config): + config = Path(config).name.removesuffix(".strategy").split("@")[0] return catalog.current_name(config) +def _newest_first(run_id: str) -> tuple: + """A sort key: by the run's date and time (`eval_` and `tournament_` alike), then its id.""" + m = re.search(r"\d{8}_\d{6}", run_id) + return (m[0] if m else "", run_id) + + def run_date(run_id: str) -> Optional[str]: m = re.search(r"(\d{4})(\d{2})(\d{2})", run_id) return f"{m[1]}-{m[2]}-{m[3]}" if m else None @@ -90,7 +101,7 @@ def _summaries(base: Path) -> list[tuple[Path, dict]]: for result in summary.get("results", []): result["replay"] = _replay_path(base, path.parent, result) out.append((path, summary)) - out.sort(key=lambda ps: ps[1].get("run_id", ""), reverse=True) + out.sort(key=lambda ps: _newest_first(ps[1].get("run_id", "")), reverse=True) return out @@ -177,6 +188,8 @@ def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict] if name not in (a, b) or a == b or r.get("reused"): continue mine, theirs, opponent = (r["score_a"], r["score_b"], b) if a == name else (r["score_b"], r["score_a"], a) + if is_frozen(r["config_b"] if a == name else r["config_a"]): + opponent += " (last release)" out.append( { "opponent": opponent, @@ -211,8 +224,9 @@ def signals_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> Optional[di """Per-match signals in the newest round with a strategy table that `name` played at least `MIN_SIGNAL_MATCHES` in (else the newest it played in at all), beside the mean of the other strategies there. A comparison with the field, not a ranking.""" + # a frozen file is not one of today's strategies: left out of both sides of the comparison tables = [ - (summary, {display_name(k): v for k, v in (summary.get("strategies") or {}).items()}) + (summary, {display_name(k): v for k, v in (summary.get("strategies") or {}).items() if not is_frozen(k)}) for _, summary in summaries ] tables = [(summary, t) for summary, t in tables if name in t] @@ -330,4 +344,4 @@ def load_runs(base: Optional[Path] = None) -> list[dict]: } for run in runs.values(): run["rounds"].sort(key=lambda s: s.get("round", 0)) - return sorted(runs.values(), key=lambda r: r["run_id"], reverse=True) + return sorted(runs.values(), key=lambda r: _newest_first(r["run_id"]), reverse=True) diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py index b7752925..28ba0669 100644 --- a/utama_core/tests/dashboard/test_strategies_view.py +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -70,6 +70,7 @@ def test_frozen_files_and_old_names_show_as_the_catalog_name(): assert view.display_name("replays/eval/frozen/pendulum@ab12cd34.strategy") == "pendulum" assert view.display_name("build_split_shape_kernel_strategy") == "pendulum" assert view.display_name("high_press") == "wolfpack" + assert view.display_name("split_shape@cffe3a28") == "pendulum" # how evaluate.py records the reference def test_the_summary_drops_the_name_and_the_boilerplate(): @@ -88,6 +89,11 @@ def test_signals_come_from_a_real_round_not_a_newer_exhibition_match(replays, mo assert sig["run_id"] == "eval_20261112_100000/round_1" +def test_runs_are_newest_first_by_date_whatever_their_prefix(replays): + _write(replays / "tournament_20261110_000000" / "summary.json", {"run_id": "tournament_20261110_000000"}) + assert [r["run_id"] for r in view.load_runs(replays)] == ["eval_20261112_100000", "tournament_20261110_000000"] + + def test_every_catalog_strategy_is_listed_once_with_its_role(replays): payload = view.load_strategies(replays) names = [s["name"] for s in payload["strategies"]] @@ -112,17 +118,20 @@ def test_a_candidates_verdict_is_shown_against_the_champion_by_name(replays): def test_matches_are_from_the_strategys_side_with_their_replays_and_reused_ones_once(replays): matches = _strategy(view.load_strategies(replays), "mirage")["matches"] - assert sorted((m["opponent"], tuple(m["score"])) for m in matches) == [("pendulum", (0, 2)), ("wolfpack", (3, 1))] + assert sorted((m["opponent"], tuple(m["score"])) for m in matches) == [ + ("pendulum (last release)", (0, 2)), + ("wolfpack", (3, 1)), + ] by_opponent = {m["opponent"]: m["replay"] for m in matches} assert by_opponent["wolfpack"] == "eval_20261112_100000/round_1/mirage_vs_wolfpack.npz" - assert by_opponent["pendulum"] is None + assert by_opponent["pendulum (last release)"] is None def test_signals_are_per_match_beside_the_other_strategies_average(replays): sig = _strategy(view.load_strategies(replays), "mirage")["signals"] rows = {r["key"]: r for r in sig["rows"]} assert rows["shots"]["value"] == 5.0 # 10 shots in 2 matches - assert rows["shots"]["field"] == 6.0 # wolfpack 4, pendulum 8 + assert rows["shots"]["field"] == 4.0 # wolfpack; the frozen pendulum file is not in the field assert rows["stalled"]["value"] == 0.5 assert rows["fouls"]["value"] is None # not in this round's table From f39f2d022ca2855a78ce701f4da2522992343301 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 11:25:31 +0000 Subject: [PATCH 52/59] dashboard: light theme, position and shot maps per strategy, newest matches only - Every tab light, sans-serif; the field and timeline colours redrawn for a light page. - A strategy's page: with-ball and without-ball position maps and its shots, drawn from `pitch_maps.py --data` (run in the background once per round, kept as pitch_maps.json); "how it plays" as this-against-others dots; the newest run's matches only. - Runs: evaluate.py runs first; older round robins in one collapsed group. - Fix: the frozen release file's matches were listed as today's strategy's own. Co-Authored-By: Claude Opus 5.5 --- docs/tools.md | 4 +- tools/debug/pitch_maps.py | 47 +++ utama_core/dashboard/static/app.css | 177 +++++---- utama_core/dashboard/static/field_canvas.js | 37 +- utama_core/dashboard/static/replay.js | 2 +- utama_core/dashboard/static/strategies.js | 346 ++++++++++-------- utama_core/dashboard/static/timeline.js | 42 +-- utama_core/dashboard/views/strategies.py | 49 +++ utama_core/tests/analysis/test_pitch_maps.py | 14 + .../tests/dashboard/test_strategies_view.py | 41 +++ 10 files changed, 499 insertions(+), 260 deletions(-) diff --git a/docs/tools.md b/docs/tools.md index 52e4ca69..4ec18bbc 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -12,7 +12,7 @@ New to the repo? You need only these ([first_strategy.md](first_strategy.md) wal | `pixi run main A B` | Watch strategy A (yellow) play strategy B in the simulator | | `pixi run test`, `pixi run lint` | Check nothing broke, before every pull request | | `pixi run evaluate NAME` | Is strategy NAME better than the champion? Read the verdict and the mean diff | -| `pixi run dashboard` | http://localhost:8080: the Strategies tab (every strategy, its tactics, verdicts, signals and matches; every evaluation run) and recorded replays | +| `pixi run dashboard` | http://localhost:8080: the Strategies tab (every strategy, its tactics, verdict, position and shot maps, signals and newest matches; every evaluation run) and recorded replays | Everything below is for specialists. @@ -79,7 +79,7 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/debug/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | +| `tools/debug/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold). `--data PATH`: the position and shot maps' numbers as JSON, no figures (the dashboard runs it once per round and keeps `pitch_maps.json` beside the summary) | | `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | | `tools/dev/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | diff --git a/tools/debug/pitch_maps.py b/tools/debug/pitch_maps.py index 411ee050..bd28c2af 100644 --- a/tools/debug/pitch_maps.py +++ b/tools/debug/pitch_maps.py @@ -15,6 +15,9 @@ - `fouls_map.png`: where the strategy committed its fouls, coloured by rule: the four most common rules in the run, then all other rules. +With `--data PATH` it writes the numbers behind the position and shot maps as JSON instead (the +dashboard's Strategies tab draws them; `map_data`), and no figures. + Possession is `MatchStatsAccumulator`'s notion without its hysteresis: the nearest robot to the ball, within `_POSSESSION_RADIUS_M`, while the ball is slower than `_PASS_RELEASE_MPS`. Positions are sampled every `STEP` ticks in live play (NORMAL_START, FORCE_START); the goalkeeper is the @@ -219,6 +222,43 @@ def shot_marks(views: list[MatchView], strategy: str) -> dict: } +def map_data(views: list[MatchView], order: list[str]) -> dict: + """The position and shot maps' numbers, for the dashboard: per strategy, both position grids + (shares per cell, rows y and columns x, with each robot's mean) and its shots for and against as + (x, y, scored). `vmax` is one colour scale per grid kind across all strategies, as in the figures.""" + out: dict = { + "pitch": { + "half_length": L, + "half_width": W, + "box_depth": BOX_D, + "box_half_width": BOX_W, + "goal_half_width": F.half_goal_width, + "goal_depth": GOAL_D, + "centre_radius": F.center_circle_radius, + }, + "bin_m": BIN_M, + "vmax": {}, + "strategies": {n: {} for n in order}, + } + for key, in_possession in (("attack", True), ("defence", False)): + grids = {n: position_grid(views, n, in_possession) for n in order} + nonzero = [g["share"][g["share"] > 0] for g in grids.values()] + nonzero = np.concatenate(nonzero) if nonzero else np.empty(0) + out["vmax"][key] = float(np.percentile(nonzero, 99)) if nonzero.size else 1.0 + for n, g in grids.items(): + out["strategies"][n][key] = { + "share": np.round(g["share"], 5).tolist(), + "means": [[round(x, 3), round(y, 3)] for x, y in g["means"]], + } + for n in order: + marks = shot_marks(views, n) + out["strategies"][n]["shots"] = { + side: [[round(float(x), 3), round(float(y), 3), bool(scored)] for x, y, scored in marks[side]] + for side in ("own", "faced") + } + return out + + def top_rules(views: list[MatchView], k: int = TOP_RULES) -> list[str]: counts = Counter(f["rule"] for v in views for f in v.fouls) return [rule for rule, _ in counts.most_common(k)] @@ -486,11 +526,18 @@ def main() -> None: parser.add_argument( "--findings", metavar="PATH", help="also write the zone shares per strategy as JSON lines (- for stdout)" ) + parser.add_argument("--data", type=Path, metavar="PATH", help="write the maps' numbers as JSON here, no figures") args = parser.parse_args() summary = json.loads((args.run_dir / "summary.json").read_text()) order = sorted(summary["strategies"], key=plain_name) labels = {n: plain_name(n) for n in order} views = run_views(args.run_dir, args.workers) + if args.data is not None: + played = [n for n in order if any(v.strategy == n for v in views)] + tmp = args.data.with_suffix(".tmp") + tmp.write_text(json.dumps(map_data(views, played))) + tmp.replace(args.data) # whole or not at all: the dashboard may be reading it + return args.out.mkdir(parents=True, exist_ok=True) attack_png = args.out / "positions_attack.png" defence_png = args.out / "positions_defence.png" diff --git a/utama_core/dashboard/static/app.css b/utama_core/dashboard/static/app.css index 03ed6e83..3e99519d 100644 --- a/utama_core/dashboard/static/app.css +++ b/utama_core/dashboard/static/app.css @@ -4,15 +4,19 @@ safety-relevant, not decorative. */ :root { - --bg: #17191d; - --surface: #1e2126; - --surface-2: #262a31; - --border: #33373f; - --text: #dfe2e8; - --muted: #8b909b; - --accent: #7ea6c9; - --halt: #b8615a; - --radius: 5px; + --bg: #f5f6f8; + --surface: #ffffff; + --surface-2: #f0f2f5; + --border: #e2e5ea; + --text: #1c2230; + --muted: #6b7280; + --accent: #2563eb; + --halt: #c53030; + --ok: #15803d; + --warn: #b45309; + --fail: #b91c1c; + --radius: 8px; + --mono: ui-monospace, "SF Mono", "Cascadia Code", monospace; } * , *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; } @@ -22,40 +26,40 @@ html, body { height: 100%; } body { background: var(--bg); color: var(--text); - font-family: ui-monospace, "SF Mono", "Cascadia Code", monospace; + font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", sans-serif; + font-size: 14px; + line-height: 1.45; height: 100vh; display: flex; flex-direction: column; overflow: hidden; } +code, pre { font-family: var(--mono); font-size: .85em; } + #tabs { display: flex; - gap: 2px; - padding: 6px 8px 0; + gap: 4px; + padding: 0 16px; background: var(--surface); border-bottom: 1px solid var(--border); flex-shrink: 0; } .tab { - padding: 7px 16px; - font-size: .72rem; - letter-spacing: .04em; - text-transform: uppercase; + padding: 12px 14px 10px; + font-size: .9rem; + font-weight: 500; color: var(--muted); background: transparent; - border: 1px solid transparent; - border-bottom: none; - border-radius: var(--radius) var(--radius) 0 0; + border: none; + border-bottom: 2px solid transparent; + border-radius: 0; cursor: pointer; } -.tab.active { - color: var(--text); - background: var(--bg); - border-color: var(--border); -} +.tab:hover { color: var(--text); border-color: transparent; border-bottom-color: var(--border); } +.tab.active { color: var(--text); border-bottom-color: var(--accent); } .view { flex: 1; @@ -77,11 +81,10 @@ body { } .panel-title { - padding: 7px 14px; - font-size: .62rem; - letter-spacing: .1em; - text-transform: uppercase; - color: var(--muted); + padding: 10px 14px; + font-size: .85rem; + font-weight: 600; + color: var(--text); border-bottom: 1px solid var(--border); flex-shrink: 0; } @@ -107,38 +110,36 @@ body { justify-content: center; background: color-mix(in srgb, var(--bg) 80%, transparent); color: var(--muted); - font-size: .78rem; - letter-spacing: .04em; - text-transform: uppercase; + font-size: .9rem; } button { padding: 6px 12px; border: 1px solid var(--border); border-radius: var(--radius); - background: var(--surface-2); + background: var(--surface); color: var(--text); font-family: inherit; - font-size: .72rem; - letter-spacing: .03em; + font-size: .82rem; cursor: pointer; } button:hover { border-color: var(--accent); } button:active { transform: translateY(1px); } button.btn-halt { color: var(--halt); border-color: var(--halt); } -button.btn-accent { color: var(--accent); border-color: var(--accent); } +button.btn-accent { color: #fff; background: var(--accent); border-color: var(--accent); } +button.btn-accent:hover { filter: brightness(1.08); } select, input[type="range"] { font-family: inherit; - font-size: .72rem; + font-size: .82rem; color: var(--text); } select { padding: 6px 10px; border: 1px solid var(--border); border-radius: var(--radius); - background: var(--surface-2); + background: var(--surface); } input[type="range"] { accent-color: var(--accent); @@ -148,20 +149,19 @@ input[type="range"] { .row { display: flex; gap: 6px; flex-wrap: wrap; } .stack { display: flex; flex-direction: column; gap: 8px; } -table { border-collapse: collapse; width: 100%; font-size: .78rem; } -th, td { padding: 5px 10px; text-align: left; border-bottom: 1px solid var(--border); } -th { color: var(--muted); font-weight: 600; font-size: .68rem; text-transform: uppercase; letter-spacing: .05em; } +table { border-collapse: collapse; width: 100%; font-size: .88rem; } +th, td { padding: 7px 10px; text-align: left; border-bottom: 1px solid var(--border); } +th { color: var(--muted); font-weight: 500; font-size: .8rem; } td.num { text-align: right; font-variant-numeric: tabular-nums; } .muted { color: var(--muted); } .accent { color: var(--accent); } .ref-section-title { - font-size: .62rem; - letter-spacing: .08em; - text-transform: uppercase; + font-size: .8rem; + font-weight: 600; color: var(--muted); - padding-top: 6px; + padding-top: 8px; border-top: 1px solid var(--border); } .ref-row { @@ -182,11 +182,11 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } .conn-dot.live { background: var(--accent); } /* Field check (live view): one row per check, coloured by status; the auto-HALT banner. */ -.check-ok { color: #5fb87a; } -.check-warn { color: #e0a14a; } -.check-fail { color: #e06a60; font-weight: 600; } +.check-ok { color: var(--ok); } +.check-warn { color: var(--warn); } +.check-fail { color: var(--fail); font-weight: 600; } /* A robot's ball sensor on (live view's robot panel), in the field's ball colour. */ -.ball-on { background: #c98a3f; color: #1a1d24; font-weight: 600; padding: 0 6px; border-radius: 3px; } +.ball-on { background: #e8892b; color: #fff; font-weight: 600; padding: 0 6px; border-radius: 3px; } .auto-halt { background: var(--halt); color: #fff; padding: 6px 8px; border-radius: var(--radius); font-size: .75rem; } /* Replay timeline (timeline.js): swimlanes under the transport controls. */ @@ -198,7 +198,7 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } .play-row { display: flex; gap: 8px; padding: 3px 4px 3px 6px; border-left: 3px solid var(--border); cursor: pointer; } .play-row:hover { background: var(--surface-2); } .play-row.current { background: var(--surface-2); } -.play-row.goal .play-ended { color: #e0c14f; font-weight: bold; } +.play-row.goal .play-ended { color: #a16207; font-weight: bold; } .play-time { min-width: 38px; color: var(--muted); font-variant-numeric: tabular-nums; } .play-detail { color: var(--muted); } .raw-log summary { cursor: pointer; font-size: .68rem; margin-top: 8px; } @@ -209,13 +209,13 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } /* Replay timeline markers: one tick per goal / foul / stall / ball loss. */ .marker-strip { position: relative; height: 10px; margin: 0 7px; } .marker { position: absolute; top: 0; width: 3px; height: 10px; margin-left: -1px; border-radius: 1px; cursor: pointer; } -.marker-goal { background: #e0c14f; } -.marker-foul { background: #d08a4a; } +.marker-goal { background: #ca8a04; } +.marker-foul { background: #ea7a2e; } .marker-stall { background: var(--halt); } .marker-loss { background: var(--muted); } -.marker-kind { display: inline-block; min-width: 38px; font-size: .62rem; text-transform: uppercase; letter-spacing: .04em; } +.marker-kind { display: inline-block; min-width: 38px; font-size: .72rem; border-radius: 4px; } .marker-kind.marker-goal, .marker-kind.marker-foul, .marker-kind.marker-stall, .marker-kind.marker-loss { - position: static; width: auto; height: auto; margin: 0 6px 0 0; padding: 0 4px; color: #17191d; + position: static; width: auto; height: auto; margin: 0 6px 0 0; padding: 0 5px; color: #fff; } /* Live: right-click / long-press menu on the field (live.js, ball placement). */ @@ -241,25 +241,56 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } } /* Strategies tab (strategies.js) */ -.subtab.active { border-color: var(--accent); color: var(--accent); } -.strategies-layout { display: flex; gap: 8px; width: 100%; min-height: 0; align-items: flex-start; } -.strategy-list { width: 280px; flex-shrink: 0; max-height: calc(100vh - 110px); overflow-y: auto; } -.strategy-item { padding: 8px 10px; border-bottom: 1px solid var(--border); border-left: 3px solid transparent; cursor: pointer; } +#view-strategies { background: var(--bg); } +.subtabs { display: flex; gap: 4px; margin-bottom: 12px; } +.subtab { border: none; background: transparent; color: var(--muted); font-weight: 500; padding: 6px 12px; border-radius: 999px; } +.subtab:hover { color: var(--text); } +.subtab.active { background: var(--surface); color: var(--text); box-shadow: 0 0 0 1px var(--border); } +.strategies-layout { display: flex; gap: 16px; width: 100%; min-height: 0; align-items: flex-start; } +.strategy-list { width: 250px; flex-shrink: 0; max-height: calc(100vh - 120px); overflow-y: auto; padding: 4px; } +.strategy-group { font-size: .75rem; color: var(--muted); padding: 10px 10px 4px; } +.strategy-item { padding: 7px 10px; border-radius: 6px; cursor: pointer; display: flex; justify-content: space-between; align-items: baseline; gap: 8px; } .strategy-item:hover { background: var(--surface-2); } -.strategy-item.active { border-left-color: var(--accent); background: var(--surface-2); } -.strategy-summary { font-size: .72rem; margin-top: 2px; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; } -.signal-row { display: grid; grid-template-columns: 170px 1fr 56px 56px; gap: 8px; align-items: center; font-size: .75rem; padding: 2px 0; } -.signal-bar { position: relative; height: 10px; background: var(--surface-2); border-radius: 2px; } -.signal-fill { height: 100%; background: var(--accent); border-radius: 2px; } -.signal-field { position: absolute; top: -2px; width: 2px; height: 14px; margin-left: -1px; background: var(--text); } -.verdict-card { padding: 8px 10px; margin-bottom: 6px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--surface-2); } -@media (max-width: 720px) { +.strategy-item.active { background: color-mix(in srgb, var(--accent) 10%, transparent); color: var(--accent); font-weight: 600; } +.strategy-page { flex: 1; padding: 20px 24px; gap: 22px; overflow-y: auto; max-height: calc(100vh - 120px); } +.strategy-page h1 { font-size: 1.5rem; font-weight: 650; } +.strategy-page h2 { font-size: .95rem; font-weight: 600; margin-bottom: 8px; } +.strategy-page .lead { color: var(--muted); margin-top: 2px; } +.pill { display: inline-block; padding: 1px 9px; border-radius: 999px; font-size: .75rem; font-weight: 500; background: var(--surface-2); color: var(--muted); } +.pill.champion { background: #fef3c7; color: #92400e; } +.pill.core { background: color-mix(in srgb, var(--accent) 12%, transparent); color: var(--accent); } +.pill.better { background: #dcfce7; color: var(--ok); } +.pill.dropped { background: #fee2e2; color: var(--fail); } +.pill.undecided { background: #fef3c7; color: var(--warn); } +.tactic-chip { display: inline-block; padding: 1px 9px; border: 1px solid var(--border); border-radius: 999px; font-size: .78rem; cursor: help; } +.meta-row { display: flex; flex-wrap: wrap; gap: 6px 18px; align-items: center; font-size: .85rem; margin-top: 10px; } +.maps { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 14px; } +.map figcaption { font-size: .8rem; color: var(--muted); margin-bottom: 4px; } +.map svg { width: 100%; height: auto; display: block; } +.signals { display: grid; grid-template-columns: 190px 1fr 52px 52px; gap: 6px 12px; align-items: center; font-size: .85rem; max-width: 760px; } +.signals .head { font-size: .75rem; color: var(--muted); } +.signals .num { text-align: right; font-variant-numeric: tabular-nums; } +.dumbbell { position: relative; height: 14px; } +.dumbbell .track { position: absolute; left: 0; right: 0; top: 6px; height: 2px; background: var(--surface-2); } +.dumbbell .link { position: absolute; top: 6px; height: 2px; background: color-mix(in srgb, var(--accent) 35%, transparent); } +.dumbbell .dot { position: absolute; top: 2px; width: 10px; height: 10px; margin-left: -5px; border-radius: 50%; } +.dumbbell .dot.this { background: var(--accent); } +.dumbbell .dot.others { background: #fff; border: 2px solid #9ca3af; } +.matches { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 8px; } +.match { display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 8px 10px; border: 1px solid var(--border); border-radius: 6px; font-size: .88rem; } +.match .score { font-weight: 600; font-variant-numeric: tabular-nums; } +.match .win { color: var(--ok); } .match .loss { color: var(--fail); } .match .draw { color: var(--muted); } +.icon-btn { padding: 2px 9px; border-radius: 999px; font-size: .75rem; } +.run-card { margin-bottom: 10px; } +.run-header { cursor: pointer; display: flex; gap: 10px; align-items: baseline; } +.run-body { padding: 10px 16px 14px; gap: 12px; font-size: .88rem; } +.round-header { cursor: pointer; color: var(--muted); margin-top: 4px; } +.verdict-card { padding: 10px 12px; margin-bottom: 6px; border: 1px solid var(--border); border-radius: 6px; } +.archive-header { cursor: pointer; color: var(--muted); padding: 8px 2px; } +@media (max-width: 900px) { .strategies-layout { flex-direction: column; } - .strategy-list { width: 100%; max-height: 40vh; } - .signal-row { grid-template-columns: 110px 1fr 44px 44px; } + .strategy-list { width: 100%; max-height: 30vh; } + .strategy-page { max-height: none; padding: 16px; } + .maps { grid-template-columns: 1fr; } + .signals { grid-template-columns: 130px 1fr 44px 44px; } } - -.strategy-facts { display: grid; grid-template-columns: max-content 1fr; gap: 6px 14px; align-items: baseline; } -.strategy-facts .ref-section-title { margin: 0; } -.tactic-chip { display: inline-block; padding: 1px 8px; border: 1px solid var(--border, #333); border-radius: 10px; font-size: .74rem; cursor: help; } -.strategy-summary { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } diff --git a/utama_core/dashboard/static/field_canvas.js b/utama_core/dashboard/static/field_canvas.js index 8798ad6a..ddf83265 100644 --- a/utama_core/dashboard/static/field_canvas.js +++ b/utama_core/dashboard/static/field_canvas.js @@ -9,15 +9,16 @@ // tactic_tags: {robotId: "attack" | "defense" | "mixed"} }); const FIELD_COLORS = { - pitch: "#242832", - line: "#4b5162", - yellow: "#e0a527", - blue: "#3d7fd1", - ball: "#c98a3f", - marker: "#e8eaf0", - laneOpen: "#5fb87a", - laneBlocked: "#c0524a", - committed: "#e0a14a", + pitch: "#e9f0e8", + line: "#a5b3a7", + yellow: "#eab308", + blue: "#2563eb", + ball: "#ea580c", + marker: "#1c2230", + heading: "#1c2230", + laneOpen: "#16a34a", + laneBlocked: "#dc2626", + committed: "#d97706", }; // Ring colour per `TacticTag` value (utama_core/engine/tactic.py) around a @@ -25,10 +26,10 @@ const FIELD_COLORS = { // the body keeps its jersey colour. Purely a display of the tag the robot's // current tactic declares; nothing in the scheduler reads it. const TACTIC_TAG_COLORS = { - attack: "#d9694f", - defense: "#4fb3a9", - mixed: "#a68fd6", - referee: "#c8c8c8", // a restart or HALT drives the robot, not its tactic + attack: "#e11d48", + defense: "#0d9488", + mixed: "#7c3aed", + referee: "#9ca3af", // a restart or HALT drives the robot, not its tactic }; // Robot body radius, world meters -> px is ROBOT_RADIUS * scale so the drawn @@ -220,7 +221,7 @@ class FieldCanvas { } // Heading dash extends past the body edge so it reads as a // direction pointer rather than disappearing into the fill. - ctx.strokeStyle = FIELD_COLORS.pitch; + ctx.strokeStyle = FIELD_COLORS.heading; ctx.lineWidth = Math.max(1, r * 0.28); // Through toX/toY, so a mirrored view (our goal on the right) mirrors it too. const headingM = (r * 1.6) / scale; @@ -260,7 +261,7 @@ class FieldCanvas { // A robot past the area in play by more than the margin has forced HALT on real robots. const [x1, y1, x2, y2] = state.field_check.bounds; const m = state.field_check.margin; - ctx.strokeStyle = "#e06a60"; + ctx.strokeStyle = "#dc2626"; ctx.lineWidth = 2; for (const bot of [...(robots.friendly || []), ...(robots.enemy || [])]) { if (bot.x < x1 - m || bot.x > x2 + m || bot.y < y1 - m || bot.y > y2 + m) { @@ -314,7 +315,7 @@ class FieldCanvas { const [x1, y1, x2, y2] = fieldCheck.bounds; const r = rectBounds(x1, y1, x2, y2); ctx.save(); - ctx.fillStyle = "rgba(0, 0, 0, 0.45)"; + ctx.fillStyle = "rgba(28, 34, 48, 0.18)"; ctx.beginPath(); ctx.rect(0, 0, CW, CH); ctx.rect(r.x + r.w, r.y, -r.w, r.h); // opposite winding cuts the area in play out @@ -324,8 +325,8 @@ class FieldCanvas { ctx.lineWidth = 1.5; ctx.strokeRect(r.x, r.y, r.w, r.h); // Keep-out zones (StrategyRunner's keep_out): no robot may enter; one inside forces HALT. - ctx.fillStyle = "rgba(224, 106, 96, 0.25)"; - ctx.strokeStyle = "#e06a60"; + ctx.fillStyle = "rgba(220, 38, 38, 0.15)"; + ctx.strokeStyle = "#dc2626"; for (const [kx1, ky1, kx2, ky2] of fieldCheck.keep_out || []) { const k = rectBounds(kx1, ky1, kx2, ky2); ctx.fillRect(k.x, k.y, k.w, k.h); diff --git a/utama_core/dashboard/static/replay.js b/utama_core/dashboard/static/replay.js index 3ada7ebd..35919a91 100644 --- a/utama_core/dashboard/static/replay.js +++ b/utama_core/dashboard/static/replay.js @@ -208,7 +208,7 @@ function framesFromColumns(c) { return; } const t0 = frameTs(0); - const colour = { Yellow: "#e0a527", Blue: "#3d7fd1" }; + const colour = { Yellow: "#eab308", Blue: "#2563eb" }; list.innerHTML = play .map((r, i) => { const goal = r.ended && r.ended.startsWith("Goal") ? " goal" : ""; diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js index d955e78d..0c623202 100644 --- a/utama_core/dashboard/static/strategies.js +++ b/utama_core/dashboard/static/strategies.js @@ -1,152 +1,197 @@ -// Strategies tab: every strategy in the catalog (what it is, the tactics it uses, its verdicts, how it -// plays, its matches with their replays), and every evaluation run, verdicts first. -// Data: GET /strategies and /strategies/runs (dashboard/views/strategies.py), read from replays/. -// There are no standings: the verdict (goals, paired against the champion) is the only ranking, and -// signals are shown beside the other strategies' average to explain how a strategy plays, never to -// rank it (docs/signals.md). +// Strategies tab: every strategy in the catalog (what it is, its tactics, its verdict, where it +// stands and shoots on the pitch, how it plays, its newest matches) and every evaluation run. +// Data: GET /strategies, /strategies/runs and /strategies/maps (dashboard/views/strategies.py). +// There are no standings: the verdict (goals, paired against the champion) is the only ranking; +// signals sit beside the other strategies' average to explain how a strategy plays (docs/signals.md). (function () { let data = null; // /strategies let runs = null; // /strategies/runs, loaded when the Runs page is first opened let page = "strategies"; // "strategies" | "runs" let selected = null; // strategy name - let showAllMatches = false; + let showArchive = false; + const maps = {}; // round run_id -> /strategies/maps answer const expandedRun = {}; // run_id -> bool; the newest starts open const expandedRound = {}; // "run_id:k" -> bool const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]); - const pct = (x) => Math.round((x || 0) * 1000) / 10 + "%"; + const pct = (x) => Math.round((x || 0) * 100) + "%"; const num = (x, d = 2) => (x == null ? "—" : Number(x).toFixed(d)); const signed = (x, d = 2) => (x == null ? "—" : (x > 0 ? "+" : "") + Number(x).toFixed(d)); - const VERDICT_COLOUR = { better: "check-ok", dropped: "check-fail", undecided: "check-warn" }; - function verdictBadge(v) { - return `${esc(v)}`; - } - function roleBadge(role) { - const label = role === "champion" ? "★ champion" : role; - const colour = role === "champion" ? "accent" : role === "core" ? "" : "muted"; - return `${label}`; - } + const pill = (text, cls, title) => `${esc(text)}`; function replayButton(path, atTime, label) { if (!path) return ""; const at = atTime != null ? ` data-at="${atTime}"` : ""; - return ``; - } - function testLine(t) { - if (!t) return ""; - return `mean diff ${signed(t.mean)} ± ${num(t.se)} goals/match (n ${t.n ?? "—"}, p ${num(t.p, 3)})`; + return ``; } - // --- the strategy list and one strategy --------------------------------------------------------- + // --- the strategy list -------------------------------------------------------------------------- function renderList() { - const order = { champion: 0, core: 1, reserve: 2 }; - const rows = [...data.strategies].sort((a, b) => order[a.role] - order[b.role] || a.name.localeCompare(b.name)); - return rows - .map((s) => { - const last = s.verdicts[0]; + const groups = [ + ["Champion", (s) => s.role === "champion"], + ["Core", (s) => s.role === "core"], + ["Reserve", (s) => s.role === "reserve"], + ]; + return groups + .map(([title, keep]) => { + const rows = data.strategies.filter(keep).sort((a, b) => a.name.localeCompare(b.name)); + if (!rows.length) return ""; return ( - `
` + - `
${esc(s.name)}${roleBadge(s.role)}
` + - `
${esc(s.summary) || "no description"}
` + - (last ? `
${verdictBadge(last.verdict)} ${esc(last.date || "")}
` : "") + - `
` + `
${title}
` + + rows + .map((s) => { + const v = s.verdicts[0]; + return ( + `
` + + `${esc(s.name)}${v ? pill(v.verdict, v.verdict) : ""}
` + ); + }) + .join("") ); }) .join(""); } + // --- one strategy ------------------------------------------------------------------------------- + function renderTactics(s) { - if (!s.tactics.length) return 'its own'; - // one chip per tactic; what it does and its file on hover return s.tactics .map((t) => `${esc(t.name.replace(/Tactic$/, ""))}`) .join(" "); } - function renderVerdicts(s) { - if (!s.verdicts.length) { - return `not evaluated`; + function renderVerdict(s) { + const v = s.verdicts[0]; + if (!v) return pill("not evaluated", "", `pixi run evaluate ${s.name}`); + const detail = `decided in the ${v.decided_in} after ${v.rounds} round(s), n ${v.n}, p ${num(v.p, 3)}, ${v.date || v.run_id}`; + return `${pill(v.verdict, v.verdict, detail)} ${signed(v.mean)} ± ${num(v.se)} goals/match vs ${esc(v.reference)}`; + } + + // An SVG pitch in the maps' frame (metres, attacking right), with `inner` drawn under the lines. + function pitchSvg(p, inner) { + const L = p.half_length, W = p.half_width, gd = p.goal_depth, pad = 0.12; + const vb = `${-L - gd - pad} ${-W - pad} ${2 * (L + gd + pad)} ${2 * (W + pad)}`; + const line = 'fill="none" stroke="#a5b3a7" stroke-width="1" vector-effect="non-scaling-stroke"'; + const lines = + `` + + `` + + `` + + `` + + `` + + `` + + ``; + return ( + `` + + `` + + `${inner}${lines}` + ); + } + + function heatmap(m, grid, vmax) { + const L = m.pitch.half_length, W = m.pitch.half_width, b = m.bin_m; + let out = ""; + grid.share.forEach((row, i) => + row.forEach((v, j) => { + if (v > 0) { + const a = Math.min(1, v / vmax).toFixed(2); + out += ``; + } + }) + ); + for (const [x, y] of grid.means) out += ``; + return out; + } + + function shotMarks(shots) { + const mark = ([x, y, scored], colour) => + ``; + return (shots.faced || []).map((s) => mark(s, "#dc2626")).join("") + (shots.own || []).map((s) => mark(s, "#2563eb")).join(""); + } + + function renderMaps(s) { + if (!s.signals) return ""; + const m = maps[s.signals.run_id]; + let body; + if (!m || m.status === "computing") body = '
Drawing the maps from the replays… (about a minute, once per run)
'; + else if (m.status !== "ready") body = '
No maps: this round has no replays.
'; + else if (!m.strategies[s.name]) body = '
No replays of this strategy in this round.
'; + else { + const d = m.strategies[s.name]; + const fig = (title, svg) => `
${title}
${svg}
`; + body = + `
` + + fig("With the ball", pitchSvg(m.pitch, heatmap(m, d.attack, m.vmax.attack))) + + fig("Without the ball", pitchSvg(m.pitch, heatmap(m, d.defence, m.vmax.defence))) + + fig( + `Shots ● ours ● against, hollow missed`, + pitchSvg(m.pitch, shotMarks(d.shots)) + ) + + `
`; } - return s.verdicts - .map((v) => - `
` + - `${verdictBadge(v.verdict)} ${signed(v.mean)} ± ${num(v.se)} goals/match vs ${esc(v.reference)} ` + - `${esc(v.date || v.run_id)}
`) - .join(""); + return `

On the pitch attacking →, dots are each robot's average spot

${body}
`; } function renderSignals(s) { const sig = s.signals; - if (!sig) return '
No round with this strategy yet.
'; - const max = (r) => Math.max(Math.abs(r.value || 0), Math.abs(r.field || 0)) || 1; + if (!sig) return ""; const fmt = (r, x) => (x == null ? "—" : r.key.endsWith("_share") || r.key === "stalled" ? pct(x) : num(x, r.key === "pass_progress_m" ? 2 : 1)); const rows = sig.rows + .filter((r) => r.value != null || r.field != null) .map((r) => { - const m = max(r); - const w = r.value == null ? 0 : (Math.abs(r.value) / m) * 100; - const fw = r.field == null ? null : (Math.abs(r.field) / m) * 100; - const tick = fw == null ? "" : `
`; - return ( - `
${esc(r.label)}` + - `
${tick}
` + - `${fmt(r, r.value)}${fmt(r, r.field)}
` - ); + const max = Math.max(Math.abs(r.value || 0), Math.abs(r.field || 0)) * 1.15 || 1; + const at = (x) => (Math.abs(x || 0) / max) * 100; + const a = at(r.value), b = at(r.field); + const bar = + `
` + + (r.value != null && r.field != null ? `` : "") + + (r.field != null ? `
` : "") + + (r.value != null ? `
` : "") + + `
`; + return `${esc(r.label)}${bar}${fmt(r, r.value)}${fmt(r, r.field)}`; }) .join(""); - const title = `${sig.matches} matches in ${sig.run_id}. More is not better: these explain how it plays (docs/signals.md).`; + const title = `${sig.matches} matches in ${sig.run_id}. More is not always better: these explain how it plays (docs/signals.md).`; return ( - `
per match, ${esc(sig.date || "")}` + - `thisothers
` + - rows + `

How it plays per match

` + + `
thisothers${rows}
` ); } - function renderMatchList(s) { - if (!s.matches.length) return '
None yet.
'; - // the newest run's matches; older ones (older code, maybe older names) on request - const newest = s.matches[0].run_id; - const shown = showAllMatches ? s.matches : s.matches.filter((m) => m.run_id === newest); - const rows = shown + function renderMatches(s) { + if (!s.matches.length) return ""; + const newest = s.matches[0].run_id; // older runs played older code: not shown here + const cards = s.matches + .filter((m) => m.run_id === newest) .map((m) => { const [f, a] = m.score; - const res = f > a ? "check-ok" : f < a ? "check-fail" : "muted"; + const res = f > a ? "win" : f < a ? "loss" : "draw"; return ( - `vs ${esc(m.opponent)}${f} – ${a}` + - `${esc(m.date || "")}` + - `${m.stalled ? 'stalled' : ""}` + - `${replayButton(m.replay)}` + `
${esc(m.opponent)}` + + `${f}–${a}` + + `${m.stalled ? pill("stalled", "dropped") : ""}${replayButton(m.replay)}
` ); }) .join(""); - const more = - s.matches.length > shown.length - ? `` - : ""; - return ( - `` + - `${rows}
${more}` - ); + return `

Matches ${esc(s.matches[0].date || "")}

${cards}
`; } function renderStrategy(s) { - const old = s.old_names.length ? ` (was ${s.old_names.map(esc).join(", ")})` : ""; - const facts = [ - ["Tactics", renderTactics(s)], - ["Verdict", renderVerdicts(s)], - ["Code", `${esc(s.file)}`], - ]; + const old = s.old_names.length ? ` was ${s.old_names.map(esc).join(", ")}` : ""; + const role = s.role === "champion" ? pill("champion", "champion") : s.role === "core" ? pill("core", "core") : pill("reserve"); return ` -
+
-

${esc(s.name)}${old}

${roleBadge(s.role)}
-
${esc(s.summary)}
+

${esc(s.name)}

${role}${old}
+
${esc(s.summary)}
+
${renderTactics(s)}${renderVerdict(s)} + ${esc(s.file)}
-
${facts.map(([k, v]) => `${k}
${v}
`).join("")}
-
How it plays
${renderSignals(s)}
-
Matches
${renderMatchList(s)}
+ ${renderMaps(s)} + ${renderSignals(s)} + ${renderMatches(s)}
`; } @@ -154,32 +199,29 @@ if (!data) return '
Loading…
'; if (!selected || !data.strategies.find((s) => s.name === selected)) selected = data.champion || data.strategies[0]?.name; const s = data.strategies.find((x) => x.name === selected); + if (s) loadMaps(s); return `
${renderList()}
-
${s ? renderStrategy(s) : ""}
+ ${s ? renderStrategy(s) : ""}
`; } // --- runs --------------------------------------------------------------------------------------- function renderVerdictCards(run) { - const cands = Object.entries((run.report || {}).candidates || {}); - if (!run.report) { - return run.run_id.startsWith("eval_") - ? '
No report.json: the run did not finish.
' - : '
An older round robin: no verdicts.
'; - } - if (!cands.length) return '
No candidate: a health check of the field only.
'; + if (!run.report) return '
Did not finish.
'; + const cands = Object.entries(run.report.candidates || {}); + if (!cands.length) return '
No candidate: a health check only.
'; return cands .map(([name, r]) => { - const decided = r[r.decided_in] || {}; + const t = r[r.decided_in] || {}; const h2h = r.vs_todays_champion; + const detail = `in the ${r.decided_in} after ${r.rounds} round(s), n ${t.n ?? "—"}, p ${num(t.p, 3)}`; return ( - `
${esc(name)}${verdictBadge(r.verdict)}
` + - `
in the ${esc(r.decided_in)} after ${r.rounds} round(s) · ${testLine(decided)}
` + - `
against ${esc(run.reference)} (the champion at the last release)` + - (h2h ? `; against today's ${esc(h2h.name)}: ${signed(h2h.mean)} ± ${num(h2h.se)}` : "") + + `
${esc(name)}${pill(r.verdict, r.verdict, detail)}
` + + `
${signed(t.mean)} ± ${num(t.se)} goals/match vs ${esc(run.reference)} at the last release` + + (h2h ? ` · vs today's ${esc(h2h.name)} ${signed(h2h.mean)} ± ${num(h2h.se)}` : "") + `
` ); }) @@ -199,83 +241,77 @@ const rows = incidents .map( (inc) => - `
stall${esc(inc.kind)} at ${inc.sim_time.toFixed(1)}s ` + - `for ${inc.duration_s.toFixed(0)}s` + - inc.matches.map((m) => replayButton(replayOfMatch(round, m), inc.sim_time, m)).join("") + + `
${esc(inc.kind)} at ${inc.sim_time.toFixed(1)}s for ${inc.duration_s.toFixed(0)}s` + + inc.matches.map((m) => replayButton(replayOfMatch(round, m), inc.sim_time, "▶ " + m)).join("") + `
` ) .join(""); - parts.push(`
Stalls: ${incidents.length} incidents
` + (rows || '
none
')); + parts.push(`
Stalls ${incidents.length}${rows}
`); } const rs = round.restarts; - if (rs && rs.restarts) { - parts.push( - `
Restarts: ${rs.reached_normal_start}/${rs.restarts} reached NORMAL_START (${pct(rs.reached_normal_start / rs.restarts)})
` - ); - } + if (rs && rs.restarts) parts.push(`
Restarts ${pct(rs.reached_normal_start / rs.restarts)} went live
`); if (round.fouls) { const byRule = Object.entries(round.fouls) .map(([rule, f]) => [rule, f.total]) .sort((a, b) => b[1] - a[1]) .map(([rule, n]) => `${n} ${rule.replace(/_/g, " ")}`) .join(", "); - parts.push(`
Fouls
${byRule || "none"}
`); - } - if ((round.failed || []).length) { - parts.push(`
${round.failed.length} match(es) crashed
`); + parts.push(`
Fouls ${byRule || "none"}
`); } - return parts.join("") || '
No health data in this round.
'; + if ((round.failed || []).length) parts.push(`
${round.failed.length} match(es) crashed
`); + return parts.join(""); } function renderRoundMatches(round) { const rows = (round.results || []) - .map((r) => { - return ( - `${esc(r.display_a)} (yellow) vs ${esc(r.display_b)}` + - `${r.score_a} – ${r.score_b}` + - `${r.stalled ? 'stalled' : ""}${r.reused ? 'from store' : ""}` + - `${replayButton(r.replay)}` - ); - }) + .map( + (r) => + `${esc(r.display_a)} vs ${esc(r.display_b)}${r.score_a}–${r.score_b}` + + `${r.stalled ? pill("stalled", "dropped") : ""}${replayButton(r.replay)}` + ) .join(""); return `${rows}
`; } function renderRun(run) { - const meta = (run.report || {}).run || {}; - const commit = meta.git_commit ? ` · ${esc(meta.git_commit.slice(0, 8))}${meta.git_dirty ? " (dirty)" : ""}` : ""; const nMatches = run.rounds.reduce((n, s) => n + (s.results || []).length, 0); const open = expandedRun[run.run_id]; const header = - `
${open ? "▼" : "▶"} ` + - `${esc(run.run_id)} · ${run.rounds.length} round(s) · ${nMatches} matches${commit}
`; - if (!open) return `
${header}
`; + `
${open ? "▾" : "▸"}` + + `${esc(run.date || run.run_id)}${run.rounds.length} round(s), ${nMatches} matches
`; + if (!open) return `
${header}
`; const rounds = run.rounds .map((round) => { const key = `${run.run_id}:${round.round ?? 1}`; const o = expandedRound[key]; return ( - `
${o ? "▼" : "▶"} ` + - `Round ${round.round ?? 1}${round.seed != null ? ` (seed ${round.seed})` : ""} · ${(round.results || []).length} matches
` + + `
${o ? "▾" : "▸"} Round ${round.round ?? 1}` + + `${round.seed != null ? ` · seed ${round.seed}` : ""} · ${(round.results || []).length} matches
` + (o ? renderRoundMatches(round) : "") ); }) .join(""); return ` -
+
${header} -
-
Verdicts
${renderVerdictCards(run)}
-
Health check (round 1)
${run.rounds[0] ? renderHealth(run.rounds[0]) : ""}
-
Matches
${rounds}
+
+ ${run.run_id.startsWith("eval_") ? `
${renderVerdictCards(run)}
` : ""} + ${run.rounds[0] ? renderHealth(run.rounds[0]) : ""} +
${rounds}
`; } function renderRunsPage() { if (!runs) return '
Loading…
'; - if (!runs.length) return '
No runs yet. Start one with pixi run evaluate NAME.
'; - return runs.map(renderRun).join(""); + const current = runs.filter((r) => r.run_id.startsWith("eval_")); + const archive = runs.filter((r) => !r.run_id.startsWith("eval_")); + const empty = current.length ? "" : '
No runs yet: pixi run evaluate NAME
'; + const older = archive.length + ? `
${showArchive ? "▾" : "▸"} Older round robins (${archive.length}): older code, not comparable
` + + (showArchive ? archive.map(renderRun).join("") : "") + : ""; + return `
${empty}${current.map(renderRun).join("")}${older}
`; } // --- shell -------------------------------------------------------------------------------------- @@ -285,7 +321,7 @@ if (!root) return; const tab = (p, label) => ``; root.innerHTML = - `
${tab("strategies", "Strategies")}${tab("runs", "Evaluation runs")}
` + + `
${tab("strategies", "Strategies")}${tab("runs", "Evaluation runs")}
` + (page === "strategies" ? renderStrategiesPage() : renderRunsPage()); for (const b of root.querySelectorAll(".subtab")) { @@ -298,13 +334,12 @@ for (const el of root.querySelectorAll(".strategy-item")) { el.addEventListener("click", () => { selected = el.dataset.name; - showAllMatches = false; render(); }); } - for (const b of root.querySelectorAll(".show-all-matches")) { - b.addEventListener("click", () => { - showAllMatches = true; + for (const h of root.querySelectorAll(".archive-header")) { + h.addEventListener("click", () => { + showArchive = !showArchive; render(); }); } @@ -329,6 +364,26 @@ } } + // The maps of the round a strategy's signals come from: asked once, polled while computing. + function loadMaps(s) { + const round = s.signals && s.signals.run_id; + const known = round && maps[round]; + if (!round || (known && (known.status !== "computing" || known.pending || known.retryAt > Date.now()))) return; + maps[round] = { status: "computing", pending: true }; + fetch("/strategies/maps?round=" + encodeURIComponent(round)) + .then((r) => r.json()) + .then((m) => { + const computing = m.status === "computing"; + maps[round] = computing ? { ...m, retryAt: Date.now() + 3000 } : m; + if (computing) setTimeout(() => page === "strategies" && render(), 3100); + render(); + }) + .catch((err) => { + maps[round] = { status: "failed" }; + console.error("maps fetch error:", err); + }); + } + function load() { fetch("/strategies") .then((r) => r.json()) @@ -345,7 +400,8 @@ .then((r) => r.json()) .then((d) => { runs = d; - if (runs.length && !Object.keys(expandedRun).length) expandedRun[runs[0].run_id] = true; + const first = runs.find((r) => r.run_id.startsWith("eval_")) || runs[0]; + if (first && !Object.keys(expandedRun).length) expandedRun[first.run_id] = true; render(); }) .catch((err) => console.error("runs fetch error:", err)); diff --git a/utama_core/dashboard/static/timeline.js b/utama_core/dashboard/static/timeline.js index f58c6190..f1ba51d3 100644 --- a/utama_core/dashboard/static/timeline.js +++ b/utama_core/dashboard/static/timeline.js @@ -17,19 +17,19 @@ (function () { const SLOTS = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6"]; - const OTHER = "#5f636c"; // tactics beyond the seven slots - const TEAM = { yellow: "#e0a527", blue: "#3d7fd1" }; // field_canvas.js's robot colours + const OTHER = "#9ca3af"; // tactics beyond the seven slots + const TEAM = { yellow: "#eab308", blue: "#2563eb" }; // field_canvas.js's robot colours const REF_FILL = { - "live play": "#2b3a30", - STOP: "#5b5f68", - HALT: "#b8615a", - kickoff: "#3d5a80", - "free kick": "#7a5236", - penalty: "#6d4560", - placement: "#6e6436", - other: "#33373f", + "live play": "#d7eedd", + STOP: "#dde0e5", + HALT: "#f6c9c4", + kickoff: "#d3e3f8", + "free kick": "#f5dfc8", + penalty: "#ecd6ea", + placement: "#efe7c2", + other: "#e7e9ed", }; - const MARKER_FILL = { goal: "#e0c14f", foul: "#d08a4a", stall: "#b8615a", loss: "#8b909b" }; + const MARKER_FILL = { goal: "#ca8a04", foul: "#ea7a2e", stall: "#c53030", loss: "#9ca3af" }; const KEEPER = "goalkeeper"; // the label the Live view's tactic status gives the keeper const LIVE_KEEP_S = 300; const MAX_DIST_M = 3; @@ -486,7 +486,7 @@ this._view = [t0, t1]; const w = cssW - GUTTER; const x = (t) => GUTTER + ((t - t0) / span) * w; - ctx.font = "10px ui-monospace, monospace"; + ctx.font = "10px system-ui, sans-serif"; ctx.textBaseline = "middle"; const band = (spans, y, h, fill, label) => { @@ -498,14 +498,14 @@ ctx.fillRect(a, y, Math.max(1, b - a - 1), h); const text = label && label(s); if (text && ctx.measureText(text).width + 6 < b - a) { - ctx.fillStyle = "#dfe2e8"; + ctx.fillStyle = "#1c2230"; ctx.fillText(text, a + 3, y + h / 2); } } }; const row = (kind, text, y, h, lane) => { this._rows.push({ kind, y0: y, y1: y + h, lane }); - ctx.fillStyle = "#8b909b"; + ctx.fillStyle = "#6b7280"; ctx.fillText(text, 2, y + h / 2); }; @@ -534,20 +534,20 @@ (s) => short(s.label) ); // a tick where the robot switched from one tactic to another - ctx.fillStyle = "#101114"; + ctx.fillStyle = "#ffffff"; let prev = null; for (const s of lane.tactics) { if (!s.label) continue; if (prev && prev !== s.label && s.t0 >= t0 && s.t0 <= t1) ctx.fillRect(x(s.t0) - 1, y, 2, LANE_H - 2); prev = s.label; } - band(lane.ball, y + LANE_H - 5, 3, () => "#f2f2f2"); + band(lane.ball, y + LANE_H - 5, 3, () => "#1c2230"); y += LANE_H; } y += GAP; row("dist", "ball m", y, DIST_H); - ctx.strokeStyle = "#33373f"; + ctx.strokeStyle = "#e5e7eb"; ctx.beginPath(); for (const m of [1, 2]) { const gy = y + DIST_H * (1 - m / MAX_DIST_M); @@ -582,10 +582,10 @@ row("events", "events", y, EVENT_H); for (const m of d.markers) { if (m.sim_time < t0 || m.sim_time > t1) continue; - ctx.fillStyle = MARKER_FILL[m.kind] || "#8b909b"; + ctx.fillStyle = MARKER_FILL[m.kind] || "#9ca3af"; ctx.fillRect(x(m.sim_time) - 1.5, y, 3, EVENT_H); } - ctx.strokeStyle = "#101114"; + ctx.strokeStyle = "#ffffff"; for (const s of d.shots) { if (s.t < t0 || s.t > t1) continue; ctx.fillStyle = d.team[s.side] || OTHER; @@ -598,7 +598,7 @@ // axis: a tick every 5 s or 10 s or 30 s, labelled as match time (m:ss) const step = span > 180 ? 30 : span > 60 ? 10 : 5; - ctx.fillStyle = "#8b909b"; + ctx.fillStyle = "#6b7280"; ctx.textAlign = "center"; for (let s = Math.ceil((t0 - d.origin) / step) * step; d.origin + s <= t1; s += step) { const px = x(d.origin + s); @@ -608,7 +608,7 @@ ctx.textAlign = "start"; const cx = x(ts); - ctx.fillStyle = "#dfe2e8"; + ctx.fillStyle = "#1c2230"; ctx.fillRect(cx - 0.5, 0, 1.5, y); } } diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py index c195c8ad..775eab35 100644 --- a/utama_core/dashboard/views/strategies.py +++ b/utama_core/dashboard/views/strategies.py @@ -3,6 +3,7 @@ GET /strategies {"champion", "core", "strategies": [...]} one entry per catalog strategy GET /strategies/runs every run under `replays/`, newest first + GET /strategies/maps?round= the round's position and shot maps per strategy A strategy's entry: its description (the module docstring), file, role (champion / core / reserve, `tools/evaluation/reference/players.json`), the tactics it imports, its verdicts (from each @@ -11,6 +12,9 @@ replay. Names are shown as the catalog calls them today: a `.strategy` file (`name@commit.strategy`) and a pre-rename name both show as the strategy's name, so frozen files never appear as strategies of their own. Matches played under an older name or older code keep their date, which is how to tell. + +The maps are `tools/debug/pitch_maps.py --data`, run in the background the first time a round's maps +are asked for and kept beside its summary (`pitch_maps.json`); until then the answer is "computing". """ from __future__ import annotations @@ -18,6 +22,9 @@ import ast import json import re +import subprocess +import sys +import threading from pathlib import Path from typing import Iterable, Optional @@ -49,6 +56,7 @@ def attach(server: DashboardServer) -> None: server.add_route("/strategies", lambda: json.dumps(load_strategies()).encode()) server.add_route("/strategies/runs", lambda: json.dumps(load_runs()).encode()) + server.add_route("/strategies/maps", lambda q=None: json.dumps(maps_of((q or {}).get("round", ""))).encode()) # --- names ------------------------------------------------------------------------------------ @@ -187,6 +195,8 @@ def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict] # a match reused from the store is listed under the run that played it if name not in (a, b) or a == b or r.get("reused"): continue + if is_frozen(r["config_a"] if a == name else r["config_b"]): + continue # the last release's file playing, not today's strategy mine, theirs, opponent = (r["score_a"], r["score_b"], b) if a == name else (r["score_b"], r["score_a"], a) if is_frozen(r["config_b"] if a == name else r["config_a"]): opponent += " (last release)" @@ -345,3 +355,42 @@ def load_runs(base: Optional[Path] = None) -> list[dict]: for run in runs.values(): run["rounds"].sort(key=lambda s: s.get("round", 0)) return sorted(runs.values(), key=lambda r: _newest_first(r["run_id"]), reverse=True) + + +# --- maps ------------------------------------------------------------------------------------- + +MAPS_FILE = "pitch_maps.json" +PITCH_MAPS = REPO / "tools" / "debug" / "pitch_maps.py" +_jobs: dict[Path, subprocess.Popen] = {} +_jobs_lock = threading.Lock() + + +def maps_of(round_id: str, base: Optional[Path] = None, start=subprocess.Popen) -> dict: + """A round's maps by catalog name (frozen files left out), or its status: "computing" while + `pitch_maps.py` runs, "failed" if it ended without writing them (asking again retries), "missing" + for no such round. `start` runs the command (a test passes a fake).""" + base = Path(base or REPLAY_BASE_PATH).resolve() + round_dir = (base / round_id).resolve() + if base not in round_dir.parents or not (round_dir / "summary.json").exists(): + return {"status": "missing"} + data = _read_json(round_dir / MAPS_FILE) + if data is not None: + strategies = {display_name(k): v for k, v in data.pop("strategies", {}).items() if not is_frozen(k)} + return {"status": "ready", **data, "strategies": strategies} + with _jobs_lock: + job = _jobs.get(round_dir) + if job is not None and job.poll() is not None: + del _jobs[round_dir] + return {"status": "failed"} + if job is None: + cmd = [ + sys.executable, + str(PITCH_MAPS), + str(round_dir), + "--data", + str(round_dir / MAPS_FILE), + "--workers", + "4", + ] + _jobs[round_dir] = start(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + return {"status": "computing"} diff --git a/utama_core/tests/analysis/test_pitch_maps.py b/utama_core/tests/analysis/test_pitch_maps.py index abab892b..6abe6722 100644 --- a/utama_core/tests/analysis/test_pitch_maps.py +++ b/utama_core/tests/analysis/test_pitch_maps.py @@ -1,6 +1,8 @@ """`tools/debug/pitch_maps.py` on tiny synthetic replays: the side normalisation, possession and the goalkeeper exclusion, and that each figure is written.""" +import json + import numpy as np import pytest @@ -171,6 +173,18 @@ def test_each_figure_is_written(tmp_path, which): assert path.read_bytes()[:8] == b"\x89PNG\r\n\x1a\n" +def test_map_data_is_json_with_both_grids_the_shots_and_one_scale_per_grid(): + order, _, views = _views() + data = json.loads(json.dumps(pm.map_data(views, order))) # plain JSON all the way down + a = data["strategies"]["a"] + rows, cols = len(a["attack"]["share"]), len(a["attack"]["share"][0]) + assert (rows, cols) == (round(2 * pm.W / pm.BIN_M), round(2 * pm.L / pm.BIN_M)) + assert sum(map(sum, a["attack"]["share"])) == pytest.approx(1.0) + assert a["defence"]["means"] == [[1.0, 0.5]] # robot 1's only sample without the ball + assert a["shots"] == {"own": [[2.0, 0.5, True]], "faced": [[-1.0, 0.0, False]]} + assert set(data["vmax"]) == {"attack", "defence"} and data["pitch"]["half_length"] == pm.L + + def test_rule_colours_take_fixed_slots_in_rank_order(): assert pm.rule_colours(["crashing", "double_touch"]) == {"crashing": pm.sr.SLOTS[0], "double_touch": pm.sr.SLOTS[1]} diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py index 28ba0669..db4f9911 100644 --- a/utama_core/tests/dashboard/test_strategies_view.py +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -127,6 +127,10 @@ def test_matches_are_from_the_strategys_side_with_their_replays_and_reused_ones_ assert by_opponent["pendulum (last release)"] is None +def test_the_frozen_files_matches_are_not_todays_strategys(replays): + assert _strategy(view.load_strategies(replays), "pendulum")["matches"] == [] + + def test_signals_are_per_match_beside_the_other_strategies_average(replays): sig = _strategy(view.load_strategies(replays), "mirage")["signals"] rows = {r["key"]: r for r in sig["rows"]} @@ -163,3 +167,40 @@ def test_an_older_round_robin_is_one_round_and_finds_side_tagged_replays(tmp_pat def test_no_replays_folder_gives_empty_pages(tmp_path): assert view.load_runs(tmp_path / "missing") == [] assert all(not s["matches"] for s in view.load_strategies(tmp_path / "missing")["strategies"]) + + +class _Job: + def __init__(self, done=False): + self.done = done + + def poll(self): + return 0 if self.done else None + + +def test_maps_start_once_in_the_background_then_come_back_by_catalog_name(replays, monkeypatch): + monkeypatch.setattr(view, "_jobs", {}) + started = [] + start = lambda cmd, **kw: started.append(cmd) or _Job() # noqa: E731 + round_id = "eval_20261112_100000/round_1" + assert view.maps_of(round_id, replays, start)["status"] == "computing" + assert view.maps_of(round_id, replays, start)["status"] == "computing" + assert len(started) == 1 and "--data" in started[0] + _write( + replays / round_id / view.MAPS_FILE, + {"vmax": {"attack": 0.1}, "strategies": {"high_press": {"shots": {}}, "pendulum@ab12cd34": {"shots": {}}}}, + ) + maps = view.maps_of(round_id, replays, start) + assert maps["status"] == "ready" and maps["vmax"] == {"attack": 0.1} + assert list(maps["strategies"]) == ["wolfpack"] # renamed; the frozen file left out + + +def test_maps_report_a_failed_job_once_then_retry(replays, monkeypatch): + round_dir = (replays / "eval_20261112_100000" / "round_1").resolve() + monkeypatch.setattr(view, "_jobs", {round_dir: _Job(done=True)}) + assert view.maps_of("eval_20261112_100000/round_1", replays, lambda cmd, **kw: _Job())["status"] == "failed" + assert view.maps_of("eval_20261112_100000/round_1", replays, lambda cmd, **kw: _Job())["status"] == "computing" + + +def test_maps_never_leave_the_replays_folder(replays): + assert view.maps_of("../../etc", replays)["status"] == "missing" + assert view.maps_of("eval_20261112_100000/round_9", replays)["status"] == "missing" From 62bb4949e8dedbea5e88f8e43f4b2f8ecab3147c Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 11:41:50 +0000 Subject: [PATCH 53/59] dashboard: no test strategy in the list; the release file's matches labelled and playable - `catalog.player_names()`: every strategy but the tests' minimal `default`; the match tool, the strategy tests and the dashboard use it instead of each filtering the name. - Matches against the last release's file read "pendulum (last release)" in runs too, and find their replay under the name evaluate.py saves it as (split_shape@_vs_...). - Today's strategy against its own last release is listed on its page. - Replay: no robot coordinate list; a tactic tag only when it differs from the label; robot ids readable on the light pitch. Match cards never wrap. Co-Authored-By: Claude Opus 5.5 --- tools/evaluation/match.py | 2 +- utama_core/dashboard/static/app.css | 5 ++- utama_core/dashboard/static/field_canvas.js | 3 +- utama_core/dashboard/static/replay.js | 2 +- utama_core/dashboard/static/status_panel.js | 2 +- utama_core/dashboard/static/strategies.js | 2 +- utama_core/dashboard/views/strategies.py | 43 +++++++++++++------ utama_core/strategy/catalog.py | 8 ++++ .../tests/dashboard/test_strategies_view.py | 24 ++++++++++- .../tests/engine/test_all_strategy_configs.py | 2 +- 10 files changed, 71 insertions(+), 22 deletions(-) diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index 1a367e9a..01921a77 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -55,7 +55,7 @@ def replay_name(run_dir: Path, match_tag: str) -> str: # single-tactic smoke-test scaffold (see its docstring), used across the test # suite with as few as zero outfield robots, and plays a real match with 3 of 5 # outfield robots never issued a command. Every other strategy is playable here. -_CONFIG_NAMES = [name for name in catalog.names() if name != "default"] +_CONFIG_NAMES = catalog.player_names() def _short_name(config_name: str) -> str: diff --git a/utama_core/dashboard/static/app.css b/utama_core/dashboard/static/app.css index 3e99519d..c8676209 100644 --- a/utama_core/dashboard/static/app.css +++ b/utama_core/dashboard/static/app.css @@ -276,7 +276,10 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; } .dumbbell .dot { position: absolute; top: 2px; width: 10px; height: 10px; margin-left: -5px; border-radius: 50%; } .dumbbell .dot.this { background: var(--accent); } .dumbbell .dot.others { background: #fff; border: 2px solid #9ca3af; } -.matches { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 8px; } +.matches { display: grid; grid-template-columns: repeat(auto-fill, minmax(230px, 1fr)); gap: 8px; } +.match > span:first-child { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.match .score { white-space: nowrap; } +.match > .row { flex-wrap: nowrap; flex-shrink: 0; } .match { display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 8px 10px; border: 1px solid var(--border); border-radius: 6px; font-size: .88rem; } .match .score { font-weight: 600; font-variant-numeric: tabular-nums; } .match .win { color: var(--ok); } .match .loss { color: var(--fail); } .match .draw { color: var(--muted); } diff --git a/utama_core/dashboard/static/field_canvas.js b/utama_core/dashboard/static/field_canvas.js index ddf83265..bc9f79d9 100644 --- a/utama_core/dashboard/static/field_canvas.js +++ b/utama_core/dashboard/static/field_canvas.js @@ -232,7 +232,8 @@ class FieldCanvas { toY(bot.y + headingM * Math.sin(bot.orientation)) ); ctx.stroke(); - this._label(ctx, bot.id, cx, cy - r - 2, "bottom", "bold " + textPx, fill); + // yellow text is unreadable on the light pitch: the id takes a darker yellow + this._label(ctx, bot.id, cx, cy - r - 2, "bottom", "bold " + textPx, fill === FIELD_COLORS.yellow ? "#a16207" : fill); if (label && tactics[String(bot.id)]) { this._label(ctx, tactics[String(bot.id)], cx, cy + r + 2, "top", textPx, FIELD_COLORS.marker); } diff --git a/utama_core/dashboard/static/replay.js b/utama_core/dashboard/static/replay.js index 35919a91..c9a7481b 100644 --- a/utama_core/dashboard/static/replay.js +++ b/utama_core/dashboard/static/replay.js @@ -307,7 +307,7 @@ function framesFromColumns(c) { if (fieldView) fieldView.draw(frame); if (timeline) timeline.draw(frame.ts); markPlay(frame.ts); - renderRobotStatusInto("replay-status-entries", frame, { hideFeedback: true }); + renderRobotStatusInto("replay-status-entries", frame, { hideFeedback: true, hideFriendly: true }); renderTacticStatusInto("replay-tactic-entries", tacticStatus, { emptyLabel: "no tactic data at this frame", }); diff --git a/utama_core/dashboard/static/status_panel.js b/utama_core/dashboard/static/status_panel.js index a6abb89a..ad173eff 100644 --- a/utama_core/dashboard/static/status_panel.js +++ b/utama_core/dashboard/static/status_panel.js @@ -93,7 +93,7 @@ function renderTacticStatusInto(containerId, tacticStatus, options) { robotId + "" + label.replace(/\s*\(committed\)/, "") + - (tagColor ? ' ' + tag + "" : "") + + (tagColor && tag !== label ? ' ' + tag + "" : "") + "" + (committed ? 'committed' : "") + "
" + diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js index 0c623202..c4c071e1 100644 --- a/utama_core/dashboard/static/strategies.js +++ b/utama_core/dashboard/static/strategies.js @@ -169,7 +169,7 @@ const [f, a] = m.score; const res = f > a ? "win" : f < a ? "loss" : "draw"; return ( - `
${esc(m.opponent)}` + + `
${esc(m.opponent)}` + `${f}–${a}` + `${m.stalled ? pill("stalled", "dropped") : ""}${replayButton(m.replay)}
` ); diff --git a/utama_core/dashboard/views/strategies.py b/utama_core/dashboard/views/strategies.py index 775eab35..bd9606fc 100644 --- a/utama_core/dashboard/views/strategies.py +++ b/utama_core/dashboard/views/strategies.py @@ -75,6 +75,11 @@ def display_name(config: str) -> str: return catalog.current_name(config) +def _label(config: str) -> str: + """How a player is shown in a match: its catalog name, marked when it is the last release's file.""" + return display_name(config) + (" (last release)" if is_frozen(config) else "") + + def _newest_first(run_id: str) -> tuple: """A sort key: by the run's date and time (`eval_` and `tournament_` alike), then its id.""" m = re.search(r"\d{8}_\d{6}", run_id) @@ -113,11 +118,17 @@ def _summaries(base: Path) -> list[tuple[Path, dict]]: return out +def _file_name(config: str) -> str: + """A player's name in replay file names, as `tools/evaluation/match._short_name` writes it: a + `.strategy` file by its file name (`split_shape@cffe3a28`), anything else by its plain name.""" + return Path(config).stem if config.endswith(".strategy") else catalog.plain_name(config) + + def _replay_path(base: Path, run_dir: Path, result: dict) -> Optional[str]: """The result's replay, relative to `base`: `evaluate.py` writes `
_vs_.npz`. Older runs (the retired `ladder.py`, `full_match_tournament.py`) wrote side and kickoff tags, `_vs__` (as `.pkl` for the latter).""" - stem = f"{catalog.plain_name(result['config_a'])}_vs_{catalog.plain_name(result['config_b'])}" + stem = f"{_file_name(result['config_a'])}_vs_{_file_name(result['config_b'])}" names = [f"{stem}.npz", f"{stem}.pkl"] if "a_is_right" in result: names.insert(0, f"{stem}_{'R' if result['a_is_right'] else 'L'}{'K' if result.get('a_kicks_off') else 'k'}.pkl") @@ -191,19 +202,25 @@ def _matches_of(name: str, summaries: Iterable[tuple[Path, dict]]) -> list[dict] for _, summary in summaries: run_id = summary.get("run_id", "") for r in summary.get("results", []): - a, b = display_name(r["config_a"]), display_name(r["config_b"]) - # a match reused from the store is listed under the run that played it - if name not in (a, b) or a == b or r.get("reused"): + if r.get("reused"): # listed under the run that played it + continue + sides = ( + (r["config_a"], r["config_b"], r["score_a"], r["score_b"]), + (r["config_b"], r["config_a"], r["score_b"], r["score_a"]), + ) + # today's strategy only (not the last release's file of it), and never against itself + mine = [ + side + for side in sides + if display_name(side[0]) == name and not is_frozen(side[0]) and _label(side[1]) != name + ] + if not mine: continue - if is_frozen(r["config_a"] if a == name else r["config_b"]): - continue # the last release's file playing, not today's strategy - mine, theirs, opponent = (r["score_a"], r["score_b"], b) if a == name else (r["score_b"], r["score_a"], a) - if is_frozen(r["config_b"] if a == name else r["config_a"]): - opponent += " (last release)" + _, them, score_me, score_them = mine[0] out.append( { - "opponent": opponent, - "score": [mine, theirs], + "opponent": _label(them), + "score": [score_me, score_them], "seed": r.get("seed"), "run_id": run_id, "date": run_date(run_id), @@ -296,7 +313,7 @@ def load_strategies(base: Optional[Path] = None) -> dict: summaries = _summaries(base) if base.exists() else [] reports = _reports(base) if base.exists() else [] strategies = [] - for name in catalog.names(): + for name in catalog.player_names(): path = STRATEGY_DIR / f"{name}.py" doc = _docstring(path) strategies.append( @@ -329,7 +346,7 @@ def load_runs(base: Optional[Path] = None) -> list[dict]: runs: dict[str, dict] = {} for path, summary in _summaries(base): for r in summary.get("results", []): - r["display_a"], r["display_b"] = display_name(r["config_a"]), display_name(r["config_b"]) + r["display_a"], r["display_b"] = _label(r["config_a"]), _label(r["config_b"]) # the page needs only whether it stalled; the full stats are ~95% of the payload r["stalled"] = _stalled(r) r.pop("stats", None) diff --git a/utama_core/strategy/catalog.py b/utama_core/strategy/catalog.py index bfdb8afd..fdf35223 100644 --- a/utama_core/strategy/catalog.py +++ b/utama_core/strategy/catalog.py @@ -18,6 +18,14 @@ def names() -> list[str]: return sorted(p.stem for p in _PACKAGE.glob("*.py") if "\ndef build(" in p.read_text()) +TEST_ONLY = "default" # everyone attacks with one tactic: the tests' minimal strategy, never a player + + +def player_names() -> list[str]: + """Every strategy that plays matches: `names()` without the tests' minimal one.""" + return [name for name in names() if name != TEST_ONLY] + + # The names strategies had until 2026-11-12, so old replays and summaries still load. Only `builder` # and `current_name` read this: replay files keep the names they were saved under, so `plain_name` # (which tools use to find those files) does not. diff --git a/utama_core/tests/dashboard/test_strategies_view.py b/utama_core/tests/dashboard/test_strategies_view.py index db4f9911..d7dac457 100644 --- a/utama_core/tests/dashboard/test_strategies_view.py +++ b/utama_core/tests/dashboard/test_strategies_view.py @@ -124,7 +124,27 @@ def test_matches_are_from_the_strategys_side_with_their_replays_and_reused_ones_ ] by_opponent = {m["opponent"]: m["replay"] for m in matches} assert by_opponent["wolfpack"] == "eval_20261112_100000/round_1/mirage_vs_wolfpack.npz" - assert by_opponent["pendulum (last release)"] is None + assert by_opponent["pendulum (last release)"] is None # no replay file in the fixture + + +def test_a_frozen_files_replay_is_found_under_the_name_evaluate_saves_it_as(replays): + (replays / "eval_20261112_100000" / "round_1" / "pendulum@ab12cd34_vs_mirage.npz").write_bytes(b"") + matches = _strategy(view.load_strategies(replays), "mirage")["matches"] + (m,) = [m for m in matches if m["opponent"] == "pendulum (last release)"] + assert m["replay"] == "eval_20261112_100000/round_1/pendulum@ab12cd34_vs_mirage.npz" + + +def test_todays_strategy_against_its_last_release_is_listed(replays): + path = replays / "eval_20261112_100000" / "round_1" / "summary.json" + summary = json.loads(path.read_text()) + summary["results"].append(_row("replays/eval/frozen/pendulum@ab12cd34.strategy", "pendulum", 0, 4)) + _write(path, summary) + (m,) = _strategy(view.load_strategies(replays), "pendulum")["matches"] + assert (m["opponent"], m["score"]) == ("pendulum (last release)", [4, 0]) + + +def test_the_tests_minimal_strategy_is_not_listed(replays): + assert "default" not in [s["name"] for s in view.load_strategies(replays)["strategies"]] def test_the_frozen_files_matches_are_not_todays_strategys(replays): @@ -146,7 +166,7 @@ def test_a_run_groups_its_rounds_and_its_report_without_the_bulky_stalls(replays assert run["report"]["candidates"]["mirage"]["verdict"] == "dropped" assert "stalls" not in run["report"]["candidates"]["mirage"] results = run["rounds"][0]["results"] - assert [r["display_a"] for r in results] == ["mirage", "pendulum", "wolfpack"] + assert [r["display_a"] for r in results] == ["mirage", "pendulum (last release)", "wolfpack"] # only the stall flag of each match's stats is sent: the full stats are megabytes over all runs assert [r["stalled"] for r in results] == [True, False, False] assert not any("stats" in r for r in results) diff --git a/utama_core/tests/engine/test_all_strategy_configs.py b/utama_core/tests/engine/test_all_strategy_configs.py index 5449c825..c0bc89c9 100644 --- a/utama_core/tests/engine/test_all_strategy_configs.py +++ b/utama_core/tests/engine/test_all_strategy_configs.py @@ -38,7 +38,7 @@ # Every strategy, as round-robins discover them, so a new one is covered without editing this # file (a strategy branch can't: see tools/dev/check_strategy_branch.py). -_CONFIGS = [pytest.param(name, id=name) for name in catalog.names() if name != "default"] +_CONFIGS = [pytest.param(name, id=name) for name in catalog.player_names()] @pytest.fixture From c1799afda0ddece15d9a8bc73f7589a6471f3667 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 11:56:38 +0000 Subject: [PATCH 54/59] docs: the tutorial looks around the dashboard first, with the replays zip of the release - first_strategy.md step 2: download replays-v2.6.0.zip (core round 1 of the health check), open the Strategies tab, read the maps and numbers, watch a replay; two screenshots. - Step 9 points back to the dashboard for the new strategy's verdict and maps. - A strategy with no matches says how it would get some. Co-Authored-By: Claude Opus 5.5 --- docs/first_strategy.md | 51 +++++++++++++++++----- docs/img/dashboard/replay.png | Bin 0 -> 183567 bytes docs/img/dashboard/strategy_page.png | Bin 0 -> 139075 bytes utama_core/dashboard/static/strategies.js | 1 + 4 files changed, 40 insertions(+), 12 deletions(-) create mode 100644 docs/img/dashboard/replay.png create mode 100644 docs/img/dashboard/strategy_page.png diff --git a/docs/first_strategy.md b/docs/first_strategy.md index b2128f60..9b0aa4ed 100644 --- a/docs/first_strategy.md +++ b/docs/first_strategy.md @@ -1,7 +1,7 @@ # Your first strategy This page takes you from zero to a strategy of your own, playing in the simulator. -You need no knowledge of the codebase. Allow about an hour. +You need no knowledge of the codebase. Allow about an hour and a half. First, install everything: follow steps 1 to 3 of the [README](../README.md#quick-start). @@ -22,7 +22,35 @@ pixi run main riptide terrier The strategies are listed in [strategies.md](strategies.md). -## 2. Three words you need +## 2. Look around our strategies + +The dashboard shows every strategy, how it plays and replays of its matches. To fill it, download +[`replays-v2.6.0.zip`](https://github.com/First-Order-RoboCup-SSL/Utama-Core/releases/download/v2.6.0/replays-v2.6.0.zip) +(160 MB: the core strategies playing each other once) and unpack it: + +``` +pixi run python -m zipfile -e replays-v2.6.0.zip replays/ +pixi run dashboard +``` + +Open http://localhost:8080 and click **Strategies**. + +![A strategy's page](img/dashboard/strategy_page.png) + +- **On the pitch**: where its robots stand with the ball and without it (darker is more time), and + where its shots came from. Every picture attacks to the right. +- **How it plays**: each number beside the other strategies' average. These explain a style; more is + not always better. +- **Matches**: click ▶ to watch one. + +![A replay](img/dashboard/replay.png) + +The replay shows the robots, the referee's decisions and which tactic each robot ran, on a timeline +under the pitch. The list on the right has one row per restart or ball won; click a row to jump to it. + +Pick two strategies with different maps and watch a match of each. What do they do differently? + +## 3. Three words you need - **Strategy**: decides what the whole team does. One file in `utama_core/strategy/`. The file's name is the strategy's name. @@ -34,7 +62,7 @@ The strategies are listed in [strategies.md](strategies.md). The goalkeeper is handled for you. Your strategy controls the other five robots. Restarts (kickoffs, free kicks, stops) are also handled for you. -## 3. Make a branch +## 4. Make a branch ``` git switch main @@ -42,7 +70,7 @@ git pull git switch -c strategy/rookie ``` -## 4. Write the strategy +## 5. Write the strategy Create the file `utama_core/strategy/rookie.py` and paste this in: @@ -108,7 +136,7 @@ What it does: - It returns one command per robot. - `build` puts the tactic into a strategy. Every strategy file needs a `build` function. -## 5. Watch it play +## 6. Watch it play ``` pixi run main rookie wolfpack @@ -116,7 +144,7 @@ pixi run main rookie wolfpack Your team is yellow. Does the chaser reach the ball? Do the helpers follow the play? -## 6. Change something +## 7. Change something Try one small change, then watch again: @@ -126,7 +154,7 @@ Try one small change, then watch again: Change one thing at a time, so you know what made the difference. -## 7. Test it +## 8. Test it ``` pixi run pytest utama_core/tests/engine/test_all_strategy_configs.py --headless @@ -136,7 +164,7 @@ pixi run lint All three must pass before you open a pull request. -## 8. Is it better? Run an evaluation +## 9. Is it better? Run an evaluation Watching one match is not enough. Football is full of luck. The evaluation plays many matches and tells you if your strategy beats the champion (our best strategy). @@ -165,11 +193,10 @@ Read two things: Ignore everything else in the output for now. -To see it all in a browser, run `pixi run dashboard` and open http://localhost:8080. -The **Strategies** tab shows every strategy: what it does, its verdicts, how it plays and its matches. -Click ▶ on a match to watch its replay. +Then open the dashboard again: `rookie` is on the **Strategies** tab with its verdict, its maps +and its matches, beside the strategies you looked at in step 2. -## 9. Now let an agent write one +## 10. Now let an agent write one You know how a strategy works now. A coding agent (like Claude Code) can write and test new ones much faster. This repo has a step-by-step guide for agents: the `change-strategy` skill. diff --git a/docs/img/dashboard/replay.png b/docs/img/dashboard/replay.png new file mode 100644 index 0000000000000000000000000000000000000000..d2a176d71c62b4d108b047199a1691ddfd039c24 GIT binary patch literal 183567 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 QkQaS4 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 K#VSP%gZ>B1c`h~p literal 0 HcmV?d00001 diff --git a/docs/img/dashboard/strategy_page.png b/docs/img/dashboard/strategy_page.png new file mode 100644 index 0000000000000000000000000000000000000000..d52e69c1c1a7cb23741011c3971fac259e660b0c GIT binary patch literal 139075 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%0Ajvs>~w`6Qps<5UZqZ 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%0A(#nCY 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 Q93mn`IW=hcvsdr`8>4cchX4Qo literal 0 HcmV?d00001 diff --git a/utama_core/dashboard/static/strategies.js b/utama_core/dashboard/static/strategies.js index c4c071e1..6d46e972 100644 --- a/utama_core/dashboard/static/strategies.js +++ b/utama_core/dashboard/static/strategies.js @@ -189,6 +189,7 @@
${renderTactics(s)}${renderVerdict(s)} ${esc(s.file)}
+ ${s.signals || s.matches.length ? "" : `
No matches yet. Reserve strategies play in pixi run evaluate --all.
`} ${renderMaps(s)} ${renderSignals(s)} ${renderMatches(s)} From 7b02b5d8b1c8bcd4fbd4b16cf9168cd57febae80 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 12:15:06 +0000 Subject: [PATCH 55/59] check_strategy_branch: docs/strategies.md is no longer on a strategy branch's allowlist The catalog doc is deleted (next commit): the dashboard reads every strategy, its description and its results from the code and replays/. Co-Authored-By: Claude Opus 5.5 --- docs/contributing.md | 78 --- docs/field_log_replay.md | 144 ----- docs/field_logs.md | 100 --- .../decoy_and_overload_110-170.png | Bin 155393 -> 0 bytes .../stall_split_shape_773-796.png | Bin 117060 -> 0 bytes .../motion_planning/trajectories_direct.png | Bin 82011 -> 0 bytes docs/img/signals/fouls.png | Bin 77396 -> 0 bytes docs/img/signals/fouls_map.png | Bin 120481 -> 0 bytes docs/img/signals/positions_attack.png | Bin 322869 -> 0 bytes docs/img/signals/positions_defence.png | Bin 299742 -> 0 bytes docs/img/signals/shots.png | Bin 205723 -> 0 bytes docs/in_house_vision.md | 306 --------- docs/motion_planning_results.md | 84 --- docs/pipeline_method.md | 75 --- docs/pitch_zones.md | 71 --- docs/referee_design_decisions.md | 91 --- docs/referee_gui.md | 85 --- docs/referee_integration.md | 62 -- docs/roadmap.md | 286 --------- docs/scheduling_math_model.md | 72 --- docs/setup_external.md | 56 -- docs/sim_realism.md | 579 ------------------ docs/strategies.md | 97 --- docs/testing_gaps.md | 63 -- docs/visual_guide.md | 195 ------ tools/dev/check_strategy_branch.py | 1 - .../engine/test_check_strategy_branch.py | 7 +- 27 files changed, 2 insertions(+), 2450 deletions(-) delete mode 100644 docs/contributing.md delete mode 100644 docs/field_log_replay.md delete mode 100644 docs/field_logs.md delete mode 100644 docs/img/match_timeline/decoy_and_overload_110-170.png delete mode 100644 docs/img/match_timeline/stall_split_shape_773-796.png delete mode 100644 docs/img/motion_planning/trajectories_direct.png delete mode 100644 docs/img/signals/fouls.png delete mode 100644 docs/img/signals/fouls_map.png delete mode 100644 docs/img/signals/positions_attack.png delete mode 100644 docs/img/signals/positions_defence.png delete mode 100644 docs/img/signals/shots.png delete mode 100644 docs/in_house_vision.md delete mode 100644 docs/motion_planning_results.md delete mode 100644 docs/pipeline_method.md delete mode 100644 docs/pitch_zones.md delete mode 100644 docs/referee_design_decisions.md delete mode 100644 docs/referee_gui.md delete mode 100644 docs/referee_integration.md delete mode 100644 docs/roadmap.md delete mode 100644 docs/scheduling_math_model.md delete mode 100644 docs/setup_external.md delete mode 100644 docs/sim_realism.md delete mode 100644 docs/strategies.md delete mode 100644 docs/testing_gaps.md delete mode 100644 docs/visual_guide.md diff --git a/docs/contributing.md b/docs/contributing.md deleted file mode 100644 index 0fd3eed6..00000000 --- a/docs/contributing.md +++ /dev/null @@ -1,78 +0,0 @@ -# Contributing - -How to set up an editor, commit, and get a pull request merged. Quick start and repository -layout: the [README](../README.md). Context for coding agents: [`AGENTS.md`](../AGENTS.md). - -## pixi - -- `pixi install` installs the environment, including every package with an `__init__.py`: - run it again after adding one. -- `pixi shell` enters the environment; `pixi run ` runs a task from `pixi.toml` without - entering it (see [tools.md](tools.md#pixi-tasks)). -- For a one-off run of a module, `pixi run python -m path.to.your_file` (`/` replaced by `.`, - no `.py`). -- In VS Code, if the run button picks the wrong environment (`robosim`), choose the interpreter - by hand: `Ctrl + Shift + P` → `Select Interpreter`. - -## Code style - -- Type every variable. -- Format with Black. In VS Code, install the `Black Formatter` extension, open - `Open User Settings (JSON)` from the command palette and add to the `"[python]"` field: - - ```json - "[python]": { - "editor.defaultFormatter": "ms-python.black-formatter", - "editor.formatOnSave": true - } - ``` - -- `pixi run lint` runs the whole pre-commit stack (black, ruff, isort) on every file; - `pixi run test` runs the tests. Run both before calling a change done. - -## Commits - -1. Each feature lives on its own branch. Clear out stale branches. -2. Run `pixi run precommit-install` once, so the pre-commit checks run on every commit. -3. If a commit fails the pre-commit checks, the hook has often already fixed the files: look at - the output (`Open Git Log` in VS Code's popup), stage the changes and commit again. -4. On Windows the popup may show `bash: warning: setlocale: LC_ALL: cannot change locale - (en_US.UTF-8)`. That is not the failure, just the first warning in the output. To silence it: - - ```bash - sudo apt-get update - sudo apt-get install -y locales - sudo locale-gen en_US.UTF-8 - sudo update-locale LANG=en_US.UTF-8 - source ~/.bashrc - ``` - -## Pull requests - -A pull request into `main` needs: - -1. a `release:major`, `release:minor` or `release:patch` label: every merge to `main` releases - a new version automatically (`.github/workflows/release.yml`); -2. passing CI, tests and lint; -3. to be up to date with `main`: - - ```bash - git checkout main - git pull - git checkout - git merge main - ``` - -4. every Copilot comment reviewed (not all must be addressed: Copilot makes mistakes too); -5. an approval from an assigned reviewer. - -A strategy branch (`strategy/*`) is also checked by `tools/dev/check_strategy_branch.py`: it must not -change the evaluation or the opponents it is scored against. - -## `CLAUDE.md` and `AGENTS.md` - -`CLAUDE.md` is a symlink to `AGENTS.md`, the single source of agent context (`AGENTS.md` is the -cross-vendor default; Claude Code reads `CLAUDE.md`). Edit `AGENTS.md`, never the symlink. -Linux, macOS and WSL check it out correctly. On native Windows, git only creates symlinks with -Developer Mode or Administrator privileges; without them `CLAUDE.md` arrives as a 9-byte text -file, fixed by `git config --global core.symlinks true && git checkout -- CLAUDE.md`. diff --git a/docs/field_log_replay.md b/docs/field_log_replay.md deleted file mode 100644 index 053846ec..00000000 --- a/docs/field_log_replay.md +++ /dev/null @@ -1,144 +0,0 @@ -# Field logs: finding a moment and replaying it offline (design) - -Status: design, 2026-10-28. Nothing here is built yet except what "Today" lists. - -## Why - -On the 2026-10-27 field day every bug was found the same way: a symptom someone saw ("it drives -sideways and back", "blue misses passes", "placement throws the ball away"), then a throwaway -script to find the moment in the log, then another to rebuild what the robot saw and decided at -that moment. The second step found every cause. Running the recorded camera packets through the -same refiners and tactic offline showed blue's receive point clamped to x 0.43, and the -attacker's hold point at (0.43, +0.07) wherever the ball was. Each script took 10-30 minutes -to write, and all of them were lost when `/tmp` was cleared. This doc designs one tool for the -whole loop, so a field symptom becomes a cause, and then a regression test, in minutes. - -## Today - -- Every real run records `replays/field/
rsQ>`$-zyeB4wDr5MsG}o^H3kexH1=dU! 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

F$D-w8zOzQ-hta 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 diff --git a/docs/img/match_timeline/stall_split_shape_773-796.png b/docs/img/match_timeline/stall_split_shape_773-796.png deleted file mode 100644 index 950842a9aed43d6e253d393f1c051532469ab4cb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 117060 zcmdSB2UJsA7cPo|SZFFLf=4ghe{LIiIoaGe;*YdpllE zZf;I)_IsAj&JIpcE-v^#XK>m(T5vgz;qQZ1E<4ESI^p4wpW^qdgkzq9`rxvVyt-vTUjsvu%|;?&aj@7@guZ=`=a3rK$Op72NyJVYlIG zVeX3Dija@@6Qf*&f$jS?3fn#*Ts!+0x)2I4u9mO z2Y-LYtGs6X&u2UO#(zHle|m$f|LQ|44e$RU9SyHE@20BW9YdK88r@ilWQ1md$D$ztN8{`9G32cJbxN|u=Rqem~5QV-L{U$mw! zB>0^kSkxDX2VNvg;yK=EA#>3#O7bQ-8*7P{-})mL@WO^C>%HdRaUmj{dMN3A4!4W8 zD{iuBcO=^*SSrUIOSe}?F$tQ-VbsE1vxeTA-}}pLMohMDhd$CO*80;bs zc34eU%x0?FWZdD0s;XZx@~GAKygfqsCZW_`FOLsV#TD3KG6)lMn)~zmqVTRRc8#D{ zuT*%f2R}ktbd>7}!$o(iR!2+o`j3K1sp;Zju8BxweoV}bgY{ap+3XJzbxlq7&-#^d zm>yvry>e?8rH;Ix+Sxwe?ygrJLiAlKE4e>i>866#U z9Dgy0@ zDTEJ??=gXH{n!h_p#fEKdN6On-@bpZ)|5G$s}=I|#Fi0dS?1$aFI-^6gQX*Jm=7-o zC>d6IgwbER2^@0$u%`_*Elat0lQC2n+b-MCs6=iWANg8 zY{~QQj+aSE1(4R$vjIe$5uk%QdKI=T@rKYRGqbZ`ew3Lew6wM3-tk|;by?!%vHv-j z=cr*gkI4_>(R#1SSHZ!G#fJ5BUQbXI! z;$f^$o;*=;T5H(qC~%w&6-?3;n)1ecuG<+-UO?y=`Dh_dJ%bMPHL?sm=5O+A+j(6i zy&DlOcKFNL8a(HZ_X(WI0+ItZT}k|kr>9<_**Q6hi+R*qX0j#Pd1BxUJ9RhPDFiGa zFwnFuf|kc~+j4W))n_?2M=`!b7+uGv19QnqacI6gzn;!Be=|C4Za&_qV(6u?i{>?p zVy)4U3RcwcXI?WKWX0!kFLeD@uQ;}iHuE9OG!zgBBzR4~;(avss9|w_ z$`9+p(m1_hlAD{GkPK;-NG%hj2HBc{(5=TUOI*zIqlMLH1-sYH61O22up8Pm0#N1qt0{7 zGljb>BDXm7?sIc9G)+~^qv~_?U@A2Ked$QYkjsrS`jeS= zT#>tL$W9GaQ8Vbzf>Of3(yb~Cv_?;b`e)(0tElE0Z8YMjsBU-6#yr!=4O4D|*z>?F z$nUMUw%6}XTGXBdl8Ht1il>|RTo!NW5Ed#Yhhe_QlRPjrHI3=)^lKpzOfVVqT1d2* z2P=oG(huHm9J+I22@9m9qZ=o&{t4Y>^?d4)GQl*iGUQsBq3Qk5? zqU#=Hv+<)&Zck8oekiHDBwO}I@Zj?4is5OZjGxXsnI7(%F6Pzz5MfOo(Pif4D% z;&jS#yt!zGj4ft_J}d+t=#F_tpNc?Dk2(@%M6e8?p^x3!Oh zi6pRES75Wmqt$1@E{nQjUnj3!WbllpcjB<`=jXj~r{YA>jI4BFw{^PFQC(p0lys{c zGMD##mokG5JbT7AT@IJ?lI!O5CfnNNf=Q7nDR&beJbPTevh)<8&1>OHKVsxpPfQKf z6g%F)=S5}Jq{QYyi?d1{nV8o3sB@Ek$U#5QGY*eqYqD_ zB%<0Da^LVzyvgf#>di|oJwQm!K~k|)O>^gtO#oNY6`4S&=OiN&lLE~1_v`i&%b&$O zE-RW~LiLrueDCd@%Jil2-gv~TD1~BXXV+|QZe|r3HVGFs4q>+GxAA${r z_%Z+^`_V)6Xm@Sa!PZB0rJ`n`B~$X#){i^(9l)Y-y`$iYdlX1GYOZVP@JP7D#Z^*G zEh7;=({Z#@SlYwGYhFfdhEGh@)i+|gZ8_5ac&GwgHI>3fFY{h#1@7|W4QEGMbTkLB zA^g0b)*G;hEIqfp53PfTgBjx=q~9rB&4SfdEVz=atk_;CH+yHc8>v@+Xn&cQIA%aa zxSQblj%a4-Eke?}rsvao%-x3;|BD5ah3*x>C>=~;Pf-rFu6?mN)b2^X&0_~2=!JTr zHZjXF1I~g_&%v8D4;C*or&vNmT$+a8_8SkHR`Z*E?@HvgrS2TN><56vd~pLi{ckNW z3SCS4Ov+)-V@6(U{7m;Us1uUVwQlH1yOH4B&7XWwDu*xWLm5bG-z`ECYNx6VUP_I4K^s!X%M>vGJxNhrh=cmMc{j`<3u$~T&?>FN+ z@yW)~5$p50$#y*SedSIi&~rgEGta9R(`vgPS7}oid4DCQat>JbFABj6bTJPN%dH?2 zu^MA`>v?JNJH@GooBD*x__n|*!^53Hjn1KPS1A;6Q2vrq*xsaRZ-y5t{(sP8O6=4RIs;b#&E!c*RMXRO%BiU~@4;~HJa2Qlc1OxSXlV|P{fefpFw zrsAba8ah6h?k-jfrhiRrfnPm|<%aW%&JjZ|n4z!7TlwOwESGZ0Iv3P1um#S-yQ$B| znzB;I$1;l!24N%*23@PUs^^{uKS4pS>sjzwUb(@RN)izj^&HAJQfy=a%_=itWnpQr zhCQ}p5~ zd1ERRdJ9103(-G53TOmr0yLoAqy1SgQDtVdbTQ#)yN5^h2VF1V=1gTwQSUG73>b{o z0uxVtI>HYr%Yxy{jlEp9TgfT$++N}YK%Dy#XX>*o>czt`lvid&&&#Y#Ui*}vdx?as zTNupTLb5%JTSJ)o)R$-VE%3u*@L1P_k%bV50o8tN&U|p?b z59ivs5^m`CiteRUD_ig_*}ULOU2Tmb^k&UZU$GOm>L)SJ4f6f*S+BgKYpY*VIw`G4 z`rR$2iIMH)0qWiA`M6}Z)Zc1DCM&jIQc?_}W$c;)E-VPZvVI4WO~(Js>aFk*&}$%a zU032mFM{Yn{`z%jvaVE(N_dZ*7x3nD4OpMAO^8aI2RC%77V+-!A7+TZ>r-Y(IeT? ziomed;T@W?Xe|ng2C!>vQQ?EKW1rBro9<@Ru?W{S@r68K`5%&EZ5oSLn>&X`dJhvb z(CrRLQpFQArUWzF}NHPB*}5A;*&Si904oE{s?LC$RW99rod z7wCH4{@0hE?6>rvOqH&;vLF7? zcWvSw1$Lf~Lexl&#}i*?@~Usk3TL=H zLlqPw^j5NZ#f}EM2w7^)zx}kcLGRBV38xf5P4aB-eJU9xDiX^rihthFw#}UWbl6zv zH$mqZm4b%0RSje6YhzXMV*dS7pCi}2-tQVy`nX~C59%(bxtS4UX_3##o*e69s#)op zo#xyxzks+vbPH;W9kVG;e1g%2s%uhYmuJ6mu$QXiUu#479EE#S!!oUcYFtp(>V{7- zh3RgS9wjENVG4UMa>P^~&fkcZk)`-TEohh05+1fb1b2}t7k1VTaE-9KxVJUmX@*(o zCiQ5vsR_$J(mUAS?-=}q?s!dMXz7@0Gcouoze6K+R^==<|T<~(qHx@P0E)S7F`?IipinQpfcW{4HvhqTuwTdgq}((63k?= zT*beaM5RR0Fj;05z546-!MmR;bW>w2h0AWv)IlX^Zjwt{6++HheD#Uzc|=!iY8cp* z3v%D()hcL2FGEQo-W!?n;n~zvhly$sD@y(^F1w>y;hy^S4XcF}0RiVd0Cwz}8s>Wp zfZV(xFYInDH2f24a;fWrSIub<=Z`{O&F#|04l3s%ld+?n5u@(seLc6n+7qKW&St>k zIU&AvY}f|`$P>)}l!fr8(sSrn#Kgpy>eji3R5zHkl9D2A^73+1`nI9a0I&8a#$0lF z3YwxqjgLI3P{xF*F)M)N3v82f6_Za)w`{Vw}}L?#CKhT%af{ zqEmdT4`ME6;2PraFOnu1N7kI|Vl}JL9*e0qGG^&s>mE$T*^6npLH*vCU0n1j(`jRU z8x~<;(P2ATCx3e4mbxqw9`g15>7MDKq32dR^V}iI{z29(zfjg<4dE~!UYXM(C$FTm z(_F3Oz|y!w%MO$1@WyZE3={olMD_yA5_?mT8mk@5WXUGboPP? zOD~VH?pl2U=FZv!WMbw4=#DCGI34T48yHon@eLy+DJ;FtI&gdPY;)oDO8K8FSI}@> zYHmz=E;}H-6wZI)ovUM-785qyH3Id~2X#JaWqUw1p2E<*X|2_6r0BCQuY_#8HNs{d zWuwbbo!hzg76dB8*^)n1SWccWr#J*WoRp>rEpUKI-ny_}oeJ(Iahzr2Ge zd3jC;=KS;Z)-RLrL;x}64F&SNl!t%*tkYHy)+|r+_BoluWqF#L&sT$pZQK)46!!64_0P; zZ*r=q_!~cznVbOk5LMbkWrkG2r>MEVU+018dOowen7R-@;*?3-N6CoWZD08kvcIptd#S~bFFk`&dh6>q@vB+YZhikDo5!mv0zSH-9I*p+cU zk`1{6C4wGF;v4Pq;eGtn;jAqS@L2dnfesfYvC4DD+9{dv){axnszvPNDcEG~u{wrk z>UWmI`7OOcSSNg9Ys3E6hFjcZWo301PZV^BagM3XJ@@mwT~=0B*QLIV4F}}On7q$~ z%Sfl-lsA1#Fd1*EjMv^eZ`O3@!sZC+!?pJVkq6MIsuE=3_KR}Ks*HP6**Ui#7)yl4 z>I-9Bw3{}5w{&vUR6G2pYwzfAUg{bG!0oMpY;+~a^JLR0$jfu5Rzc|uDKuRx#a69W z-iO{1OzJU%WoybJXu2&I9y%?^d3x4(C@Cjura~QMrExh+xYpsja(wYB}@+Ss#*;jAO<8Qe#cAh=P2BBr3V^0;0P% ztVKy`8pSV%-c#~^Z*4{9G=>x)7Zw+jJ(1N;c?1Oe$KLa2N*>}y0S+dEtFG|eC^M&{SIZ99%LAnpw&iFWUm7;i}NPgGCz zEho`HdCh*jr{sAq)m_-oXoIuDczCRj-!kx7*JP}NP;%W_xH}J)dJVm!1rtFZYLD!E z7FqAVwpJtOq~*;0T-oH+kKbut>yc|nw*=#;o-edQL}zV;@q@JIAm2nUh;e@7+Ax9$ zCyFk6j8xVX+0Va-=VU?^9*?yv`DbqKpC0Kly-wgHJvqi;WmoQ=UGLC!%~+zI&tX~u zXI--OE9pHZ!Y`}|4Y$59s}0hGxNO#;^kE~FTU9oLAD{FC-^*J0mGc;igTfPpsyRe& zP&PR>q8W}y7!Y9|!XFv;gV=CeQ5BU%Oe{nEE zyZ?VBYWx+`yml#dYh6joFPu#s9^QjX4;mSh1?{8WzbCf-vmWs9jNNbEycwr=D&@1i znC{nRMWA8wzdn7Fu(s!j5{yB;9fnynbm>A3QVK9xpN zbZ3qnM;d?l zGR*)=;+>ArLWc|M$gzlna5C99~S5;pGD3yX@4HCwl*gm8h>WY+T4uVW2<4aYT> znPv7PlQ||IfhFtcuud>S15?0gq?%k6hB%@@-8F$XA4Z6`< zw_=ga{jBTcci2pN9?H(>mq$?;xg&;Am+<_Pz5q6flHWAL))U3OT;-f}@EKbStBt#I zM%QIrC%C=x3IF15CvY2VdlOiHV)26;%M-QX!2L6XynP!7o;3-62$?dHQZW1ecD~}o z7rUlo1(K{~=)R^Llc%YU9hb<3`rsgaXpKw7G++(k>wwXy-{0R)(7ghyagBZTieR+F ztd!5HUy8G8`tkB;X?%+7*z(r5Xw?x%j&pbp+k9$%i~RAOHlp71V_{7^+0t)7FQ;DY zn32Bp{Nc92S7w zeaJ$^l<$!;2&)#hxC^1KE2c+CBvL;~0M2SQR%JF_Q^XSY1PdI_#_6L_-Bu z^0B1y)yD&D=kTWGd#LyoeC2oIvd8Iykvo3%F!aTgrKB8jk}EoOa4dk!gI}3}9>NnnO@}#OpLIiII7!oaw$>UypYd)2~xevBtxE zUn}|S!2!7xE+sA9j_~oqu_N3>V))?Z$0sNA4I1K6$wi2+!s-mGNauwBLW*tIddOKH zVis}Sx5o#cL85kf`KYu=yZ*aYi@wqVcH_oSiLr7U^e(pmeEj~47cZ_;-7>F*0~2xm z)-CgZi`vV}%Tdl788I<&3XdNLRCBEL(aMWD%OwfgEPMerAuTtfu_Obtt9&OL_Lzd# z>E-kvzYzOhaNNy*mNn?h|Jh{uzX*GOlW@v^^LPIzv-qGc`Z@^9!&W z{~J{fL4?^~zNjfED6G`{ElBW}@yCbMzi#OjBw*Q1Ko#rVa46`W*l z;X*ul`|h31JonC~_Hk+EBsK7u8DDDwYcpRtbsBN_0TGLPzK>Q2eqX7LOlmJ;Pb>D^nSihO+B=P!kJ|u?Mn{^@fG9QBSDw}aCx_5CA+*ST0<+&|hL! zXTbB~!}j__tG1y|#V3+a%aqse-nhS`ytoTrslidUi&}WS|bgedUJ0UsaPraUPVdd2vzSQkc#WT>+H4}&%CLGs^9F1e; z0c3?uE<8;>{O-2Z5p2|vxlLSp8jwrxxx0R6zFJT`Dk9?^%YF73ah;;b0aYpn9V7P& zrIRf$-Hnke?OgX`p5Y(0g_5@>9jZ}fd|ElpUqX;!(eU1w27Q(|6~Gdp-@&2*o)*}Zwn@g#QyI%dN~pVtDV!ii%`cJlm$+hokr zk|hfVN9^)IL(FR;3VBzRFygyH5=FJU)_~|O-q^1}Cvaz(ZO$;3n00C|_aW**Ox?Zk z^rpu~rtBQ>LN_7y5UWuhl^>zCYC*(bv+WOO-W8j!jrq;BGeb(@4HmtI)dz7%rGpP2 z5<p};!dsDE2%ESo;5dd8asnJC8Ir8RGTGyi51Kj-imAU4wO9*NI8u_{l0;g~`L( z2A&$%=I@o_thIa8G0fO*NMls_cx4G zpAGO}7u6;FLkO3V4}VM7MtRafcjfiFcWsF-i5&hS=YbzmIR2KVXzLbKjsmKlw)#C$ zwdGB~(y)T;LxS`AxbCSFk^{IuT5_)X{%p?AZ7w5*^u3}-Wg?s3vUr@Au2!#!yLBX$ z+jRQ`UQEBw+i)PWyFOuoJOzrOm@i)*1mKYQ$I65zHC0PyKj%{O3ao~P1|tWDG7u(^ zc%VKDcEa^3-F62CWp*pwP){Gz5d$e*U9$@Hng^zfxh6k@-UH-*n=own0nO1cIEmd>Y+6xX2(%j!aic&Y- zE_X|8^;`)Jd z`+CcY$AMHj+RaV2cljl2 z4-x_vIp>1xV6{-H?`O+|Q3)6f+xgF$@|OR&Has^z0|ORVP=D$f%SO{kXJPfZ#u6&f|D z)VK&2jUfm5A?ftIcu6uriW2?}N*;4zj^`pt;d%<@t}3y6It$Cf_7N-)rFhxXy^6$T zwZxB1*P_xA&CJ;~<96Hrda(CYF1aF@RcvB8sd-ldi$%(dBoJdHA0>g@4ZcH~=hll& zj?!B?sNvXRUe~2Q+F+~(S}ijk`A(c+GuHhV8!em&w0; zd5)GLOhxx@Ru z`5Jiy%OhxakCSp8vz-;KsKi7T;R^eBGI4h!Ts#?H`APMVW@I#5Os~p4=kCa-RQbH@ z(#s3%hl&CC_^FddiE-RNw@zxgI*Ju_+EY~f;;2^Uh2Ghx75(C0=_pl-@I!=PL%vZnyICjq`>eD8d`G=`#L!ar<#|Z}D+kwuVd!Yf}^L*2&&fJHODwQ*;%E^8iTxlpfHDio$^6$n4jbXZ_gyQ#-hZ5y1t*Hd!taRyUE8 zsJg?=`0JE3=C_OyCo7jZCyZ{AD0yRsF+8Wk!Sg?4nK}!?Cm0ckFsr=neTb5;l%2=w zg=Oy*q01zsQ7Ul#c4Y53diN{nqr>)(G`}>17xVo670P!8e%jA3E;1J@d9<^Si7Z8D zg83yctr#5|G0>Xd3==L&eorMT1Bh%!etv0?AAMo<^MiEt8ZHCGoXRH!^a$N$=|Csj zg@6kGn!I4r8_%L)7%S%E2~q`NHlaAsu@kEE z`ZISTHDzk|AUBL4kP!GSEjuq|t?Z++uy>yxRL!jV9=%SU)&G`Y{Ia9HGx~FgS2oO> z=rYOWxKQME#v+fhSFyVHpe+2#Zx!D%3P3yNO@;`jNb%>UU)J+G0;lSKXp5{^1MtU; z@R#Ox11oT#z`H6)Nxk~^J(i5%erir~l4l$HuED6DmGzvJMMwSKI3q~DMgx6~f~_sl z=AL-et((@Km&L#N+T%fULBF?Vh;?^17z0?z>og2#(=B2$$Q%xa;Civ3k3nb0${Qj+1U$a z!YZG&5Qc<>3E;M3=r!KkB4mFQx*1d;+#Z!qsC8a$M&TL{Z+=UO`yY4w??mEf84_Hh z|7DD3C@uXuXB|zbsS1Jzt^Z!|u=yEvKI6sa*6t@19Ut@+1+EQn+$91etj(1xTZ|7M zCQ|*0H}KRl0SMaMBg=3VApoQ}6$z)((J{I8pA06R#Ooib2_OpP_(V{w3tT>-A5wczFM7Vr*Pgb+^7b;QVOSi`2Qr zMR`qUUO=nYyL)(ORl!wMDs0E93_+;EAchG2_O0UMc9oUYrxG~I9OHIGn##aaVwHoW z`PHE6idMM+ff&gzjcWx2O0td@m6d5;C$E%OaEu}#AW&HBnfTT_)zA!AeEZIO(AytF_(u(^n!r62hpG2yPd#Pi~7 zV93ir>xyK`-L;HlyQ6x}bznIf1j-hQ=ms{zBhx;oZ6E@ozZ z0k{Fz_wUlzAyYEXpX+OSrho|nIn>gFTAyH*>y)Eq{cy6?Ddt)?=C|SD#SG5tI45z_ zPDf9VH6#Sd!1z%9{Q2`aPK$Oki)eKJmAyH#9MBEiZ5u7rwK(nW&$LGrs%gRX_= z0u-gy3Eki2%w$;a{8w|Zp$Yt6(6?_=2Y>_5(J4-IJl1&4sUeeclBOLpgq*p9 zw^xMi>sO90U!by&WK@hB{AM#^{J`nIza-2Lcy5O@$q~yue{el8^7i|0#tek?O_&FP zzwaw0Jb3h2QnGt$ZLB;t*{(*H#&d}lmuRhC%S-o-0ve*W5;Mgdkhxp{H2Gs3;b_(r zaKI_v6T?z0r>&g}l+~g$C=?se&qd-iz$K-n*)}6~JkOflH@SFE+C~L{yr$B?v7NER zYCz@ysBgMgL3CO5I7!fcefI^EN}bg3XMJWioua5{6)IMfAMalrR9`c|t(O0Gn*J>3 ze_!7LJIASP=ZRlm4sS&+xBZ_;&k7gg@vAKfjU^PzRZX`$Mf?uB( z-b6lE0MX#N#dGKjVr2VDb6zjeGGiCZA}yJ(|GT01)5R}FStMz}cr8z=j@D}dk*DLj zK5nIcx&C-d@%qi1X0_s6T&j8%@11_NCaJRsR&Kp90PMnhP;YUAf})*FyesO>n@dhd z&98~N3xj}r9zO=mNK!f=Ep$uGKX)RZraA$-K!w1_2+$|CxQ&l&rF^)hS-BEAecq+f zqtWYSFTNQ0f#Gy*@fL4Kaq6_ir z>({U4_4JZj;K8K2r(|Sg1>04Wl$7SMS9k1FOo=$}D;wRoaf1N}8eaTD7&Z8slU&lN z{AxW`_NfI+byr?N!SP6F*UUNSKkthH9FpNn->4?}P6P!d9D%vjvl}6l0RHTP0}XF1 z#CN~xSvtv`;dkNT;Vm`9X5WAO=wK^Wip2Cn*nE9Y9l;ezNd2-m(Oq3il>95~0DcrX z80l1e9V@j6Z^72Ou0`$d$Js$zsgnhY1bKO9W|4AAw(k@w6%`d@;rfEf4M?{ohRDdU zrmJ2TchS)kwdCElQLlPnj6y=$&1=qtGS6oODm0TNFD+TCMYQBw^KT?w1zbwFdk zHS-S3Um1G)#aoZ}vJjuaY_5{AI*-z0KuB}io9t}1LKH!D$AP{DCny4n#}!RfhR>1$ z5BKyEkD12B!E;SA0ilHG3upc+;AT4b<XoE>3EFWAbmrwbW{wr1TF%Zf#55vOo_p&YK#eRwq-o?bq=lQWE(7CT z!hihW&o=3-|Ct}0!?6Q;Bd<6302^2WaClGb82xY4YFU7Tm0eV(BS!RiBVkA-QqpnFG??_UJ?JKZ^DJk?9L0 zUMmD741cgu`bBT1t@=hc`ZfG9xiWGqHm7=tJRWKk0R2;Nf4ZxNvb_5T z_53xcBMo=x>FB5{=9?4$9l;6B)c#qsjf;<3uu4)V(m2HSKN%n6G6DKw%JSZ>3yakG z+nKm~Y!CpjUyv}|HmE`+#}{#9@f_I3#!X&-aDnmnv+p| zR;q=IC#H4(my`o%REp}OM+gRHW(}Xe0u$BLl+WmPtX08gO$TXPcPpVSu=V(fskYld2g$? zT=AF3!1?*>P`B9W>4+qup?(olP67zIM39>uxx78UkwZV>0ICoY-1^yUH z211L6s_RefyR0Ht&*EwDtHi7%sNd@t5FWnFscHCEsES7g3VT2Df{kTI{ij(x%Y7gW zQsEm6+xZc5E95V#6R)r8nz4WP;SS1dzC&w47TeR&kzeAvi=MKt=o{6BCNe&v(Wruh~`4-+DOvo_8X@ zDd^YNo-SOE=>xbt`ub&#wwIv=anqZ7Z?TQMjF_A|IYKXBp)^Qlu}9}+jhGRiuS>ms zm*aq8ZBNFe#W1YJ9V%EDo7Ouu+^{!doBRrAJf0+Dov7GvRB88K=h=gN8&RcW#?n!$ z!q^#Eyf`Xj7-*!x!8#MK&eIWJNK9TN%qPgOavPI>KHTHRk>wJgM zc3k+VEKErt7`m)tMY_*L$gt(vN@-zYRxTjxH1m`?lp zPP}|imkz^mld3erx82qI=H|F<`_U$B6Xlh^|E(f63SXGfYYZ#jj)1E`T9}Ih-Gim% z)(b18uQ+zYUw8Tmh?8dRr{Csc4BpkZTj|q(T;y)h4-s2zo9*?OB6w7nrLVBLt{laC za)CvDa<>0uQu#TfX3 zU3cwd8}p0~m~V(lgsHRUFn+I)@b7WmxN_wt3oCfM)TpDDTJ>#ox~ySK+ro9{9xx!8 zd5KMt4aP}x*u(OiB56`AXKdYt0Y>yuB_Po9ZT-Nab!R$H?BK95eXi8O$W4h+ z6(J*u+jpV7m#HH{OWCUu6E%23=X>tDE7C^2Y{$Oc^T52+r;&yH8{3CO)8nc6{<+s4 z3vTjThMlwSv57-!-%oRvlSS9u!!vf|5WkAbF}C2lcaO1#I|aBKLqG_;Dz8 z`t;)#;xFJ-p;;s%e*arpY>H|+cj{1%m3$Ot-mhEEYt3E2`352^ySF#;!;WIM@o4YN zh*N?Y_7!60=3UNeqXveY#82j;FUQlx9o>o31tz+<-&TI+#xC}zGo1$Za_Gd>K_(+- zM3Zy)gkf70K8%RZwN=}eeftWPsS;vw#1JREetTaMdh zntD{pTX@^iv%x-3Yyq9J9IcEeZ6P?<3mO`_2rHm3rKT;m|HjXR)*#M z9~C0!%@lvHTu`ri7P9XGv0dLnJ=Cl_#%EY8wdjTt9Y!DJ5IRM5y}#IbDjh4P5_<$J zWFtLy;JH}Ntz(ep@5BLafYKv>w{TFnwgxb}6$&nt$?dw_V+`iH53CdG?}@@3If;nn zn99ZZHI7MTlbkt;5BuptGUtQBZlXUv?QCqXf5$Geb2bo_nXv7%k`NV%;^!u zv#{f-X8P7WqO0ky6FKfj;QVR7QGbBQ zWg4$!If*Z3*lp9zFiUg!N+);P=OjwM2!h@i6+eqQogP(BiZ`i!XuNTow^_WEvr)~8 zGF4P&boZHO)SNFSiGaAFt?T)H-Es*9exYZnk_GvyJ^5%i%O1XXKl=-mP~}} zjRLu^J&Ai=Mt1R$_lMaoJz`Mvm1AtSQn`wa-9U+bBTy=t^pQ~5g$p)Oz{HzT8_g3? zj1;67;Tt9rg!!IXFb)9=ohIal{KtM!RD2&7;ey(bU#`g0lcR1Z3CP9pU_n7c&vAOx z%-9JiqrQ* z#pRa~{8E-x%uaw5f_z*XY_5ydn z4<#NH^adQZwtf16qacStP$QtHUiX{0T3yx*gTr9C`WI){*j~i}(StI}#qERSk&G`A z3hKM^R=#2TF4XsZTdC#a^)`CZOhQ-rb_F)CT;VNcIu8gC!{1Msrk_Mb(~5D7X?q^C z?g2RDFAHK2+Zxw3R*-XgI4I}sU3c~_0G!a|EgL6=y}do42#w|@-13r+fLxp-nz_OF z6ai{B&4ARHbI4M1?Ww(zRpcd3&{oGjL|py&C}q__f4Be}SvZ1@$Z)cc+PElAUhIF5 zSA*7V7`brzA+$5wVMye11Dbxo!>G*X^NrJ^kw|>70fzPW!r?_viu!JYZg2OUT;L@7U$*qO_6L$%ls?#4w7?`xT!FjJ(rO+G z1#3CnsC6}6P?n5v9eJaGqeS_DTZ>CCc}oOS8Jcxq*V5|oH4;}`tS$DN4}a!&7qv^; zx>4EX?y!4%C=)J{y5``HZKGI}2lrRl4D(|fA0ItY(b5`zyQ0ylt*-9TL8oIFShAgP z2u(P2RmT-8x&q*Ak+^mxyos1_Fh6MctKCpSAdZVAEz_vZy|w8wFErePkv!x64Y+|joW ztYGTac9=^5QS8W{#z0jYc+t-aantJ{{eL0>vEmOOn)_=w3GjNg^&*%-L^AUIPZR#k znB7}k*v1;p3*-OBF;#`$kpFW6=<`29Q3NXfK!bwvR2Iw+bfbwAqItb#v# z^wM^`N(B_NFtFAnmi@)(j0^m?jLuc z7w)oQT;eYODQ00_XgtmNfxN`Vwch>6!b}lc;pkMsU{3hk^>OKK4LTANobYmA93GdFLo z^;;O3wKjhJ-D9JX?vTcJH_emuJYHV{lF{351o95Dt~Mg=pM2?JrV3w7*iH$RiNjxO zRALra99ES1@7pQ?mrkLp>T~#4R14lpbGG+*o&LVg1b5w^z4zBju=EBotu}udh-ncS zr9RXdt}woPk3B0%3%|}DxW60skSUWQ@c1$E7#?4li@F1{Czh#GTn2~bB>6wz4(@7c zT7Dn7vGW8TxA$~V5Xd24T5N-$8@#MWi|6^bPYV{?OFtb4lm*+tn|M0ml|Ty#Qt4!Ms=-JmlnT`Ts>FcTT>$47J%=mK10ubS zR*0YGXDCC}^nr`NNtV8W|F%5^!#Ur{5E9c0zpJ zERf!;efVy0jY2O=T-}GLm0LGKfOMOB`ay3yVzVWJvgok+P#OD;R`a7to$~&INIA;DzIz#MB22pabcK%^CSHX{MlhU9elad z=dIIRwT-y5LqxWB&K=B8u_M< zr6{aLU5RsvDNAy^CI@BqD(y;vCSp@a728Wht@F>1P_L8F-1i5EXFt-by8nDjY5fkH zcb!qOr$<5FXr#Hd&+^ukF07TW{~3yXOk|)exV|uYT!>C?(kO;SHvo^`QeO%iYiQrN zG7)~ z>JnFqewOEM3vFx}!-R{6!A;S?pxqJ#o^$U9A~F_cc3x=r(ONNOV!74efU?p$8QYBS zWU;YVnGL^=F=YAY+mm(*;U8)03UAgGStEMLGvQ>i)~*ZuoyaT;AeUGXSU*ZuTN^Hn z#st=Z&=!>yzA^E0kno}mKrSXUs@$oP@17$@X{2PgzCp{=yG8G=9$We>nkYCT2v6!` z;;j43_Rj@&=z-Z{q>LjZH1@2QkwYb8YGmvR;W}sBWKBxCo{B830R z+?rl&P-+IP$o5bqyV)#$R8Vo}DQWm^8A0S=nju8W)F+4mTUgYWC z=puioel+{iE?xw z90DWcWnp>;Do0bz?50~olumg$%kPRrwA^h2ccJ$fxNR-jACpMGI$7Gi9^LZ*5%qQi z3x9hj%AE59Z*~!^J|#>|Uze9R3_*>uZt)8TD_pTgiTV^iquzm1@T0;btf&D%>s&2Kw?5p(xwoYUgB6XQzAW9JwX#@7u_q=u*E> zPZip`5er5v^N>(meQhVr&g6J0?lwTINzhhkKW{_DCwvb}igYe}+lk;|<;s%y;#n&+@hRnEg{I@8 z%H@qPRhyk+(C!vZzAT9OJV7-wmS}kxh)`{a_eoRTngoKGJ8)J5sUjm zb3zBI%<=`ko-w3v$e$Ky@bvz(0x!D|8+k_&t~?w2xjrX&N3%cOypL$QjK!Ps@h3U4 zU^Mo=2~)LWSBPxAZ^wQ8d?>UTLN*zXSdd=I&iQK)iroyKZ+P6*iRJI(vJ`7@I!0Ye z(^Rx4<~x3z%{bV*6x2UIe1d|%`Q9Dz?8sU^_^4>iDXTXvZ(u*lhz>J#652ZxM-k#D zEFAfe>lWbeo_k31hLbNbbVPTsrS4pehtU@r-hD7t(D{hjw~X@PqY`}B^*nJZKSd7} zAL|oUAMF8Z&(&)G#m$fl1#W-YNkdrc%lEcsJ<{e*TAD^4{m~h19@;H%XJQy6r{F@9 zPfSH~Vq}VMrEwcAu4s~j?PYst9AYCfT_c?3Z?kTB0-X(1oWJmv3A-=K={CI%*`6=Q zgJy?J8hoKsrL8M=H&0A6<&6~OGe?chn`t7zat!g#j_N5UP^qNV>G|`FnysJrAlGrv zsx8$!WNvwYl&Mdk%|Gh-AZe7 zx81#v(|mr1J@48#2qXcZcGKuQxAB*{Mwup;#ONNX|{yC_eB!Op{L7Nhxt_E z-W|1%)`omivnHK2$=I=;{*hC>luE9o896-p-s`AXG+(8Aoq{RV<6T?Du&Y4l9Tm;N z&x1(l0{K9l=Z6I+`&s?!PALQ{kKq8bp+wg^hi~=ey7Y9bzhvr_iq2=3=plEjHN{o4 z*=xhOrK`bF%9<)|eBE%&wld7onsy&q)=FhA*|D&>&X-L-$Wpx@-p$e*dNk&Z1otu) zib?)~PVWI<{IQ??e1RW7|KeS_CNn7wIoV_1GA#3eI0ak$$}-lLaP z#^Ua(i7b^{t(l@ots(XmtvIz3=ZJdULOCA|`!~^q8+UAO7nJ3!ACcXT*3vcdh~rQ* zcmK3;%NEjQw6$T|PgJ4}t`YVLqw~W#JgK;br_o?yw!o*IoRlt{1yy1XI4?8GiQ5O4 zMq@IW;R}g=zRFn(ApImWJ?bR6#j!2)s)-qc$j7|-E>#^ zl?FkWO4%D6Uge#x^D<`XN!{1222IP$1q8&(2U>B%^=xao1?oRJh5H;YrK#6De?%Aw z>Fx{GP7tOsUtqUBM#9{FtuHbetGZ0!n>(ABiK;irNuw=AUUvDfeZ+df z8OxWAkUdC~8jig)dc;WT_!OZb8z}OCGhk^UICX*sEGB#e^u^7MR%Lvk#H%u%hU(vQ z(o**OXUZB-+NBY!%2uz&IL8+In*H*bqf4p2damCkopkAn>ci=>1F)miR z;JnlHolqcQUCaBVT1(k4sQDZPPnzhJ`?>FGL#&5N9IG2fb!e1y1iN5{_RE)WHCTWl z8betfo$gp-;y6calZ4!gYXHa2RAE0G_@GMD|9X*0LM%a+r9g@td8SiMSH~wUPWVP9 zU6rv>h?cJ-D)VF>;g-GKuxS~lZqM)}kK;ykgf0U;aR_zEVk{zwsNi5t?}}FD-qrA$ zAEexO6;?X2sXiB0I`NJq@0N2|)wKhxa~8&C7R;R^(<^hpxda_Z%#*s%rBmM5UwZfOA zEZFrd-`aVF@Y>o#cXWklsz;2%5&vkB@S%D!zLLdBCk5t|IzMJ}^D_Eq=~SivM6-`4 zPJsTII%M@nSNC$>bt=!)?5I4n_}UvP1aGz&((xnJP-^cnQVO1LEq6t$j~Z46Mg)Yf z(NztQ%B0GLNo3gVYf)fH1K@fqh{0s#)L!I7P*MQnYVT^CBCPFR} z{4Be*=_b8m;;7HTBAj_fKwZq7r&A|!2Ii{BnU?K0Ss|pP#keTja>pk;rB%-SiqI3* zw!D|gmccxGp=VMbbg^fv{kL~xKC%0S-Q&`B5T?p$Lt0_U8V!)9RXl@2TUXmjapOFjR6<#-zUOxX3umeF9X zP@1p#b#X9M-Xd2hrE8*=cDTETMcrhXEMfzd#Yst2ZRIFB9_S zWJ%8d4B3~fhIk|CMS4GJoE#-7=$5e$!_IR#qtf6+HXfW8@pLEsL7h0+1%t+rt8Wiu zb|tGgB&Hh4P2_e;ZAHG=arBm&=t;v@r1FB_6mvWWoRGRW}a0xrLD%bLh%1nv9A}9SxD&Y93mqGpN$lb*b&db%?u zcoSU1;*gJZLxBhpXN{?Cbmih>B(bQn;eC&ZNulW9Gca_N@_uZv8I&0J&@GlsqDmgREPHl;TAx5I zUFvO;d{2w6+frUvDI&51xet%Z{bhew!Q5G0Rd?O4-?&Y4b0f6msRWuAwcNvU?FIfx#n!dk7KQ15w^KrFB1 zs^H&yk*f$4M0W8x;N89RlyBS(x_Yxa{C%T(k2uI=ajJg1xp{1|)kwuq(OLC0Yw9&Z zW$7x%Ywy2N7L4qtGx-0gg#CUH5fC}o zFc0D;|NRi~JSGhPb(Mo>{BLc&0;5M-eV|(F{HO8{unvqw`3M^$`(w7dG(cH@=8kuX zGIHFHl(rlAXzo7t%mT{mX_0Y3BidhCL{qM|#&pte>i(VVmQ z(Af*m-D;w+u#|`I)OXySbHcUyX!n^4-@f7FLJ;F0%L)wsUsxahE2$pfUmu&a<>Xn} z>9Ahs`QwE*%gd$naJJ0sr}@jOu^5GgzfeP)Opn+vA+nX9D&Hki7RI}TWzmTyt*c)n zMr#ploBxS6z>qtDU|mi2dZtXVJFoSiPz39BVniNYAkkiEY4!7`<3?ezbVe`xIK1{X zUH+5AUvxM__4jd?=n*DbT-x6XMXlDuYbG5y4`+DGV=fSLnXkZ zRXG1SiIQJ}TyKGX6;PX!*8^CyGb_u0wBMOEU&T%G6;=`I-Fy}Jg7EDA&~qfKx)ha z_^S~hP^cA{Ng24fkYy9|ZQ%=z#G(-ehSeC=pUtR72c+TMbz9ATVCYWydx%llx$If1 zVD1hv3T)9XObUr!xv$*K66KeIyesSyZrt%sOR6O}@YgLG&d^#*DMz-_54({$lO%&) z2Kl*pHKc9qLff9yf=`~;=_PUy44G@M#ef3bj)nfC-X3`_N8x(mc$#pNPNEm=__o8%w);p9r^j%7sPGD9o#}?#hg@> z%oqIZdPYZ#x|6!Ftmh$KQ_B!XNY5iTC-09nBBFyX9w(6V?Jg*^bIOZ)l&!gCy6QB) zL;qt^;X(;5*GP+jK?Z~zwIOOJmoh(!gKr?Raf^Kc{Vto!932|e0vDOomq-UA(w+~ZntI_*C`-3Xkm$0%Zz|A8YBy-3D>&)-m{E9PR?{PS+2ZZ9HtF3Kt{}{vX zyGE89XRsZud>H^O)emAwjs)b+<6bJ7Eq)|qW_D5}yS>bgDdB0Td0&aPjRPwhDd_^c zc64q-P!2?8*`koLn&5E)^Nra}D1_i4m1-uxC0ZI{DKZW;WFo3#lMv$QCySY_M=jE= z)%Dblcbe0!DVLpkTe6prD%2)511lFtfLeqQ-jKqkGc|ivunWC8?>G^`F7GgUZJ1Np zE)%$d{Mcbpw*%8*^)DM#X2I z3Wlo>g{VGj_vO9+BYcB7?ZQ;;kz*qs@G0UXM7r(uGG(AOU4A{2LO(z+4=LGAaPgPu zTtkS{MV1$`SZr%dQt$4B^@`cawzHK%Q=wUBD^g{17AL&SsjXiXOiuL2{7phazC0nP zv@Fp@iGp=(aRsPmWYvsO3zged;2Y^AZAzWdo9-0|1?(r6R59yEeWaFOlQe%$+0GF~ zU^HP_eRkg0rEs@LUu4u;Fp64&Mj7RQOZb7c2S@7^>h_0TiYftY9Up5Cl|uZ|Gs8c- zl3a#CjDY!(@$q9-C4rSR#{&>$YlsQ+$j;8jhzV`Cv<+xMhm;g~#ON0Ra6JItZ;KzP zBi*IoZ+8>TsqE>|8?|BnLN8S42rV9fuKJ17`bl389uzf=W#{JLQmh~Jko+`hX!9xDzkta()Tt~6*r+HY3v$SQVD=4tJH&+XGYDkwub$sDbc5_Sw+th~XqD~4Upb93 zIX-JK2CWaf zZBC*L{01rlx%b#RCMBehC7Q{)BS$_i^wSYW_s=(HZ!`E*_ z?}z&|N8T9cKTr^*a+ETCEEJq5dPQWm3FH;egbxS3D~|>qT8=g;7l>A78}L;Gf*Qwz z1Mi|2M%8)go`)y2M>Ct9ECS%Wj8j*u@LRzPbm~XV$Z3t^N9n0Y_l9?Km9UH6M52(t(6lBKgL8 zBCMDDQEAKejhQb{VmtaM{|7FFQ7;oDOzRBCqz&i9@a$l=Bq}o)y&NH&{rw8Ta~I-B zP)X&X+BG?T-?k&lBv^{6yfDiv6~Uk+_g{*OY>yeV>?cQ|oAHY>yiUGrYnJ2L3A4-L zmJydB@XQO_A~Nd)EeLolgssQup`6wp8%e@riGufsuiIIzZsml>wI7OyX5{CVkQ-H{ zy#woPT5c^L`+j5P#mT&pK!6R)B`T5^3DW7Wk7mk z=8T|M5P7s!7~op+{NLJo8M>d%+`Z0nTFHolDft{q$K|2I%?0*51nNLW?an0iP0wDX zleW263nzmVi$5&3*G+d!&^Lw&LIWQ>Z?6tezbP!tH+1DXQyoGclZsbKU_u#u)`?RT z7N=?IcLfBvZ2yW`+@8W`pZ_uJ5*Kt^m=RWWF6yyuW*lIw{=7D;k7xtv$X$7tPC|{V z?oU4O(c>TzJ?B>ZxgTPG_0dxgk?wZu^h@})-v_Z8b!&f^?sW@|!WVU1K}F*F>J0{M zr3n*1>Y-8cA+Z1@-(lVx8K<+azv_~l5GY-buW^%-FVWe3!pf~cRrmDkJGW0Sdu+H% zNZ&JDkw00CnpWE!@?B747|pf1&HxQxRnCN!?1ae+eqp`1x0GRsYF0a9BVOn7 zb$$&~0rZR5I}b2rfi+%>rJC~**ALb$$7`5l;Nbm9H+=e|t7}j&zMGXzUSm-b^dla znzK+Q^4)*#J+GH+l_kpZ%?zmX6kGcEuFJ64kNnh~c<6P?IyC{!J?O6vh?^1!pGU~g z%@?xsZ_iT7!;4u$x`eo7Wc(=vRHWB_2z*&Qa$r|@WPDhHQmEEO4a8B)0q=s9AEWGjd!1LaN;jXzaGRH5dfY%D&%joBOac7;H9Os?-#h|Ph3+3r zUA#F3?n|Y$BEUeAlatGOdfp2Rg!W|(Cx~@b?}dA1+;oQ(KEkLkY!!tG6wRia@LLoa z+(ztUF;K_a)ht(!8SzQT@v)!tC|9!Aw@Ss#!UIr6Q(w%8v0QO)ut>tz7W{Fta#o)f za{{|ZB|Q9?>3g1K@?JgZ?qL6|yzE=N^{sX+YNDc*UxwIx*5-%++|?;M*!S%|jXkRJ*~QYElCb z^d8HT&|r6OuZS&mNq}eP2{#|?x&Pkm$$=t22Oi#Uc~hl+;xRPIvyx}xQ>o8E&THM* zK7y4FlIq;8-&di+!BrkG9Z&-T5yJs*+yvh zb}yD)zv@~0I9WK0%mZ2sPf!}X9nMj72?93@z{an#FX=w@bT;}pD!o!fZr9~3Bg<2v z{(<6c3R?WS%CZ8^8Oq2EGnAv*b&|}+z9hUlWk)wKMi%O-s!r&5)w7fss7QC5ZaHsl zFBHR~{RqrZ{&7~YP(u%uBzT!qQi5|YpT{$7@(u$+B1$yC`Ub8*9wj5C61DU7*fSGc z;usiUVGeUYHTBeivo8V|a64w3`42n`;qah1n1?SW_In|=IBZ2mlgucEFkOQ{*1T8bHx-k^G0q$yX`^gz{$L^Jk!oeBK%&6N) z7+j8AsLt6mg5pLBl=>_mO=1RpF9(9wyKh&YAX~c%xzB$DcKen&<||=bZce%`)HS< zUOLXb;>Ry>en+XD3gbBz0)5uR#AL{ptJ^z#D;W_)70fIg z`MZ@*ok{^6u5uGB{naqOP0+-o4Xj`2K<~4tFJEqel;*IoFj9Qta-JKJ8M0&Lc1caZ z&6LZBj}cntzkRd$+`n4>;)>hRzJU{MN`FE^ABlM!a(VT@1>`hYnx`-)7b2>fJR#aH;y)*t}@@V(1au?S+ z-4A-19oE4*xjQFPKu2G9u23|8R^#m!UsLjMaK=rmN!P987=RV=L&6Fo=Zy}upv6Z9 zOMg^aECn%*!A;I#pKqBzcyRW|B#+t@=~L!`P!|_u%L^bLCY>~w46>Maho!dY5Hl~d zbJ=svwH(3Uf-N8VP5BE09dl+|VV(O_h8D!Doo&+HmK;xfYKCE_xq$63MKY@{ZhC>? z!lX)l2TQjEg=8ugEkK{gV4*Bt8>X_d^|llU$CwCgDWf6aQ$tCS>()710CeYQ>6b$! zE-9?f#2ST+bKh>X)^A(eVK33hodrUz7lOy|`N6elHl=GK3HzMUl%;jcDprJgm0rOCsrt3%;TCy;7HZ3-vGOH31&?prxL->EAdqz( zcrqhFw>lT*hY!DimMUGRNui;%nTZ0(D^wzf(-N_usPc)@Ee^Aq<*0k@heE8Z{I$X_ z5fIy3k?I+KQqD&;73VFJ>1yrHQ2YI)gJVy{4AyleL8*WqQMz+9VEff^;ujO3zayeJ zNKae&A43E@ruclBG7B_ayaPSU1^Qu4Yp*fw2k3wU6{` z7+dmulHFX0 zacK4>2i1jFHR)2zlgHP+R!Nh%FYSb_Og;Q#Al&HA`BLda3dag1SlLIV!4Nwu*_)am zW$zN!8*@Bz$T;$6X+CU%6|FEFyaMo?Djv9+U;{!zg!X5c!1jCrt>fH>hXJF-airUr z!nlp{S>HQ9^k!0#kl_Z+L?>bJ@+8;yyuNhbE7qA+WtA|#cLn+BXt8wkGxidq;38aU z9!*HU3QfQpe`g=6tTbyoevAlD)yWoBa$YSVawyz|#_Y>Y53s^jsLe^Y%+;1MpI@DG z4kX|S!SGQ4<49}F)4i@I=n%{F?$7Qd85<^_K>mI1Nn}GroxBSd` z2|U)b@<3r~^Ve&qi#DE10nQ%m4gR8KrtqM6se8d}Lr+SbK6L7;Z>7L6%%3bitx{45 z>w<8EA=?W7E#>PyoNTYkf}h!HVfLbq7ID`Ir_&H5ZfSSK?eU`9X<3`2Z$Xc$bZxDJZv41Y6k~E& zgzEewulgL!sj-A)>h4Nfk1Xpu&!9iM;P@ChnSXg9xaVNBZcV*7s7s8{15_RqP|||) z&Zrqf3A6U5r{O8f6H?iZ-wV2S*7F!pY*(miFOG%ePuj=Mky7swwJxaEhi+g|bL0w8 z%BB8VqL71*`q+#vNJ4CK12L4Cqtu$1XpNFiG`|ZL^Z8{uI_7Ht%3o8MM!OvzrEW9! z>Q)~Vl;Qrd>&!Wc7mszRMLB<7AzHVD^Dv?u*%S?77ttpRKh9?|(EK&>Srp%1B_U-{ zl~wyqgNoMSk z=zeGKe0_npfuh%O<9paCY{^osmZdTT}(gK1@-%A#5 zN60WIF<{+ICTR@#7#-10L$D|?E^;`po<7hazsP==KlUHVW`XBVTazAdC4#=Bf8G_A z{k@s{|M>df1E~I!v-zm1oXn4JhpWkz%t{V6f7|6Fe0`YCjMN^cj~t!|NQM z_s^~-Kbw1?5K&PP1zg&o(!#=)zxFKI0mO3s^_Sn|Jo0ZS`Ij!awkDzG|GPK!-?#aV zyd(7b+mXYbi)%1Anbg-%>K&iAUxVE6#Dd4((Y!yG2nWcf?h2BsTz`jyQ|vG&(ALuv zp0x}?W+-}WZExq;gNA!HqooeDAQa`#!a;S#q5uB_yUUdefAdLNpGzFV8HxLEqO~NsW7o|0L!o0RJ67#$NiIRSl)hPUqFEJ^;b6>eyJlpdaX)E)ZKu2h!m9 zMDg(x%;sDB=SzA-a*N-C*@;rg8Op96t)>Vn!{8#05)ebLQPb$8k^?8a5r%2@I~AU@ z{#w?d-@j*QNc_o`34080(D^ZN#R%IQ7`!R9Q7b{;guZz9TE^pBS%(MPYPG7;QiYP_DxHg@ra?7G(`*nt15zEADuHv=oW*{`m>hdDxL; zE3Br*Gn(4}w|{4P!p;>LX*cmiu!dUT9 zti`bZK;DISZ0jJ{iU~}}1WOZq^x%wmTpx1`wZJkyZi!G)EdSR5@fR?g2>kpRgsIjW z0n(Db1k%M)J^}hh&x3|H(b?)#x02+Lmn+-}>>RoDmn{ zI?K>fYh#`#;kY+08TbCUb-|zB`gA101UpUM;Ee%)X<#E7FlrqR?AV>le48d3u1V}l zPkgVRsS4!&IIce@yA`cx3`RroPx|skpTGIKDP^?d_KMQFfZ_dq+HLC zZ&;Ke8_l_c%syrDCrH&RnKVKh8n&vV^If_l2gMAwDQ{DT8iD#36%-`VaheR=S`o_5 z&Hxssa6Eiwvr=YoO38N}xa_px9XL;0M)z5}0!5sz;WZ{pcIXO4yw6QkBXK7yC zKBG|@#wQ~FpRBi(`uR(P(G6$=2SqZRSC z7XYFfLniCavAm`_2&9AWB`e9KP`hz%uX-p?9YWYb^tE{Z^I)1gv|vFk3n?f|LYivl zn3biLiQ~E!m%724PT~=<#iqF?9`*`Jk0{2OB>@Mq(2>5f(C#2Ne1l?$v8i)tU_T6T zeTaW(s#JaB>{b1dk4k_s_lNoHP2#wHePF>*peDE8DDSTLaBc4~w;n?HaG@(d9a@^S zE+fLlt?thZ-(QmNzmaqeGZ{VeQV%9vy~Adxcct~cR}|lHg>UG>m_G(>E_U;&lMFbL z>(TOEJTLBECb3#w#L%aVF3^&2fq)oav!VUz&zU^DA=-`=!iN(%3O5`9D>03Q`#feuck1Y*n`A z?vnZTgu~hrWyC1}D~(VRoeDL$e*y1(hC8;fQNJ+ou;k)}zN2YJ!(}%Izq!gx@@E2! z9$f_ny2ZTGwofawSH`v6L!SWn1q!Rhm2gK8l`i-Vc6(fZsN+vywZ1j8-PKOWeQYE+ z+Coh;^Xv6kXkiK8Z=od@R&~-DN#Qv2<|^t#;WSolg;ULUN3ADA#o(~TL`cGkb^LB= zg)3RI3}3fqvFlWJj!QA#sMlRA%HWg@_m7p@-q2)E2M(mh<~8~yzGx^Ofob1QHvWr4 zd#9Ov^_hOhj|)J-hg`fkZz~qcx49T*WH!7L*gZO0E&7N0gU`qxGzmnAhn%(Y zcbQEjdiLY?$EJiN43CeOpQwb!yBlOd6)z_+CZolv;!}>x3BvgLyosQURBS2G+%yGw z`)R*(l7*qCy)C)xM^9M`SvZ&@DLVSQ?%y0lNWI}9-U)qoj}6Mq3YgAzM_Z>7+~E)( z^D)0$`_4`sVC`Tno|CqqF+pwcZ4#LXFJn;LPbY7?r`;4wQKmIaWJjm``EzJf#53J* zBJ#j&^2Dsq#aK?O2%lm3Tp&owQrKD_HHy*ZZbKe@Zveh8TF{6tQCFQ-RP+TH&TK1p zk@C<3PMvQmAmNS!wCFxj9W?mc$V{p4s)XVsPMqlcB-2k27a3T&-Sv@h6z*awc>yZK zZLCh}om1|8<%glcq{B_hE}6IElpL&EDuU;cK^nEa$UaS9ZzCpYGyotG3kSmlwc4DY zOBS*R30hI2Q|9}cW4>owd-?O21=ORG5rcsh8N{ZxdE6VnV2=I^-q*>gKX-rh$oXF} zKfsU1sMY5eFo!r#Ps5rT5zgk9+wx{T5BN*6+PBC0Ynu9*5K+vc58z8DgGfSdt}Y{> zfu)yV!F~eJzVcvqmVpV8UeU4 zu9ivO@2nOSsx=%5pL&rGxkMGp8?-o+6Kjw`^ZwC(tabsHoFU(Bq+n_Wa%@vrS{i5<+!}1 z5*NOO`>5xQ))aMh>7Q##9u0P?9fF0T<%L(RP~#9akM(^v*(c?kWpI+@Xvw90f@oQq z4c-f7{V52$(a9&j2|sDQpP z>2_0fWnNrdTnnK383iyv6|KBpsifQ?Km!2tBNJ#_dsMj2lbQkhSkCb)Gy5H={&WoS z*X>P*2HmQ~>KiYZ@r|N25>Q+7yF`NI7@Ja19cEt9+EP3P202vPrQ&0crBH(JhZ#{P zdvrsqNy0}ENu6rQx#J`5;WQj1fizmIhxuV>Y)Ah>5L^!q-Mg%w`B8smU<=e5-Aq53 zHNla=`!j~mx-@)%h^m}yH@JYvB(EMD_1?k{g}5Js@>?ty3ZnxLMa!C`!EoON{}4P_ zkZf~xaQLpJc-EQcHw6Cw;Uhq2H#Ku#6(Fk2EX)WTy!E7N);|jWit8y(;Ra9YAVN56 zh1Gl0FbE>j)fJ;IUcB3^Wnv@E% zrX^+Ww!A*Ury2#yiwi2jjE}xLXE#I_XDb*&d#L`B^+CYY52-|b5I+uJml_a_rMgkI zW{UzbB0fo&Hk3nox+W)m=*_A%B@j4S_nTt?2HlqTF3;CwIJ#a`FR6TuALZ_JNjh^U z+}};vNL|yH4Z12Co+6#;y(UvACTfQoaKA-rKTpT9Yj6DH-1`LOcUsdKM?7S?AwUNe z3o!0jE@kIme5S-10lR(~E%~DCto0!))z@@xnsxH3{*`%h!mF+iU4NG|I*>sq_;X1r zC2oybtqC2?(nlp38tv_@kF!$^bZzuGwL~lHBKgaL8BTT!d2|un%9n{l9(HuHllagS zI+B+Z2w<{9-kA6Drh?X|cy$8CkjUVT1>h~2tY?}`V~(ruMlK#f)ywj`QhhI5do;`8 z8R?kO*zSy$SHcn=C9GIM;VYj8FQNUr@^BRS)6g8y!r`{Jf832RD2HO_b%M1po8^(-U z`Atk!sgwj$_ct%+F#&^JTHdRYb6>qmdTl!Y8nbb5H>Yd43+qLYo{uJ&-{Vc^eiUp+ zZYr?kj4?0lFs>l0HNUXi*=fc{ma`=+dhfJ&ETkuePZYp&(jd1wG}T?@pXJpHd5Gsp zh|GUnR=81nH4%{Xr`vW>l`-qRr>!PXkr+EQqm|C9pnalBh+VBQAwix{@^AmwbS3PO ze?}f*vAlC?>IOnlM>W7rD%*(%@r7u$HyC;yYZ({}71628Axwk<$c930v3%I{he@Bn z31~Fo$B12n4)p3~f*aGc{YqeH*>22O8CYHY^g1eoh3VNEzSR*NMx*@4bPLf@E?uYb zA{YyXyt(H1?$)FubFe`+*o7ss4&F_4Xq4h%&iq)!Z6ie|e0v%=r4LWsJD^E= zjyEq(m7~U8^de%%>R-Mvs^q1OM}rEQP;{AjDg9{x3f1oWiLQSii4%mF;DtKG$wO}| z3h!BwwCXAmpXbRVW2S#%zo7nx zSc8FvC2RZ@;RW@P*7xik7kV?cCkwO7=HgvFD^9DQOucL{Upudw!T}uA{I$!M%=m$w zW6Y(%7VM|Fy27!2$SELJzyW<)!Xat4!hJKGK(Q*r&d!=16~=~cNN`ygLeOp;y{Z@T zQO%1-vJd15XIMtqp4cQwc>GG^paqKp?@D*a-(Y-0ZdPk^lP_p%KY;_SGf zf@VfCl9H0|F1-is5P=f)NVMC+{I$fYj@>$efd1MajB`k?BXG5k}}y$>`tli;Q4LxH~Fcj z3|y_!L+jm6D@PidMpS1RRA;F0cF|y?_ye0;%io@Y2^L_)+b1(h6oT#UnXXE49_Pc} z`*FloI9!AVXk$F4phF%%3G$V z4meBJmIdVj8ivc-R2Q_F&49pSLMY#MH^)T0WN@bLx*@|&U)(skN`{u|c zbxk+H=0kbeY_m&C#XRpYssYn-GU{nA{A0V?K3_ik656k8r`Ya^)jj^+Vbn{9rS770 zQtEkneIl|CNg*;eZ<8#sQRPdZ90{jj6*y_E6DB8LvA%rsn9?~ZamzR3%yJ4h-^wRh z;I7F(;r5sTJ8GcXtzK7N|0}erKo}PYxV`sDjDHCwx;u>A;hew6@^4@;XcHg6dq;)y zhQY7(zhU*?K`=Y>AOs`+c3a*5P{tFcpDp}5uPb5yFT&yb5bzcx|6UvXQ5Zkp1K@ns z`>`UWzhgU0Fo_(P_>KI32;ZLp9}a?c{^TwGe&*-UfArdTW8T63FjP%M7K=xW{yp(6 zPUc9_+nvr8UccHh<+7urJN19*|L2+m%+v0RsL8A_{=X9F|Lo%Se+7|u4WAjlS!I6M z8V#C><$%!$vx&V+Nlk5@5`8nabpw2$#y3P%=1zd#dKum0K#16s}p*Ji~O_sriyG^R60gw!@{1mhM4<(XIKL?9*|)3Zm{ zJb{sxHkb-f(8|$@a5gHW7Dxd9f`5~#!T^39<9Wg4ZZ1$$_Zt``!0GBw;hOY=X$eb( zMt2`zCymfm;-v4@ty)*t@ET4H@_v)}Vly7iY01y%tcQ8~143Xa4_O^Jz%(NN^8Gtj zTUS>kDCz0~iIx@QmN;gm7uF}z)}J5ej&>i}_xZ?|ICAOX0e?edelYK@>k->(&t_ z1g5Kz0tINd-Wz@G{{EM+aoa&yH}t#?D2@0?Yv zP)sU8ZE9RwqQtu}brqKUxZ^hM4&*`?PByi^aCz{jFc9q#7mG!6ny8i9Qim>mxPoGm zF-nT2+hh|ktv-t=__}>sq0`pN9{RG!Hau=|bB>XGKjholl(2}{_BDC44&Tc=KHjQ< zr$zjkdM(}?KXfXc#zb`Mgoj;F{x7JqeAU1;m@EQ{jB=pWpDgJ0X){%qI_|YLZ1+e! zV0jsWX^#eimQv+;W$phIAupfR%wvr8H>ap0Hnq&gYy~szURSpFk!(OFe)=s#LC< zY-U*%B|J^h8=j~OH2kQ;4(@1kvJ!_gbdevzTVwsfO=+0OT94ye%tX16p1W zrfvHfx7vZdu=C<9T(o<{knvRH!NSrUBX|q3Q)>qc@(zJA;I1~iMi1GS1BP(Q z&WB;wPqtYVLN)q;005%fFc^D$Jmu)Om;M0vcOxpdrYUzZH8(TsSRM4~5Iz{ER~Fi; zP>ADc`|b2|h5%0rc;bD!R_Rl(TC@IhdMcCvi#NzP2xzD1f6&=^t+)G-ddqiv|A$6@ zWdWdnBD;$&F}+g;xITobNs$H}IsQ!E!$juUx6>)9q6~Urq25e`2Pery4cp`I9v5@g zwthkqQ?>&%i16ev|>#TvrM`FH&8)UEA_fQ#< z)y3~SQm&6O89R=G*c^~Qv=U$bV$RrH&bRdQe&H{SP^VWSsGQQsW*Kwawl%7(&l|}+ z^n&RkX8ne-z1EYcVzRgs7vKKam=SItSlM&#R! zA2v-&i?8~s={%IP=_V;D>8u>7(3k0rvhN&g8*>|Iv#HJT)s2>3L zYFaus3@KSWn$a?gf7}wl7%rq!!bx}KeUgEZ--SmO$>w@6;qhVcw+0%9_b>0fe;M-_ zmw-?K7qkXxBKH0zA(=`dba6`XkeRt5y8d+Glb82yDvg;W+qmy(il`eR09T{KNGe1yjim@s9ssDq}S4Goj(TLyq%n{+OC1)BzRApiw$A zS&km&Eg!%sl>dS5DZQq;INVcimL?--{;kE8(nyQx_rblh_z);2v4mt&x251_y5f)S zH2LA|sOsp%6e&-^WI#`f{AFNZLSq|sZ9#PGtf9Ug3qRLKcc$$H9@tFa|MeQPK?i)( z(jiair^B|shCBV59nP3Vk&_2r9br(mTPOMX`jv?y8FeO`8aX3#x0X~@QaI#Tax4+& zmhEFD%lEBM&wi~=e)xb#ifi=>Qlw7#z_OHS!)TNliKF@zvOV_V#m!sKE=%Emc_Kn_ z&b;cYBQgP}eMHF}`%$Cgp@Jm&+Y~0HgoTc$!wp6~zTHpe?%Z>4T8memZ<3NPemmVu zgKY?BP|jN$RW?X|`1ztb>qgSK`2_8tW-^%?S&{hgJ0t^RQV{Zf8!1--cly(uwPjHp zjTgbYTZD~|z`xFAKl(c{mx6?Rw!@#yG~HDGu|DebtC`dL<#*Odh0vRypA*04ZGpc` zXvR6Yi+KWJBZHfXv<}bX3l`X{Z;!^S!Nf<26J%s2MUrwfbg_=ok&Lv@R7x9|OFTyg z$!}>kQepz)K*uLX5D&FZSq(4l2u@kQ;hm5soO=MNyh6Ng9-yKBPaE> zte-*><5&szLkibO-rKUgKg~W^2o$*9w$!!V`qZg_X6e+^?tP!PcqM^oZ83v{@tqIY z33e|wd@>0l-IPw(x`HL@`24qeb2zr#&s|LTMRp3^ZL-S?yTsVwvm~=WD(gq0<@zO^ z8NzJrK7D1-Z=Uy*&N<{ZR4!);bicvy>*1NQ3GwPb&XEy699)RX{~_%yqvG0@XyE|C z-6cqH2=4BU6Fdah1PQ_2gE#I3cY<5+V8J1{JB@2__qRE6?>YCqKi~MqX!ZcQdwJEG zt7g?I>mR!`_q$3y9ai;AG(?17MJ}tNa%*Z{0^q6_aNaluauTlhiacU&4JJGEy>}>m zHBD=;op)}TRfSLVylxa+`@jzssc%j?wz61{Cmgr#1EExMSEdfKVe~WWvY?h~0$zw- zyxMx-0220Lm%$zqf+N*ih!7}e>Vz2BNGD3SU(jymkt!{aX)i?pY(Tq#!NC``gyY?- z%~h6)x&oBV)P0kjX&79`Z|*Pq3xkx>GQPeUQ~+;V?cfr}el8AcKZ=!%S^Lnw=F2;J za~X)l3GsA!Fw#qfIXT|54p^soJYKc;++B7rEh6GQZK#sRt~lwW-9|79cnL3ud7-@~ zlvfB>jCs-<6~CTo;|N|KZ@k|K!K;c0NEk@`7^bcgq3165Th>0Sm*Y>_GC{^8NW#f{ zJTG8#Fg5jp{W?JXG6+cD)5-Z3@OoHFc(30B+-Kqk*zApW$MYN3BMq{foA0A5He6Xt zuX;h)_>^i%s9vCS`U|7SP=-y8 z5qFjK;N>1b&su%kaM;Dm31=!~C#ZGQ4l@7o)y0BD4^+ilh{LYH<#|w+jEmz1B46Pr zOUxX}*tbq9HMG;R>J2xCaJn^AU$m&1OUpu6dZT!9e?mO=UH2)6cx|#p-nFf{u+-&u z`5p<)hwm#5V%C!FT*UmWw09vOAz#lT9r;reg)>pVK{Qac{=%}nP+Fd{OjGM5O`#iL2$=f$2E@TpOg9b zGuai;H{o>aLzTiY$ovHcFn?F|=Lcv=pDX<3%28U~VEF%hQUi39K#bV?y-d zbBh>i-`W@3DzNx&s7g}#&tZyxmPjyfiH^ zLaw1J?Wq)pfwLw+WC)vEWJQI+Yns?mn}sz@NF7bwqQ;h627i){3O@Q2P*+bVC0}n| zb@46)9>%_$?2|0oWUOvs!j1C4+3V_^{|*Q-wWi^p;=m^!eppG8UztlfpJ6J>qq?x6 zOO{qWu#%>S)|&?{Q#^je7JvUja8fY|R-VU@(?zV}2m=#C+Y3HCkvZu=tgFbXsFsXM zRynkK^>tPD_ZN}BpiewwyK0GnzVy5~fAwMlOU1SlD}{9-f=X`i>!k^N5?>fTgLre0QTw?nB+rclmW&ZWbN6k9Y*{)`0swJgWP zez?7USx_Q5ef)rG5Y<2qer7+L@Jx=|Hw+%G&Q{?Zo-U_sD?%Zzp_dA3y0j^Gp-*Ez z{Z3fo6Xj%H@B6)ZsG=MO4H&j|Fx*@U9(ZI${H@{R*NA!FoWd`P{K%FA#d;{F2>F@u z*{vqS0c(ka3LIh@PP0Q~sCh}1L6eSH(S*Vx$nfAB;>9F-$>06WNUsVtERTT7?I$(TaXV;=jK!e3+J%}e+_ z3knj51}#wr>;_{L22mP^+-i~r%G^5fse=gs&A>^k1n1urla?@>E=RfiWNXr7Y|ii$M+B^s<;BEEgy`$3hW5zUbkyIZAi z1|2Lme%cx6wXDe6@;u@rWx)=Le9&K+AT|bae6QR+Yb#YMf3mUzKap%GFflSIC%NeQ z75MBAm8hb;#6hw>?ZU2tq;zsmyCi^aOCjY8>8EhZh;~7Hix)S*X_QBU@^JZm$0GLa zfRs2&)`4+b4cmMMul296K{SWo^N%2@h7XbY)9q@An}qCpf^2FPnvbib|ecuIFiA-N8C`ND7fP2^&( z7lF>Jd6T)OzX1o^%!x_HkJcnD7QS5hu-BP4PgSS=$jTQ&R}c@wiN#{ zT}ER6IqU;m-a;kLT%n}mU2KSY#Ax+?0HzXo`ww1eP$NAo6dkM%1t!ST?IX@09Wz<0`^DD`?AHo_lyKnOeShfz3UFyb_jf}^^OV)3;(mz#*ku&}E>%$85v z5ZL_4VtqrCe;6<(yfmA6Iw<>!QuXX=Ii&gcI&3%O72<>_I9q zZ;2o;IOIx;7~==dhF1cPJJ$YMi&87Z!f3L^XsTu4@7PGe4A6`>n1xr02Y9 z{^=c)^QZh2?v>5AmzHu;`h#x*6)-`7F2zpDQ!e3goc9xl$4zW5pv;(0G;Bv0+;iuAn)Baz(QY9bDY?`Urxuu<#!Y;c zG0V%=q>s)H(R7>MlF$w-2mL4HqW1?|w_W$rir%EMKXc8^ZE_0u?pdXz3ep6qD#Z<$*SAB6LA?zWSirWUK@>>~HV-T-35gFFO21+w<-Tn@n;V&RA=i8)k;Q^qVYw#APyVa|; zg;${SuVa&QN5m0Z0_Osvetz01CLWWqqk_MD@Ii0M*ncH#b+kBYi;E(LO)5&M;fL2* z6O;+DYBx!y5T?(!CJy=+vd1@zz8M$mr-UiTm#b3(B}e8Hp>w`hkXl2M&inu>FZ7ME z-5A5ND2!#=ZOM?Kj9cwyo{sC;0Hq|eZU6Abk#zxO-$kDDaST;We0>LNFAjRmCZ>2^ z!<^n@=8}b<#1W9=?*ITbX?W52LV1 zKj|b9s_1*)eB|WfT8+zG6#4FJlqAtc&Nc66+##_%ye3svE4`RTg0o@wHiI)G;C*xN z$5#gyTCQWXIZ(RE-BrJ%mjhg*f6LMl1jo^*6sjpIekvsHNgZ^oBG>xBR-CUYO73PN zo81zU)=N=Q0u~$tWlK@wbb=+0_yXyWD{^aWKVorX84Y?lw9R{^WW~!dOzqFbhYHIG zOZPaCuB2U_Rmz|B$qgW;#z=4r`FuWQ>tFR2x?;bQhh&`Y?cX(QL|9Tl%Dk#m>M}IH zjbv(Pz)QOcZ`_}3<4QuvD9R>E*{c+bIMxJS1xPa>qEr0xwNDhjA)O5Me#s1nsGS|EkP?Ud{s zq;WA5B1?3c8g02Ykx#8scdd7qcH#X=43|wUnQl{GMwqUiT!UnvgtLFJxp|MVHVIa5 zz4Z$AI!bSNqA_c|-Xa?7GI_AZv`S0cw_mC{f%mGH-{_me#JV~?H2HREjojTOq%iGN z5aE8}BiI4m`EuPCo)pIkzr6Lf*xx(+n?=r6hv5YgfoYB?pKw2c^e;Zb^?;K`bcz&iX;=E zS4tMKeaXyS@S&5`W8^W*0WXRCwN18TGC&n8(J~yI8_{~H0cc}=MZM(XFyHnJ@-{a| z`erf@S8}P+d4Kbzv@A;t8WNbwWYgJghhvSY=9o*%Ov+*_va7R{(fVC~BO2SO-bvD6 zRNds=PONTsBc3)yXsLu+LT?RR97$(sO{HY04=cpGO)rpYdrw6d3|XWZZ@2%Iw;Bi= zga`r*({W0|A%OE3$>wH@+_B;P&4^ErjnAEq%5S%^9Lej`uWbSH%#9yrM-q&rka3{j z@(lzQRx+GWCcp*ms)7YK{qjZ~kP>KBd~FzM&>SV`PZ^a&OES5F`n%UC2yHG|JI7Ch0W8Kjo#7IH(YOQiYZr{mb1<@7@NpwI@ z5gMXJk5k2%7O{NTz}{t`cX6i({!vIh%@g}Y6^oh@ZKtKLuRF7En}q_e@In?U#j!_* zg;U-O(gy~~=btDxzV@P7hpdEe;Ik&+{mKV3r?9=@reU-sxK#<(4 zD#v4L+gvat;W$JJdVdtO9iT;Vs|{+QW|td1LZe49elSFC=Lkmi`A&loCGyBCo{dr7 zbU5!n|MYO=BVygK3dgA1@Pdhn>3S^6I~?6>r}Mg#%sa}mg5;i{wzjsgqGE(#|FBNt zlWb{L4{L7BMi*#diAsFCADiN#7i_KG*EGbItA75lNr%s)Eumf+ZbYzEnDxtckQsYO z-ncUoPNhH$WJ7H|?Kgb2qRom}p0Ab_zg<=Ni*-;XFiq4r^;4ErN#I!8E{3?WBYg;x zF)2^23_(WRaZ5iY#kiNL1oNSQjwqwNjI?q94=Oy5bcQAMue3unSkD8bZ#OjPi#>i z9nvTtbn}_;#CzvQPg^;5fILeJ%2CS|sq^nyw5VPOP3%@&hGD#pcHrU%xTPyvksCzs z+lkDN;qTPr*G+i55zI2Z(2$Uk(Qj@DO=rQo(R)p=ryNC#cLOHllI0=4uG&-LksVZ- zm5D1m>i}an&EC~!26x{=Dmm9B(Q&CR`XFC-r712n>9&fHB=9!Il8Q`|4*Aiiz)3tg zRGs*`Z=>iXye~?qUX<|46SM;*BmumN`1~@8n-2CUu|h%|hhiGE=3(Bg-+pPle2tla(Gb_JJ$|bc3ePTGI(NDG6iTFRW z=>F=|SymPOLwuV_6|d*t)jj`D4!(x9Ze1qF^3#4gb6r{ zi$sN4P^gl(T4&05#iz8nrRA`;IEdvJzM>r8eYVXgXag59|7Za>SE>wZRf~9`#rrX~ z3g=>!LkV22;K*VJJl$`TW8QjH?#94%$l%QLj|R5@mr~X^0El8 zG14eygy-bs7zyeG@v$>@28>N2mh~|26-?EI{6O+LJC02fC9R93myDh`JqGquR(N#6 z^Fnh{E)D`o#|PoA>EFI%^Zv*3uQ0uxICRh6tmq4?;TXKy^PC6vUW4#M@G*Bp`BEy| zSM2VsuZn?|)_nNCKL8dOG{mE1WQ+w(tL+`g#LMj(<5oWuhXA0xP_xZ$9KaQT;egs) zfH|x-Y!_$L`+)=Khfd=M;0p2f`PzNk&4l-cdy_>JOJi2`55zikpS#HQOiY&gd+uQO3fV6fg=lNZ2@ExadzM5Y)1wobq zuP^!Su%+M95BY94B-=8jQ6W_WHq3MUvgpSLa-_%cEBU(jV5CE8wd{@C>yBshW-yPz zMdK=;6?4akjp)vtldb3JXT|+~R%ryt+}jtVUgs(=p`m~TLQ^n@>sNOxC+AWuK!&3P z3ggvj9h+_->~GbU*LILi{sg$TXEgv@kszDHEa}0LHc5|s=dB)V%8x7_C-DkP|2e|t zBUSo9tq!$ml^FC|c7sxRc$tH4VA@eoaq>l%4JYX&NdmK_Aq%Lv+1Ty98sz8q?hXCQ z4W2ad#N0USC@@JzzamxvT?r*=>rE!K~c~I*Rt+NS%NM#XNU9?vocKHbVaa zhOr+8&YQFB#BGU7-kUdou`8T{aY^*EJX6lmAr7V)v=&z51fcYMwPPJ>lwypMa#eJ) z%Sp!GHGx)5cP<5$hGi#h`GPDPo|kf`#Ah`w_s421`=1eusVo>;=z#G!3D~Ms{ImZOF>nEckP|b2U33e4je7Vrbn!Ev5Zt1;9cTTq zx~{%#HxSwmGOqTiJ=;Gt?S?A?e%J>WE)aNI3V0sr{Cw|;bJlk$jlp3Y{hE9rA;JyT zfsNinwMTg5z>Sn->@vKn`deBcv`srg=0TS~K^IWluir)i@G_} zTLs0E$#9BnG{5-3)dx`3KbIr1TSKz}^J96s77|ckYl)}Nqb-ASWL}t1@A}nVnWVeC<}71+E`2+oP!k^?pl{6*)jBD5?J!-cYRv=m>GSwSb)-?fs?Dle>_X<@R%1g zatv>_Dp1;MJVI3w=ymu-+<>PTlxK@d5=2-ss>{||h8FX#DeK5mHlidBd6mzaKh1&R zH(2x8nonp%oB(UfTnO@1L+xO(2CaPGyeADe7Owt1(O})~WPH;)bhR4PD;&T=`UJb- zcB*>kxtFB0))^-3i8Eqv+yQV!YrNa>?Rpx+@Bd_;eSbT(d)#`uDyBv3%mdp-Evl3} z58x<*zxtIs#O~_5g?P9rz#JGl2K|OUvb^d*lIl*{P+ip)ggrDV2y^@jEI1U0nv*h3 z#sJ&U@-xOv#M;ss&7pApH`Q+>A-Ma$FbJG$j=FLMNO2dw;<0Q_mQcQgIX2 za7Mdy{N0{7&7`?hNtFMHC1`&`NrxOyGIf@L@HaKl8UBWjI@V(hCx%pZVeZTEzE1Z0 zdW!pBrU3w8&LN~L_Wg7L^!S`jLIpJQTk^bRiB&-SGV4tzmk-ur@6Z?Rn2{c$XBnDY z%i~8-{an}lqAap}2K2q-Q zAcZ&sPqfKJAbfFNU_13x-ccM??niNCFwkH2!|veT@;H~r#}jAR@tI@<<{5Z#?Aa;2 z30R*O-+7x(5g=4oMO5W<2XYu@_TQdt%uyx-)LwvC*7%ud zvr%cS)jyLtglftGpB<+Z35J%yrHfEUMGjGy^lbjeaU9-$gg!|j9^6a*=uEd5KTMWv z`_Np8GbV-iQ>SwUe~!^nLjBF_4JP>_b;1eTLN}W+gEq^ae-0JP2`^E}r4Xga7KUja!&FQzU0DT!uQXJcDS|MHNXb1Nd z>#dz7bg|XSfEbh~p?!LuC+Nh_;S*ch83QIn*Zk!nW3<0l~2JKyv<4!~T z^R(>>C;+_sdqb4gA`GVcLjpM*HQ7+dt}b7Hw-*>Z1QWzLcs(PF!+bSzzS#<(v3R+Z zR5|{I=GC~NA#D8zUo87^8luvnYFWcrXr5OCGaJ9e&h^2>7t_~wxkrGleQZoP-!AH7 z3fQJd^7^8Tl}JG4xTPc#nBZUph{a!GZ$jF?S=k-1ZU(+ZiQ%d1Fh3C6>E}Xd`%ajF zZHgFWIkzr2U+{}Hmq*(OunpnW2)z~UKz&Q!4+$gnO#UeA-D_@e4M&qSO?#ols2U!;Y%oRj1uz)lNdzEBU4O4fu|c* z@Vd1HEoP=3z$(($-4V{hOMvxT*qI+-56dThvi8p-Szd;A3~BIM8(;@R&os;3RjVeC zWa2*8ExyX<7AZ3&;m}v!)`IZV-P_LAcx;|I-OwKX30%HR9crP|UPusk_Hdjb_UE) zLI>^XG&g8@K7$=BfUn?pl-8~My+!)&ya#ZB<~+T02F)D8I;w^9eZvK$fOt$k))4?w zeBuCADTVTv@DOq}Zq?6F)@37|=%E(9BI%1o@Nof{T|hknv>qlR8z#z#Gql?q|bzcdSU@71rwodp7Xwe9(^TYfE@<)U!lNPhN8z`zSnJe+L6n5NS< z0)V^Nvx8z%ySIEN8##OQl@PAaH+8>dwXF_^)6b8nB%rhqn-WRK3sUpDlmjtD+u^dx zz`#?_$JAHS&u$U~f6X1oJZr9<$}D$X5#0Qtl#!?s#f|PWIOi{VrfBITwM>4wD)Km+ zx)4aYfX?f_U|_?UX@6VRkAjjC|3C;Ga2<_9D#%QyMcOx~4`72ahLDf_`yZlejXK!h zsuU(uILj!=x3&QU>P##>g|=A#8T!n`GXXo;(6xg^d4KQT#jO$M#Mg@q;gbj9FnX*m z>@Y2XTkCajY!rdumB#Esf9LVfg|J$|P6rozR$sEic1-#Y{L|h;_a`TBO`6ZbFc8&c zP8{7l=|yKjW2FpAk=9gHU(5!9C(z(cMR8W4j1!|m@&2&F$vuvhz(zeVGfDp%s2_+ex}KV zm)uU$3u!aZ@^jEg#=xcXsmTi`i2lxl_ze8+yuvc5@;lrJ||8$5J8XaMeomqVVFd%E+AQ!7eSt(|C)b^ zxO8Sh&YqM$6zvcieUZ>cI_AI*j}Dw2fQp`9-#gvYY==rPB2aEjbudnZA}DNHG#22h zg%Dcm-qvUuNbnK%_DhJY00_O`!NB!Y09Qsac&A^JMHLk@r`k}(on{HcB9-nP_C-#& zlMV=>*8}z?7Pbs0uO>|En}zN8OY$=9jFIG2n2s_NtDe8)}5s;-E z-tV3EyLsEG9qF@6g8p{@jceNdOIea zanDdwW`n-#z~SFnZU5(p1?|GP4Ku((xgtUTJmKgjAiVDXQo`dj=jDJOK5dQp__pz2 z;%ot(mSX-32#Q6Lq~TzBA4_T@90w##4lOE3Cg~o1B7zAe65U1=LMLvU1r8f#4Ijn` zk9<9dwkJ`?D>lPBWS()NEBuv7c!LTA{($om5o2!IjzM%3wPkGbW5MOT26ApTNA26w zA1f&aP%|C<6t(!$U!Ilj;IXJm`r*fkl{5q2z7haNnH3zb6o~hf-y|HT37Ykx{>~Lw zFFX?UbU+2XQaEzFrb0b|oepm1UY3#_UaepdUO@uHPKW60%jX_Gq6IKEe<*Vlwhl0m zWG|q-K*GXTHRDEoA&V9%Oz@f>iM%X72cNE2x#N(90$v?9_Dum3Lo{(HD_$6#KZpec z8|AQ=*N~m61aRzG)99uO@?cciF><;9__zS@a5VV$XpuL_%Hyf`>PObbtP>d>YMiDb z7=1F#k`GRmRYk=L>-+hhhWTW13WxPhzuG8Yf$j#kvjPJtj}O^%%Q*0&mlUsu^`Nh+ zCNRCdN)E=9c9D2A!XO_*X_IxfX8yj5|R|%iB~ON9*$}z!?6%EhLQAEE~b+sm-Mnv?;?qk&l{#_H>1MH zk<*DHA(>cY`t(Nm7D|pb0WE*cewaDf!MYKnIp|F{?jNHa92`p~x-!1LDg<0FYI7v& zcwueskpjxS3G^8I(152zdf`Mw_l{PQUU{Cjm`iL8I{!>T{ERAe-j*rpWvw8je2PoF z3*tpIzg2Ho#}lfat7Y(Tmt>2V{9o)3U_w7@8fq+PXj0xc$hY{f#o3xxoG2c!ro3eE z$?4u7ixt$V;`WgSlU%Gg&*#A4GB{FEDyr)Q$dn>0sDa49DTH2$MfkPcGRg?O2M+sa z1*iB|lEWvVGewGT0!&nW>9~bsdH!_UA|{qggl~1g>vWjcjbW#+bFN6T1oly8qWl%d zVZd!cgPu4JDa!qWKVgW3&9jrvo358--`-75$dRku<_hwf#fLg*$e%^d6H{sVx3i-L zJl?(yczl3)*?QcRYtO7e^PibQ;dp!r2B|~;I=fry4gci)054~m@L32GlaM@7LPZnv zElw$3V2KAx7A=1>t)dEUqcA3>1cje!8j~Oi{kY$=HcYBY;P3Z1C3aOz0c6!F0gB_^!**iETr$^X$1e#=+)>Yw7x^)tm~h5+9~9F zpQ67Sd=D-xGn$P-NMQycRFUOlzHWLELi`;i`fDcR!m@V=O%E<1Ryqvs!SHuW$x;5` z+dnqXYhUk~sqcc<1E(tjHi+l*++8l5;1oE3ItAEBz$f(1BTX5pI&0(lwVBGi6grg| zge!>+NaEFB|{#ZoorUk4QyjxNDL zAD^Ucx+i^((gPDUD?!;srTe^*Gk0gGB&Y?h5Untw8c4wv=>hmnY~Md#wMo-W>U^Q@ z2QJ|BEmA8WK0awT!~l{@G6Eo-&Fz#b&1Komwo&Q{AN6lFgPXHc*Qwb5r~9LW<{6?E z9-QZ=R@^W{$6&yP4tY$h!X|im^5aZ&u{Ew$pYn$oYnA>BiT<-N{cpk|FQ_3l0>a_; z@v;uD?>P4D8%J89+KZV+OX|haIpOE$zhW3Xh0fA63L=Pj!f%v%UfbNxsqpWI_~-4< zixS~+paB6Nc;6J$LxFT|TqgJPmKE*iyA$wUzYmu@Z2PJ4b1N$mXww}j^gU0glfH!j zmk|+5N=gQMGGAOcH9WO8*yny6vcaZB{C61Ds_kWQvBnM^62_Uv-%f&xm_SVd0EBmZHhQ3B=am>sZ@?V+T zfjkzG@T9I7F)}YnqY5CsjZ2rVjClSFOFFti(}+=K$9^0&J=)G0fqsNt5G}WVDIF<7eLY!``IDC?{%J zSy^Fe>2DXZQ0~`6uU@fz{1rdRTeh$O{~p`I1L6h948U7tD-s|6+c|j9SM%ib$WW6; zH#C%#DF{pH1ti&pR3m;6Z(;pgq|c!j{?qIoH~+fxbOHk{Q+NF~5PYt24IOn!F%l(o zN#}iXwxGI?{;(}}e;a9FRAYCw^wdN4bRA47tO%KLVXc^9Me)4Tfph`(@W`D;GM{_4 z#fzx6b(x~#V!z_zzL60!+sySS5&iR{mUNP7U zSLLOD`=mQBR=*}$IQ(H7y36C%jCAuzI|f=XCV$@<(K)Y|KBT>Q8A!c|hZY>FRc%T# z=8);OrR91t^t1l4Zqk{RD}3m&xs3os}Xc3AwijX0$q;EqXTy_u5|gNIYF!GArB{}9Z<_R(C)G2#QU zuXx>L&Mm%0t)A-c4!27@rM)N43&Nhpx3Zpg(z!p62LZz4W;+w+wb5a-n=LPCzrl8hv@{>J_26Y`Hnh z?9GvEkqpW7JPm=mayyuMfBd_81OfdaHr818(ih!Suuf!$H+~#Eejm_Do@Uz-(y+H@ znMLQ!T)v&*CFOdBtzQ8jSD?^7_1+-t`}a;3nP#hfjhg!U)!C1|rg@fozjs9Sy@k20 zHKPn!12zY~uAdH6`~-xaRin)P{Un_$B-v~=Cu}*>u6g|{OD{>=Ew%M+*IVT~-MiK_ z`(N~~XG1*49mp((y^-ljJT}7RZIABcc*-fcj>1=sBiW^l9B+(<)A(GkmRybjb(fo+ z4aEbw=hJl@lN8_icSJxCA)|LLWd0u3+mHug5LdxSo@Gy% z5{-%uEweIFtGB2rsi}5nLz(z@xA%|X+po+s>z6&TeE^dAxGKtr*uiw9{a5|_HCiAx z$oqUf(|Eqd0w&{WZ>nU)miIV$#9NWz0g!7*=XXY3mj_hiyIr$pB@hBewk^Vl@EJ<$ zQ_Im>qyYr6ej%dMXkePDur%#u!9YSx`7V$Ky7LBK7o2MI2u(!v>Udzm$G3jj9h)}Y z6RGvK)+X!QH*Ew&bwjsyzrdp2;WRevDovCo=OaAmpT5Vgg04?@9Fn1r4V#H9R{|Mv zasIEYD=X0d+A99i^n+uC?Z>{M-8}B6#*Py0>-4n7#?~QOxda!A@cn8O_{^a0 zwMMul45f1CR9DOAsUyL8j4qCQ&Th+7gi#$;tVe%|$@oTxf$;O7KRh<8 zD#N--QHnB`;aFz9%*(Z7*^mc6liuS7?#LFGK(fasSK7Mz+d~iV9*0Y z>xCmG6olU9#nU(G-aC$-BOMj86_2~Y+d_HDPs0w+#7giDaezI$FnR4uF`73*ad)Nj z5K*a4J)Y0)I$40&Q(}cDDu?MHZz=Y-v)7$IknMb@H==?B8#fS0BQ4og6J(iw9N!D@ zMUga8Atx?|c{+OXy8F^g627>oJ2^dl$$<4+q^|AQ_(H4TY@()tm-&DCpy@k4Wn;1A zN9!UKSl}!YSpNy)XOZkL{O#wazs~TW=h=-`!FnjqlP_wz6F3#FxZ}Y1ew^nqcHT@@ zk?+y{zP9sRE=dB9fX++V+grH!@&J3+GgkdzL11USPyQ+C;{YgEBr6kg$su^!_O!-e z@Q?zweLZH(dV6S+DGhabu*5Jq(G0kJW z_(iAn^c^N@4ChvT?VL|q@BrZY0IK?gMUO_+LyQ9C0>s07&0#jozh?43fDVOLMJV)r zv3|E&Q$|-@Q>OU4_cq+b1#4Zqaf-cx9LzsqCs=l_PFR|c9PT3Co@|;-@fpaLRS0jF zbUI!RMo$~^-laL5bYVv!O9+L)+B84%bEBzdW;K-{``qmtfMQH3u+VZ#O4M-BXiiU0 zM<*w##z|2@K6hz8?Xa$={j`C7qNRFGQaCcLD}KoELQi#d+=BPV609gN=_Di#N39;V zz=t|B>6qVkz)I>wBVa~=j<-dgR6xkYh*Uki#EPHinh7P^e>m+|x}IREG$;RSD<&|l z86!OC5=uR6-$Xa?%@GK-8}r9sy|R3K-4%#sfM~6IuOfKg9z1&AO(W=ap?1AkmDyRd z2%N-fk~>$Tb@y1jpSpAO+h6tE*=KWCn{uxITSl7ez_&lEFXgcse95}27;v@R50Dw1fHh4Jj6T5PJ zm*HS$nVRhpEz30P$Skd)o~@?%0sIlMUeF<>O20>sJf%7MK* z027PVyrpf1XLSGIZqeX&4ga{z#_LrajnXjh*Gb{*=$+l#yiEA~q*M0;W2zCs2b}40 zy|AadZ%n1(TmY#3FI%H^GbT*(@6JVjX#qBazDVg~fRvXMf@M%q(MWig#UH61;nL3?c*Z7WSINh0@rZ zZ5qtZT6V&nL)qFUqDr>)0xh=9QD|S+bCi)@7z74Da z@X7pKt<9hLgzGk>bos92$k|c260;>Bw`j&k!Z23rmVFQJZ1O;{4c2Q5M=UrwV(+`U z(nspo9G=QM!wfQMx?Zj|Jpm!L^^r{?S|Q4VT})S8p;iXG1%`bi$^8NU+uJ0>zRS9U z>j#gv-Zt*XS3)PGY>C^$ofpXEoznO|ILKjmX!6Y39g#K-4XUi&ryr-06Yi+e}XbQtwAcWNZBxbgeDA zpw<6J1E2}7GndYYy<7HXT)mIZicThI(<7A_Z+My0z33NV7xqr(> z4CGI&@IQL;MhR_y=>>Pa6|Ad!b>j_7Jy&Ppp(BBk2+LTwBeV^R%j_tvFzK>a*yn(9 zV`=36clh6bCfhVEmyqbO`af+~9BV%U1vCBHmNl6vh!EsLHk@UO z9D%U3-f~RL@Z`?ZlqCJX1L^>+O1Q514URz(dh0H%i#tk9N})dMl}2%)1M4SbWMSF@X(DUa#J<1H1sqc2 zgqo{F1SGGFE`JBiRlhQ|tzQZ*E|gn47ObL@IE|OMeCzkSB;a={G@l1^{BO7D>TOZg zAmKphKSWzvQN97TP47YAezip;OK6_CXA5_*^L--3uVmW*wZM3Wf#B15$^lsT!NvTQ zel+68l? zbS@fZf*js-zQu-}ikujw(=D05R7Pk}xpv9V!_e8L6VRFiwwaH~x1&_%_%ti~b+7j7ncd0)HwRVG%_t&tmwm0SnrIRti zkI#C5&?P#_c6$%9cIje`PXS{$79M81Zvp9!U8C;2Y&NY_%M%Z6c{KRR`PpbSoMF`+ zG8O$WCvhogw-oS3KKc$sIm#8DNhuwN8SW) zD=vuEskL11N~jsK63b;=AEOSN+a0~-hCRnv58&9Oy7Mm*>$7=U5n5LH$azQi^Q9_O zn7qk|<0=AjPuXL}L!QxCQYU4O7C*4kxUw#hfm0t_>lw|EmNOpW386!TzYFZG0vz(Xm5PHW4`|FzR75%mKkY_?TK3e1-Yj9ef88 z$_&gz7sg1>(jAVcFwo_ddem93f5ZLB<$Yp>#OZ7OsrP!m%C;x6Zx~D z_3?WJ5L``$JrwF9R^o*+-wOX*8{0_eXx7Q}nk6aT2=VfS@0pqj> z3D@lW5;$FmNz-SUC+L1L83=L!07DS$L=DCm<2eZR9Q5{O?zf$|eIZQjc7ltL3r+h$ zQHAOiyI-~fRDimIwkCx2hP{D$cOD3ZyV;1QKyUkVb4NrW@_9xHw#<#CQZOJV@LevC zh#IBu!et+eY=<5hf&K>mW=@N?iQX6ta+pWWNgmTMe~13Mb>D_nfQO=Pb32E=`^evN zcu0AGC4lNgH|n`KaB=yYd&mH!%U_2KXMfYz{(d8zY<=(My#(nNMBb{GDB$RcaB%C> zFR_<17GFEh9+kvSuhDJ^?9_U<%B7lT^dqK7xWqNhBQH?)-8d*=o`DK6j>-^7XH?Xq zPgF-)+GDg&7kzGE2@^XzDa3X$fNPL?qbLX+5!FFXPg8ldrvnLpE1_}K=_G>gPkj%c z>%d{W;Eif^)S~`bESw&e_9xesJg{hdsTl63siK!)#cl0|Z&AYQ-hq#9OXys!I9tMP zCkCQnI9Ain+{mS5_S#>uJ`a_t;28FP`^a)DYMcA^doUrJD~Z16$D8-I1E(yV+r-Nd zX^zRjKFT%;&&_pXJ?3;cNbM86)1IGysPgRi5_tPn{c6Ot(CnyIR8o=I@3^D$)!Ak_ z;y4{dzNFxp>B=H^MvC1Z+=DctTjpY98~6sEh(J;o7QhMnWw1ndj%3(zLWL(Ta6^p1 z%DNK&E>%s2c=b=Iw=HB%! zhw4;aj-g*zF+&zqFv^4`9c$nYT8rOGywf56QPsA?TGkhmA1B1?911`1%~d(RTSWN} z@QZTPykPE$SXI{Mw|xBBn4L!{ea+)B6QFo-cXxLuxJxM#+}+)+KyfQjTw0(w#VK&I-}C)Fqo7m>*&;0N30#~(MH6*?dcbGh3lFB5SpFJb2?nPI;V-x5RjEHwE zYzM&XMTa2NRKTg_xfX=bZL-!!lvYN_GWRZNM;?)O>_vV%uT1tXYfsH{@GeB2x?yQz z>%blVtt_3*ip1%NvPae6V`>m_p4GG$%^Q8!#w~+|hJKLMbJP4|uQ<)ggkJ-F7dy9&kLpuF8UlOjN)PrE&>LRUwGKo&(&*h}}@62@eYq?hryzb&OcUlr|3O0X= z?F<^@bPZg;9(mi8HGmt&`bYkp`NiBQuMK^>W&pFSvU%sVXCJ3`vlnkpz-fearU!f3 zsVJ1m%f<{i=?Kx{GeAbu!}MWM{8r-7eLW{24B9A)Z7L28KUJL_lT(@8x)chZgCMj1 zpy}0PkRv>VAh^!FBWBbZa}T3y$7;s=pNg1MjhA8}AHl112>$yoc<*;y6rGZr8{IN1 z%*!uJI|60qnoNgaMIU$JknoA?`|kAvF9SL-C!gpMqIhQqP@jNjet;AbQM+)}pZm<+ zg9`CHg>SBBw{T*z!lUC8Y3yvikP%K|bOg7p(H~L7+Z#kf0ReQn1_T6cl#AKMhod)k zl;jdK@fH>SU?v{=KmAtJ_Q&(eaB=i9sa8xW01iM!Z9?p+z|W#n=xF>fw+Mj_lXH0{ z^B>?B1}2`u3EW;4JwO9KB7XhKe_#up*}9hEIxj>vaQxB?NIIHz$QhUUS=pQ?bRK!{y9s%Gc@BxWn_N!^ z=0&ppHs(J2gfKOa6YxtSM)b*snlkcmCj1DlAll;z;YF;&np9fTx6+#3*zqUK)}OYX z={c6Mb%quowgTIq&V1W z!SQRRZ_twXRmIzTe}!J94NecSSK^?DbLE~N0xSCJ~%WXOMlS*cgDAT_0#AZ zVJs_?DcqyXUd&q`l@J@Zk&6?TBEE6A7@I+^X}~c0D#~2vV|~a6S>1%mu6SS&0*|jE z>YQ6NT-&a1WyK~2?<3u4`#;$0tq`KIqN=JdRH3=xs9uJVo6Y}$W8C?^?-BxUcqSny zWVZ3GLuH*;cX$IyP|!~R^&Ojq1P49%gWo+w5`N~HZ~1NdNgJlXWiP;Qbmv|bFmp2Sy@sq(&jQRAKQk6+Wr zmCr>6|8hkmzB&f~EtWQHgNP-QM4ia#t_9{YNhgeMO0xGzBBLo>pOBXcN>98^UXh0| z8lv@wtz~ZD?A#F@^S=Wde-A*RSGdETK+$ii@sR%i4$drdk16ZG`}MiK#2kUq=Qw6o z*Q2h1q3Pbe2B4{T8|}^UC3eUINfQTA#z?@5&R$lJXq&2yXoB47r+o?j)5fM6aei?| zwFFj{ue*zJKql9x2a!)(UkCc>zyUhm`{!G!%a4=1eVy0KhN+-^*AkxFXB!xWFNe&^ zi40?rmdcEMPhLz2jO0JAvt=SQ=#{zp@9JFkItE@Tpz9hOhTiLC5f=et1UmbFY8t+! zF~l#dt;K9OzX)vy{#D)#d4JVy+OL(OGB7ZRe}3NPq$uv`K_mOoF!V*o2&xU<(D;c> zk47a_fi&dQ;){&XO2i1Ib7Pp0V=KekeUT}y zl~ut+-4Z_(?w#=RPd&Pg6AeF{l)$z`#yoLLjZe`}rUWXo#eB2H$|>H8?Uw_{sZsGf z6MdTCHI3uM;(cx3m6SN<6)oc`apvtd#37jPAifWyJ_>VeNHF9i z*w)_l`P?qG1FR}Ii-F^bT54-e+`m7R@{L53>2iWpyrzle!TH6WTL0#`i=!VZQkb}& zV1l+>;<$E0@ZGouHY3vfhBuJ=0oz2M#=?KJ~mCB zn#yemYKg=}WeTjUcS(l?IiaW&9Ec32LQ8#+v-bQ)JKo5D)(?P;>95&KRQgd>zCY!P zJ=hj(gU1v2X!_4FZF}C}k5M?kf1lbF{_Q&c2u|hGgOu^8P z`)|M2WH(OeYqGp>>0`~i)a}UtToc!>>yXzyhHIV|JAJg`W^UgqC?Z6wZn!1U07u~b zEZyFaL5yfG3nsSR13FNO6^DMQk?3B+8zAQ zDVp-tRGB|e4w?pFbGwn}=uJWHhl*)K6T4F*!KG2jiR9zRp zNlo5`0=F?EpY^Uy#E5>S#Q~fkNWm2hpzg z>qmu+jaSIVD7?@F)V(Y@g+IK}!Y9DU%6#$N{Qh~2z0_zT7atw05f+_o&T%U}cvlkO zUZ`?_}axAZ89Yrybh-vC!iyXgEQ4Eojd zplGZ1NWsqHn9W|YP8VqR=yZY$FH;wfTq^{u9>Ph_i;0Gtu>T-a;LgidKoK>UK)Zjg z=J1BucF!R%i=4S1{pq!a>w5zpBJ%%O52s$WzqI|Y_dX!9YP^Res_Ykf+S8JXkXlaTj_UvqXJx$K$HDp zDCkZ&oZEx#mv4yURrvjt2;&cy`nJwxy!lK&@_p-QQwI#uXYT zEQ2?_%z}NsEGirj+G2JnXY?=N?C%5L{vCxGxxh-IL~!R>3LVr%PO_1eia6S#Hact) zKu7q|2<9l<#eH;G_p?>oZ$ju{gm>!xcI`^_Ai~rYpLAdKpE8+HSl)wZ5`0Z4+I;|O z3Rarre%ulo7;9d%8VQcP6(hqA`j^b*-9U8eer?$)@dy1@U0x<7?ADF63Q0-Su=anbX)yh!Z?-Ik(f4L| zoX81_pPB-=rhWNSAB=$b(7dq+@z2v;B{i0O{1U%6U@KFNC}Yx^BZm`wpl@kJVaeDF zrBb3$2FsOm|MSPE1#dWmMkkPQl=xEQ!} z9)%X(u|CYJtKJ?p1y!cdLKFzxC#(Pu5(No?rxuXgjE|GQEYG3Cqjt1u_()(=$$csG zZp!d7Br`iHCRt)iRzyy|$68|1OhhX434XeXj&P<%>4^&KC^b`rz2RLu=-k7p+zvZ(81n1t1Q$&g_0!#b6`FE{3PD z-4spnQI1wptA_p48N)&mKgZ&^8bw5Xj1jtDWg*uvc|-Vr*VBQx8$)}{j9-H4QyKl0 zpB7`i^1O=cE-OdM>k$Dn#w!Ke>s@+dg4`jfDr{MCcsCW)yRKO4emv8@MPj7~HzG9) zq*Q|z$%w6Y=Le#_yEU`pA0qZ2zuqsdm#9B~YwFV?v9h z8-B8=)7a&nkz%Du5MBHghlM5|io_|0seA@vk!n`U9g)#mrd$t}@m$T;13@;;5%C~|ckFNvM@keHB%T$y3_SbUh9=^3A!vEW$;_33FAgoQ#cUDA zPXgc)+r2Nz5Kz?O_yM&Cl2u~S;2gi2p*9UVi~%*n#^Xj5Ph(_+VEq{CA93z7Ms8KY zaI;W-ey}|@+YFr)(7XRuNE$&y!!K5?{Ql;4vWcv5n``RrGW7@(!HbmC{CBUi7jXD1 zog4<8KvN@>ma1~Xb+ZwwF7U_6&U^M;NcyK5v#6Z8eZLa6x{f$=TSG|rZ0K5jvzHfP zXBuQfq1}Elw&C>B*xmP0#9lK^>L{r8k;#9j3%qMG#D7!y?gm8b-cfbd6R zd1c!vBg)3i+E+##9X?o+DExAq2<8x-;TrkK=JR@Y;tE z7fsrncr3ClbK4anwUaOJadAH!^rOvn;L_exe$d6I|6?&>+8x0xM}8tyo<s@+QYLn)aRL?Hb7vVD_+!!c6lOwD z+Wtw?ut2dlQlQu?3cCN&DRQ6hr+=3_(Dbu0K&%4H&PpvK5^8V7U_=O5n*omCK zP&V8k?1*4_Tbou4+O;n_)Cr9a-781j^m)3$YlM;-|M7JMr^({aOn?6T`L96%6$C}O zWD+mybAYg8=wdVl)R;Mr`4pH2I|B3zk#1`F9b-(!E8M6_Rrm}{rC2w6xCN?+X;RUX zdJsr@6F~(pNp~VC@2`?K_%iCUKLWO)q_m5_7I+85+tYFRaPYgbSNHI5x)=ko%P9I5 zA^Fey{h3TL=!8}N$4>k%SiwHqs4O*zwjc$i*KV;Q)K&aA#d_ZPH}Vtc_}{jwPMmGg z-r$*YMEjc-@m-G@-|C=aUF7<926K!8Zbsa?>$C(;5&|RIkQC`)dW>0C#J@8jDbB{t zUnMiMMQF#r^ek+D!U3{7Uu>@rTEe%lqur2}5BXLDVEvo^k|6v4?kva_Ai^kJ5lfR_ zF`^~`r4&1Xzj7Z>y9Z+LpxJlm^~GoZtco@2T!?)M+}&Lduyu?D?< z^T+u1KAz@(dHj3PfxT=&yD?Pu3+;M6yTZ)6&~?x@Qf}4rU~grs$`%2LIGc4af|NY- zEta>Jwyo9*0M$ES`|i1+vO82^PV3H6pI3bsfW(4%9QBfI5Yl4Ls02CE{MT%r6>EmMAC z;Od0G3-7dTXs?HOh^m4Tiw_qSx7Ymq3c59%lq|@1!OAt+>c{!sEw= z8j^r%j*L-;>DZno-M{8`o6!gpVGZsa%aebLRPxcv9EA^yp};&}l6QIt1r5LHssh{? z3U0h&CnWsFJsjV1?*>>6R4!GZhRS+-#y47;m61@H&sZsFA-?_5q*3Q?nffMpzH>xd;*ixmR z@Hx!zKehG_Zr;#&)8LNsV)L3s|G-=Sq$SQ~&%s06R7Lwbczg*1&E*pFAmq~Pz$#8# zK1=DlyCw~bVK*BZR3NeLr1XE)nE#Ux<*sQ>Z?`w(`@}{ z@*0}-)j1h8Qs&$%>QkjDeh9|81Gdpm|JcfE@N43_7=oRNN09yC7r9i3uNnn0K^1C% zcQ43`A?Pa~U=aF2Fu#UB4IfXz8K z+{^MrFpPJJOyiH=L4pc|Zc!xFgbz>G6d}{o=8_(N(pq-K4pM36>Kog1WnhU*nb4AeNF9wzIN^HPMTg-C<6jD z3;dRx&0#Mlw|v)>-$s=mF@)IB+r}bXn=g5bu6AO$w4O;#FKcXAKcl&+Op-4U{>qS| z909SRdvK}2JUG1TCeAj-Cg)|wb3!y+M`@-~-`_}^bSUvb7K^}w!L28=e}3l$O=WEY zoF`Cn=BkN7U>|&gr?#pQjWI)ZWjqq_U!6m){-=>fTol!%%H=$1M_u{w2x~Mff+!8J zScR(~jUQ}EuXlQ%UJ8^Du_2P2r#P`Uf-5K{X_;M>Ubr^n`{C9_T=n&$%+CBhxM%S1e$ie7`np=XJr3_` zv%OW@j+o?n%=EdGV(zA`MC>#Cdt~#zRBG68GM@feu(13rounh%t|QfNf+MuUdPD9i z;#)s_7NXjqCB_u|QiUklEzlQml3aAiA$1(t0(houI}7wx4RDnQL^TrrS4V*29P;9A zTOMU@!tE?^O4Mn;ttI1ZDL{Hpdw-8dYd-X+2?)o;LXM^qb~+kgIBSGCfokl$9lO!q z7h1QaZ2omUj5aXn0u`di$9e$q=KFSa8%4SBM89KHs3REpfhai zho)Uy_h6|hvAjs&nql(c%O7UnsD^rY-v3-V|BDTOBQ4#|9TMaExjJYYFn6)BS}MAI zFQZQL#6t7(5qiAFb>nHyNx2inQ|W;M!u@Twvq0A){^Sj9XWu*$4WO?Frl)(kU#Dv)XjYJ7s%@F>Uhg~SjJ{r)kdyV{Bg?TxT7TJoon1oMe33+0gu zHVsaHgWZZp03i_qAX#NSdxKJ&2~!FUk0~0Ka=|E$q(ENeym_Z}Y3g&2 zV{?v^vXH+iLB~`4&7+QG+|U*}V=J9$6r{ss!^0xwrTJnOy|*Zn<1&efUb3tBm`fs| zYS4`+5(}O(GS-uK!I8$d=^!GHL*gwFfD?n$+<@sAo~(}z=5n#d9^@Veq$YTRZR_dO z0*tb4p_p`i9`V*c9%&^LZU4(1_!McNwxY!V2@nsOuDE(#8b~I8n19XGO~u}KFqU-u zg~xU8q>!l5t$7qnG~{>Il>*mg?&uZ3AKZS2(7R#G@Pk!UsMG2`yR+1sCIg&KEu@}W zc(oiwiPOYB1ZXOOiT7}5G*=fR{H09?EjcQ&z%c#kMU*!2X1DLJu8h##pSDlhygHen z{C^q$tn0L%1=Nd(g+2=FhjzdKoV6=et?T*F%5n+?%0k#EQqOT4HZ`Pc-&*??^G`ba zDo0LG2IF|QovBs;f4<9R)KN}*#V{*MMeXim@1$UfZ8;O6aw?|WOCX6glb@{?QUALw zFQghg5L8PZ&x*zFR7j9a``Fca8(&C zASA$!*CXPMwh#u7giHBDpg~Tiv7=ERx8iIRY8lAdW0#AhBl^-zMG%EXz>Pv+2KQF) zoMlu8HPa#0zR36)IW>hXPJSr|BP|?#apktR9_6OPh;e$=qB7g#f!@?|BN4166Y`B> zoE|A#gRo+{Acx7A%1v7F_uZfmc8^B@%YdsvWe2q04dF;!Y%{3fC+47#h*+1 za{8x9#O5Zr@KI>dv_t2Oxr$%*+~v)K4>iy7+iOq@zb`8mSKPAP^OWfqc?GboYk0z1 z6}9HlE5I!ZZmGs_XBQKP);EUDHil(VQnZ~5+l%nw@N;7uSAeS`Ri>HT&1IX=c;n9V z0Vw@CBviWP9QJ2wt>N2`=Jtlnf-tjs1>qKpNJt4PT;1)|xBGsyX;RFBINM89;b$De zrAIsK{dgvUZ;HO&b1mktS!rdDTU`SqZdT)FOohibL94=}JHh1FZJcoWN(qXT5|HtH zxFZxIscb&RyNBMA3X%?|AecFU^^?LIs2jlT`MR^&k&s*#Iq&>#tPb&sBUs# z8v=qoS{!7C$&F7s(x`w1?sF8R1=$|z8bVdY?>nqJoWo9s7Q#%&{5OHI-IO3W?aE)P zmN;?e2qZfoS^cWBi6i z#ZqYVs!GKdKiXD&CDN`xaC(Yk=wGe+G&266Ukbuvjm@Hra^Q5#`tUCGaez6xf!>KEp+(i=PFI}ZwIa%W5Ux6%%z~|IRGlgCt02m zgqa%V#lm_GnV{$-{{@H2(`De!d{sOXSZ1h90lCxaaSLjSK?wfZr_{H~faW%M&^QKT zz$R~?ZPl4aPq}s=Eia#-p;|m>8@9;G&o~x!FK92~x!gJqTB-9+ki_P99!+uSxU_ySCuZr+3W&vTE`)Ea?2DUiL_QqZ~Cst zD-9I(Vm)@MiGmAi|1k$Y&2r)h>`!*`|_dX3m_L_bCy z6}bdqSXYv$p-XZX;eU~2ZU_b3X(V#7u~a$&a8{&k(c7r;Ps7Pbdo!aPC&42LlETD{ z6Rn=}?myT-U*&Iw&}I*FSVUH=%%0oW z;6PQ~T@BjOimbk{U-s0AzsvWXgPEh*Nl(6!6k-t_W726+L*@L=PhbT?vl0X0``iw$ zEab58t#Ve&AY|9|L32!K{dn@VQMI+Q#d};KswqcaN+|HxJeH0#eEc(R?RSCHhL6PSVB8KisMqgp74v83AXiXgpJpdd_x)*AcwvV4NZ)P6 zKY=mwPpO^E3EL}9q<@6@XlR!iM&WU>rIE0)C#a1x%HlF4ik}D${qg#UTRN=#?foAZA}{Y)*!wsACa-eZ$JD(au1p9MCwqwe^)_1n zE~N0h4@-8Vr^-zzAU{UXL#2;0jrXN7i7fb)1$yg@3s9Vk4T;zHisp|#QwE0-s;idb`E==c*(1l0B>6gUbWX)l4i zSA<4b7Bo*cY%#P*7fKQd1fl}t%QD${7na^m4oEfv#wP_WK$zw%XOQh=H+rAc%0!x{ zk1{CJjcA@Wb75)x(S6)mGU4i2hVK=m(D^XeAEH#w1Ks#HAMyi9_N6EBdxO^b9|tuA zsLP}GW^)pSc%26YjtZioQ72TGP-k6epcNd|h$A;TkNt_y(*bmLX7}y)g{F@*Gln6Bfkl^ z--UyziMX-q+(O(!=4Sdn@aaEAKqMWKR+Zxn&QzAFlBJ_*qT=%Ok||faD)*Dz4eToP znRbSlhf?3aAK+_5l(H_L7PKtUEQ{GyFlJ~9mK!6j{%eq)%n@t8U_yUmL|tJHbYFy$&H3yv+Wy*!5>3;E8^WbjY}=_KvFL$uGz4M zlSquDL(9@{ttFVr4(nu1Ib6m=+EboQ!@ugS&{O#~SS>O7^V2dUD?_*ZA$}}+Z)CB% zXhjs!X(z}VwX~Esi8Rz=(aKfjg$utL#ua?xH;Ka4{QP&``&GHN=l44mIod${7JE1L zd0Y#Aui-1IbI`eVZLIZY85GI{&F1 zio&#SvrT@8;ZmM#2J5+{36OcfMrKhkeXEs(`KQUI?@RiCBQWhNjZ9<4ka@g>kYQWk zb`$6vK~k+!Hg${z`a7(JJZXeHsbwlBqJ|HK#KaXo6CF+#sq3>)6|SA~HI>9t+NM?f z#1n6N2UUut`X_@IvNK<}#VclOR14xrNh)NwBf7jbTNB=7M_+<>Tjeads8fqr&G$zt z4tF#EqP`Fj1qbj#4IcA~<-6@mDuWF=!D!_q5u5>({cg{5t{!He8n3m9>uN?{sN)A@ zZUT#QQE}hQ_c!TvDCu2NVG24p)g=0=q!}I4&5q(u@Rz!x?NXBCkp=YxF`%+zp zBlu&_(hv0EX5yTw?zj}!T~!3arSc5OtCSHEK17KsQk?9OPvtniesj@ z@69EZwh6^lwYsB8X)&M-cy_t5teBjbNZwUD5q6u}rTY}7ejA`az$N5kGCH&oi8%#H z4}W8}Bi<{a;&4pmJKV7k&8xr#JUyX=S2_p#vPIFP~Uywew4>^qU+2nkLCMe zNl@Ih;Aor|b@!7^%;jTHaeXxW_#x|_{uM^5aJW!!>!+g5Skq+=Nj85LX>xv`l-W!p zfX2+7xB~K)Q9YhL@laq$WKreh{_WYd^r~n_yxM1exvZo~ktiJIF3~8bFQ2$X80J;# zD3eb`<9g2%Ck!55!D5u$=vb`$A!RhGkKIkP!=aKUtdgChSZNw2P((g(;-Q8Korwv# zlIfQ5Ih3VX5%Bk?7|Q1o=CNg4z%*}9yJSNMqW&wdx29C{VB;A+^C?850qRj6N|CEt z@)-B|2ea_d&-T0N5;!;LQ#}w%dg2EVdnnne#ep(KJpI{D`~KbhZS*1;7W0Kn%j_Ek0jgEAp0RJk$DFg_ER(Ji zamP@%$zN5=d#FkM2Xv-*~J72gJOu9hgEXDOBsgp8F3P(4Z zI5G9tcj>MHa;q>NrJ3yT6KE+cosV$&FQt*&&66vU*Akh|xJWZ#cw;fjUf2&ip`7ET zA5KHGjvcPp)~X`47wtnDN@XR&PSEQiGL7(BAH=|MwV#P85@ICyk&gCQKg}&nbh7Qw zJ8DyQ%Ine|UkK!Z`6T>i7*ij|eGfjq?NFI$1OEk2a@}ZT^ZA(TN^y0S<0%_-< zlyl|faaU$N*jv`?&**HdufXwP(*<{wYPV{MQL8&aL|$n{1zm)0XC&Z` zFQY{tj)GBUg$ju70Mny8g@UX&QU|!Q!Ph<{^${dh5hV4|1ocEylfm-9<}m7!?88PN z?>fw9Hjy(|Cshs3Ra)oP}`dUZ>0!SM>dMMk5 z5L>|pg$`20{>V|3;Li)V{%Xkl5uklm9O;o;LtJueQ|k-#>DhurJwIrCA|cP8%@fZ) zGQiZUV;HJ{t#9S)wvQnN)GD(r1tS5pal_#VesV-YzOr>XH7M$pR2;Wo8J}$;L(@T{ zHI!$G+SH($f3%=p5WCS3qS5b|rFBnPbWbok_@LY!>pN7ycB1txpcmZ|#r4TXN$~Uqy6Xh7J z%o=P^*9RJ2G9y`N&5WLHtW}ZFzMKYMXjCJWvKgnabot{fiM?B5zr&gImN&@xxnF_s zh;YXwHhf#N)4{44_*4foMv#+I%f<1KnW~wgk2J?IGAZ?fGT1%e+~$c zf{rq5y!UC(`5{yR1Xk9Hf8LzhJh&-+AW0p|WBbOI)JitU3*X!3QSW2D8h(vGZELvM zjlr_j-nzQETWbzNNgDJ2T9&8PkTF}}fP&DG-QPA}%vA`>v{=BZUWsw>WUCgoX#7R| z%b`hXc*6Tq+$TWJS@{QV!&MT)KPa;+{>VtXX%~!h9g!kCo@u9~9MW@GC#q(k0 zySZfi;=fHUyB(A$4Fm+VgtgKEcM)957y?Qna08y_5#-G-=*v*YpWd^^M3|i*E?@?p z1zQz(Q1vO?mcl#Lw+X_8Utn17wEuDTdrVHzya%q-*{$`@w^KRwc%V8p!=lLKwt{>= z)I$;1`b)vBWLpOey$1yqc{`pu<2q^RL_7xD#(S?-Wit_I^uqb~!c|j(OTB31nLU}> zG(#$2P&C}jO;z3?fZRkO1P?BO5RMyBKjJA}eR6B8Sd4S#g`qQhs2GjhQb%cRKsP=6 zduZtsXyJSlS7e`N09tzzr>laDtx04qn24E)Qt~PW4V%f-_#<0C{8;`p32m)q6R`7~D3vT$$*rqG^X5+((QZ@WUaoRR>T9x?^#C_amm7?jtLk_2>Rk zb+ns0TXQWx&L1-Y9F7nd+54=D*vHnv_IyYjOIQ!KabF}`Pu0IrMmkh#O;xDFT~fk{ zm9#Un-w4ncqYt>bph8xF<1HIBt9YB#2D)wTgRjL{%|=UC#SD#CZ+qmwNhvT$SD^>c zBGTrti-MVH_ddYFlbC$Ix?%uh6IM@=*E!f=BE-q5N{oSJzjo|vBTZ(#@ym6wDWFQ@;6T?hESv-M&lFpv1N0y zjXA3o8T<*JT0V7^?5M0_mJy02n6yQuQ4$P@M19`;S%B2z!vIEmPQu+sh;4Sq5O}_0g&#MWFPQCeHMB>AP_9?4R%tkmV~+&xcB?SN zpqtJnm{T?g*MOH7=m^;`BjHYr$lMdZX4~p@Ouy>gG|N8QF~kykr9+VVf$TT zCpwO}{)F__wyK!F{$1Fr!m8uEvl{a(8-Gv!-(W%Pfx5 zcIuGW;(&ni~5DTsr^ON^J6OJaa&@bA!gQJN<(EbPO@QsVy@M9pKd8uyjB5 zvorSl`bpMt4g-q<@`gUoXS_T5USBO-Q^-}ERRy;BX!AZ;&dXH82JVMWU+4~)O0sJu zvakjFrrD&#^Cv+>aCFcsw1!`=jo?cpr-ehk*!ox6JKLW=1zg@C&^%~IKrXN}0@8#0 zKjTQC@HbrVykz61A%!?>O;7PfCiQ6KRJuiY-gP-rQ(*2W#uLmEHHZ&fVMv^8^^QN$ zUqxHce+;(-mXx~W%#(8})d=KtJgXjmo)y0C_c~oLp7Rl70z|WorX*%zQwqyqRG$1q za|$I}qIF4)anCYH!KeC-3RBEeSE#Q6l_`=j@x>P5x?@8dtHioz zOW*$dp{8Uq*d=Q1*O$?=&NJDLv`Fi+4;bz+_H}`L@(8vW=Ra6}4HuGrJiym#5?l1> zjpMpVxi*Gw{(hoUl!lK@0SP-lWC%yApQ^=C@bsoKa*-U6Hzy(7vM>n0hXabZiw&>yhA$$pYo|NLWp7g& zW+$n&s>m}|V-tC1Tl!QHquqKc22!=)2vE9pUeLHTckej{ejf&Wr@R)+GE|xI_3vPO z0QJRc=FPhOCCkJwp1E-P&t|uM(|#ODyj9?<(zek28)p4)q2)|CFBe8!mWdLM>>FJd z2fe*oT$v_3-yOa5=ue=Oulq3EGqs5X@ zoj{p~hViS}FuNR%T6duWlFGR*MQ(WAwa}WQ%7}Fp?#41KV3Rwmo-(T*n;PriE1jM5 z1W4l0_Jcc{DW?Oae0NPp_KO^B%nR>iD6CeXi`>+w;vUaD!TgYe$bI6`w9n3g_qA++ zcXjdC+UEv>9^bQl|5P&;l`n2n61(5V)CH1XcTnQ}WeuwxYghRiH%B4Qln{rN93+i5c&MTD^}H&x>>i-r1zca`$l@L3ec z87)4MbWN^pkz*7K{h%9-ghN4srzn~DCD$YpN~`k$xZHDo_jy}X>F!sol^=xc`!^mD z|D5ZMM6A8$KLrQGCE5vf_iW#Od{3t9a3#4h3TCn_TsT<6vnPnU=+J*Ce?t`O4%6s! z7VX@#K|TR(?!pCU%PrgjT{*i6l1>Dqb4+)1=w)?N5uq9ItUdh=T|5=G_@?e5F$|P3 zG$Aeuchip>6B55xf*=v$%rnqVb_CJ)`BL>hF`W-V$*M{RqwQi=?b2~NPSnO z9rruQaVsA+PS;ND?7Y)9#+qLR7g5kh0LHC21baqIXqQqzUrrXyN$~>DcOpg z_>?mlC3jj(M)Nc{H$m+7N}-~me(lc@$>@01Wh3!Sz1sMctf&P9pVdqQ}Go6D(lv`{NF2xRSfzGPpYG2|WZNfchgz9U2-YSC$G3b(1zxf1}YFeJzp00_LRT5c6(im51W%F0 z+CPRQae8((Zd)t0>Yv8$C+R^ThjeH0 zDryG_0a21)(l49nr7j}#_iq<;Ji*|_-ajw(jLA*`;~!sMlT-UcLeQfbC&Tjp7AB?M z`=?Ju*&&ahp&&NFEUJ(*TRN6Kyt;zuf%q?_|9<{OJF*C~MdNBP-L7Q1pG4=p?O4J^ zi)~zwlJAh00@%e?GMZ6$DFrP~J*gGt;>Ph%yA|ppBL&k?(nrE`Utm(tomgF)LK>^R zu)OPDxK&)bvBcM+{;V#a_2xs}VB?f?DjW{Uwp8a?KZY77?d*|K6jk8Zv? zpS-wZ66xCfQqr9m`x@>U03UU~FxQRwOY+x0y-I&OQ=Nb`b`-W3RYTBrBWYh-wRg2OX)p}XRR9PlyV-IN6X#wE^`5!*VrO5L_T#zN9i zRzzRglt6Czu8+GH@TKB^k=HTA-ub{DbFvlhY@Xkj)FZWk1=_Y>o=unK>!K~}qI47n zJW}o&lMyZF3ra4B0xgJspZ0LgttFB>gn(-FzK^L`p?b5VH>onqv_LrZb2H#Pu+4JL zE+=nMPwb4+*t=9H&#T-jz@g;PCa0kio9I53BuVwMh3Q}h+#Jjl?WvO}bzuyJCncs| zya0_U8_Aoi-uS}H=C%7Bsf_@as89u2Ll*67!aUfvW6cSnc+Ah9<+q^EIJE1>yikzB z6hr_th?!GbesiRctS=n|hS1$&FfD58Wis(7BG@qB6b?4T^`2$GTGa;h$G>FDizVE9 zdBd#Vw-t9tw=XzLPMj8~KgTWy6QuN7nP=Oh>NTTDEdkatu$$Qc?4Ob2Eh`DW>C<8I z5^R~0xl(ZLrm_i|4bx>`4T8}=;w!>2>4z_lshx9PKV~seJ6qjOPKfx^c1tMsrnay1 zwKB0#DUBg5eZg8vMH|UR+R8?n$%flXMVm>D=*)@FqC?8biR?TB zV*(FTR_V1$_ZKR^ec`et<1!oM^OBdvZ{DU;7gUdv`D0awx2=oUyq`F+k^?Giqn$gW zyz2c^>gcHUy~&t)9I=gj18UcUoOpO^rD=!(uTt>jLvZG!;bO7z2^7b*Ct1Z7;_u$R zS(57P%AcNlY=k6?#@|}pCNb}O(OYQ4BjF6?`g7tv+_x8rEigI~-cp$AM!7;O#-DS` z1||j3=@2IqWEB2UpoQf@`q&f!IO719xMz4885s{lxkTq8t$50e1087o8XBuDUQgY^ zU&)JBa7l{cqU1Q{UkVKCe$G1fSinWwukn~2KC;e_3UT=-ApSg>IJ|JZ^8c~* z)j@Ft@3u&AcXxMp_hoSj9tf~F1cEyRmmrI~yN1OA!QCOa1$TFX=I!s^TlMa%djIT9 zP1Vj$&vt*^{hjljLuT3wm9N9}73W(H|GTC^{V??J^Q;LoL9Gj^36mMB$6^E0r_Cw> z!hz}5&M2g+rI^Ra3yE$)8wAdJlZnUliHzX?@Hi17HtmCCn?LsJ2cpaVMgVP5TPmfo z1xs6qWH06#vd96Tq>BMp&mmC~z|nA45kZ9rzS7BXQW!cew*{>NQ1`Bha-sMr#-mtd zK5R&nE=zXO7I+uei#U%&Hbd-4KJ&}pXo{a)#}z#-m9rm`WF=e%VsTwhF-y*j8bGHw zSKg+f5rs01tTSmbl2o)5|3rqwiOH}w6`u2N=(dG zj1Mj<>eS%B^?{nkDR{4AG=H0!4WV_4iUQDRn4Qqw z&xGF3v{#2c*4MO3EB=chXFK^2B1zl}bJDNVAlQz7nu4%gF(sR9;v#>jxN+qfLo7mP z_1!k+kJxNlrH1b?lOIq^dYDE|eKyuq{X)*p?T9D(PQ*gIAs-->46K)X$+&7hS5!Z@ z2kF;G)PLnGk&N*Dlb>L4Y%-u?O=l{OXLOC8@!pa04WKM$eIkx)S!o(E60P>s5IN`r z#r)k{mMw4-cbFv^&fq6}_n-z>U zBlK>O@3NG_5B(A29hslT3-;K9lNzyk?^kXO5+!pS)FRHN;%2hV!Z+@+eqN-sTT6k; zqtYPZ$H!0%g!+Y%?u=bNc~7bMSQ=VZ%QUPDbiC3$JeAZ%9|Bu$_OUC-b9}6 zP_(n?H+e2CdPRBLi}YqV|8zNjHvTvJr4K5LXt8vlyG2as37(yJGjn?rayxE-jW}(c zl-p;Vhz%^?{3FS#^=!J?|({Z2tAn`r*LM0L%xTPA&Y- zwsyYfrt7`7vUi5Gm$laV!=8e}RL}2p=74zcJE{DX-pWIcyH#`_q!?#%=06qH*CzDfHTBDcVCWAF{GW z0Zfy1+TuUlJP6}k7;hM6-9N~eaz{cATsz zPw^;bbL}cdCBmFMi;)Z3p45ad3}m@U#w9fk*)dV(v^B%nixtGa#5^3xqcOinSM%z8 zKWIsOuOL*EPoOSR!Xbe3Td$L`(5Aqpkik1@`1}~XA1dLNz;2l&7ChSJuZo#sNw|kCt>;YPXy(65?Bpba_e(9CE43+B;OgC2M%NuK zqs5;JC3m;fuEA)$@651Yls&%%ijqH7Ol3t5t^3%r)r zBi&lew|1gAjRS3sH@_{+ZTteyUVWU35cPnauS8Se0`~@>PfJX=XaF6#PjCa?zG(Tk zn}HBq)oDu3;6_%$6C2T}t@dN1khG$*Vl-n9U~}r^Z5zQ*vj_!Myu6hr_0HulTsrnK z8%__F1H=+}Ee_WcMayNdqx%tis^U}y$%MbI-B&U zF>RgGFT%mBc+#5lioyR7b}qlj%H8#BI=ctS9}BR2#3Xqip$Y%~t>wq^DUZfDs!yp- zZE}janB9+-xCOa=tsv%^r}B;$s~3~G&bQP(Ui!cE6e4=aBGv|XE7rs-*2sp|*sy$I z!M{U;Ny4U)WnfWAJaur@%BCq7)Nuzx85(MIVuS{fK3(^@fTFEMTtEAa!EE9)f3tHz zEbBk5maiM1B@yZ&Yz$F9B{|=jhPTbKOo~FPD`q!h%hK+#A)&%p*;`

u!7(WgZTV41&thtdD)hxnNkPN&b6pRc;Z8&aO%TsQ&@Tht z`xHG^7UskwzSWIZ_^)e=L|55P(?tQ(QaA}-&~i)XzRRhXKkr4d(31abeOcp2TqvL9 z0WpR*GYHqDJP_t&eIJRUHgPX5P2#7=oX#>yQ?Av2O6{DdrS#`dEHfIQm_Ia6AwZk~ zj*yk`YP#&niV*Owzm}-^;*E8hwTNP=E}A0uvIoQ^Q^yVIhYH=%wnJ@MtP9*FSG&@2 zx(>yD?8xX&N}&)5N`;rXpmAn>#gUXet^a!vv>HxyQ(wn2n0YH~HDVjuA$s0~r)+7} zr)fuG8{=+aX+zQCzGUuZBeCe&THK#hSWfV(bRL)*kBd*ta5WfHaED*eXsqCn5dQ_J zQuIjmQAyCnt4NsrUiW)y%;3S(M|>L=X7mc?F>S4k(jwu40`W*~2YDFY*Hf8{26gwy zlbKnaxU|m{S)mxVC;~+c>)+E{#O#azR4g*9!OjRq;ch1flVE;ML!EGi;iKpgN8(mH zmr4aC{WzAX*88s4iCpVTV{~uPWUp}46jLAugwYVm>B0pey+X+zP|C;1Bil>)1(=^% zP0al4&j+Yl%aNa8531*d{+vv11OCZ`%d5fsECJrY}j&WEXB zbfYP@Z=#p-!WEOEh)HXaDBCjXT9|4JMMB07(4xJl4M%5Dc5~yS!x<`bs8b?-k}Z@+iOxu{Mo z+J!N{ej%Y?@6=`QiB12>weo7rcBDo@@d-RU%lxyFxw4W8wIDehb3=$&JQo>-um*J3 zs7p~h@ZwsTb;ZHYz!h!MOk0eY4*iWZD&?_+m-QgsCn`Z)&Kj#~j*FjWVZlX4=;wD# zYvMU+qsE@@x0nzhbLY8l=*UrqJGRmAgL(v0Glnhem>AL4N}bS+k{FlR8Hg$W49xv& z%!{eTBAGO&NJK!}kxI?f~vl@B#Ij~H;)2i;((>pfs3)#H< zd;QB3uXwwJ2A18AnO^A=bWvhJz*kX6)eYuYJfiWP0S3rXPZ28V+BeB>vr={4BK?Jf zpGmNn%w%6>)t4plWKYcYzD%(#sjPqll9rnzO*BRIG50Bx+*b4Gq!QkgW8VYYsXv+i z<5ROTlKd%Z>f4Gb{QH+$6$<~vV+sEF6deLY{OO0|n0g94gL2YtHoFxp=JQh&E;};O zWlq^nDjCDZ6L`mroHKC4)M$nfk=C|&_v5D`xsDPAJTp6z<6;H9>~J3k{-7V-hD;QQ zeyTLZ#o=KpHzmS{1t9CQl+Mai1|GLxXVWWmez%z8bs_94pK`cHOQ#qpWhFXFL-l_S z_zkHf-(cbztja-DvQ-*1_^#2SlNrr%aEXrDCi^-WB-fS7U82bAO~s&^mJ*eX=8vKR z>tetw>eWxV7!J(ScFmmKAu@AR;5O!EZTXgjQim}+NQeH`-4vhEcQOs&t|b{S!R?*GxIkq z)>XqqPSOg)ar>PUI3+FlodE)Def`5418e$g81^wKM43T4K-AK8(Cqn9yJDK`=L+u+ zB=y|a$jCf4vedt5nEKhNQuFBd|8k}MtF$5SMtH*FQhAv_LsRkm03ijcX@6lA{O1Ky zw2cUBORV;xt1t{9Wek75x#Ge{VaHDhrp4h}T0NkA|IKG z-tCRpT+=!mkX5N2at032&T9TN1`$-TJFrfbtfJ=H-)1lcm&fSO_3r#}PxKa`pwEMC zAU%(xtsI|wum{hl9=`~<^`udAnTaqIwcW+ra!T~?mbw9&__5H-Ve=9dN7%;AQeXac znss!9me~Dr*ss*#N_JR9pOF-O?DTVYgcGN;82q&+ecf9<4s(4~7bs0z;v==*DGx35 z*F+r$HgUCg?z*(KoWpof;?5=(hJKqTapz8aex_~|a;RsQ{IPuEzMNzqPtPsgG|j@( zIls+a@kD)0w4`AaG3z2-6-lTO3Lev**kE>yUuCRNmX*`(hZ!ndf4m@=YuR^YmQ?3N zH)MNp!yGxTRZlnEwFU-j1UEZF$Vc|@MR^a?GsVl=h);NpZYCIbpTCG81YFh73o`K zj0}ueEbJ^gk?`asm2Hg5Q-aDs&r15kj7=u1OnRP9`PkM){?a54g*+7Pvo_-xaomy- zw*-7YC$L2V9l=G=pQ85hf&+Mv^ec=<*HUWDXS-E%o^ylR`lQ_Ib6O+zDv%fmeYvobRPiSzM0udDbP8hXeB=ukeeM{V zTPb-w8os)QdI}^3UOUTGdMptEE|QG5-d~m0MffjKG*S+hc^<6{BaVhJ^I6;xr`93b zg%aWLcPo33J?UA+O}}gk9MkumZG_0^{m$~Yj^gnT~J_ryg+Ej#JH2IMq${7$xVugK|J!nG2mV__;M^#IXdgUcEXWBVP7FbFuW_!j$W?~b1X^|vENerMmR}ZP z)4U#s8``C61qX46AB%pQZjgT5H_zN@L@Jw6xw|2p-g3D{j>Df$WF+M|ihi6K#fWyq z$C|c#vV-hxX*c$7_gENuc&B2DI`+y{YKgZS>*@y>aBy-g!Yv@od=wxsTH>(}lJ;a- zW&(r+gffgk5A1WFH>pt`P|~QgSlU?GcY8sUZr$a)`f?qa=8eCRIvAMyx zxvS#oT&cc0*LBstD%_+CKpB57{-ZX;G7iX=Y9-9YYXU1z-1j@U!u`9s|HLJa2KL8< zBPi?AZSsR0-zG|)*7eQ;q|v+ejNP>MSF~647bcKum?f;7kD_@5h|n5nt(6up76a58 zF4pW$!1%(*A)Bpon|P3=<-w~3VofUPpr4df8&iXHXe2eg>MC zbEz)*xmf-6d8%xLeN^`lT%Hf%OHBoI#UD>_t;c46kO!)2)(k`rD4PH}__3mwSR{uL z2eaT2n}q8{`r-1g$%g$j6cM9L;a^&T$L~%Db~~6j^Xc4NH2abaNo(xdyv75-FF(8S zpYT=ezE*h?lmZOwT0Q`xKcu7s46bpm-G60`qx1-wh{GG(!di0#QY@;8_q7Adf;!H) zM$$Uljv**hVKw~_k<%ZGLM|UL!vevzB|*u0qTvHt0f;05rOJK_ZJ@L>zAoXa3TOXC zFU0`dwRZZW$j*QPc;0%+G#1I?%UdkmgdXh1TLKTI5uQgWI|RGcR$HpjM}*^5DQRn@ zM-}mZ=Jp**W?SKoWT{OzzXR!EEd8idC%J-DwT{+=42G|Wrz2m&^WERP0_eKw&7K1m z&00#GlGk3=8SC@ztHfLPHGF~|EuycklAI6Tn7-~X6zWLf)gKWKzlyQVK8*4iAB?q6 zgg&=9*w%>ue)B(GD*1@rIF_hedSCXW|W3!fAe~JA2R%E>utvcX@Y|I)?(U zh6U=OMtaC`{g`@C@^^=?2ABs_T5_jUyFp$o#d?mc$=Th)^lW&j^ME+jh^wAw7cFE4i6h2MtsZ9*?0I873nZL=HsKE z3N(7BX0!g{s1HRjRHwi~WbPwAJ1_*W^N&JQ^LvA&UDwj^E5Zy~np*eXDVx z!<4VYEqTggXDh4&qv?Ht*$b4PQbw8L3Y{;hmyDM6F}{8&8fyK)EI{wAKqpp|>O;B) z+;=_cTLx$3GDnLb?SGE<$;t@WIyyWHwO{7t-CBqBD4SowUX|UMx$LK|dkhwC1d9u+ z#~Cusvc#Pd#|QWOL@pS*&sH#*`$h@NupF6DVC$jznUn(G@`;?Tw%M9dJA2s8>i?aIOp%4A*3zu~=}pZ&GZ-06^8gkW%(n(jd3X~q-n+@}0m zqWe0g_PjF9J8hOT1 znI!slOZ*J@&bv?OvRG2T%Bw1Vy_5T;`vt?0)kCj%Knf6BQ+(8}4!#fXJ5{q7WGid- z7PRx!PB_FS{$TUmyB@k)Pk+duVyfIFiZX*lWUygFbXaiI)v}~9Rp|w8u zU*W{K2s?$F>s}=1p~^rdUBa)D&(U)5-|%y@FoKBV8uB)SuCt|Zf4m?5|*XX(u1P(sDtsz6yBpf>vClu&*$HE z>RBsC1}K!hI6DNJrX9u}IQ4p;27X!Tr?LxY7FB*l$2uUNPXXe`Z=^P;P*DbmcX~)i zGUKCbe%4gPC+qna`Bk)DSRbjp&D(Gz`*8pCa6QQ+mo~h+{jcxSDoMP#a4@V428zAB zZ5h@Na`$$uDL!%((n&wtwmdhRsbIoF4qd?#Xwm*LG1RJ5-ZN!+ix}k|V*v?H_&aN? zEX0GKm`i-!Kq{TEvY4%0cn!BX%PP|vplDupFF|W~&HaHT>IB>LfTN+*`w6I8nJ|#{ zbo8>UO=VY>AHdK)Z|qN6QT|xCVk5l05Yb1tddgF)|VphK4x1zNgV94QW0-lwhc7uEDV{$@WwEmmF zw#ZLT2h;%DJTQ7QyD04HrDg`?v0cJ2+i;G%t!q}p(qtq}XVL-`S<(I8g zG}Xw7sFBfZX=ws+aCfLG>pyoRquijS!sKgSKcWyy z2u$osx1$7*9mk57Vsru5H>3n}fOO$-apO>4MjH>aJIeNDn6r4fOZ z+1V$u)fZk~o6`X{|8U7vH+N)X<+FpenCBVcAvnRWR|R>c=>6%kk3r6tmayRnr7cwf zsCIfWE-$3Z$o&0tS^`=U_2Aa+88UY#g znRk4(9`TNOWBk;notDm`ZKB|J_kc59#xcOwlIq<%ib~S{_u<6F2@sF;J+jr9H@3C> zGLgbg>`o$Yjhydx9U-8=X@&@{>q>G)Ow+%^|K9NIXk4j7qJv`z*R)i$PJp)vm19Ng zX_YB!bC(3$(%a3`=zs@_x^S~EkoK3z@{;(}Ae!NA25qdV)JujG9e{BJ={7`Q?)~Vd zm&u86&(`It24qaApf~SI>wjf&ZThNAJk3Ac882is8NheO-n6+ zAtHb1kRtS*2%y{|AK)+sK`W0{tRgtn1N08sbWHz{|4saxpIEw_pzQebJVn3!?aaZf zWKpMklq1(UooIzQ`Q=(f>jLaoON7wB&B_i|D>Q)68qG{>Vq5YAv!#l<=)*3!twBM$>_m&g*v^TehJd1VgOba#zpkargSCJa1}~a~LJVCt@T+?cNL~?O1Sp_?@d3En<&oNK@pGHnZhB1aT_o={gX@*$rNcb( zSiY9;L6vhRu2fU}iZGSc4GVKNFZ`bZC%nFhol!fu-492zew{1#2=4IvnDh7L=i?7o zNRpW@VQTvF2sL*GcZCTZeet6k$#=dD{X$;lm%V=)^FHL!3X+& z%_C#R`oCL`H!&A4+~)VD(LQ+yOZ zz7+VG-;>zP;gRjAwpONC=VWJW<+mCS5>bP5F_*Xz-Kv@$*_3!tn7AFSUkv^g zfl1u56(*2_F(N6F;%5-I6X}X+EJ@|+@T$4y?fV>^uJOa$cbA|&MB< z5@-hXLbKt$&}fT@*UCk@2M2bTJja36FTGrjO z^n8Hg*RB$R!^(c{PH22aZKNmIZGP1qWmir1pC{wqSFU8y9|PVD=;qLr?YOgWxtagH zyGnxTW{yU-XZ&5rQKDdAd^}&$=$>%GcrBA?hz3rR!D$adu9<<40)YJcgg$Rgdi7&0K7I7%UlbaoTrzC*}$o=O0)z%X&soE^$sAKnPQ=E&xbO-BW-9EXb`rnQInUPVARMY!K=R za|f$^{3hQct|=p4Em??-&)@ocxh5J3jg$&qCtt@@!Lv-1QTLUIZu9`vhfs z;a?Kw-uXy|F)=>01KUHE@W--uXG{)h*zP7q;Tx zm(DcrmRKP1kidyv$!AlOph!oiNnePtU5z?fu5;j%&yx`dl+g9cj@y`+);#riqko7z zCA2yev3KwL>Vg#^cXUrsf9m$&RxZW#i1BmDH()Q|E;z-}fI6DOcXS}WmVQl_`JaQB zCgriOXX)dH9D?D^TH)l)+qY&2-EfV2@cZAY#kcte>|-yBd;*k8wEryJ5Gl}^q^#*| zVlp0_(`Vm|C!c@3v;cif2W{<3HjAi>yv8}J?9ihb5)z~EvWpV3$f1r&k_XD8$+6dZk5ukWq@kBFEj=Z4-cQms! zF&Z{Ol&vT+E~YU$DpDgBP*yKwyn+HfYc;GHoW~>aQHKmn&in<#a(Fc5n?=(?fZPpnfwK#+~50eYx=`5}lI_^zHOf6vX3F zy(h5wqLKJ|g_feKkxb4BOz)q8wAcxe=Gxh5cvGlYPhJNj5df4bQsfI1fV9GTRERvA ziRnFZ1x^DMyJ%XLBZRVQ-^o?f&}}ow1bCr45B{u&`mk>P5Ol1({P<_x;veI@Nmi%T z$$KO#%u*l940Exma{qx9uk<42NElofl%h$arJ5`YIz$UIPd4(u7kEnhnpToSgwfrz z>@ux0=Nl3~X*QEXDTL*V_1vZ|#1(Wj6T@c!BRA{Nl?455YxJlSKAOGND!OpNU03?e3!G-rOT0%`dT0$YW#akpfqH>xVm*C#Z z)8-5uHX#8Kb4yqOC$_6yHrIi^8%4C}l2lG<<(684knC_)XN|aEU3Hjt0%J!4h)cC^ z=RjstG%MKwnwYi$p&*f@{GxB@E8&@0YUQgtRty%b99oq$1J8ccmO71=9krLuT||@wma{iqi zgH(##SQ;$M9BJe_;JwV4g`;jMsZS64Ru!+9=$jrG4-`eb#Z}0upNK{{6|fVniG+?pnVu<_I27v7j$iJMU4BsalgK!Tj3jYQ zHFON~Yn1y89VUs7vh>XxOub5&3UKTi?EBZ19+GdmbaMnvIK?y9?sU-C$ z388V?dr(>+#Eq8tvQdYPpG-=FMejR$K+Tl(X&6g3Eok50HKskihg z$)El+)u_{Y64a3kVXY~G5$_aP{q-GH=0;&W69U0OA0_(CHcHeorvbhypE!|=&+ICb z8XqI!zh6gXg~*^@>Y#lN9@C`jy6y>y#1pUB;*+Ka6E?}ogS}&dDgpA9<@_A1=@sj; z(X8yL8N5_>MkgFucopgE_JL}sbyk22|0y-&ym3~9uh27lLc|9MRSSs0Ft)yE`Mxd(pM_PN zcJK+Qq=Z^I1`RX15;?v-#tD8l@KaGcATsJ|yD`J|m|=nXehH<7F_ z0Hk3ZayGi`lxKwArsdEJO}-Lhj;%z08TXw{LUE%stJQgVeQiiBK-{M+8Gncsg9< z#J1<(bh9wcXH8j8cydBpKhqI(+y+r*-kN&2IG6Aa?0BVu)&x=XEp~1Vcm{G3tY=;^ z{Hv-uRYclmFY7biOrnuaN3}n!+1i3tg$opIMDk?)Q4to65xaj9-C}M~l7$nfqge=} zCpq*+I{sz_dd zW7v+CXuD0l)F4+;%J5`h=tz5oBWH-wI_%IHN2M{y@bWXgYT#hXNRV*882`+EfmA8bQsb753gGWIT6;v_tZ*j)21z>1cmgb`rw8@L5 zT_j_kHF}AI&q>+qO;xDlznDdg3>OnsC*-P2Dy(S@>Dn?8N~L;p%r(<13W%werUJ3I zz1OJ%Io7yQLB?i+w}}A-I%F#n!d=%LHh`PV?#7X+G{O@}8oVDGjgqtc%trZUI3{5} zLJwV9mrFfO&arzPzQwC>Az!?;{QWQ&o>a8)_TmMkjsqaPF8@UN%8I|ooYv`pQgCON z3;r9J#9mYV2HAUCL`RzYb}lOIMe^_8ZMXMG#eY@$*<(x}igx{Fo~` zO1V4B^rVZ}DU1NUcz^N4;8fF9CW9M{0#$KVtc|XJ9I;5V3nzbJY%F`$jDq!HsC|i1 z4j!|1v|ZkcNKrT&2PPOuLGv!NLqK4|IfOCFSna4&VK_AU5cEW)wluJXttCU2Bs9`a zciNnB{k(T?|M{z6!R2C8wZL4V{shY`Tf0p&ou+^Tz0{h?BmCj0Hl2Jd2GPNBgCIn> zW>zOL7lPg%=S$4}mpX)>#;socnuG*3eh@%`W=6{f8~;HV|CwK`b_zr4`5%o_7@#2q zp76N#?Z1#fZA?+;)~@#x@gJhN>|7>f7y@$xMt3fcz6(qd>J5@jYdfd)@re2A0fWDE z%x;4uF^7xUTqrtz-ZA*N?UNt(^`f-j;PyKIHmnWvX^k2 z5T&o4eHcYTgcUV_)zVSI@kW zor`gadL?^Vb�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 B-`M~F diff --git a/docs/img/motion_planning/trajectories_direct.png b/docs/img/motion_planning/trajectories_direct.png deleted file mode 100644 index f142ad63d3565401906e253fe880d900e85073f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 82011 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 diff --git a/docs/img/signals/fouls_map.png b/docs/img/signals/fouls_map.png deleted file mode 100644 index b45537e30ce470cc5f5fa2b2a7f70216c41a14c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 120481 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 diff --git a/docs/in_house_vision.md b/docs/in_house_vision.md deleted file mode 100644 index bbcfe293..00000000 --- a/docs/in_house_vision.md +++ /dev/null @@ -1,306 +0,0 @@ -# In-house vision: plan, experiments and findings - -Status: plan, 2026-10-24; on 2026-10-25 the team chose the full in-house stack (below, -"Plan now"). Nothing below is built unless it says so. Written after the 2026-10-22 test day, -where vision took most of the day. - -The goal is less time spent on vision each test day, and robot positions accurate to about -1 cm instead of 3–9 cm. This applies to **lab and test days only**: at competitions the league -runs ssl-vision with the standard colour patterns, and our stack only receives its packets. - -## What went wrong on 2026-10-22 - -The setup: two cameras, ssl-vision on its own Linux laptop sending 224.5.23.2:10006 at 61 fps -per camera, our stack in WSL on the robot laptop (`docs/real_robot_setup.md`). - -- **The cameras disagree.** The same robot was reported 13–20 cm apart by the two cameras - early on; after the distortion was retuned in ssl-vision, 5 cm, then 85 mm later in the day - (`replays/field/20261022_211142_score_goal.log`, constant 83–85 mm in every frame). - Something moved between those checks, and nothing tells us when. -- **Against known spots** (`tools/field/vision_check.py --guided ball`, - `replays/field/20261022_212332_vision_truth_ball.json`): camera 0 saw 7 of 9 points, 33 mm - mean error, 61 mm worst; camera 1 saw 5 of 9, 55 mm mean, 92 mm worst. Neither saw the ball - at (1500, 0), right in front of the +x goal. -- **Camera height is unknown.** Nobody has a good measurement of it, and ssl-vision's - calibration leans on it. A wrong robot height shifts each camera's robots along its own line - of sight, in opposite directions for the two cameras. -- **Camera 1 never sent its calibration** in the geometry packet, so our camera weighting - (`CameraCombiner`, below) ran with equal weights all day. -- **Colour calibration is slow and noisy at the edges and corners.** Yellow detection - collapsed after a change to the robot tops (1.3 to 0.1 detections per packet), and one - yellow robot came out as IDs 1, 2 and 3 at the same spot. Camera 0 detected no ball at all - in one 2,010-packet run. -- **Stray orange objects became balls.** Camera 0 saw 1–4 fake balls in a line about 15 cm - outside the +y touchline, each at confidence 1.00. Our stack picked a fake 22% of the time - and switched between balls 107 times in 6 s: the flickering ball. -- **Focus and zoom can't be locked** on our cameras, so the lens changes whenever a camera is - packed up, and every calibration starts from zero. - -## What our stack already does about it - -Built during the test day; it hides the cameras' disagreement but cannot remove it. - -- `CameraCombiner` (`utama_core/data_processing/refiners/position.py`) weights each camera by - how steeply it sees a robot (cos⁴ of the view angle) once every camera's position is known, - and drops a detection more than `CAMERA_AGREEMENT` (0.1 m) from the best camera's. -- The ball is fused across cameras by the same rule, and each camera's ball is first moved by - that camera's own error at the robot nearest it (`BALL_ROBOT_SHIFT_RANGE`), so a ball at the - dribbler stays at the dribbler. When a camera loses the robot for a frame or two, it places - the robot from another camera plus the gap between them just before: the 2.4% of frames of - the log above that put the ball inside the robot are gone. -- `PositionRefiner` takes a ball inside the field or a goal over one outside them, then the one - nearest the last ball. Replayed, `20261022_213347_score_goal.log`'s ball jumps of over 0.3 m in one frame went - from 5,439 to 4. -- `tools/field/vision_check.py` prints where each camera puts each robot and ball and the gap - between them, and with `--guided` checks each camera against 9 known spots and saves the - result as a baseline. - -## Options considered - -| | Time per test day | Build cost | Risk | -|---|---|---|---| -| 1. ssl-vision, more tuning and better fusion | stays high | none | what we have now | -| 2. Our own stack, with tags (and patterns) | low | weeks | most work, but ours to fix | -| 3. Modify ssl-vision's own code | medium | high: a large C++/Qt codebase and a fork to maintain | avoid | - -Improving ssl-vision from the outside (our own calibration tool writing its settings) gets most -of what option 3 would, without a fork. So the real choice is 1 or 2, and two experiments -decide it (below). - -## Decision, under working assumptions - -The plan below assumes three things, each to be confirmed by an experiment: - -1. **The cameras can't be locked** (focus and zoom change between sessions). -2. **Proper calibration alone doesn't remove the position error** (experiment 1). -3. **Tags are better than colour patterns** for robots (experiment 2; early indications say so). - -Under those, **build our own stack, tag-only for robots, and recalibrate it automatically at -the start of every session**. Pattern mode is not rebuilt: when we want to practise with -patterns (as at competitions), we run ssl-vision. If an experiment contradicts an assumption, -revisit this section before building past the step it gates. - -What the assumptions imply: - -- Cameras that can't be locked: the lens changes each session, so calibration must run every - session, in about a minute, with nothing done by hand, and keep checking during the session. -- Calibration that doesn't fix the error: don't rely on a correct camera model. Fit the - image-to-field mapping each session from measurements, then correct what is left. -- Tags better than patterns: identify robots and their heading from tags, so robots need no - colour at all. The ball is the only thing left that needs colour. - -## Design - -``` -cameras -> capture -> [calibration each session] -> tag detector + ball detector -> SSL_WrapperPacket -> our stack (unchanged) -``` - -### 1. Calibration each session: one button - -- About 20 A4 tags (AprilTag 36h11) on the floor; 3 of them on measured spots (the centre and - two corners, lined up with the field lines) that fix the field's axes. The rest go anywhere: - the solver finds where they are. -- A few tags on boxes at robot-top height (about 14 cm). A flat floor alone cannot tell a longer - lens from a higher camera, which is today's camera-height problem; tags off the floor - separate the two, and they calibrate exactly the plane the robot positions come from. -- Tags are told apart by ID. A small config file gives each tag's height and names the - anchors, for example tags 0–19 on the floor (z = 0), tags 20–24 on boxes (z = 0.143 m, - box plus paper, measured once with a ruler), tags 0–2 on the anchor spots. Only the - height is given: the solver finds each loose tag's x, y and rotation. The box height and - the printed tag size are the only things measured by hand. -- Press calibrate: one fit of all the numbers at once (bundle adjustment). Unknowns: - - per camera, about 11: focal length, image centre, 1–2 distortion terms, position - (x, y, height) and tilt; - - per loose tag, 3: x, y and rotation on its plane. - - Measurements: each tag's 4 corners in each image, about 200 coordinates per camera for 25 - tags. The fit moves every number until each tag, projected from its place through its - camera, lands on the corners seen. Both cameras see shared tags, so they agree with each - other by construction. Put a box or two where the cameras overlap, so they are tied at - robot height too. -- Why raised tags fix the camera height: a raised tag is nearer the camera, so it appears - pushed outward, away from the spot under the camera. A tag at height h, a distance d out, - looks like a floor point at about d × H / (H − h). With the camera at H = 3 m, a 14 cm box - 1.5 m out appears about 73 mm further out; were the camera 10 cm higher, about 2.5 mm less. - Corners are found to about 1 mm, so the fit pins the height down. With the camera model - known, a pixel's line of sight gives the field position at any height: robots at the tag's - height (about 14 cm), the ball at its centre (about 2 cm). Tags at a single height, all at - robot height for example, would leave the ball's height poorly fixed. -- The fit prints each tag's error (where its corners land against where they were seen), so - a tag set up wrongly, at a height the config doesn't say, stands out straight away. -- Because the camera model alone isn't trusted (assumption 2), fit a smooth correction map from - the residual error at the tags: one for robot-top height, one for ball height (about 21 mm). -- It ends by running the guided check itself and prints the error per camera. -- Expected accuracy: the field is about 3 m in roughly 1,300 pixels, 2–3 mm per pixel; tag - corners are found to a fraction of a pixel and averaged over hundreds, so a few mm. - -### 2. Watching for camera movement during the session - -A few tags stay just outside the field lines all session. Every few seconds the tool -re-estimates each camera's position from them, corrects for a small move and raises an alarm -for a large one (a bumped or sagging mount). This answers "something moved between 52 mm and -85 mm" from the test day. - -### 3. Robots: tags - -- One tag per robot top; a config file maps tag ID to team and robot ID. -- `cv2.aruco` has AprilTag 36h11 built in; each detection gives position and heading from the - tag's 4 corners. -- When a moving robot's tag is found but can't be decoded, tracking keeps its ID. -- Short exposure: motion blur is the main weakness of tags. - -### 4. Ball: colour, but the easy kind - -- Only inside the field mask that calibration gives, plus a margin: that alone would have - removed the test day's fake balls. -- Flat-field correction from an empty-field frame (the median over a few seconds), so the ball - looks the same colour in the corners as in the centre. -- Orange by hue, not brightness; blobs on a robot tag are ignored. - -### 5. Output: standard SSL packets - -The same `SSL_WrapperPacket` on the same multicast address, so `CameraCombiner`, the refiners -and everything above stay unchanged. While both run, send on a second port so the two can be -compared side by side on the same scene with `vision_check`. - -### A session, start to finish - -1. Set up the cameras; the program sets fixed exposure (about 2 ms, so moving tags don't - blur), gain and white balance, and timestamps each frame at capture. -2. Lay out the tags, press calibrate (about a minute), check the error it prints, and pick - up the floor tags, leaving the few just outside the field lines for the movement watch. -3. Play: per frame, robots from tags and the ball from colour inside the field mask, sent as - SSL packets. Calibration also outputs the field mask and the empty-field picture for - flat-field correction. - -### Code - -A handful of Python modules on OpenCV and numpy, roughly 1,000–1,500 lines: -- `capture` (one backend per camera type); -- `calibrate` (the hardest part); -- `robots`; -- `ball`; -- `send`; -- a config holding camera settings, tag heights and anchors, and the tag-to-robot map. - -### Practical - -- Python and OpenCV; move to C++ only if measured latency forces it. Tag detection at 60 fps is - fine with decimation. -- Runs on the vision laptop. FLIR cameras through PySpin (Spinnaker's Python API), webcams - through OpenCV directly. -- Roughly 2–4 weeks part-time to step 4 of the order below. The calibration tool is the hardest - part and the most valuable. - -## Experiments - -Run on recorded frames where possible, so they need no test-day time beyond the recording. - -### Experiment 1: does proper calibration fix the position error? - -- Checkerboard on A4, about 20 stills per camera, tilted, all over the image; OpenCV computes - focal length and distortion. -- Tags or checkerboards on known spots for each camera's position and height; feed the result - into ssl-vision. -- Rerun `tools/field/vision_check.py --guided ball` and compare with the 2026-10-22 baseline above. -- **Down to about 1 cm:** calibration was the main problem. Stay on ssl-vision with our - calibration tool (option 1), and assumption 2 is wrong. -- **Not down:** the error is elsewhere (colour, ssl-vision's simpler camera model), which - points to our own stack. - -### Experiment 2: are tags better than colour patterns? - -- An AprilTag (8–10 cm) taped on one robot; record both cameras while pushing it slowly across - the field, corners included. -- Offline, compare the tag detector with ssl-vision's pattern on the same frames: detection - rate, position and heading jitter, ID swaps, corners against the centre, moving against still. -- Whether tags are big enough in pixels depends on the camera resolution; this answers it. - -### Results - -None yet. Record each result here with its date, the recording it used and the numbers. - -## Plan now (team decision, 2026-10-25) - -The team chose the full in-house stack. The guided check by hand (`tools/field/vision_check.py --guided`) -took too long to run every session, and we have one ball, which rolls off its spot. So -experiments 1 and 2 no longer decide anything: their questions become pass marks below. Every -step is measured on recordings, so most of the work happens off test days. - -### Before the next test day (no hardware) - -- **Facts to collect:** - - the camera models, resolution, frame rate and interface (USB/V4L2 or FLIR Spinnaker); - - whether we can SSH into the vision laptop and run Python there. - - Resolution decides whether robot tags are big enough. A robot top fits a tag of about - 100 mm; at 2–3 mm per pixel that is 35–50 pixels, 4–5 pixels per tag cell, which is - marginal. Exposure decides motion blur: 1 m/s for 10 ms is 1 cm, about 4 pixels, so - exposure must be about 2 ms. -- **Vision scorecard** (`tools/vision_bench.py`, to build): replays `replays/field/*.log` - through our vision layer and gives one table: - - robot and ball jitter at rest; - - dropped frames; - - camera disagreement where the cameras overlap; - - how far rolling balls stray from a straight line; - - the spread of the IR-on ball offset (ball in the mouth); - - ball jumps, balls off the field, balls inside a robot, ID swaps. - - Its first run is the ssl-vision baseline from 2026-10-22 that every step below must beat. - Our own stack sends the same `SSL_WrapperPacket`s, so the same scorecard judges it. -- **Calibration solver, offline:** `cv2.aruco` AprilTag 36h11 detection, then a least-squares - fit of each camera's lens, position and tilt and of every loose tag's position (design 1). - It is tested on synthetic images rendered from a known camera, so it is right before it - meets a real one. -- **Print** about 20 A4 tags, 3 with crosshairs for the anchor spots (centre and two - corners), plus a few robot-top tags and boxes about 14 cm high for raised tags. - -### Next test day (about 30 minutes of vision) - -1. **Recorder:** a small script on the vision laptop that saves frames from both cameras to - disk, with ssl-vision stopped, since a camera opens for one program at a time. Needs the - facts above. -2. **Record:** - - the tag layout, still: calibration; - - one robot with a top tag driving a scripted path over the whole field: tag - detection while moving, blur and corners; - - the ball rolled across the field: ball detection and straight-line checks; - - the empty field: flat-field correction. - -### Then, offline on those recordings, each with a pass mark - -3. **Calibration from the tag frames.** Pass: - - the anchors land within 3 mm of their spots; - - the two cameras agree within 1 cm on shared tags; - - raised tags fit as well as floor tags. - - This answers experiment 1 for our own model. -4. **Robot tag detector, sending SSL packets** on a second port, replayed from the robot - recording. Pass: beats the ssl-vision baseline on the scorecard for jitter, dropouts and - ID swaps, corners included. This is experiment 2's question. -5. **Ball detector**, inside the field mask, after flat-field correction. Pass: - - no false balls on the empty field; - - the ball tracked while a robot moves it; - - straight-line error under 1 cm. -6. **Live on a test day**, side by side with ssl-vision, then retire ssl-vision on lab days. - Calibration and the movement watch (design 2) then run every session. - -The IR offset correction (`docs/sim_realism.md`, the IR finding) sits above either stack and -is judged by the same scorecard. It waits until our own calibration shows how much offset is -left. - -## Risks - -- Tags blur on fast robots, and may be too few pixels at the far corners. Experiment 2's - recordings show both early; the fixes are a shorter exposure or bigger tags. -- A lens that changes during a session (focus hunting) breaks the calibration mid-run; the - movement watch (design 2) is meant to catch it. -- Lab-only: the team still needs ssl-vision and patterns working for competitions, so the - patterns on the robots stay usable alongside the tags. - -## Open questions - -- Camera models, lenses and resolutions of both cameras (the RER webcam is 1280x960 MJPEG). -- Whether the cameras' focus and zoom are software controls (`v4l2-ctl`) that a startup script - can set, even if they can't be locked physically. -- SSH access to the vision laptop, and which ssl-vision commit it runs. diff --git a/docs/motion_planning_results.md b/docs/motion_planning_results.md deleted file mode 100644 index eb8ab23d..00000000 --- a/docs/motion_planning_results.md +++ /dev/null @@ -1,84 +0,0 @@ -# Motion-planning comparison report - -Generated: 2026-10-04T22:27:19.706334+00:00 -Git revision: `b4f8e508` -Schemes: fpp, dwa, trajsample -Repeats per cell: 1 - -A cell passes only if every repeat completed all moving robots within the scenario tolerance, without any observed robot overlap or exceeding the simulator's speed limit. Timing is the normal `MotionController.calculate()` call, excluding the configured warm-up calls. "Cmd jumps / dir changes / brakes" are black-box proxies computed from the commanded velocity itself (not observed post-physics robot state): see `_ControllerTimer` for exactly what each does and does not claim to measure -- none of them is a true replan count, since that is planner-internal state this tool cannot observe through the public controller interface. - -| Scenario | Scheme | Result | Pass rate | Time (s) | Path/direct | Worst clearance (m) | Stopped ratio | Mean / p95 controller (ms) | Cmd jumps / dir changes / brakes | -|---|---|---:|---:|---:|---:|---:|---:|---:|---:| -| direct | fpp | PASS | 100% | 4.17 | 0.98 | — | 0.008 | 0.14 / 0.19 | 0.0 / 0.0 / 0.0 | -| direct | dwa | PASS | 100% | 4.30 | 0.98 | — | 0.008 | 0.60 / 0.84 | 0.0 / 0.0 / 0.0 | -| direct | trajsample | PASS | 100% | 3.53 | 0.98 | — | 0.009 | 0.27 / 0.35 | 0.0 / 0.0 / 0.0 | -| static_slalom | fpp | PASS | 100% | 4.17 | 0.98 | 0.120 | 0.008 | 0.19 / 0.27 | 0.0 / 0.0 / 0.0 | -| static_slalom | dwa | FAIL | 0% | 5.47 | 0.52 | -0.000 | 0.006 | 0.66 / 0.91 | 0.0 / 0.0 / 0.0 | -| static_slalom | trajsample | PASS | 100% | 5.27 | 1.26 | 0.942 | 0.006 | 0.38 / 0.48 | 8.0 / 3.0 / 0.0 | -| crossing | fpp | PASS | 100% | 3.27 | 0.98 | 0.168 | 0.011 | 0.20 / 0.28 | 177.0 / 177.0 / 0.0 | -| crossing | dwa | FAIL | 0% | 3.07 | 0.89 | -0.001 | 0.011 | 0.66 / 1.65 | 124.0 / 73.0 / 0.0 | -| crossing | trajsample | PASS | 100% | 3.67 | 1.03 | 0.821 | 0.011 | 0.30 / 0.45 | 220.0 / 162.0 / 26.0 | -| crossing_oblique_45 | fpp | PASS | 100% | 3.20 | 0.98 | 0.426 | 0.011 | 0.14 / 0.23 | 153.0 / 29.0 / 0.0 | -| crossing_oblique_45 | dwa | FAIL | 0% | 2.85 | 0.84 | -0.000 | 0.012 | 0.63 / 0.89 | 77.0 / 0.0 / 0.0 | -| crossing_oblique_45 | trajsample | PASS | 100% | 4.83 | 1.18 | 0.858 | 0.009 | 0.29 / 0.39 | 279.0 / 44.0 / 66.0 | -| crossing_oblique_135 | fpp | PASS | 100% | 3.07 | 0.98 | 0.381 | 0.011 | 0.14 / 0.24 | 180.0 / 180.0 / 0.0 | -| crossing_oblique_135 | dwa | FAIL | 0% | 3.12 | 0.74 | -0.001 | 0.011 | 0.94 / 1.56 | 129.0 / 95.0 / 0.0 | -| crossing_oblique_135 | trajsample | PASS | 100% | 3.35 | 1.04 | 0.783 | 0.010 | 0.30 / 0.42 | 202.0 / 198.0 / 0.0 | -| crossing_offset | fpp | PASS | 100% | 3.07 | 0.97 | 0.845 | 0.011 | 0.13 / 0.19 | 171.0 / 171.0 / 0.0 | -| crossing_offset | dwa | PASS | 100% | 4.35 | 1.19 | 0.199 | 0.008 | 0.61 / 1.31 | 197.0 / 173.0 / 0.0 | -| crossing_offset | trajsample | PASS | 100% | 3.43 | 1.03 | 1.590 | 0.012 | 0.31 / 0.43 | 204.0 / 152.0 / 25.0 | -| crossing_steady_runner | fpp | PASS | 100% | 2.83 | 0.76 | 0.872 | 0.006 | 0.15 / 0.20 | 165.0 / 165.0 / 0.0 | -| crossing_steady_runner | dwa | FAIL | 0% | 2.50 | 0.59 | -0.002 | 0.010 | 0.51 / 1.49 | 143.0 / 92.0 / 6.0 | -| crossing_steady_runner | trajsample | PASS | 100% | 2.40 | 0.76 | 0.497 | 0.010 | 0.27 / 0.35 | 139.0 / 139.0 / 0.0 | -| overtaking | fpp | PASS | 100% | 3.58 | 0.70 | 0.034 | 0.008 | 0.16 / 0.35 | 165.0 / 40.0 / 0.0 | -| overtaking | dwa | FAIL | 0% | 2.28 | 0.31 | -0.000 | 0.015 | 0.31 / 0.72 | 47.0 / 0.0 / 0.0 | -| overtaking | trajsample | PASS | 100% | 3.92 | 0.79 | 0.820 | 0.009 | 0.28 / 0.38 | 226.0 / 31.0 / 0.0 | -| grid_intersection | fpp | PASS | 100% | 3.20 | 0.98 | 0.151 | 0.011 | 0.14 / 0.30 | 357.0 / 150.0 / 0.0 | -| grid_intersection | dwa | FAIL | 0% | 2.70 | 0.78 | -0.001 | 0.012 | 0.61 / 0.86 | 214.0 / 74.0 / 0.0 | -| grid_intersection | trajsample | PASS | 100% | 4.67 | 1.36 | 0.484 | 0.008 | 0.31 / 0.51 | 838.0 / 515.0 / 11.0 | -| mirror_swap | fpp | PASS | 100% | 4.12 | 0.98 | 0.056 | 0.010 | 0.13 / 0.29 | 748.0 / 245.0 / 0.0 | -| mirror_swap | dwa | FAIL | 0% | 6.35 | 1.13 | -0.002 | 0.008 | 0.87 / 2.09 | 2114.0 / 1108.0 / 5.0 | -| mirror_swap | trajsample | PASS | 100% | 10.62 | 1.51 | 0.009 | 0.011 | 0.44 / 0.90 | 5224.0 / 2421.0 / 502.0 | -| narrow_passage | fpp | PASS | 100% | 3.42 | 0.99 | 0.040 | 0.010 | 0.18 / 0.32 | 0.0 / 0.0 / 0.0 | -| narrow_passage | dwa | FAIL | 0% | 3.27 | 0.49 | -0.001 | 0.010 | 0.58 / 0.82 | 0.0 / 0.0 / 0.0 | -| narrow_passage | trajsample | PASS | 100% | 4.28 | 1.45 | 0.240 | 0.008 | 0.30 / 0.41 | 4.0 / 1.0 / 0.0 | -| head_on_swap | fpp | PASS | 100% | 2.53 | 0.95 | 0.045 | 0.013 | 0.20 / 0.39 | 150.0 / 150.0 / 0.0 | -| head_on_swap | dwa | PASS | 100% | 2.83 | 0.97 | 0.350 | 0.012 | 0.61 / 1.42 | 164.0 / 164.0 / 0.0 | -| head_on_swap | trajsample | PASS | 100% | 3.12 | 1.16 | 1.039 | 0.013 | 0.27 / 0.37 | 183.0 / 133.0 / 25.0 | -| field_boundary_corner | fpp | PASS | 100% | 3.73 | 0.97 | — | 0.009 | 0.16 / 0.21 | 0.0 / 0.0 / 0.0 | -| field_boundary_corner | dwa | PASS | 100% | 3.80 | 0.97 | — | 0.009 | 0.51 / 0.69 | 0.0 / 0.0 / 0.0 | -| field_boundary_corner | trajsample | PASS | 100% | 3.17 | 0.98 | — | 0.011 | 0.23 / 0.31 | 2.0 / 0.0 / 0.0 | -| defense_area_boundary | fpp | PASS | 100% | 2.93 | 0.92 | — | 0.011 | 0.12 / 0.15 | 0.0 / 0.0 / 0.0 | -| defense_area_boundary | dwa | PASS | 100% | 2.45 | 0.92 | — | 0.014 | 0.53 / 0.74 | 0.0 / 0.0 / 0.0 | -| defense_area_boundary | trajsample | PASS | 100% | 1.97 | 0.93 | — | 0.017 | 0.23 / 0.30 | 0.0 / 0.0 / 0.0 | -| interception | fpp | PASS | 100% | 2.22 | 0.54 | 0.647 | 0.015 | 0.11 / 0.15 | 121.0 / 121.0 / 0.0 | -| interception | dwa | PASS | 100% | 2.10 | 0.57 | 0.519 | 0.016 | 0.29 / 0.70 | 119.0 / 119.0 / 0.0 | -| interception | trajsample | PASS | 100% | 1.85 | 0.55 | 0.599 | 0.018 | 0.24 / 0.32 | 107.0 / 105.0 / 0.0 | -| sudden_obstacle | fpp | PASS | 100% | 3.18 | 0.96 | 0.676 | 0.021 | 0.13 / 0.17 | 0.0 / 0.0 / 0.0 | -| sudden_obstacle | dwa | PASS | 100% | 3.52 | 0.97 | 0.055 | 0.019 | 0.56 / 0.94 | 0.0 / 0.0 / 0.0 | -| sudden_obstacle | trajsample | PASS | 100% | 2.77 | 0.96 | 0.696 | 0.012 | 0.27 / 0.34 | 2.0 / 0.0 / 1.0 | -| disturbance_recovery | fpp | PASS | 100% | 4.27 | 2.52 | — | 0.008 | 0.11 / 0.15 | 0.0 / 0.0 / 0.0 | -| disturbance_recovery | dwa | PASS | 100% | 4.08 | 2.08 | — | 0.008 | 0.50 / 0.76 | 0.0 / 0.0 / 0.0 | -| disturbance_recovery | trajsample | PASS | 100% | 4.00 | 2.52 | — | 0.021 | 0.23 / 0.27 | 8.0 / 3.0 / 0.0 | -| start_inside_obstacle | fpp | PASS | 100% | 1.62 | 0.92 | -0.080 | 0.000 | 0.14 / 0.20 | 0.0 / 0.0 / 0.0 | -| start_inside_obstacle | dwa | PASS | 100% | 1.10 | 0.93 | -0.080 | 0.000 | 0.55 / 0.81 | 0.0 / 0.0 / 0.0 | -| start_inside_obstacle | trajsample | PASS | 100% | 0.95 | 0.92 | -0.080 | 0.000 | 0.29 / 0.35 | 0.0 / 0.0 / 0.0 | -| jittering_target | fpp | PASS | 100% | 4.17 | 0.98 | — | 0.008 | 0.12 / 0.15 | 0.0 / 0.0 / 0.0 | -| jittering_target | dwa | PASS | 100% | 4.30 | 0.98 | — | 0.008 | 0.49 / 0.66 | 0.0 / 0.0 / 0.0 | -| jittering_target | trajsample | PASS | 100% | 3.53 | 0.98 | — | 0.009 | 0.23 / 0.30 | 0.0 / 0.0 / 0.0 | - -## Failures - -- `static_slalom` / `dwa` repeat 1: collision; reached 0/1, collisions 1. -- `crossing` / `dwa` repeat 1: collision; reached 0/2, collisions 1. -- `crossing_oblique_45` / `dwa` repeat 1: collision; reached 0/2, collisions 1. -- `crossing_oblique_135` / `dwa` repeat 1: collision; reached 0/2, collisions 1. -- `crossing_steady_runner` / `dwa` repeat 1: collision; reached 1/2, collisions 1. -- `overtaking` / `dwa` repeat 1: collision; reached 1/2, collisions 1. -- `grid_intersection` / `dwa` repeat 1: collision; reached 0/4, collisions 1. -- `mirror_swap` / `dwa` repeat 1: collision; reached 9/12, collisions 1. -- `narrow_passage` / `dwa` repeat 1: collision; reached 0/1, collisions 1. - -## Interpretation - -PASS/FAIL is a universal safety-and-completion gate, not a ranking. Compare passing planners using completion time, path ratio, clearance, stopped ratio, and controller latency together; no single metric is an overall score. diff --git a/docs/pipeline_method.md b/docs/pipeline_method.md deleted file mode 100644 index 7ff0c305..00000000 --- a/docs/pipeline_method.md +++ /dev/null @@ -1,75 +0,0 @@ -# Pipeline method - -![One tick of StrategyRunner](img/pipeline/one_tick.png) - -Drawn by `docs/img/pipeline/make_one_tick.py`; rerun it when a box's name changes. The same tick as a -Mermaid diagram with every module path: [architecture.md](architecture.md#one-tick). - -How vision, robot and referee data become one `Game` state, and how one tick turns that -state into robot commands. Everything below runs inside `StrategyRunner` -(`utama_core/run/strategy_runner.py`). - -## Data in - -The referee is one of three sources (`run/referee_source.py`): none, the official -GameController over the network, or `CustomReferee`, which runs in the same process and is what -rsim matches and tournaments use (`docs/referee.md`). - -**Problem.** Combining new data with prior knowledge (e.g. a Kalman filter) kept bloating -`GameFrame` with new functions, and access to past and current state wasn't uniform. - -**Solution.** `Game` holds our best estimate of the true current state and is updated by a -chain of **refiners**: each takes the current game frame and one kind of new data and returns -an updated frame. Later refiners see earlier updates: `RobotInfoRefiner` takes has-ball from our -robots' IR, or infers it from the refined positions for a robot whose IR isn't trusted, and -takes the enemy's from their responses when the sim provides them (both teams in rsim). -Friendly and enemy robots expose the same fields, estimated from different sources. - -- **Multiple cameras** are combined inside `PositionRefiner`. -- **Falling behind:** receivers fill one-slot buffers (`deque(maxlen=1)`), and the main loop - runs at a fixed rate and takes only the latest vision and referee data each tick. -- `GameFrame` is immutable; receivers (network) are separate from refiners, which makes - testing easier. -- `GameHistory` (`utama_core/entities/game/game_history.py`) stores past frames. -- Before the first tick, `GameGater` waits until the frames hold the expected robots and ball. - -The uniform `GameTimeline`/`Predictions` interface (pluggable per-property predictors) from -earlier drafts was never built; predictions are ad hoc per call site. - -### Inside PositionRefiner - -Camera combining and the Kalman filters (`data_processing/refiners/position.py`, -`data_processing/refiners/filters/kalman.py`). Smoothing and vanished-robot imputation are -separate switches; both run on the same per-robot filters. - -```mermaid -flowchart TD - cams["Raw vision, one RawVisionData per camera"] - comb["CameraCombiner.combine_cameras
_avg_robots per robot id, _combine_balls_by_proximity,
_bounds_check against VisionBounds"] - vd["VisionData
combined robots and balls"] - sw{"smooth_positions?"} - kf["KalmanFilter per robot, KalmanFilterBall
filters/kalman.py"] - imp{"impute_vanished?"} - vanish["_include_vanished_robots
Kalman predict for robots missing from vision"] - game["Game, GameFrame
entities/game/game.py"] - - cams --> comb --> vd --> sw - sw -->|yes| kf --> imp - sw -->|no| imp - imp -->|yes| vanish --> game - imp -->|no| game -``` - -## One tick - -`CustomReferee` steps first (when in-process), then each side refines its frame, the replay -writer and `MatchStats` record it, and `AbstractStrategy.step` runs the strategy layer: -`Strategy.tick` (referee overrides, tactic slots), tactics, skills, then the `MotionController` -(fpp, dwa or trajsample) turns targets into one `RobotCommand` per robot for rsim, grSim or the -real robots. - -In rsim both teams run in one `StrategyRunner`: each side has its own refiners, strategy and -motion controller and steps in turn, alternating which goes first. `MatchStats` and the replay -writer follow one side's frames. The dashboard's vision stream renders the same frames. -`docs/STRATEGY_DEVELOPMENT.md` covers the strategy layer; `docs/motion_planning_comparison.md` -the motion controllers. diff --git a/docs/pitch_zones.md b/docs/pitch_zones.md deleted file mode 100644 index 86763c46..00000000 --- a/docs/pitch_zones.md +++ /dev/null @@ -1,71 +0,0 @@ -# Pitch zones - -Names for the parts of the pitch, so that people, agents, docs and code mean the same place. -Every zone is defined from one team's point of view: "defensive" is near that team's own goal, -"left" is on its left as it faces the goal it attacks. Measurements are for the standard 9 × 6 m -field (`STANDARD_FIELD_DIMS`). - -![Pitch zones](img/pitch_zones/pitch_zones.png) - -(Drawn by `docs/img/pitch_zones/make_pitch_zones.py`.) - -## Along the pitch: thirds - -| Name | Where | In code | -|---|---|---| -| **Defensive third** | the 3 m nearest our own goal line | `ball_zone()` returns `"own"`; `MatchStats` robot zone time `"defensive"` | -| **Middle third** | 3 to 6 m from our goal line, either side of halfway | `"mid"` in both | -| **Attacking third** | the 3 m nearest the goal we attack | `ball_zone()` returns `"final"`; `MatchStats` `"attacking"`, `attacking_third_entries` | - -Each third is a third of the pitch length, measured from our own goal line toward the goal we -attack. On the standard field the boundaries are at |x| = 1.5 m. Say "defensive" and -"attacking" rather than "own" and "final"; the code's `own`/`final` are older spellings of the -same thirds. - -**Our half / their half**: either side of the halfway line. - -## Across the pitch: wings and centre - -| Name | Where | -|---|---| -| **Left wing** | the 2 m strip along the touch line on our left as we attack | -| **Centre** | the 2 m strip down the middle, as wide as the box, so it runs straight at both goals | -| **Right wing** | the 2 m strip along the touch line on our right | - -The centre is |y| ≤ 1 m (the box's half width). Left and right turn with the team: for a team -attacking toward +x, its left wing is y > 1 m; for a team attacking toward −x (`my_team_is_right`), -its left wing is y < −1 m. So the two teams' left wings are on opposite touch lines. - -No tactic uses the lanes yet; one that needs them should use these boundaries. - -**Ball side / far side**: the wing the ball is on, and the wing opposite it. When the ball is in -the centre, neither applies. **Weak side** is not the same thing: in `SwitchOfPlayTactic` -(`_weak_side`) it is the half of the pitch, split at y = 0, with fewer opponents in it, wherever -the ball is. - -## Cells - -A third and a strip together name one of nine cells: "attacking left wing", "defensive centre". - -## Areas the rules define - -- **The box**: the defense area, 1 m deep and 2 m wide in front of each goal. At most one - defender (the goalkeeper) may be inside its own box, and attackers may not enter the - opponent's (`referee/rules/defense_area_rule.py`). "Our box" and "their box" are from - the team's point of view. Code calls it the defense area (`FieldDimensions.right_defense_area`). -- **The goal**: 1 m wide. -- **The centre circle**: 0.5 m radius; it matters at kickoffs. - -## Words with a fixed meaning - -- **Danger**: the opponent has possession with the ball in our defensive third in live play. - Possession is the team's: a pass between two opponents, or their shot, stays theirs until we - touch the ball. The signal - `danger_s` counts the seconds of it (`analysis/chances.py`; see [signals.md](signals.md)). - Don't use "danger" for anything else. -- **Clearance condition**: when `ClearBallTactic` clears (`clear_ball.in_danger`): the ball within - 2.6 m of our goal line and an opponent within 1.2 m of it. It is narrower than danger; the function's - name predates this doc. -- **Entry**: the ball crossing into a team's attacking third, whoever touched it last - (`attacking_third_entries`). Once in, it has to come back 0.3 m behind the line before it can - count again. diff --git a/docs/referee_design_decisions.md b/docs/referee_design_decisions.md deleted file mode 100644 index 3a3c9610..00000000 --- a/docs/referee_design_decisions.md +++ /dev/null @@ -1,91 +0,0 @@ -# Custom Referee — Design Decisions - -Decisions from the audit of `CustomReferee` against the SSL rulebook. Numbers are stable. - -## Resolved - -1. **`human` profile keeps `STOP` after goals** (2026-03-31) — every auto-advance is off in - `human`, so an operator advances each stoppage. `simulation` auto-progresses. -2. **`PrepareKickoffTheirsStep` enforces own half** (2026-03-13) — after radial clearance, each - robot's x is clamped to our half. -3. **Unknown last touch no longer defaults to yellow** — `infer_last_touch_team` - (`rules/last_touch.py`) attributes colour-blind, and `OutOfBoundsRule` leaves the restart - unresolved rather than favouring a colour. -4. **`KeepOutRule`'s violation count doesn't carry over** — `CustomReferee.step()` calls - `rule.reset()` on every command transition. -5. **`BallPlacementTheirsStep` actively clears** (2026-03-13) — robots within 0.55m of the ball - are pushed radially outward, as in `DirectFreeTheirsStep`. Line-segment clearance (ball to - target) is deferred. -6. **`GoalRule` only fires in live play** — no change needed: the ball isn't in play during a - stoppage, so a goal then doesn't count. -7. **Penalty positioning, partial** (2026-03-13) — non-kickers go to the touch line - (y = ±3.0m) behind the mark. Fully off-field placement is deferred until the simulator - supports it. Penalties stay disabled in the built-in profiles. - -## Foul to restart - -Which violation gives which restart, and to whom, as the code does it (`_handle_goal` and -`_handle_foul` in `state_machine.py`). A stopping violation always goes through STOP first; when it -carries a spot, the team that gets the restart places the ball there before the restart. - -```mermaid -flowchart LR - goal["Goal
rules/goal_rule.py"] - ft["Free-kick fouls
out_of_bounds_rule.py (incl. aimless kick), double_touch_rule.py,
keeper_held_ball_rule.py, excessive_dribbling_rule.py,
pushing_rule.py (one side at fault), penalty_time_limit_rule.py"] - pen["Extra defender touches ball in own box
defense_area_rule.py"] - fs["Pushing with similar force, no progress
pushing_rule.py, no_progress_rule.py"] - stop2["2nd Defense Area Stoppage foul
defense_area_stoppage_rule.py"] - nons["Non-stopping: ball speed, crashing, keep-out, attacker in box,
robot stop speed, placement interference, 1st stoppage foul"] - o1["Kick-off for the team that conceded
BALL_PLACEMENT at centre, then PREPARE_KICKOFF"] - o2["Free kick for the other team
BALL_PLACEMENT at spot, then DIRECT_FREE
out of bounds with no known last touch: STOP only"] - o3["Penalty for the attacking team, no foul counter
BALL_PLACEMENT at penalty mark, then PREPARE_PENALTY"] - o4["FORCE_START where the ball lies
no placement, sim teleports the ball"] - o5["HALT; the interrupted restart is queued again on resume"] - o6["Foul counter and cards only
command unchanged"] - - goal -- "goal" --> o1 - goal -- "scorer fouled in last 2 s: invalid_goal" --> o2 - ft --> o2 - pen --> o3 - fs --> o4 - stop2 --> o5 - nons --> o6 -``` - -## Rulebook audit (2026-09-28, Division B) - -Checked against the [SSL rulebook](https://robocup-ssl.github.io/ssl-rules/sslrules.html). -"Sim" rows are deliberate deviations kept for the simulator; the reason is given. - -| Rule | Rulebook | Ours before | Action | -|---|---|---|---| -| Defender Too Close To Ball (§8.4.3) | 0.5 m during an opponent kick-off or free kick; non-stopping; resets the kick timer; 2 s grace per team; no automatic sanction during STOP | Stopped play and re-awarded the restart, also during penalties | Fixed: non-stopping, 2 s re-raise, off during penalties. Only the first foul of a free kick resets its clock: our cards never remove a robot, so a defender parked inside 0.5 m held a free kick for the rest of a match | -| Keeper during a penalty (§5.3.5) | Keeper on the goal line; others 1 m behind the ball; a positioning breach is a human call (§8.3.4), not Defender Too Close | `KeepOutRule` checked every defender, keeper included | Fixed by the row above: `KeepOutRule` no longer runs during penalties, so the keeper question is moot. Our non-kickers now walk round the ball to stand 1 m behind it | -| Attacker Touched Ball In Opponent Defense Area (§8.4.2) | Touching the ball while partly or fully inside; non-stopping | Presence (centre inside) stopped play with a free kick | Fixed: needs a touch, counts partial overlap (`ROBOT_RADIUS`), non-stopping, 2 s re-raise | -| Ball Speed (§8.4.2) | Over 6.5 m/s in 3D; non-stopping | Stopped play, free kick to the other team | Fixed: non-stopping. Gap: still measured on ground (x, y) speed, not 3D | -| Goal validity (§7) | No goal if the scorer committed a non-stopping foul in the last 2 s, or the ball went above 0.15 m | Any ball in the goal scored | Fixed: foul in the last 2 s turns the goal into a goal kick. Gap: ball height is not checked | -| No Progress In Game (§8.1) | 10 s without progress while both teams may play: stop, then force start | Missing | Fixed: `NoProgressRule`; STOP now continues to a queued FORCE_START once robots clear. The clock starts once the ball is in play (after a kickoff/penalty `NORMAL_START` that means 0.05 m of movement or the 10 s auto-in-play; it was firing 10 s after an unmoved restart, 226 of 422 false alarms in real matches). Not counted while the ball is inside either defense area (0 of 506 real calls there) | -| Penalty kick (§5.3.5) | Still in play after 10 s: stopped, no goal, goal kick for the defenders | The normal start turned into open play | Fixed: `PenaltyTimeLimitRule`. Not implemented: the keeper's 90° deflection and ball-moving-backwards endings | -| Ball in play after a free kick (§5.4) | In play 10 s after the free kick command | `DIRECT_FREE_*` waited for the kicker forever | Fixed: `FORCE_START` after 10 s (clock restarted once, by the first Defender Too Close foul) | -| Ball in play after a kick-off (§5.4) | In play 10 s after the kick-off | `NORMAL_START` → `FORCE_START` after 10 s if the ball hasn't moved | Already correct | -| Free-kick position (§5.3.3) | ≥ 0.2 m from all lines and ≥ 1 m from either defense area, else the closest valid spot | 0.65 m from a defense area (planner margin) | Fixed: 1 m. Sim: the spot is pushed out along x only (a square corner), not to the Euclidean closest point, and lines aren't re-clamped for in-field positions | -| Throw-in, goal kick, corner kick (§6.1.1, §6.2.1–2) | Throw-in 0.2 m in from the touch line; goal kick 1 m / 0.2 m; corner kick 0.2 m / 0.2 m, in the corner | Ball placed where it crossed, 0.25 m infield, 0.5 m on both axes near a corner, then kept 1 m off the box | Fixed: over a goal line, a corner kick 0.5 m from both lines or a goal kick 1 m from the goal line, 0.5 m from the touch line, the same spot as every other goal kick (`RefereeGeometry.goal_kick_position`; a disallowed goal or a penalty out of time put it 0.2 m from the touch line) (placing it where it crossed made a free kick 2 m in front of goal: 521 kicks, 150 goals in one round-robin). Sim: 0.5 m, not 0.2 m, from the touch line, and a throw-in stays 0.25 m in; 0.2 m from two lines at once let a drifting ball go straight back out (the corner-loop fix in `OutOfBoundsRule`) | -| Aimless kick (§6.2.3, Div B) | A ball touched by a robot that then crosses the halfway line and the opponent's goal line outside the goal, touching no other robot: free kick for the opponent from where it was kicked | Not implemented: a goal kick in the opponent's corner, so a blind clearance cost nothing (28% of goal kicks led to one at the other end within seconds, tournament_20261005_170958) | Fixed: `OutOfBoundsRule` keeps where the ball was last touched in this spell of play (`last_touch.touching_team`), and restarts from there when the touch was on the far side of the halfway line, strictly (a kick-off from the line itself is not aimless); the spot is kept 0.25 m inside the lines and 1 m off the defense areas like any free kick. `out_of_bounds.aimless_kick`, on in both profiles: we play Division B | -| Free kick stages (§5.3.3) | One free-kick command; the kick puts the ball in play | One free-kick command; `DirectFreeOursStep` takes the kick and the ball moving 0.05 m from where it was when the command began makes it `NORMAL_START` (live play, and `KeepOutRule` stops). Fixed 2026-11-10: the referee also started play 2 s after the kicker came near, before any kick, and the tactics then stood over an unstruck ball. Before, the referee missed the kick and charged a defender the ball rolled onto with keep_out (`free_kick_robot_drives_in_at_start`). Auto-advance profiles only (`direct_free_to_normal`); a human-run referee issues `NORMAL_START` itself | -| Ball placement (§5.2) | The team places the ball | With a simulator controller, `StrategyRunner` teleports the ball to `designated_position` on entry to `BALL_PLACEMENT_*`, then the restart itself follows (only a `STOP` queued for `FORCE_START`, no progress, force-starts) | Sim: kept, so matches don't wait on physical placement. Real mode still places | -| Multiple Defenders (§8.4.1) | A non-keeper entirely inside its own area touching the ball: penalty | More than `max_defenders` (1) with centres inside, one touching | Fixed: the goalkeeper's own touch is exempt. The keeper id comes from the referee data on the frame (`GameFrame.referee`, the team info's `goalkeeper`); with no referee data attached every touch counts. The occupancy proxy (`max_defenders`) is kept | -| Double Touch (§8.2) | Kicker may not touch again before another robot; free kick from the ball position | Same | Already correct | -| Crashing | §8.4.2 | Any contact with closing speeds within 0.3 m/s of each other was a "both at fault" crash, including robots at rest against each other (6694 fouls in 231 matches; 30 of 97 goals then voided by the goal-validity rule) | Fixed: a crash needs > 1.5 m/s projected on the line between the robots; the 0.3 m/s band then compares the robots' own speeds, as TIGERs AutoReferee's `BotCollisionDetector` does. Its 0.1 s brake lookahead is modelled too (each robot's speed less 0.4 m/s, floored at 0, where TIGERs reverses it): without it a round-robin had 226 crashes to TIGERs' 8 over the same frames | -| Pushing, Keeper Held Ball, Excessive Dribbling, Robot Stop Speed, Too Close To Opponent Defense Area, Ball Placement Interference | §8.3–8.4 | Audited in `434ab29` | Already correct; not re-checked beyond thresholds (10 s, 1 m, 1.5 m/s, 0.2 m, 0.5 m, 2 s grace) | -| Match timing (Game Stages) | Two halves of 300 s of playing time with a 300 s half-time; the timer "is paused whenever no team is allowed to manipulate the ball" (stop, halt, kick-off and penalty preparation, ball placement); each half starts with a kick-off; the coin-toss winner chooses the goal it attacks in the first half | The clock was sim time since the stage began, running through every stoppage; nothing ended a half, so it stopped at 0 at 300 s of sim time and stayed there (score-aware strategies, via `is_late_in_half`, played their last-minute mode from 240 s on) | Fixed: the clock runs only under `NORMAL_START`, `FORCE_START` and free kicks; with `auto_advance.end_of_half` (on in `simulation`, off in `human`) the first half ends in a `STOP`, the ball goes to the centre and the team that didn't kick off the first half kicks off the second; the second half ends in `POST_GAME`, after which the referee ignores violations. At half-time the teams change ends (`blue_team_on_positive_half` swaps; `StrategyRunner` follows it). Sim: half-time takes 0 s | -| Boundary Crossing (§8.4.1) | Kicking the ball over the field boundary | Not implemented | Gap: rsim has no boundary wall to kick over | - -## Open - -8. **`TeamInfo` should be a frozen dataclass.** It is mutable, and `RefereeRefiner` stores - `RefereeData` records that referenced the live objects, so a later `increment_score()` - rewrote history and made `__eq__` drop new records. Workaround (2026-04-07): - `GameStateMachine._generate_referee_data()` snapshots with `copy.copy`. Long-term: make it - `@dataclass(frozen=True)` and replace mutations (`increment_score()`, - `parse_referee_packet()`, ...) with `dataclasses.replace()`, including the network referee - path. Deferred because it touches that path. diff --git a/docs/referee_gui.md b/docs/referee_gui.md deleted file mode 100644 index 33bd72ef..00000000 --- a/docs/referee_gui.md +++ /dev/null @@ -1,85 +0,0 @@ -# Custom Referee Operator GUI - -The browser operator panel for `CustomReferee` is the dashboard's referee tab -(`utama_core/dashboard/views/referee.py`). Attach it with: - -```python -server = attach_dashboard() # utama_core.dashboard -referee_view.attach(server, referee, profile) # utama_core.dashboard.views.referee -``` - -`examples/demo_referee_gui_rsim.py` does this with RSim, the `human` profile and -`weaver` (constants `PROFILE`, `N_ROBOTS`, `MY_TEAM_IS_YELLOW`, `MY_TEAM_IS_RIGHT` at -the top of the file): - -```bash -pixi run python examples/demo_referee_gui_rsim.py # then open http://localhost:8080 -``` - -The page shows the score, current/next command, stage and time left, `designated_position`, the -field, the active profile and an event log; a button issues each command. - -## Field check (camera runs) - -With vision from a camera (real robots or grSim) the Live tab also shows the field check -(`utama_core/run/field_check.py`), one row per question, red / amber / green: - -| Row | Fails (red) when | Warns (amber) when | -|---|---|---| -| Camera | no vision packet for 0.5 s | | -| Field size | ssl-vision's geometry differs from `full_field_dims` | no geometry packet yet | -| ` ` (each robot we drive) | never seen, lost by vision 0.5 s, or more than 0.3 m outside `field_bounds` | | -| ` radio` (real only) | it answered on the radio, then stopped | it has not answered yet (the firmware may send no feedback) | -| ` ` (any other) | | seen inside `field_bounds` but not configured: our planners cannot see it, often a wrong ID | -| Ball | | not seen, or outside `field_bounds` | - -Before it gets that far, the runner keeps our robots inside `field_bounds` on camera runs -(`utama_core/run/field_fence.py`): each robot's speed towards an edge is capped to what it can -stop from before the line, whatever tactic sent the command, so a robot chasing a ball out of the -camera's area stops at the line. The planners' walls at `field_bounds` are only obstacles to plan -around, and did not stop it (0.5–0.9 m out in grSim before the fence). - -Only the red and amber rows are listed; the green ones fold into an "N ok" line that opens on -click. On real robots any red row forces `HALT`, whatever the command and whether or not the page is -open; the red banner says why. Pressing Force Start while a row is red halts again at once, so -the check is also the pre-start gate. The field is drawn as ssl-vision sees it (+x to the right), -with everything outside `field_bounds` dimmed, so a half-field test shows which half the runner -expects. Space halts; nothing on the keyboard starts the robots. The Kickoff and Free Kick -buttons are hidden when the profile has no rule that sets up a restart (goal detection only). - -## Strategy panel - -A script can let the page change what each side plays, or restart it, without restarting the -run (`utama_core/dashboard/views/strategy.py`): - -```python -strategy_view.attach(server, runner, - choices={"my": {"lead": make_lead, "press": make_press}}, # name -> builds a fresh AbstractStrategy - running={"my": "lead"}) -``` - -The Live tab then lists the choices per side with a Run button; Run on the one running restarts -it. `StrategyRunner.replace_strategy` takes the new strategy at the next tick and only while -halted, so the page refuses otherwise. `tools/field/shooting_drill.py` offers its attacker -and defender tactics this way. - -## Commands and what robots do - -| Button | Command | Use | Robots | -|---|---|---|---| -| Halt | `HALT` | Emergency / unsafe | Zero velocity | -| Stop | `STOP` | Between incidents, pre-match | ≤1.5 m/s, stay ≥0.5m from the ball | -| Normal Start | `NORMAL_START` | Restart formation is in position | Live play | -| Force Start | `FORCE_START` | Stalled play | Live play from the ball's current position (a tactic barrier reset, see `tactic_model_design_decisions.md` §4) | -| Kickoff Y/B | `PREPARE_KICKOFF_*` | Half start, after a goal | Kicker to centre, others to own half | -| Free Kick Y/B | `DIRECT_FREE_*` | Foul by the other team | Kicker to ball, opponents ≥0.5m | -| Penalty Y/B *(advanced)* | `PREPARE_PENALTY_*` | Manual override | Kicker at mark, others behind the line | -| Ball Placement Y/B *(advanced)* | `BALL_PLACEMENT_*` | Manual placement | One robot carries ball to `designated_position` | - -Typical sequences: `Halt → Stop → Kickoff Yellow → Normal Start` to start a half; -`Stop → Free Kick → Normal Start` for a manual free kick. With `human`, nothing auto-advances — -after a goal the referee stays in `STOP` until the operator acts. - -For a physical field, keep every `auto_advance` flag false so robots never start moving until -the operator presses a button. Profile keys, auto-advance triggers and making a custom profile: -`referee.md`. diff --git a/docs/referee_integration.md b/docs/referee_integration.md deleted file mode 100644 index 116b0849..00000000 --- a/docs/referee_integration.md +++ /dev/null @@ -1,62 +0,0 @@ -# Referee Integration - -How referee commands reach robots, and what each command requires. The original py_trees -integration is gone (BT removed in `087ee4b`, `960662c`, `48affd6`); the current mechanism is -`RefereeOverride` (`utama_core/engine/referee_override.py`, design: §13 of -`tactic_model_design_decisions.md`) driving the `*Step` classes in -`utama_core/referee/actions.py`. For the in-process referee itself see -`referee.md`. - -## Data path - -``` -AutoReferee UDP 224.5.23.1:10003 → RefereeMessageReceiver ─┐ (Real/grSim with the official GC) -CustomReferee.step() ──────────────────────────────────────┴→ ref_buffer (deque maxlen=1) - → StrategyRunner._run_step → RefereeRefiner.refine(game_frame, referee_data) - → game.referee → RefereeOverride (restart/stop commands) or the Strategy (live play) -``` - -In WSL, multicast UDP needs `networkingMode=mirrored` in `.wslconfig`. - -`RefereeData` carries `referee_command`, `stage`, `stage_time_left`, `blue_team`/`yellow_team` -(`TeamInfo`: score, cards, goalkeeper id, fouls, `can_place_ball`), `designated_position`, -`blue_team_on_positive_half`, `next_command`, `current_action_time_remaining`, -`source_identifier`, plus `game_events`, `match_type`, `status_message` — the last three are -excluded from `__eq__` so they don't trigger spurious re-records in `RefereeRefiner`. - -## Required behaviour per command ([SSL rulebook](https://robocup-ssl.github.io/ssl-rules/sslrules.html)) - -| Command | Our robots must | -|---|---| -| `HALT` | Zero velocity (2s braking grace). Highest priority. | -| `STOP` | ≤1.5 m/s, ≥0.5m from ball, ≥0.2m from opponent defense area, no ball contact. | -| `TIMEOUT_*` | Nothing forced; handled as `STOP`. | -| `PREPARE_KICKOFF` ours / theirs | All but the kicker in own half outside the 0.5m centre circle; kicker approaches, no touch. Theirs: everyone in own half outside the circle. | -| `PREPARE_PENALTY` ours / theirs | Kicker to the mark, no touch; others ≥0.4m behind the mark line. Theirs: keeper on own goal line, others ≥0.4m behind the mark. | -| `DIRECT_FREE` ours / theirs | Kicker approaches and may shoot after the ball moves ≥0.05m. Theirs: all ≥0.5m from ball, full speed allowed. | -| `BALL_PLACEMENT` ours / theirs | One robot places the ball at `designated_position` (±0.15m); others ≥0.5m. If `can_place_ball` is False, behave as `STOP`. Theirs: ≥0.5m from ball and target. | -| `NORMAL_START`, `FORCE_START` | Live play — no override; the Strategy runs. | - -Yellow/blue variants are resolved to ours/theirs at tick time against -`game.my_team_is_yellow`, so nothing depends on team colour at construction time. - -## Pre-rewrite baseline (BT priority tree) - -Code comments cite this: the old tree put a referee `Selector` as the first child of every -strategy's root, one `Sequence` per command in priority order — `HALT`, `STOP`, -`TIMEOUT_YELLOW|BLUE` (dispatched to `StopStep`, same as `STOP`), ball placement, kickoff, -penalty, direct free — each `CheckRefereeCommand(...)` → `*Step`, falling through to the -strategy tree on `NORMAL_START`/`FORCE_START`. `RefereeOverride` keeps that command→Step -mapping as a plain class. - -## Open - -- **Ball placement before a free kick.** The rulebook sequence after ball-out is - `STOP → BALL_PLACEMENT_* → DIRECT_FREE_* → NORMAL_START`; `OutOfBoundsRule` still queues - `DIRECT_FREE_*` directly (in sim the ball is teleported instead). Depends on reliable - `BallPlacementOursStep` carrying. -- **Placement carry mechanics.** Single-robot dribble tends to push rather than carry; options - are a dedicated slow "get-behind-ball" approach or the two-robot technique most SSL teams use. -- **Pre-positioning from `next_command`** during `STOP` — an optimisation, not a compliance need. -- **Operator GUI "suggested next step"** based on the current command, so an operator decides - only *when* to advance, not *what*. diff --git a/docs/roadmap.md b/docs/roadmap.md deleted file mode 100644 index e650adb7..00000000 --- a/docs/roadmap.md +++ /dev/null @@ -1,286 +0,0 @@ -# Roadmap / TODO - -Larger open workstreams. Each entry: what, why, status, pointer. Investigation history lives -in git log (`git log --grep=`) and commit messages, not here — when an item is -resolved, replace it with a one-line pointer under "Done". Open items are numbered in order: -a resolved one leaves the list and the rest move up, so a number is not a stable name — cite the -entry by its title, not its number. - -## Done (one-line pointers) - -- **More tactics (first pass)** — `press_and_contain`, `give_and_go`, 5 example configs — `dd73bbc`. -- **BT/py_trees removal** — `AbstractStrategy` rewritten kernel-native — `087ee4b`, `960662c`, `48affd6`. -- **Tournament scoreless-draw debugging** — rSim kick direction, `FastPathPlanner`, `SwitchOfPlayTactic`, `DefenseTactic` foul loop, `TwoDPID` braking — `27fd36f`, `e11094a`, `78fce73`. -- **Motion-controller discontinuity handling** — PID auto-reset on orientation target jump — `91100ff`, `87cf250`, `036077c`. -- **CustomReferee gaps** — double touch, ball speed, full-episode `reset()`, `set_debug_status` rename (see `docs/referee.md`). -- **Strategy-computation perf pass** — ~3x end-to-end — `3086337`, `0cf1e17`, `679e8cd`, `b79b863`, `b98cd29`, `4493002`. -- **Goalkeeper overshoot** — `a4df59e`, `ba59c9e`. -- **Stuck-match root causes** — `PressAndContainTactic` loose ball, `GiveAndGoTactic` hop timeout — `d6b3ff1`. -- **Defense-area retrieval stall** — `7a8e717`; trajsample equivalent in `TrajectorySamplingPlanner._enemy_defense_area_retrieval_exempt`. -- **Dashboard rebuild** — Live/Replay/Tournament views — `c3c389e`. The Tournament tab became the Strategies tab on 2026-11-12 (catalog, verdicts, signals, matches; no standings). -- **Touchline avoidance + placement-into-defense-area stall** — `3513c59`. -- **SSL §8.3/8.4 audit + 7 referee rules** — `434ab29`. -- **Restart formations read real goalkeeper id; `referee_overrides` hook** — `7cd1f61`. -- **`FORCE_START` out of a `STOP`/`HALT` pause is a barrier reset** (ball may have moved) — `46e962b`. -- **`robosim` stdout corrupting the JSON pipe** — `f613411`. -- **`score_pass_setup` pass scoring** and **GiveAndGo permanent ball-lock** — `dd14f79`. -- **Restart safety bugs (testing_gaps #7, #8)** — `ccb172b`. -- **Ball-contest deadlock** — treated as a `PushingRule` no-fault case, not a planner fix — `a3f3795`. -- **`custom_referee` missing-`designated_position` audit** — `2a8c03f`. -- **trajsample liveness fixes** — escape grace `2e53f3e`; target-jitter tolerance `5183ed1`; brake scales planned velocity; stale intermediate target; restart-scoped priority blocking `9757814`; two-segment candidate instability `4b701ae`; teleport-settle speed + 10s ball-placement timeout `43d41af`; four `COMMITTED_FROZEN` causes `70cb5c6`; `DefenseTactic` carrier clearing; `DirectFreeOursStep`/`BallPlacementOursStep` sticky kicker/placer. -- **Sumatra-fidelity audit, top 3 findings** — acceptor leniency, escaping-grace clearance, full-window priority re-check. -- **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). -- **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). -- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion at the last release (a frozen `.strategy` file) in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded sim noise (the simulated world and robots from `world.json` and `robots.json`). Candidate and reference meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 better, <= 0.2 worse, undecided after 6 rounds (`analysis/ratings.py`); the match results store (`replays/match_results/`) never replays a fixture it already has, and `tools/evaluation/explain.py` draws where the robots stand. Until 2026-11-12 it used `opponents.json` with held-out opponents and a ledger (`replays/eval/ledger.jsonl`). The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. -- **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. -- **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`test_fastpathplanner_corner.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. -- **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. -- **Shared hysteresis helper** — `Sticky` in `geometry/tolerance.py` (`fd87c7f6`), now used by `PassAndShootTactic`'s passer choice, `ClearBallTactic`'s target choice and `PressAndContainTactic`'s presser choice instead of per-site margins — `0ce4e2a2`. (`pickers.friendly_closer_to_ball` keeps its own tick-count hysteresis.) - -## Open - -1. **Stalls — latest full strict round-robin (2026-10-17, `replays/tournament_20261017_151052/`):** - 4 of 66 matches stalled, and 97% of 3232 restarts reached NORMAL_START. The kick-off that - waited the referee's 15 s cap is fixed (`1731e904`); the three committed robots frozen about - 10 s (`COMMITTED_FROZEN` in `stall_incidents`) are not yet diagnosed. Confirm any stall fix - against the full round-robin: small-subset re-runs have repeatedly overstated fixes. **Not built:** a CI job running the - strict seeded stall gate — `.github/workflows/ci.yml` runs the test suite only. - -2. **`BangBang1D` defects** — required-overshoot and `v0 > v_max` cases produce discontinuous - trajectories, pinned as 78 strict xfails on the enumerated defect seeds - (`utama_core/tests/motion_planning/implementation/test_bang_bang_edge_cases.py`; - `test_trajsampling_correctness.py` pins the same defect). A correct fix (`b26a550`) was - reverted (`90d068c`) because physically correct trajectories let mutually blocked robots - stall at kickoff (231/231). trajsample has since gained Sumatra's all-candidates-collide - fallback (`a1b8bdd6`), so re-applying the fix means validating it against that; there is - still no first-class yield/escape result for the blocked state. - -3. **trajsample architecture follow-ups** (from a TIGERs 2024 comparison; validate each with - `tools/motion_planning_benchmark.py`, see `docs/motion_planning_comparison.md`): - - `Trajectory2D` drops transverse velocity at trajectory start (`bang_bang.py`); every - trajectory ends at zero velocity. Want a concrete replay failure before starting. - - Priority: a ball carrier now outranks off-ball robots (`a1b8bdd6`), but the remaining - tie-break is fixed robot id, which can make the wrong robot yield; still no first-class - "yield" result. - - Collision sampling is adaptive-timestep, not swept. (The other two parts of this entry are - done: intermediate targets are a deterministic symmetric fan with a <=90 deg hemisphere - clamp and last-direction stiction, and a committed trajectory is re-validated over a 0.5 s - window.) - - Last: a jerk-limited generator (e.g. Ruckig). - -4. **Referee testing gaps** — see `docs/testing_gaps.md`. Open there: #4 mypy/pyright adoption - (on hold). #6 stands as written for real matches, but our sim does reach the rule: a corner - placement that trapped a defender inside the keep-out circle is pinned as a passing moment - (`utama_core/tests/moments/placement_in_corner_traps_defender.json`, from - `tournament_20261017_002337`). - -5. **Cross-tactic ball convergence** — nothing checks whether another assigned robot is already - converging on the same ball; the only guard is `DecoyOverloadTactic`'s - `_teammate_already_has_ball()` (`utama_core/tactics/decoy_and_overload.py:99`). Found twice - (`a59a8e5`, `0e510a0`/`ae6a6f3`); a third case (two tactics' robots converging on one ball) - was diagnosed in `25888cce` and closed as a planner-level matter rather than by generalizing. - Revisit only if it stalls a match again. - -6. **grsim as a CI/tournament environment.** Unverified whether grsim installs on a GitHub - runner or can run faster than real time headless. CI hardcodes `--ignore-glob "**/*grsim*"` - (`ci.yml:41,43`). - -7. **Match timeline in the dashboard.** Built 2026-10-21 (`dashboard/static/timeline.js`): the - swimlanes of `tools/debug/match_timeline.py` (referee band, each robot's tactic, possession, distance - to the ball, events) under the Replay tab's controls, following the cursor, click or drag to - seek; and in the Live tab, the last minutes up to now. Switch ticks, shots and a possession - band (each situation's side) as in the tool. The Replay side panel's Play list replaces the raw - event and intention logs: one row per situation (`goal_sources.situations`: a restart going live - or a side winning the ball), with its third, length, shots and how it ended (the stoppage's - reason, or who won the ball and how); the raw intention log stays, folded. The slow analysis is - kept beside the replay (`.timeline.json`) and ticks are sent as columns of whole numbers - (a match: 4 MB gzipped), so a replay serves in ~1.5 s. Not yet: enemy lanes (no intentions are - recorded for the opponent). - -8. **More tactics from real football vocabulary** (formations, set plays, pressing schemes) - rather than variations on existing ones. No new `Tactic` class has been added since this - entry: the recent work refactors existing ones (`ShadowAndMarkTactic` now uses the `man_mark` - skill, `ClearBallTactic`/`PressAndContainTactic`/`DecoyOverloadTactic` gained thresholds and - exits). - -9. **Ball-holding contract for every `Tactic`.** Most fouls fixed on 2026-09-24 - (`ShadowAndMark`, `PressAndContain`, `DecoyAndOverload` lure, keeper) were one pattern: a - tactic written for its main job with no branch for "my robot now has the ball", so it held - or carried until `ExcessiveDribbling`/`KeeperHeldBall` fired or both teams froze on the - ball. Idea: one parametrized test over all tactics that puts the ball on each assigned - robot in a few standard spots and checks the tactic releases it. `test_all_tactics.py` now - covers the generic properties (declared tag, `is_committed()` bool, a command for every - assigned robot) but not the ball-holding contract itself. Decisions still open: - - *Depth:* single-tick check (first command is kick/pass, turn-to-kick, or a tracked - carry) vs a short kinematic rollout that proves release before the carry limit and the - keeper hold time. Leaning single-tick first; rollout only if something slips past. - - *What counts as a valid response per tactic:* pass vs clear vs carry, and who decides - (the tactic, or a shared default like `skills/kick_upfield.py`). - - *Where the guarantee lives:* per-tactic branches (current approach), or an engine-level - safety net that takes over a robot holding the ball too long — the latter is a new - kernel concept, so it needs a concrete case the per-tactic approach can't handle. - - *Setup for role-based tactics* (passer/receiver, committed slots): which robot gets the - ball, and in which phase. - - *Rule constants:* tactics still copy limits (`CARRY_LIMIT_M` in - `geometry/pass_and_score_geometry.py`) instead of importing them from the referee rules; - decide whether to share one source. - Expect each failing tactic to be a real fix with its own regression test. - -10. **Real-robot profiles and calibration.** Each physical robot differs (top speed, - dribbler grip, kicker strength) in ways hardware can't fix soon; software should - correct what it can and use the rest. One robot measured so far (2026-10-27); nothing per - robot is built yet: this entry is the plan, with the to-do list below. - - *Known now:* the kicker is fixed power and will stay so for now (hardware team, - 2026-10-09), so the sim gets no variable-kick option. Real robots were capped at - `MAX_VEL=1` m/s as a safety limit until 2026-10-28; now 1.5 m/s and 6 rad/s - (`config/robot_params.py`). The radio packet has 4-bit kick and chip power fields that - we always send as full (`real_robot_controller.py`, `kicker_byte`): ask whether the - firmware reads them. - - *What exists:* `StrategyRunner`'s `{yellow,blue}_vision_to_cmd_mapping` (vision ID to - firmware command ID, real mode only) is the robot roster. It is validated (one entry - per expected robot, integers, no command ID used by both teams on a shared transmitter, - every observed vision ID covered: `game_gater.py`) and filters vision to those IDs. - `{yellow,blue}_robot_profiles` (`RobotProfile`: kicker, dribbler, ball sensor working - or not, 2026-10-21) say what each robot can do; a robot without a kicker pushes the - ball, one without a dribbler carries it slowly, one without a ball sensor infers - possession from vision (`robot_profile.py`). These are on/off, not measured. There is no checked-in roster - file: whoever writes the run script passes the mapping. The command ID is fixed in the - robot's firmware, so it is the key a profile would use. - - *What can differ per robot:* driving (top speed, acceleration and braking, turning, - drift from a weaker motor, command delay, battery sag over a match); the ball (dribbler - grip while driving and turning, catching a pass, kick speed and its spread, kick - direction error, kicker recharge time, chip distance and height, ball sensor); other - (radio packet loss, breakdowns and substitutions). - - *Agreed:* correct in the real-robot controller what can be corrected (speed error, - drift, delay), capping the team to its weakest robot where needed, so strategies see - identical robots. Expose to tactics only what can't be corrected (kick strength, grip, - catching). Tactics ask about abilities ("who dribbles best", "where does this robot's - kick stop"), never name a robot ID. Profiles are measured, fixed for a run and out of - reach of strategy branches, so they are not something a search tunes. - - *Open, not yet:* one profile per match day vs updated while playing; kick-to-kick - spread in the sim (more realistic, but noisier round-robins). - - *Measuring, built 2026-10-21:* every camera run records an SSL game log (raw vision, - referee, radio bytes both ways: `GameLogWriter`); `tools/field/shooting_drill.py - --calibrate` plays fixed moves (`tactics/scripted_moves.py`), and `tools/field/robot_calibration.py` - measures loop delay, speed gain, acceleration, vision noise and kick speed from any such log. - Checked on a synthetic robot (delay within 10 ms, acceleration within 15 %; turn - acceleration only roughly, its ramp lasts a few frames) and on grSim; not yet on a real robot. - Not yet done: the numbers feed nothing (the sim's latency, the controller), and drift, - dribbling, passes and chips are not measured. First real robot 2026-10-27: delay 79 ms, - turn gain 1.09, sideways acceleration ~1.8 against ~5 m/s² forward. 2026-10-28: - `pixi run calibrate` (`tools/field/calibrate_robot.py`) runs it from the terminal, no - dashboard: prompts for each set-up, prints each move, DONE, then the analysis and a - `.calibration.json`; it now also holds, turns and drives with the ball and kicks 3 times - (kick speed and direction off the heading, where the ball sits, ball sensor share, kept or lost). - - *Calibration to-do (user, 2026-10-28; revisit in later sessions):* - 1. **Full robot profile**: one checked-in file per robot (keyed by command ID), written by - `pixi run calibrate`, read by the controller, planner limits, kick aim, vision filter, - sim noise and offline replay. Covers everything below plus the setup errors in - [`field_log_replay.md`](field_log_replay.md) (tag yaw and centre offset, kicker offset). - Done 2026-10-29: `pixi run calibrate` writes `utama_core/config/robots/radio_.json` - (tag offset → vision, kick bend and bias → aim, carry caps → `move()`), every example - reads it, `--check` compares it with the committed one on the field. Tag heading is not - measured: the kick bias, fitted against the tag's heading, takes it in. - 2. **Driving**: speed gain and acceleration per axis *and diagonally* (forward, sideways, - 45°): the top speed and acceleration a robot actually holds in each direction, not one - `MAX_ACCELERATION`; braking; drift over 3 m; turn rate and turn gain. - 3. **Kicking**: ten kicks per robot: speed, direction offset and its spread, roll distance, - recharge time; chips once used. Built 2026-10-29: `pixi run calibrate` fetches the ball - and kicks 10 times, and fits the kick bend (`robot_calibration.kick_bend`). - 4. **Dribbling**: hold while turning and driving at rising speed until the ball is lost: - the fastest turn and drive that keep it. Decides whether a placer may grab a ball - from any side and turn with it, instead of going round it first (step 5). Built - 2026-10-29: the carry ladder in `pixi run calibrate` (`tools/field/ball_trials.py`); not yet - run on a real robot, so `CARRY_SPEED` 0.3 / `CARRY_TURN` 1.0 stand. - 5. **Receiving and grabbing**: the approach speed at which a robot still traps a ball, - driving onto a still ball and receiving a rolling one (passes at a few speeds); whether - it can turn on the spot smoothly with the ball at the end of an approach. - 6. **All robots at once**: several `--robot` in one run, the driving part in parallel lanes - 0.8 m apart (same moves at the same time, so no collisions), the ball part one robot at - a time. The analysis already handles every robot in a log. - 7. **Use the numbers** (each a small change): sideways and diagonal acceleration limits in - the planner, turn gain in the controller, delay prediction (plan from where the robot - will be 79 ms on), kick aim by the kicker offset, Kalman measurement noise from vision - noise, `contact_grace_s` from the sensor share. Sim-side use (latency, kick offsets, - motion limits in `sim_noise`) replays the match results store: batch with a forced rerun. - Robot-robot avoidance needs it most: on 2026-10-27 two robots met head-on at 1 m/s each - (their placer running to the ball, ours clearing away from it along the same line) and - touched; each planner saw the other, but 79 ms late and braking sideways at ~1.8 m/s². - *Delay prediction done 2026-10-28:* `move()` plans from our robots' pose - `RobotParams.CONTROL_LATENCY_S` (real: 0.079 s) ahead (`motion_planning/common/pose_ahead.py`). - Checked in rsim given the calibrated robot (delay, gains and per-axis acceleration - applied in the sim by a scratch harness): driving while turning, off-line drift 30 → 7 cm; - motion benchmark collisions with the delay alone 7 → 3 (24 → 26 of 29 pass). With the - sideways acceleration added it is still 24 of 29 with or without prediction. - *Sideways acceleration, 2026-10-28:* `RobotParams.MAX_SIDEWAYS_ACCELERATION` (real 1.8), - used by `trajsample` only; seeded, it barely changes `trajsample` (13 → 12 of 145 failed). - With the calibrated robot `trajsample` fails 12 of 145 seeded runs against `fpp`'s 27, - slower in crowds ([motion_planning_comparison.md](motion_planning_comparison.md#on-the-calibrated-robot-2026-10-28)). - *Open:* whether to run the real robots on `trajsample`: compare both in the same field - drills once 3+ robots share the field; the sim evaluation stays on `fpp`. The drill - (2026-10-29): `examples/planner_ab.py`, two robots swapping ends head on and crossing, - in blocks alternating the planners; about 40 legs per planner. Not yet run on the field. - Field logs' close calls and their referee state: `analysis/close_calls.py`. - - *Calibration routine (the full plan):* per robot, at full battery on the - competition carpet: commanded vs measured speed at a few speeds, acceleration and - braking from vision, straight-line drift over 3 m, turn rate; ten kicks (speed from - vision, direction error, roll distance) and ten chips; recharge time between kicks; - a dribble course at increasing speed until the ball is lost; ten passes received. - Output: one record per command ID. - - *Before measurements:* code that assumes kick or speed numbers should derive them from - `RobotParams` (e.g. `ClearBallTactic` assumes a 4.5 m clearance where a fixed-power kick - rolls ~17 m), so measured values change one file. No per-robot profile type until - measurements show robots differ enough to matter (to-do 1 above: build it once two - robots' calibrations disagree by more than two runs of one robot do). - -11. **Vision filter for real cameras.** Found 2026-10-09 reviewing `data_processing/`; rsim - (noise off) never exercises any of it. Needs logged SSL-Vision data from the real field - to tune, so it waits on the hardware team like "Real-robot profiles and calibration". - - *Velocity:* `KalmanFilter` tracks position only; `VelocityRefiner` differentiates - consecutive filtered positions and that velocity feeds the next prediction. With the - current noise settings (process noise twice the measurement noise) the steady-state - gain is about 0.73, so positions are barely smoothed. An estimate: 1 cm vision noise - gives roughly +/-0.5 m/s velocity jitter at 60 Hz. The usual SSL design is one filter - with position and velocity in its state (constant velocity for robots; for the ball, - rolling friction, plus a chip/flight model later). The `VelocityRefiner` note that - smoothing velocity "broke control loops" was measured in noiseless rsim. #144 only - added a fast path to that differentiator (`a1b8bdd6`); the substance is unchanged. - - *Lost objects:* a vanished ball or robot is predicted at its last velocity forever, - with no friction and no give-up time. The ball vanishes most often under a dribbling - robot, where it should stay at the dribbler. Vanished robots relate to substitutions, - issue #107. - - *Detections:* `CameraCombiner` ignores SSL-Vision confidence, so a low-confidence - false detection with a robot's ID is averaged into the real one (`_avg_robots` sums - confidence into a variable it never uses). - - *Noise settings:* 1 cm and 5 deg match rsim's noise generator, not the real cameras. - - *First step once logs exist:* replay a recorded vision log through `PositionRefiner` - and compare velocity jitter and lag against a constant-velocity filter, before - changing anything. - -12. **Sim realism (plan, 2026-10-14):** [`sim_realism.md`](sim_realism.md). Phase 0 (the - scorecard and the analysis in-repo) and Phase 1 (league ranges from the 2025-26 official - logs) are done; Phase 2's knobs are built — `SimNoise` seeds latency, kick speed and - direction spread, two-phase ball friction, per-robot acceleration limits and vision - noise/dropouts per match, and is wired through `run_match`, `evaluate.py` and the reference - `world.json` (its values differ from the v3 ranges the 2026-10-17 round-robin played as `v3_seed2`). A sensitivity sweep - was run (results in `sim_realism.md`). Still open: the - scorecard's remaining gaps (sim keepers save about twice as many good chances, and sim - shots almost never go wide), the 2022-24 held-out check, choosing which knobs become the - evaluation default, and using that noise in a round-robin by default (`round_robin.py` - still needs an explicit `--sim-noise`). P1, the real-data value model, is fitted (passes 1-3, - 2026-10-16/17, in `~/dev/ssl/xg-analysis/value/`; AUC about 0.8 on held-out years) but does - not yet rank strategies better than goals, so it explains results rather than saving matches - (`sim_realism.md`, "P1"). P2 (structured strategy search scored by it) is not started. - -13. **In-house vision for lab days (team decision 2026-10-25):** [`in_house_vision.md`](in_house_vision.md). - The 2026-10-22 test day lost most of its time to ssl-vision: cameras 5–8.5 cm apart and 3–9 cm off known spots, colour - calibration slow and noisy at the edges, fake balls, no way to lock focus or zoom. The plan: - per-session tag calibration of both cameras, tags on robots, an orange ball inside the field - mask, sent as standard SSL packets so our stack is unchanged. Lab only; competitions keep - the league's ssl-vision. The team chose to build it (2026-10-25). Next: a vision scorecard on the - recorded logs (the ssl-vision baseline to beat), an offline tag calibration solver, then - recording camera frames on the next test day; nothing is built yet. - -14. **Deferred, revisit only when forced** (minimalism): - - `@pytest.mark.engine` marker for kernel tests — wait for real CI bottleneck data. - - `TickContext` responsibilities beyond `motion_controller`/`match_log`. diff --git a/docs/scheduling_math_model.md b/docs/scheduling_math_model.md deleted file mode 100644 index abb71720..00000000 --- a/docs/scheduling_math_model.md +++ /dev/null @@ -1,72 +0,0 @@ -# A mathematical model of tactic scheduling - -Companion to [`tactic_model_design_decisions.md`](tactic_model_design_decisions.md) §15-§16. It -places our `Partitioner`s and Sumatra's role assignment in one design space, and records — without -building — how the *allocation* stage could be opened up later. Nothing here reopens §15's boolean -eligibility filter (`applicable()`). - -## 1. The general object - -State $s \in S$ is a `Game` snapshot. A **partition** $\pi : F \to \mathcal{T}$ assigns each free -outfield robot to at most one applicable tactic slot; $\Pi(s)$ is the feasible set (arity, -`applicable()`, slots pinned by `is_committed()`). A scheduling policy is a map $s \mapsto \pi \in -\Pi(s)$. Since reassigning a robot mid-action has a cost, the real objective is over a trajectory: - -$$\max_{\pi_1,\dots,\pi_T} \sum_t V(s_t, \pi_t) \;-\; \lambda \cdot \text{switch}(\pi_{t-1}, \pi_t)$$ - -## 2. Our design - -A hand-written `Partitioner` emits $\pi = p(s)$ directly: $V$ collapses to an indicator on one -candidate, and $p$ is piecewise-constant over hand-drawn regions of $S$ (e.g. "ball closer to us"). -Switching cost is bang-bang: `is_committed()` gives $\lambda = \infty$ for pinned robots, $0$ for -free ones. Deliberate: fully auditable, zero hyperparameters, and no self-reported score to -distrust. - -## 3. Sumatra (TIGERs, `Athena`/`Metis`) - -Traced from source (`RoleAssigner`, `ADesiredBotCalc`, `Metis.register()` order): per-role -calculators claim robots from a shared `desiredBotMap` in a fixed order — **lexicographic -optimization** (defense fully first, then offense on the remainder, ...). Needs no switching -margin because a deterministic claim doesn't thrash. Inherent weakness: a 9/10 defender who is an -8/10 attacker always goes to defense, however close the call. - -## 4. Opening allocation later: filter, then fitness vector - -Both optional, both behind the unchanged `Partitioner` interface (`Strategy` can't tell -implementations apart, and `_validate_partition` checks all of them the same way): - -- **Layer A — partition-level heuristic filter** before allocation (e.g. "never leave the keeper's - third empty"). Same kind of asserted domain knowledge a `Partitioner` already encodes, reusable. -- **Layer B — optional `Tactic.fitness(game, candidate_robots) -> dict[str, float]`** (default - `{}`), per named criterion, with a swappable collapse $\Phi$: (a) weighted sum — asserts an - exchange rate between unlike criteria; (b) pure lexicographic — Sumatra's mechanism, - generalized to criteria; (c) **lexicographic with tolerance** (recommended) — criterion $i$ - dominates only outside a band $\epsilon_i$, otherwise falls through. $\epsilon\to0$ recovers - (b); wide $\epsilon$ approaches (a). "Close enough not to matter" is easier to pick than an - exchange rate. -- A `Partitioner` may be hybrid: hand-code where auditability matters (defense), delegate the - remaining free robots to a fitness partitioner. - -Limits: still an approximation of $V$; a named per-criterion score is more falsifiable than a -scalar but a tactic can still misreport one criterion, so Layer B stays optional and -config-scoped; no learning loop is implied. Build neither layer until a concrete `Partitioner` -strains to express a real trade-off. - -## 5. Keep switching cost bang-bang - -A per-robot `interrupt_cost()` was considered and rejected. A wrong switch cost fails silently in -both directions — too low gives flapping (visible only in aggregate traces), too high gives stuck -assignments (no visible anomaly, just worse play) — so it is a worse hand-design ask than $V$. $V$ -(memoryless) and switch (depends on the previous partition) also stay separate terms rather than -one vector. If flapping is ever observed, reach first for a single global **minimum dwell time** -per slot ($k=0$ reproduces today). - -## 6. The far end: learned $Q_\theta(s_t, \pi_{t-1}, \pi_t)$ - -Once both terms are fit end-to-end rather than hand-set, merging them into one action-value -function is natural; Layer B's fitness vector is a hand-designed approximation to it. Adopting it -would need: shaped reward (reward design relocates, it doesn't disappear); far more rollouts, with -simulator fidelity gating feasibility (a policy can learn to exploit rsim dribble bugs); -enumeration over the small feasible $\Pi(s_t)$ (the one easy part); and `is_committed()` kept as a -hard mask, never delegated to the network. Conceptual only — start only if §4/§5's auditable moves -plateau. diff --git a/docs/setup_external.md b/docs/setup_external.md deleted file mode 100644 index 42f84072..00000000 --- a/docs/setup_external.md +++ /dev/null @@ -1,56 +0,0 @@ -# External setup: grSim, GameController, AutoReferee, SSL Vision - -None of this is needed for everyday work: rsim and the in-process -[`CustomReferee`](referee.md) run everything headless with no external process, and -behave the same across rsim, grSim and real mode. Set these up only to run against grSim, the -official competition software, or real robots. - -## grSim - -1. Go to the [grSim repo](https://github.com/RoboCup-SSL/grSim) and follow its - [installation steps](https://github.com/RoboCup-SSL/grSim/blob/master/INSTALL.md). -2. Change the configuration to the values highlighted below: - - ![grsim_setup](../assets/images/grsim_setup.png) - -3. To run it, execute `./bin/grSim` in the cloned repo. - -## AutoReferee and the GameController - -1. Make sure `grSim` is set up and can be called from a terminal. -2. `git clone` the [AutoReferee repo](https://github.com/TIGERs-Mannheim/AutoReferee) into a - folder named `AutoReferee/` in the repository root. -3. Change `DIV_A` to `DIV_B` in `AutoReferee/config/moduli/moduli.xml`: - - ```xml - - ROBOCUP - DIV_B - - ``` - -4. Get the latest [compiled game controller](https://github.com/RoboCup-SSL/ssl-game-controller/releases/), - rename it to `ssl-game-controller`, and save it in a `ssl-game-controller/` directory in the - repository root. - -Both directories are gitignored. - -### Starting the external test environment - -Only needed to test against the official referee software; the in-process `CustomReferee` -needs none of this. With grSim, the GameController and AutoReferee set up, start each in its -own terminal from the repository root: - -```bash -grSim -cd ssl-game-controller && ./ssl-game-controller -cd AutoReferee && ./gradlew run -``` - -Then run your own strategy. The GameController's web UI is at http://localhost:8081/#/match -(this repo's dashboard is :8080). - -## SSL Vision and the radio for real robots - -The whole procedure (vision laptop, WSL networking and USB, radio, the checks before a robot -moves) is in [real_robot_setup.md](real_robot_setup.md). diff --git a/docs/sim_realism.md b/docs/sim_realism.md deleted file mode 100644 index 9d9f0265..00000000 --- a/docs/sim_realism.md +++ /dev/null @@ -1,579 +0,0 @@ -# Sim realism: closing the gap between rsim and real matches - -Status: plan, 2026-10-14 (priorities added 2026-10-16; Phases 0-2 are built, 2026-10-16/17). -Nothing below is built yet unless it says so. - -*Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names -(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). - -## Where this leads - -The end goal is **search over the structured strategy space**: tactics, their parameters, and -the scheduler (partitioner) that combines them. Candidates are scored with a **dense value -signal** instead of goals alone. Three pieces, in priority order: - -| Priority | Work | Why this order | -|---|---|---| -| P0 | Sim realism, Phases 0–3 below: scorecard, league ranges, seeded per-match physics draws, calibration | Search finds whatever wins in the sim. If the sim rewards an unrealistic detail (a perfect keeper, kicks that never miss), stronger search exploits it harder. The seeded draws are also the controlled-noise framework every later evaluation uses | -| P1 | [Value model fitted on real logs](#p1-value-model-on-real-data) | A model trained on sim outcomes learns the sim's errors. Fitted on real matches, it values situations the way real matches do. Safe to apply to sim strategies only once the sim varies over realistic ranges | -| P2 | [Structured search](#p2-structured-strategy-search) scored by the value model in the randomized sim | Needs both of the above | - -A "novel" winner from search looks exactly like a sim exploit until checked. Every one gets -the per-strategy scorecard: an edge from parts the sim gets right (positioning, chance -creation) is kept; an edge from parts it gets wrong is suspect. - -## Why - -Strategies are developed and ranked in rsim. A ranking is only useful if a strategy that wins -in the sim would also win on a real field. That needs two things: - -- **Sim physics in the right range.** The sim must not reward behaviour that only works - because of an unrealistic detail, such as a perfect keeper or a perfectly accurate kick. -- **Robustness.** Real parameters drift (floor friction, kick speed as the capacitor drains, - dribbler wear, one robot slower than another). A strategy must win across that drift, not - at one tuned value. - -The goal is therefore not a perfect replica of one real robot. It is a sim whose behaviour -matches real matches on the measures that decide goals, and that varies its physics over the -ranges real robots vary over. - -We assume no measurements of our own robots for the next month. Ranges come from the official -match logs of other teams (see [Official logs](#what-the-official-logs-can-and-cannot-give)), -and are replaced by our own measurements once hardware tests are possible. - -## What we found (2026-10-14) - -Real: 54 official Division B matches from 2025–2026 (`tools/realism/convert_ssl_log.py`). Sim: the -baseline round-robin `tournament_20261014_144456` (66 matches). An expected-goals (xG) model -was fitted on real shots. On held-out matches it ranks shots with AUC 0.82 and its predicted -rates agree with observed ones. - -Goal attempts per live minute, their real xG and finishing (goals ÷ xG) each sit inside the -real 95% interval (pooled sim ÷ real: ×1.09, ×1.12, ×1.11). That agreement hides two -differences that cancel: - -| Shots of equal quality (xG band) | Real | Sim | -|---|---|---| -| Saved by the keeper, all shots | 17% | 39% | -| Saved by the keeper, xG > 0.35 | 20% | 52% | -| Wide or off the post | 22% | 6% | -| Goal rate, xG < 0.05 | 2% | 14% | -| Goal rate, xG > 0.35 | 53% | 35% | - -Sim keepers save far more good chances; sim shooters almost never miss. - -Other differences: - -- **Ball slow-down:** the sim ball keeps 57% of its speed by 1 m from goal; real balls keep 67%. -- **Kick speed:** every sim kick is 4.75 m/s; real kicks range from 3.9 to 5.5 m/s (interquartile). -- **Keeper position:** the sim keeper always stands on the goal line, 0.09 m deep; real keepers stand about 0.2 m out. -- **Shot count:** with passes and clearances counted, sim teams make 1.8× more goalward kicks than real teams. -- **Live time:** real matches have about 7.4 live minutes; the sim has about 9.1. Together with the slightly higher per-minute rates above, this is why sim matches have more goals per match. - -Lesson: **never judge realism by goal totals.** They can match for the wrong reasons. -Compare the components, as in the [scorecard](#the-realism-scorecard). - -## How one rsim tick is built - -Where the sim noise is applied in one tick: commands go down through the seeded command-side -noise, and the observations come back through the seeded vision noise. The C++ physics is the -fork in `vendor/rSim` ([FORK_NOTES.md](../vendor/rSim/FORK_NOTES.md) covers the build). - -![One rsim tick: the command-side noise, the C++ physics and the vision-side noise between the strategy layer and the physics](img/sim_realism/rsim_tick.png) - -Drawn by `docs/img/sim_realism/make_rsim_tick.py`; rerun it when a name in it changes. - -## Parameters - -Ordered by how much each one is likely to change match outcomes. - -**Between** means the value differs per robot or per match (one robot's top speed, a field's -friction). **Within** means kick-to-kick noise for the same robot. - -| Parameter | Why it matters | From official logs? | rsim today | -|---|---|---|---| -| Sensing-to-action latency (vision, decision, radio, motor response) | Likeliest cause of the keeper gap | Only as other teams' total reaction time: from a kick to their keeper accelerating; for our robots, `tools/field/robot_calibration.py` on a recorded field test (command sent to motion seen) | None: commands act on the next tick | -| Ball rolling deceleration (and the switch from sliding to rolling) | Pass and shot timing; keeper reaction time | Yes: fit free-rolling segments, per match (venue carpet) | Fixed in the C++ physics (`vendor/rSim`) | -| Kick speed: between and within | How much time the keeper has; pass weight | Yes: peak ball speed after each kick, per team | Fixed | -| Kick direction error | Wide rate (6% vs 22%) | Partly: shot miss distance, pass error relative to the receiver | None: exact | -| Robot top speed, acceleration, braking, turn rate | Who reaches the ball first | Yes: from the tracker, per robot | One limit for all robots (2 m/s for evaluation) | -| Vision noise and dropped frames (ball especially, also when blocked) | Every decision; keeper tracking | Yes from raw vision packets in the logs; the converter currently reads the filtered tracker | Yes: `SimNoise` (`--sim-noise`, the reference's `world.json`) in `run_match`, the round-robin and `evaluate.py`; `rsim_noise` and `rsim_vanishing` in `StrategyRunner` are its older form | -| Dribbler: hold strength, ball loss when turning or touched, release speed | Possession, passing | Weak: only possession-loss rates as a proxy | Fixed, with the fork's dribbler fixes (`vendor/rSim/FORK_NOTES.md`) | -| Ball bounce off robots and walls | Rebounds, deflections | Partly: speed before and after contact | Fixed | -| Robots fielded per team | Defenders in the way of each shot (real 4.5 on average, sim always 6) | Yes: robots on the field in live play, per match | Always 6 | -| Robot breakdowns and lost commands | Gaps in defence and support | Partly: robots that stop mid-play. Lost radio commands only from our hardware | None | -| Stoppages: how often, and how long (ball placement, human-confirmed goals) | Game flow: set pieces vs continuous pressing | Yes: restarts and dead time per match (real 41.6 restarts, sim 25.4) | Our referee's rules and timings | - -### What the official logs can and cannot give - -- **They describe the league, not our robots.** That's still the right range for opponents, and - a reasonable starting range for our own robots until we measure them. A strategy robust - across the league's range is unlikely to break on ours. -- **Robots and ball come from an autoref's tracker**, which filters positions. Peaks - (kick speed, acceleration) are smoothed, so tracker-based estimates are lower bounds. Raw - camera detections are also in the logs, for vision noise. -- **Latency cannot be separated from decision time** for other teams. We get their total - reaction time, which is what matters for keeper saves anyway. -- **Kick direction error needs an intended target**, which the logs don't record. Proxies are a - shot's miss distance, and a pass's distance from the nearest teammate when it arrives. - -## How varying parameters are handled in strategy development - -**Domain randomization:** each parameter gets a range, and the sim draws from it. - -1. **Between-values are drawn per match and per robot; within-noise per kick.** For example: - - friction once per match; - - a top speed and kick-speed mean per robot; - - kick speed and direction noise on every kick. -2. **Draws come from the match seed.** They join the seeded vision noise already planned for - the round-robin. When strategy A and strategy B each play the baseline, - they see the same draws, so the comparison is paired and the extra randomness costs few - extra matches. -3. **Ranges are measured, not guessed.** Use the spread of team-level medians for between- - values, and each team's own spread for within-noise. Too narrow overfits to the sim; too wide - rewards overcautious play. -4. **Randomize only what changes standings.** A sensitivity sweep decides which parameters - are randomized; the rest stay fixed at the league median. -5. **Edge cases are a separate diagnostic, not part of the ranking.** Run candidates at the - edges (slow robot, weak kick, worn dribbler) and report how far they fall. -6. **Prefer strategies that measure parameters over ones that assume them.** For example, a - pass speed chosen from the kick speeds actually observed. The sim then checks that the code - copes with the whole range. - -## The realism scorecard - -One report that compares sim with real on the components that decide goals. Each row is a -real value with a 95% interval, the sim value, and a pass mark (sim inside the real -interval): - -- shots per team per live minute (passes and kicks from beyond 6 m excluded); -- real xG per shot; -- finishing (goals ÷ real xG), overall and in each xG band; -- shot outcome shares: keeper, defender, wide or post, goal; -- ball speed kept to 1 m from the goal; -- kick speed: median and spread; -- keeper depth and keeper reaction time; -- live minutes per match and restarts per match (referee-driven, so they are checked but not targeted). - -Real values are recomputed when new logs are converted. The sim side reruns on any -round-robin. - -## Plan - -Each phase ends with a checkpoint: results reported, decision taken, then the next phase -starts. Evaluation changes and strategy changes go in separate commits. - -### Phase 0: Bring the analysis into the repo (2–3 days) — done 2026-10-16 - -`pixi run python tools/realism/realism_scorecard.py` (see `docs/tools.md`); package -`utama_core/analysis/realism/`, real reference `real_2025_2026.json`. On the baseline it -reproduces the outcome numbers above. Rows failing on the baseline: goal rate in every xG -band, keeper and defender share, wide or post, ball speed kept, kick speed spread, keeper -depth. Keeper reaction time is not a row yet (Phase 1). - -The xG and shot-outcome analysis currently lives outside the repo (`~/dev/ssl/xg-analysis/`). - -- Move it into `utama_core/analysis/`: - - `shots.py`: the kick-based shot detector. Real goals are linked through the game - controller's GOAL events, because real goals are confirmed by a human operator seconds to - minutes late. - - `xg.py`: the model fit and the decomposition. - - `shot_outcomes.py`: what happened to each shot. -- Add a `tools/realism/realism_scorecard.py` entry point, and unit tests on the shot detector and goal - linking using small synthetic frames. -- Commit the fitted real xG coefficients as data, so the sim side doesn't need the real logs. -- Done when: the scorecard reproduces the numbers above for the baseline. - -### Phase 1: League ranges from the official logs (1 week, analysis only) - -One script per parameter, each giving a between-range and a within-spread with intervals: - -1. **Ball deceleration:** free-rolling segments (no robot within 0.3 m, speed below the - sliding threshold), fitted per match. -2. **Kick speed:** peak speed after each detected kick. Spread across teams, and within each team. -3. **Robot motion:** per robot, the 95th-percentile speed and acceleration, and braking. -4. **Reaction time:** from a shot's kick to the keeper's acceleration onset, and to its first - movement toward the shot line. The same for the nearest defender. -5. **Kick direction error, by proxy:** miss distance of shots, and pass arrival error relative - to the nearest teammate. -6. **Vision noise and dropped frames:** from raw camera detections of a ball at rest, and the - share of frames missing each object. This needs the converter to keep raw detections (a - small converter option). - -Done when: a table with each range and its caveats has been added to this doc. - -#### Results so far (2026-10-16, `python -m utama_core.analysis.physics_ranges`) - -54 real 2025–2026 Division B matches against the 66-match sim baseline. Deceleration in m/s², -speed in m/s, turn rate in rad/s; brackets are 95% bootstrap intervals over matches. - -| Measure | Real | Sim | -|---|---|---| -| Ball rolling deceleration (1 s or more after a kick) | 0.29 [0.28, 0.30]; per-match IQR 0.29–0.33; within-match IQR 0.09 | 0.65 at every speed, no spread | -| Ball sliding deceleration, 0.1–0.2 / 0.2–0.3 / 0.3–0.5 s after a kick | 3.7 / 2.7 / 1.9 | 0.9 / 0.65 / 0.65 | -| Robot speed, 95th percentile (team medians) | 1.37 (0.65–2.04) | 1.66 (1.32–1.92) | -| Acceleration, 95th percentile (team medians) | 2.56 (1.54–3.49) | 2.85 (2.80–2.89) | -| Braking, 95th percentile (team medians) | 4.09 (1.77–5.79) | 2.96 (2.92–3.07) | -| Turn rate, 95th percentile (team medians) | 3.02 (1.01–6.43) | 2.56 (2.32–2.78) | -| Ball unseen in live play (tracker output) | 1% per match; 4.9 gaps per live minute, median 0.05 s, p90 0.2 s | none | - -- **The sim ball has the wrong shape, not just the wrong level.** A real ball slides for about - 0.5 s after a kick, losing 2–4 m/s², then rolls at about 0.3. The rsim ball loses a constant - 0.65. It keeps too much speed early and loses twice too much while rolling. Phase 2 needs - two-phase ball friction in the C++ fork, not one damping value. -- **Robot motion measures driving, not just hardware.** The baseline ran the FPP planner on - both sides with a 4 m/s² configured acceleration limit, so the sim's 2.85 / 2.96 m/s² are how - FPP drives. Real values mix each team's planner (often bang-bang or trajectory sampling) with - its hardware. Per-robot sim limits are hardware caps applied below any planner; take their - range from real peaks (a lower bound, because of tracker smoothing), not typical driving. -- **Sim teams are near-identical:** acceleration 2.80–2.89 across teams against 1.5–3.5 real; - real top speeds differ about 3× between teams. Per-team and per-robot draws are justified. -- Caveats: the tracker smooths peaks (robot values and sliding deceleration are lower bounds; - the first 0.1 s after a kick is unusable). Tracker dropouts understate vision dropouts, - because the tracker bridges short occlusions. Exclude 2026-07-02 TurtleRabbit vs NAMeC - (broken tracker: ball unseen 57%). Robots moving with a 95th-percentile speed under - 0.5 m/s are dropped, which also drops keepers. -- Next data: the converter discards raw camera detections and the tracker's `KickedBall` - message (kick time, kicker, velocity) and per-object `visibility`. Keeping them gives - vision noise and a direct kick-speed source. - -#### More measurements (2026-10-16, from the raw-vision and kick sidecars) - -| Measure | Real | Source | -|---|---|---| -| Raw robot position noise per detection | 0.4–1.0 mm | 2022 `.vision.zip`, 2nd difference / √6, 4 matches, one camera each | -| Raw robot heading noise | 0.2–0.3° | same | -| A robot missing for one camera frame | 0.1–0.9% | same | -| Kick speed spread at full power, within one team | IQR 0.7–1.1 m/s, SD about 0.45 | 2022 `.kicks.json`: kicks at or above 0.8 × the team's 90th percentile | -| Full-power kick speed, between teams | 4.1–6.3 m/s (team medians) | same | - -- **Kick speed spread across all kicks (IQR 1.66) is mostly teams choosing a speed**, not - kicker noise. Our kicker is fixed power, so the within-team full-power spread is the range to - draw from; the scorecard's all-kicks IQR row should not be expected to match. -- **Vision noise is small and must be set from the measurement.** A provisional 5 mm / 1° made - the recorded sim positions jitter 7 mm frame to frame (real tracker output: 0.6–0.8 mm), and - that jitter read as robots reacting: keeper "velocity change within 0.4 s" went from 68% to - 98%. Our replay records the positions after our own Kalman filter, as the strategy sees them; - real logs are another team's tracker output. Rows built on velocities are only comparable when - the sim's vision noise is realistic. - -#### First calibration samples (2026-10-16) - -Six matches each (split_shape, tiki_taka_plus, press_trigger_flow, score_aware_counter_flow, -full length, `--sim-noise ~/dev/ssl/xg-analysis/calib/v{1,2}.json`), against the 53-match real -reference. Common to both: latency 0.05–0.10 s, kick speed SD 0.45 (per robot 0.2), kick -direction SD 3° (per robot 1.5°), ball slide 2.5–4.0 then roll 0.27–0.33 m/s², acceleration cap -1.5–3.5 m/s². v1 vision noise 5 mm / 1° / 2% dropped (provisional); v2 0.7 mm / 0.3° / 0.5% -(measured). Six matches give wide intervals: read directions, not passes. - -| Row | Real | Baseline (knobs off) | v1 | v2 | -|---|---|---|---|---| -| Goals per match | about 3 | 6.2 | 3.7 | 5.2 | -| Finishing (goals / xG) | 1.00 | 1.10 | 0.89 | 1.01 | -| Keeper saves | 0.17 | 0.39 | 0.35 | 0.38 | -| Keeper velocity change, median (s) | 0.18 | 0.12 | 0.12 | 0.19 | -| Keeper moves toward the line, median (s) | 0.22 | 0.12 | 0.18 | 0.20 | -| Wide | 0.11 | 0.05 | 0.13 | 0.10 | -| Aim outside the posts | 0.20 | 0.11 | 0.21 | 0.20 | -| Ball speed kept 1 m from goal | 0.67 | 0.57 | 0.66 | 0.65 | -| Pass line offset, median (m) | 0.26 | 0.09 | 0.19 | 0.10 | -| Pass completion | 0.50 | 0.70 | 0.52 | 0.63 | -| Live minutes per match | 7.1 | 9.1 | 7.2 | 7.4 | -| Restarts per match | 42 | 25 | 44 | 48 | - -- With measured vision noise, **keeper reaction times match real** (0.19 s vs 0.18) with - latency 0.05–0.10 s, and so does the nearest defender's. The latency range is consistent with - real reactions, though it is still a stand-in for our own hardware's (Phase 5). -- **Keepers still save about twice as often as real ones**, at every xG band, with reaction - times now matching. Not explained yet. Candidates: our keeper's positioning (0.09 m off the - line vs 0.21 real), contact physics (a real ball off a keeper deflects unpredictably; rsim's - bounces cleanly), and real shots the scorecard counts as on target that real keepers cannot - reach. Look before adding a knob. -- **v1's better passing rows came from vision noise, not kick noise.** With realistic vision, - pass offset falls back to 0.10 m against 0.26 real. Real pass error includes other teams' - decisions and receivers moving, so it is not purely kick error; do not raise kick direction - noise to close it without a hardware measurement of our kicker. -- **Real "crossed, no goal" was mostly the ball bouncing inside the goal after a goal**, before a - human confirmed it (hand check: 10 of 12 cases, 8 followed by the score rising). Those kicks - no longer count as shots; the reference dropped from 1,055 to 959 attempts and real crossed- - no-goal from 7.7% to 2.8%. Against the rebuilt reference v2 reads: attempts per team per live - minute 1.85 vs 1.27 real, finishing 0.87 vs 1.00, keeper saves 0.38 vs 0.18, wide 0.10 vs - 0.10. The table above uses the old reference. -- **Keeper gap, first look** (`~/dev/ssl/xg-analysis/keeper/`): keeper depth, distance to the - shot line and the speed needed to reach it have the same distributions real and sim, and at - matched values the sim keeper still saves about twice as often (shot line within 0.1 m of the - keeper: real 0.29, sim 0.56). Lead to check when the 2025–26 kick sidecars exist: about 10% of - real kicks leave the ground (tracker `KickedBall` vertical speed, 2022–24), and a chip beats a - keeper standing on the line; our strategies rarely chip. - **Checked 2026-10-16, ruled out:** joined to the 2025–26 tracker kicks, only 21 of 1,180 real - shots (1.8%) leave the ground (vertical speed > 0.5 m/s; 2% of all 2025–26 kicks, against - ~10% in 2022–24). Flat shots alone are saved 0.17 of the time, the same as all shots, so the - sim's 0.38 is not about chips. Next suspects: what happens when the ball reaches the keeper - (contact and rebound, sim keeper body), and shot speed at the keeper. -- **First sensitivity sweep** (v2 with one change each, 6 matches per run, same 4 strategies; - `~/dev/ssl/xg-analysis/sens/summary_all.json`). Changing only the seed moves goals per match by - 0.5 and pass completion by 0.06, and reshuffles every place below the top: split_shape - wins every run, the other three swap places by chance alone. Latency 0–0.05 / 0.10–0.15 s: - goals per match 4.0 / 3.8 against 5.2, finishing 0.80 / 0.73. Kick direction 1° / 6°: goals - per match 6.0 / 3.5, pass completion 0.80 / 0.39 (real 0.50), keeper saves 0.34 / 0.27. - Kick direction moves the most and needs measuring on our kicker (Phase 5). No knob closes - the keeper gap without overshooting another row (at 6°, saves 0.27 but completion 0.39). -- **v3, 28 matches** (v2 with latency widened to 0.03–0.15 s, 8 strategies, 3 workers; - `replays/tournament_20261016_185615`, `~/dev/ssl/xg-analysis/calib/v3_compare.json`): - 3.2 goals per match (real ~3). Matching real: attempts per team per live minute 1.23 vs 1.27, - open-play and set-piece attempts, attempt distance, xG per attempt, aim outside the posts, kick - speed median, keeper reaction times. Still off: keeper saves 0.33 vs 0.18, so finishing 0.75 - vs 1.00; defender blocks 0.22 vs 0.35; wide 0.17 vs 0.10; pass completion 0.66 vs 0.50 and - pass line offset 0.11 vs 0.26 m; keeper depth 0.09 vs 0.21 m (strategy). With 8 strategies - instead of 4, attempt volume matches; the 4-strategy samples' excess was those strategies. - The knobs cost about 1% of match time (120 s match: 28.0 s off, 28.3 s on). -- **New baseline, 2026-10-16** (`replays/tournament_20261016_201213`, all 12 strategies, 66 - matches, v3 noise, 8 workers, ~70 min): 3.6 goals per match (old deterministic baseline - `tournament_20261014_144456`: 6.7). split_shape still first (26 points, GD +18; was +58). - Below it the order barely survives: rank correlation with the old baseline 0.17 - (clear_danger 10th → 2nd, decoy_and_overload 12th → 4th, press_and_pass 2nd → 10th). With - one match per pairing and per-match GD SD ≈ 3, those middle places are not resolved either - way; separating them needs repeated seeds. -- No stalls in either sample; a dribbled ball stays at the kicker with two-phase friction - (`test_dribble_with_friction.py`). - -**Checkpoint:** review which ranges are trustworthy. - -### Phase 2: Knobs in the sim (1–2 weeks) - -All of these are built (2026-10-17): `SimNoise` draws each knob per match from its range, seeded -and recorded in the replay, and reaches `run_match`, the round-robin option, `evaluate.py` and -the reference `tools/evaluation/reference/world.json` (the v3 ranges, played as `v3_seed2` in the 2026-10-17 round-robin, have since changed). A knob at zero -reproduces the old behaviour, so results played without `--sim-noise` are unchanged. - -Each knob is off by default, so current results are unchanged, and each comes with a test that -pins its effect: - -- **Latency:** a delay buffer between the strategy's command and rsim (Python). This is the cheapest and probably biggest. Current range: 50 to 90 ms in `tools/evaluation/reference/world.json`. -- **Vision noise and dropped frames:** done. `SimNoise` (`--sim-noise`, the pool's `sim_noise`) goes through `run_match`, the round-robin and `evaluate.py`. -- **Kick speed noise:** perturb the commanded kick speed (Python). -- **Kick direction noise:** perturb the direction inside the C++ kicker (fork change, recorded in `FORK_NOTES.md`). -- **Ball deceleration:** expose the ball's damping or friction in the C++ fork. -- **Per-robot motion limits:** speed and acceleration caps per robot in the sim controller. -- **One seeded draw** per match, and per robot, from the ranges, recorded in the replay so any match can be reproduced. - -Done when: a match reproduces exactly from its seed, and every knob at zero reproduces today's results. - -**Physics substeps (gated, not assumed).** rsim runs 5 substeps per tick, hardcoded in -`vendor/rSim/src/robosim/sslworld.cpp` (`SSLWorld::step`); making it a parameter is a fork change. Fewer would be -faster, but substep error is systematic (every kick, contact and dribble wrong the same way), -so it does not average out like vision noise. A fast ball at 6.5 m/s moves about 22 mm per -substep at 5 and 36 mm at 3, against a 43 mm ball, and the fork's kicker and dribbler fixes -were tuned at 5. Physics was 46% of match time (2026-10-10), so 3 substeps saves at most about -15–20% of a round-robin. Steps: - -1. Measure match time at 3, 4 and 5 substeps. -2. Measure kick speed and direction, ball slow-down, dribbler hold and release, and collisions - at 3, 4, 5 and a 10-substep reference. -3. Adopt fewer substeps only if the error against the reference sits well inside the Phase 1 - real ranges, and the scorecard and standings don't move beyond match noise. Adoption - reruns every stored match, so it goes in with the Phase 4 baseline. - -### Phase 3: Calibrate and find what matters (1 week) - -- **Sensitivity sweep:** for each knob, rerun a small fixed set of matches at the low, median - and high end of its range. Measure the change in the scorecard and in standings between a few - strategy pairs. -- **Calibrate:** set each kept knob to its league range and check the scorecard moves into the - real intervals, keeper saves and the wide rate above all. Where a knob at the league range - overshoots or does nothing, record it. That usually means a modelling gap, not a tuning problem. -- **Held-out check:** calibrate on 2025–2026, then check the scorecard on 2022–2024 (rules - changed in 2022, so compare per year). A sim that passes only on the years it was calibrated on - has fitted the scorecard, not reality. -- Done when: the scorecard passes on its main rows, or the remaining gaps are named with a cause. - -**Checkpoint:** decide which knobs become the evaluation default. - -### Phase 4: Adopt in evaluation (3–5 days) - -- The round-robin uses randomized physics by default, with several seeds per pairing (number - set by the per-match noise: goal difference varies by about 3 goals per match) and paired seeds for A/B comparisons. -- Run a new baseline round-robin. Every stored match reruns: a store invalidation, so batch it - with any pending renames. -- Update `docs/STRATEGY_DEVELOPMENT.md` (evaluation), `docs/signals.md` (scorecard rows that - become signals) and `docs/strategies.md` (new results). -- Done when: the strategy catalog has been re-ranked under the new evaluation, and the - changes in ranking are explained. - -### Phase 5: Our own robots (when hardware tests are possible) - -Replace league ranges with measurements of our robots. Tests, each short and repeatable: - -| Test | Measures | -|---|---| -| Step command, timed from the vision log | End-to-end latency | -| Repeated kicks at a target, at several charge levels | Kick speed mean and spread, direction error, drop with charge | -| Rolling and kicked balls on the competition carpet (and our lab floor) | Deceleration, sliding-to-rolling switch | -| Speed and acceleration ramps, per robot | Motion limits, spread across robots | -| Dribble while turning or being touched; release | Hold strength, loss rate, release speed | -| Ball at rest under the cameras | Vision noise and dropped frames for our setup | -| A long run with radio logging, through a full battery | Lost commands, robot dropouts, speed and kick drop as the battery drains | - -Ranges for our robots then replace the league ranges for our side only. Opponents keep the -league ranges. - -#### First measurements of our robot (field test 2026-10-22) - -From the logs in `replays/field/20261022_*_real_*.log`, one robot (blue 2, firmware 0), mostly -`score_goal` runs. Of 33 recorded minutes, the robot moved for under 3, dribbled for 3.5 -and kicked 9 times, so these are small samples. The radio log (`RADIO_OUT`) says when the -dribbler and kicker were commanded. Kicks and ball slow-down come from one camera's raw ball -detections, because the two cameras disagreed by several cm. Vision noise comes from -`tools/field/robot_calibration.py`. - -| Measure | Ours | League / sim | -|---|---|---| -| Full kick, launch speed | 1.95–2.37 m/s (3 kicks on one camera; a 4th, from the fused ball, about 2.5); one weak kick at 1.07 | league full power 4.1–6.3; sim 5 (`KICK_SPD`) | -| Kick misfire: the ball moved under 15 cm | 4 of 9, the IR sensor seeing the ball every time | sim never | -| Kick direction, against the robot's heading | +2.6° to +4.9°: a steady offset, about 1° of spread | sim 0 | -| Kick command to the ball moving (camera seen) | 63–89 ms | sim: next tick | -| Ball slide, first 0.4 s after a kick | 1.0–3.5 m/s² | league 2–4; sim 0.65 | -| Ball rolling, after 0.5 s | 0.22–0.37 m/s² | league 0.29; sim 0.65 | -| Robot position noise at rest | 0.2–0.6 mm (2–8 mm in 4 logs where the robot rocked or the cameras traded off) | league 0.4–1.0 | -| Robot heading noise at rest | 0.3–0.5° | league 0.2–0.3 | -| Robot missing from a camera frame | 3–9% | league 0.1–0.9% | -| Ball at rest, position noise | 0.2–0.5 mm | | -| Ball lost while dribbling | 12 losses, nearly all with ≥ 0.85 m/s or ≥ 2.5 rad/s commanded in the 0.7 s before; slow, straight dribbles held 10–15 s | | -| Loop delay (command to motion seen) | 80 ms, from 3 noisy steps in one log | sim 0.05–0.10 when on | - -- **Our kicker is less than half as fast as the league's and the sim's.** The electronics team - says the capacitor's charge, and so the kick strength, depends on how long it has been - charging, and they can't control it. So the sim should treat every kick as a full kick, at - about 2.1 m/s for our robots, with the league range kept for opponents. -- **Misfires aren't explained by the ball's place in the mouth.** On the misfires, vision put the - ball within 22 mm of where it sits when IR sees it, and within 8 mm sideways; full kicks sat - just as far off. Vision in those logs is only good to about ±2 cm, so a ball a centimetre - short of the kicker can't be ruled out. Off-centre balls didn't explain direction either: the - offset was +3° to +5° whatever the ball's sideways place. It is likely the robot's heading as - vision reads it, or the kicker's mounting. -- **The ball on this floor slows like the league's carpet:** it slides, then rolls at about - 0.3 m/s². This is the two-phase friction found in Phase 1, which rsim's single 0.65 doesn't - reproduce. -- **The IR ball sensor never fired with the ball more than 25 cm away.** Where vision puts the - ball while IR fires shows vision's own error at the dribbler. It was steady (95–99 mm from - the robot's centre) after the cameras were retuned, but spread over 66–104 mm earlier. -- **Still unmeasured:** loop delay and acceleration limits (they need a `--calibrate` run, not - strategy runs), spread across robots (one robot), and kick strength against charging time. - -#### Our robots' kicks in rsim rehearsals (2026-10-29) - -Removed 2026-11-09: simulation models the measured world and assumes robots work; see `tools/evaluation/reference/`. - -A robot's calibrated profile now drives its kick in rsim when a run gives the profile (the -examples do): ball speed `kick_speed` (yellow 0 2.19 m/s, blue 0 1.31, the medians of -2026-10-28's kicks), direction bias + bend × ball offset + normal scatter of `kick_spread_deg` -(`utama_core/simulator/utils/real_kick.py`). rsim's ball leaves 0.26 m/s slower than -the kick speed commanded, at 1 to 5 m/s, so the command adds that back. The strategy evaluation -passes no profiles, so its matches are unchanged: whether evaluation should use our kick is the -Phase 4 / roadmap 2a decision, not this one. Latency is not in this kick profile: rsim's latency is `SimNoise`'s (`reference/world.json`), and real robots predict their -79 ms delay, so rsim would need both to stay faithful. - -## P1: Value model on real data - -The xG model is already a small value model fitted on reality, for shots only. The extension -values every situation: V = P(we score within 10 s) − P(they score within 10 s), from a dozen -interpretable features (ball position and zone, who has the ball, defenders goal-side, -attackers ahead of the ball, keeper position, the restart it came from). Football analytics -calls these expected threat and VAEP. - -- **Fit and check** on real logs, held out by match, like the xG model: calibration and AUC. -- **Score sim strategies** by crediting each action (pass, dribble, interception, shot) with - the change in V it caused. Reported next to standings in the round-robin summary. -- **Validate** that ranking by it agrees with match results once the sim is randomized. -- **Limits:** - - 54 real matches (118 with 2022–2024) give about 1,300 shots and 5 live hours: enough for - a compact model, not for a learned world model or policy. - - Where sim strategies reach situations the real data rarely contains, the model is - guessing. Measure the overlap, and fall back to match results there. - - V assumes league-average play from each situation on, so it cannot credit a tactic whose - payoff comes after the situation it scores. -- The 2026-10-12 sim-trained value model failed as a cheaper outcome partly because it was - trained on sim outcomes; this one is not. - -**First results, 2026-10-16** (`~/dev/ssl/xg-analysis/value/`, report2.md and -estimators/report.md). Fitted on the 118 real matches only (486 goals): two boosted-tree -classifiers, "we score next within H s" and "they do", V their difference. On held-out years at -H = 10 s, AUC 0.82 and R² 0.23 (0.17 without the last second before goals), against 0.73 / 0.08 -for ball position alone. V rises toward the opponent goal and orders our ball > loose > theirs. -On the 66-match v3 baseline, as a way to rank strategies with fewer matches: mean V (k = 0) -fails again (split-half 0.05 against 0.27 for goal difference). Real goals for k s and then V -improves with k, but the best (k = 20 s, split-half 0.41) is only a little better than -discounted goals with no V at all (0.39), and both are inside each other's noise. -Most of the gain over goal difference needs no model: goal difference per live minute is -already 0.30. So V does not yet save matches; it is for explaining results and for scoring -paired starts cut off at T s (the scenario bench, retired 2026-10-17). 12.7% of sim states have some feature outside the real -1st–99th percentile range (mostly ball speed toward goal). - -Pass 3 (2026-10-17, `report3.md`): converted real logs hold an unseen ball at its last -position with zero velocity and do not keep the seen flag (`ssl_log.py` `finish()`), so a hidden -ball reads as a stopped one. Dropping balls held over 0.5 s, frames with no robots of a team and -the last 80 live s, and weighting matches equally, changes little: H = 10 s AUC 0.805 (pass 2 -0.821, on a different set of states); in the ranking test the best V estimator rises to -split-half 0.42 (discounted goals alone 0.39, goal difference per live minute 0.30). -Writing `ball_seen` into converted logs would let a later pass tell hidden from stopped. - -## Evaluation infrastructure (2026-10-17) - -Built instead of a cheaper outcome (V, shots, xG, stat combinations: all rejected, see -`docs/signals.md`, "Ranking"): `tools/evaluation/evaluate.py` judges a candidate against the -champion at the last release, in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded -noisy matches, with ratings from goal margins (`analysis/ratings.py`) and a store of every -match (`replays/match_results/`); see `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". -This covers Phase 4's "several seeds per pairing, paired seeds for A/B". - -Measured on a second noisy round-robin (`tournament_20261017_002337`, seed 2, same 12 -strategies and code as `tournament_20261016_201213`, seed 1): -- Per-match goal-difference SD 1.85 (seed 1) and 2.83 (seed 2); residual SD after strengths 1.9, - close to normal tails. "~3 goals" above was the old sim. -- The noise is drawn per colour and robot, and config_a is always yellow: seed 1 gave yellow - +0.26 ± 0.23 goals per match, seed 2 gave blue +0.64 ± 0.35. split_shape went from +1.5 to - +4.9 between seeds. evaluate.py plays the candidate and the champion in the same colour for - each seed. -- Same-seed matches against a common opponent correlate slightly between *different* - strategies (residual correlation +0.03 against -0.11 across seeds), but fully for identical - code: a match is a pure function of (both strategies' code, seed, colours). A byte copy of - split_shape (6 rounds, 2026-10-17) reproduced every one of the champion's 24 results against - the opponents, while the old decision rule (from the ratings fit, which treats every match - as independent) put P(copy better) at 0.93 after four lucky head-to-heads. The decision now - uses the paired differences, with their spread estimated from the data - (`ratings.paired_difference`): the copy stays at P 0.55-0.68, undecided. Small edits of a - strategy, the common case, sit between the two and gain the most. -- Mirror matches of one strategy (yellow minus blue over seeds 1-6: +1, -4, +1, 0, -2, -9) show - how much a colour's robot draws can matter in one match. Giving both teams the same draws - narrowed it (+2, 0, -1, -5, +1, 0) but not to zero, the rest being the match's own chaos; not - adopted, since it would replay the whole store and the paired decision already cancels the - draws (candidate and champion get identical ones against each opponent). - -## P2: Structured strategy search - -Search over what the repo already composes: -- which tactics fill each slot; -- tactic parameters; -- the partitioner that splits robots between slots (for example `split_shape`'s - possession split). - -Candidates are scored by `evaluate.py` (match results in the randomized sim, paired seeds; the -value signal was dropped as a scorer). The 2026-10-11 search (PR #142) is the manual version of this loop: candidates -written by hand, screened by round-robin, held out on a ladder (retired 2026-10-17, replaced by `evaluate.py`). Its lesson carries over: a lead -from one match per pairing is not evidence. - -## Risks and rules - -- **Don't tune the sim toward goal totals.** Only components, with a named physical cause each. -- **League ranges are a prior.** Don't treat the league median as our robot. -- **More randomness means more matches** for the same confidence. Paired seeds and sequential - stopping keep that affordable. Measure the cost in Phase 3 before adopting. -- **Real logs are other teams under real referees.** Live time and restarts differ for - referee reasons, not physics. Compare per live minute. - -## Related - -- [`signals.md`](signals.md): how strategies are measured. -- [`roadmap.md`](roadmap.md): the workstream entry. -- `tools/realism/convert_ssl_log.py`: official logs as replays. -- `vendor/rSim/FORK_NOTES.md`: physics fork changes. diff --git a/docs/strategies.md b/docs/strategies.md deleted file mode 100644 index 3ff53d57..00000000 --- a/docs/strategies.md +++ /dev/null @@ -1,97 +0,0 @@ -# Strategy catalog - -Every strategy in `utama_core/strategy/` (one module each, named after the strategy), whether it -is core or reserve, and the latest results. - -Run: - -- `pixi run evaluate` — one round robin of the core and the champion - at the last release: stalls and signals (`--all` plays every strategy). -- `pixi run evaluate ` — judges a candidate against the champion - at the last release. The way to judge a strategy. `--help` lists the flags. -- `pixi run python tools/debug/debug_match.py --strategy
--opponent [--dump-ticks PATH]` — one - instrumented matchup. - -rsim is deterministic: re-running an identical match gives an identical result. Variance comes -from the seeded sim noise: `evaluate.py`'s round k plays with seed k. - -**The catalog.** Core strategies play every round of `evaluate.py`; reserve ones play only with -`--all` (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results -below were played under the old names (column "Was"), which `catalog.RENAMED` still loads. - -**Recording a verdict.** Write it as `evaluate.py` gives it: better / dropped / undecided, the -stage that decided it (screen, seeds 1-6, or confirm, seeds 101-106), its mean diff ± SE in goals per -match and p, and the run id. "Dropped" means not promising, not worse: an equal strategy is dropped -about half the time. - -| Strategy | Was | Role | Description | -|---|---|---|---| -| `avalanche` | `overload_press` | core | 4-robot overload/switch attack + 1 block, built to outnumber a shadow line. | -| `breakwater` | `clear_press_plus` | core | `firebreak` plus `weaver`'s final-third overload. | -| `mirage` | `decoy_and_overload` | core | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | -| `pendulum` | `split_shape` | core | `LeadAndSupportTactic` + `ShadowAndMarkTactic`, split by possession edge. | -| `wolfpack` | `high_press` | core | Same pair as `terrier`, fixed 80/20 attack-heavy split ignoring possession. | -| `chameleon` | `score_aware_counter_flow` | reserve | `riptide` plus a late-half scoreline shift (protect a lead / chase). | -| `firebreak` | `clear_danger` | reserve | `riptide` postures plus an own-third `ClearBallTactic` danger-clearance valve. | -| `ricochet` | `give_and_go_solo` | reserve | Whole pool runs `GiveAndGoTactic`, no defense slot. | -| `riptide` | `counter_flow` | reserve | Give-and-go attack, press on the ball, `BlockShapeTactic` screen; 3/2 with possession hysteresis. | -| `terrier` | `press_and_pass` | reserve | `GiveAndGoTactic` + `PressAndContainTactic`, possession-edge split. | -| `tripwire` | `press_trigger_flow` | reserve | `riptide`, but an all-in press when the ball is lost in our own third. | -| `weaver` | `tiki_taka_plus` | reserve | Short passing, handing off to `DecoyOverloadTactic`'s duet in the final third. | - -**Deleted** (2026-11-12): the ten strategies retired on 2026-10-10 (`tiki_taka`, `counter_press`, -`high_line_zone`, `three_slot`, `switch_of_play`, `low_block`, `zone_fluid`, `score_aware_zone_flow`, -`overload_flow`, `shadow_switch`), because nobody knew whether they still worked. Git history keeps them. - -`default`: Everyone runs `PassAndShootTactic`; only 2 robots are ever commanded (see bugs). Excluded from the catalog `evaluate.py` plays. - -Strategies are judged with `evaluate.py` against the champion at the last release -(`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). The round-robin results below are a -snapshot of the catalog, not the verdict on any one strategy. - -## Latest results - -**Round-robin** (2026-10-17, sim-realism-20261016 at 423f63a0, the 12 strategies above, 66 -matches, two halves of 300 s of playing time, seeded sim noise `v3_seed2`, -`replays/tournament_20261017_151052/summary.json`). Points are 3 a win, 1 a draw; 14 of 66 -matches were draws. 4 matches stalled (three committed robots frozen about 10 s, and one kick-off -that waited the referee's 15 s cap, fixed after this run in 1731e904); 97% of 3232 restarts -reached NORMAL_START. - -Against the 2026-10-10 run: rsim is our fork with the v3 sim noise (latency, motion limits, ball -friction, kick direction), and restarts, ball placement and the carry limit were fixed, so goals -fell from 7.1 a match to 4.0 and the results are not comparable with earlier runs. -`pendulum` is still first, unbeaten; `riptide`, second before, is eleventh. - -| Strategy | W-D-L | GF-GA | Points per match | -|---|---|---|---| -| `pendulum` | 10-1-0 | 66-14 | 2.82 | -| `breakwater` | 5-5-1 | 14-9 | 1.82 | -| `avalanche` | 6-2-3 | 22-18 | 1.82 | -| `firebreak` | 5-2-4 | 20-24 | 1.55 | -| `weaver` | 5-1-5 | 23-21 | 1.45 | -| `wolfpack` | 4-3-4 | 24-27 | 1.36 | -| `tripwire` | 4-1-6 | 13-19 | 1.18 | -| `ricochet` | 3-3-5 | 20-30 | 1.09 | -| `terrier` | 3-3-5 | 14-28 | 1.09 | -| `mirage` | 3-2-6 | 16-27 | 1.00 | -| `riptide` | 2-4-5 | 17-21 | 0.91 | -| `chameleon` | 2-1-8 | 16-27 | 0.64 | - -## Known open bugs - -Writeups of bugs since fixed were removed from this file; code comments that cite "Known open -bugs" refer to them — read them with `git log -p -- docs/strategies.md`. Still open: - -- **`default` commands only 2 of 5 robots** (robots 3-5 idle) and draws 0-0 with - `low_block` (an opponent-aware approach in `go_to_ball` reduced it; still 0-0). `default` is the - kernel's smoke-test scaffold and `low_block` is retired, so not worth fixing for its own sake. - -## Updating this file - -- New strategy → add a row with a one-line description to the table (it starts as reserve). -- New tournament → replace the matching results table (one table per tournament type) and - record the run directory; don't append narrative. Findings belong in commit messages. -- Strategy abandoned after losing → delete its module and its row. -- Only single matches, no evaluation → put them in the pull request, not here: this - file holds round-robin and evaluation results only. diff --git a/docs/testing_gaps.md b/docs/testing_gaps.md deleted file mode 100644 index 849d223b..00000000 --- a/docs/testing_gaps.md +++ /dev/null @@ -1,63 +0,0 @@ -# Testing gaps - -Found 2026-08-25 while three parallel agents added 7 `custom_referee` rules (SSL §8.3/8.4 -audit): every agent's own unit tests passed, yet a real bug reached the merged tree and only -the pre-existing full suite caught it. This file records the kinds of gap that allowed that, -plus adjacent ones. **Numbering is fixed** (code and docs cite gaps by number); append new -gaps, never renumber. Full writeups: `git log -p -- docs/testing_gaps.md`. - -## Open - -**4. No static type checking in CI.** CI runs Ruff (a linter), which cannot flag a subclass -override whose signature drifted from its abstract base — the structural fix for gap #1's -symptom. Adopting mypy/pyright is undecided given the codebase isn't typed to that standard. - -**6. New rules never systematically fuzzed against real match dynamics** — partly open. -`pushing` (closed, `a3f3795`) and `keeper_held_ball` (fired 10 times in 6 full matches) are -confirmed live. `ball_placement_interference` has never fired in real play: across ~200 -placements the longest non-placer dwell in the 0.5m stadium was 1.0s, under the rulebook's 2s -grace. Not treated as a bug; recheck if a real match produces a ≥2s linger, or build an -adversarial scenario. Our own sim does reach it, so it is no longer untested: -`tests/moments/placement_in_corner_traps_defender.json` (round-robin -`tournament_20261017_002337`) pins a corner placement that trapped a defender inside the -keep-out circle, and must keep passing. - -## Closed (one line each) - -1. **Unit-testing a rule in isolation skips the interface it's called through.** - `BaseRule.check()` gained a 4th parameter; 7 overrides kept 3 and their direct-call unit - tests still passed (Python doesn't check override signatures). Fix: one integration test - per §8.4 rule through `CustomReferee.step()` (`test_referee_rules_integration.py`, - `test_ball_contest_deadlock.py`) — `de5e69b`. -2. **Foul counter / yellow card never driven end-to-end.** `test_foul_counter_end_to_end.py` - — `de5e69b`. Non-stopping fouls don't touch the 0.3s transition cooldown, so several can - land at one timestamp. -3. **Two rules in one tick / non-stopping vs stopping foul untested.** - `test_referee_scan_order.py` — `de5e69b`. -5. **`game_frame=None` in a test.** No real caller passes `None`; the test was fixed to pass a - real `GameFrame` and the dead guard removed rather than copied to other rules — `f7e9a2a`. -7. **`RobotStopSpeedRule` fouled robots obeying `StopStep`'s clearing motion.** The rule now - exempts a robot while it is inside `BALL_KEEP_OUT_DISTANCE` — `ccb172b` - (`test_dribble_placement_stopspeed.py`). -8. **`HALT` had no automated resume**, so a sim run tripping it froze silently. - `StrategyRunner` now auto-resumes `HALT` → `NORMAL_START` after 5s, sim only — `ccb172b` - (`test_halt_auto_resumes_to_normal_start_in_sim`). -9. **`ball_placement_interference` was structurally unreachable in sim**: a sim-only - `StrategyRunner` fast path teleported the ball and jumped straight to `FORCE_START`, - skipping `BALL_PLACEMENT_*`. Gated on `next_command` — `f0ff450` - (`test_real_out_of_bounds_restart_reaches_ball_placement`). The physical-carry gap is - separate (`referee_integration.md`, Open). -10. **Replay investigations used raw numbers instead of `render_window()`** — the guidance now - lives in `STRATEGY_DEVELOPMENT.md`'s Observability section. -11. **No automated stuck-match detector.** `utama_core/analysis/stuck_detector.py`'s - `find_stuck_windows()` (`39257ee`): per-3s window, ball frozen (position std-dev) or robot - oscillating (FFT peak fraction); excludes non-live referee states, held/shielded ball, and - ball resting in a defense area (`ce6abe3`). Bugs it found, each with a regression test: - `PressAndContainTactic` loose-ball and `GiveAndGoTactic` hop timeout (`d6b3ff1`); - `shielding.shielded_approach_angle` hysteresis reset by an enemy stepping in and out of - range (the shielding fix, `ce6abe3`); a ~360s post-restart freeze with three layered causes - — `clear` picker holding other robots on `block` (`0e510a0`), `DecoyOverloadTactic`'s 12s - finish timeout (`ae6a6f3`), `ball_is_loose` ignoring a legally barred enemy near our - defense area (`10fc89c`); and a same-team two-robot ball scrum - (`_teammate_already_has_ball()`, `a59a8e5`). Cross-tactic convergence in general is - the roadmap's "Cross-tactic ball convergence". diff --git a/docs/visual_guide.md b/docs/visual_guide.md deleted file mode 100644 index 152f5cf5..00000000 --- a/docs/visual_guide.md +++ /dev/null @@ -1,195 +0,0 @@ -# Seeing the game - -What our robots actually do, drawn on the pitch from real replays: how each strategy plays, one match -over time, a restart, and the motion planner, from fixed scenarios down to a single tick. Each section -gives the picture, how to read it, what it has shown us so far, and the command that draws it. - -A picture explains a result; it never makes one. Strategies are judged on goals -([STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Evaluating a strategy"), and every claim a -picture suggests is confirmed with numbers before it is acted on. Each picture tool can also write the -problems it flags as JSON (`--findings`, format in [tools.md](tools.md)), for filtering without -opening images. An agent misread a planner trace once in this repo: the numbers caught it. - -Conventions in every pitch picture: blue is the side being studied, orange the other team (faded when it -is context), the pitch is in metres with the centre at (0, 0), and the strategy maps turn every match -so the studied strategy attacks right. Zone names (defensive third, the box, ...) are the ones in -[pitch_zones.md](pitch_zones.md). - -## Start here: find bugs - -`pixi run python tools/debug/find_bugs.py RUN_DIR --strategy NAME` picks the strategy's worst matches (by goal -difference, among those it played as config_a), collects every problem the tools flag (tactic flip-backs, -stalls, and with `--restarts` illegal restart targets), and draws the worst few with the picture for that -kind. Read its `index.md` first: each problem's numbers, then the picture path. About 20 s a match -(a minute with `--restarts`). - -A stall it found in `pendulum` against `weaver`: from 783 to 786 s, four of our robots -oscillate with the ball frozen. The picture is the match timeline around it, recorded data only: - -![a stall in the match timeline](img/match_timeline/stall_pendulum_773-796.png) - -Robots 2-4 switch between `ShadowAndMarkTactic` and `LeadAndSupportTactic` together, three times within -half a second at 780.5 s and again at 782.4, 783.2 and 785.2 s, while robots 0, 1, 2 and 5 stay within -about 2 m of the ball and robot 4 stays 5-8 m away. - -## 1. How a strategy plays - -### Where its robots stand: the position map - -![positions in possession](img/signals/positions_attack.png) - -One panel per strategy from the latest round-robin, in order of points per match (the number after the -name). Darker cells hold more of the outfield robots' samples while the strategy has the ball; black dots -are each robot's mean position. The same picture without the ball: - -![positions out of possession](img/signals/positions_defence.png) - -What it shows: - -- Most strategies stand on **vertical lines**: robots spread across the pitch at one depth, one line - just outside our box (x ≈ −2.6 m) and one near theirs (x ≈ +3.0 m), with or without the ball. - Which tactic draws them, from the intentions log (live play, robots on the line): - - the line in our half is mostly `BlockShapeTactic`'s screen, held at a fixed depth by design - (`_SCREEN_OFFSET` in front of our box, shifting only sideways with the ball): 73-83% of the - samples there in `firebreak`, `riptide`, `tripwire`, `chameleon` - and `breakwater`. Those robots stand still 57-63% of the time, with the ball a median - 2-3 m ahead of them. `pendulum` and `mirage` draw the same kind of line with - `ShadowAndMarkTactic` a little deeper (x ≈ −3.0 m). - - the lines from `GiveAndGoTactic` (x ≈ −2.4 and +3.0 m in `ricochet` and `wolfpack`) - are not explained yet: the ball is at the same depth (median 0 m ahead), mostly near a - touchline (median |y| 2.4-2.6 m). - A fixed line is not by itself why a strategy loses: `firebreak` holds the screen and ranks - fourth. Whether a ball-following depth beats it is a question for `evaluate.py`, not this - picture. -- `pendulum`, the top scorer, keeps most of its outfield robots in **its own defensive third even - with the ball**, and attacks with one or two. `avalanche` is the opposite: a block just past - halfway, in and out of possession. -- `mirage` sits deep in a cluster in front of its own box. - -### Where it shoots from, and concedes: the shot map - -![shots for and against](img/signals/shots.png) - -Blue are the strategy's own shots at the spot they were struck from (filled: a goal), faded orange the -shots it conceded. `pendulum` takes 241 shots in its 11 matches, from all over the attacking half, -two and a half times the next strategy; the others take 69-98. - -### Where it fouls - -![fouls by rule](img/signals/fouls_map.png) - -Each foul at the ball's spot, coloured by rule (one fixed colour per rule, the same in every panel): -which rules a strategy breaks, and where on the pitch. - -Draw: `pixi run python tools/debug/pitch_maps.py replays/tournament_` (a full round-robin, about 3 min). - -## 2. A candidate against the champion - -![candidate against champion, positions](img/explain/positions.png) - -The same maps for just two strategies, a candidate and the champion, side by side on one colour scale; -`tools/evaluation/explain.py` draws them (with shots, fouls and a `summary.json`). This example is drawn from the round-robin: `pendulum` holds 37% of its possession in the -attacking half against `breakwater`'s 65%, yet takes 21.9 shots a match against 6.3, and commits -twice the fouls (10.0 against 4.7 a match, mostly ball held in the defense area and crashing). - -Draw: `tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR` on any run dir. - -## 3. One match over time - -![pendulum timeline](img/match_timeline/pendulum_100-160.png) - -Sixty seconds of `pendulum` against `weaver`. From the top: events (fouls, shots), the -referee command, one lane per robot coloured by the tactic it was in (a tick at each switch, a black strip -while it had the ball), and each robot's distance to the ball. Hatched lanes are stoppages, where the -referee override moves robots instead of their tactics. - -What it shows: robots 2-4 switch between `ShadowAndMarkTactic` and `LeadAndSupportTactic` together, -several times within a few seconds (112-117 s, 139-146 s), while robots 1 and 5 hold one tactic. Over a -whole round-robin, a tactic held under 1 s and then reverted (a flip-back) happens about 5 times a -minute in most strategies that split attack and defence on possession, 13 in `terrier`, and -almost never in `ricochet`, `wolfpack` or `mirage`. Not fixed yet. - -Draw: `pixi run python tools/debug/match_timeline.py REPLAY.npz T0 T1`. - -## 4. A restart - -![free kick against us](img/restart_picture/free_kick_against_us.png) - -Where the referee override sends each of our robots at one restart: a free kick against us, ball at the -cross, the 0.8 m keep-out circle dashed. Each robot moves toward its commanded target (grey cross; red -when a target breaks a rule) or holds; the table lists each target and its distance from the ball. -Robot 3 starts inside the circle and is sent to exactly 0.80 m. - -Across more replays this picture found a real defect: the step that clears robots out of the circle -stops 1 cm short and leaves them at 0.79 m (`keep_out_short` in the findings). Fixed. - -Draw: `pixi run python tools/debug/restart_picture.py REPLAY.npz --t S`, or `--all-restarts` for one panel per -restart command in the match. - -## 5. The motion planner on fixed scenarios - -The benchmark runs the three planners (`fpp`, the fast path planner we use, `dwa` and `trajsample`) on -fixed scenarios in headless rsim, with no strategy involved. - -![static slalom](img/motion_planning/trajectories_static_slalom.png) - -One robot crosses a staggered line of three parked opponents. `fpp` and `trajsample` drive almost -straight through (the gaps are wide enough) at 2 m/s, 12 cm from the nearest robot at worst; -`trajsample` brakes briefly at each obstacle. `dwa` slows down from 1.3 s, weaves, stalls beside the -middle obstacle at x = 0 and touches it. - -![crossing](img/motion_planning/trajectories_crossing.png) - -Two of our robots, both driven by the planner under test, cross at right angles (dashed is the -second robot). With `fpp` one robot holds its line and the other swerves round it: closest pass 0.18 m, -both arrive. With `dwa` they converge and collide, and neither arrives. With speed modulation and angular penalties, `trajsample` yields cleanly with a tight bypass (path ratio 1.09x, 3.4s vs fpp's 3.3s). - -![benchmark summary](img/motion_planning/summary.png) - -Every metric per planner and scenario, each on its own scale; hollow dots are failed runs. - -Draw: `pixi run python tools/motion_planning_benchmark.py --figures DIR`. How to read the full -benchmark: [motion_planning_comparison.md](motion_planning_comparison.md). - -## 6. The motion planner in a real match - -### One tick - -![planner snapshot](img/plan_snapshot/kickoff_keep_out.png) - -The planner's decision for one robot on one recorded tick: every robot with its clearance ring, the -ball's keep-out circle (dashed), the robot's target and the carrot (the point the planner steers to this -tick). Here `weaver`'s robot 4 (the replay's enemy side) sits on the keep-out circle at a kickoff, 0.799 m from the ball; its target -(−1.0, −0.3) is across the circle. The planner's answer is a carrot 5 cm away: push the robot out to -0.85 m first. - -Draw: `pixi run python tools/debug/plan_snapshot.py REPLAY.npz --t S --robot ID [--side enemy] [--target X Y]`. - -### A window - -![planner trace](img/plan_trace/kickoff_keep_out.png) - -The same robot over 12 s: its path coloured by time, the carrot at each sample (green dots, joined to -where the robot was), then distance to the ball, distance to the carrot, speed and the referee command. -The robot runs in, reaches the circle at about 255.5 s (dipping to 0.76 m), then holds 0.80 m from the ball for the rest of the -prepare-kickoff, 1.76 m short of its target. That was the planner before the push-out fix: it -parked robots on the circle. - -The trace replays recorded positions and runs today's planner on them; it does not re-simulate. So the -robot's path is the old behaviour, and the carrot line (0.05 m, at 0.85 m from the ball) is what today's -planner would do from there: push out first. The annotation names it "pushed out of the keep-out"; a -short carrot with nothing to push out of is labelled "parked". - -Draw: `pixi run python tools/debug/plan_trace.py REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] -[--target X Y]`. - -## Which picture for which question - -| Question | Picture | -|---|---| -| How does this strategy play, overall? | pitch maps (1) | -| Why did the candidate win or lose against the champion? | `explain.py` (2) | -| What were the robots doing in this stretch of a match? Thrashing, everyone chasing the ball? | match timeline (3) | -| Where did the referee override put us at this restart, and was it legal? | restart picture (4) | -| Is the planner itself good at driving, with no strategy involved? | benchmark (5) | -| Why did this robot stop, detour or go the wrong way? | plan snapshot, then plan trace (6) | diff --git a/tools/dev/check_strategy_branch.py b/tools/dev/check_strategy_branch.py index 2498cfac..e2501c38 100644 --- a/tools/dev/check_strategy_branch.py +++ b/tools/dev/check_strategy_branch.py @@ -42,7 +42,6 @@ "utama_core/strategy/", "utama_core/tactics/", # new modules only (check 2) "utama_core/tests/strategy/", - "docs/strategies.md", ) STRATEGY_DIR = "utama_core/strategy/" diff --git a/utama_core/tests/engine/test_check_strategy_branch.py b/utama_core/tests/engine/test_check_strategy_branch.py index e4eb805f..729530ef 100644 --- a/utama_core/tests/engine/test_check_strategy_branch.py +++ b/utama_core/tests/engine/test_check_strategy_branch.py @@ -30,7 +30,6 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): [ "utama_core/strategy/new_idea.py", "utama_core/tests/strategy/test_new_idea.py", - "docs/strategies.md", ] ) == [] @@ -48,7 +47,7 @@ def test_strategy_modules_tests_and_catalog_are_allowed(): # Prefix matches on whole directory names only. "utama_core/strategy_runner/x.py", "utama_core/tests/run/test_x.py", - "docs/strategies.md.bak", + "docs/strategies.md", # the catalog doc is gone: the dashboard reads the strategies ], ) def test_anything_else_is_reported(path): @@ -61,7 +60,6 @@ def test_allowlist_is_strategy_code_only(): "utama_core/strategy/", "utama_core/tactics/", "utama_core/tests/strategy/", - "docs/strategies.md", ) @@ -193,11 +191,10 @@ def test_changing_pickers_or_deleting_a_strategy_is_reported(): assert opponent_problems({"utama_core/strategy/b.py": "D"}) -def test_tests_and_the_catalog_do_not_count_as_strategies(): +def test_tests_do_not_count_as_strategies(): changes = { "utama_core/strategy/a.py": "M", "utama_core/tests/strategy/test_a.py": "A", - "docs/strategies.md": "M", } assert opponent_problems(changes) == [] From e7ff86a5115fb0d4085fb56057d292eb7abf7fc5 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 12:15:08 +0000 Subject: [PATCH 56/59] docs: 27 files down to 10; merge what is still used, delete history, plans and the catalog Kept: first_strategy, STRATEGY_DEVELOPMENT, tactic_model_design_decisions, signals, referee, motion_planning_comparison, real_robot_setup, architecture, tools, README (a 9-line index). Merged: pitch_zones into signals; referee_integration, referee_gui and referee_design_decisions into referee; field_logs and setup_external into real_robot_setup; pipeline_method into architecture; contributing into the top-level README. References updated to the new sections. Deleted (in git history): strategies and visual_guide (the dashboard shows every strategy, its maps and matches), sim_realism, roadmap, in_house_vision, testing_gaps, field_log_replay, scheduling_math_model, motion_planning_results, and the pictures only they used. The rsim tick diagram moves to vendor/rSim/FORK_NOTES.md. Code comments citing a deleted doc keep pointing at history, as docs/README.md says. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 4 +- .claude/skills/debug-incident/SKILL.md | 2 +- .claude/skills/explain-result/SKILL.md | 2 +- .claude/skills/field-session/SKILL.md | 4 +- AGENTS.md | 12 +- README.md | 22 +- docs/README.md | 47 +--- docs/STRATEGY_DEVELOPMENT.md | 21 +- docs/architecture.md | 78 +++++- docs/first_strategy.md | 3 +- docs/img/pipeline/make_one_tick.py | 2 +- docs/img/pitch_zones/make_pitch_zones.py | 2 +- docs/real_robot_setup.md | 160 +++++++++++- docs/referee.md | 244 ++++++++++++++++++- docs/signals.md | 76 +++++- docs/tactic_model_design_decisions.md | 7 +- docs/tools.md | 13 +- main.py | 4 +- tools/debug/pitch_maps.py | 2 +- tools/field/shooting_drill.py | 2 +- utama_core/engine/referee_override.py | 2 +- utama_core/tests/analysis/test_pitch_maps.py | 2 +- vendor/rSim/FORK_NOTES.md | 7 +- 23 files changed, 622 insertions(+), 96 deletions(-) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index 0020babc..e841be99 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -27,7 +27,7 @@ to forget. change the copy. - No module-level state (keep it inside `build`), no import-time effects, no imports of another strategy. CI checks a `strategy/*` branch touches only `strategy/`, new `tactics/` modules, - `tests/strategy/` and `docs/strategies.md` (`tools/dev/check_strategy_branch.py`). + `tests/strategy/` (`tools/dev/check_strategy_branch.py`). - Every change needs a reason in game terms (what the robots will do differently, and why that wins goals), not a threshold nudged until results move. @@ -60,7 +60,7 @@ pixi run evaluate NAME [NAME ...] ## 5. Record and promote -- Add or update the strategy's row in `docs/strategies.md` with the verdict and margin. +- Write the strategy's one-line description in its module docstring: the dashboard shows it. - Open a draft pull request into `main` with the result. An agent never merges. - Better than the champion: promoting is one line in `tools/evaluation/reference/players.json` (`champion`, and the core if it should play every round), in its own small pull request after diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md index 3970b04f..6ca755fc 100644 --- a/.claude/skills/debug-incident/SKILL.md +++ b/.claude/skills/debug-incident/SKILL.md @@ -40,7 +40,7 @@ All run as `pixi run python tools/.py ...`. Never conclude from a picture ## 3. Find the cause in the code From the trace: which tactic or override sent the robot there, with which target, waypoint -and obstacles. Then ask whether the rule was really broken (`docs/referee_design_decisions.md`) +and obstacles. Then ask whether the rule was really broken (`docs/referee.md ("Design decisions")`) and whether the check reads it right. Frame trap: rsim stores y negated; anything written into the sim negates y and heading. diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md index f413101a..18e14902 100644 --- a/.claude/skills/explain-result/SKILL.md +++ b/.claude/skills/explain-result/SKILL.md @@ -45,7 +45,7 @@ they suggest changing, never a new ranking. `pixi run python tools/evaluation/explain.py ROUND_DIR CANDIDATE REFERENCE --out DIR` (`positions.png`, `shots.png`, `fouls.png`, `summary.json`). REFERENCE is the name as `report.json` gives it (a frozen file is named by its stem, e.g. `split_shape@cffe3a28`). - Zones: use the names in `docs/pitch_zones.md` (defensive / middle / attacking third, wings, box). + Zones: use the names in `docs/signals.md ("Pitch zones")` (defensive / middle / attacking third, wings, box). 5. **Write it up** in a few lines: the verdict and margin; which opponents decided it; the two or three signals or pictures that explain it, with numbers; any bug found (handed to diff --git a/.claude/skills/field-session/SKILL.md b/.claude/skills/field-session/SKILL.md index 47b83796..4070a289 100644 --- a/.claude/skills/field-session/SKILL.md +++ b/.claude/skills/field-session/SKILL.md @@ -6,7 +6,7 @@ description: Run a test day on the real robots, and process what it recorded - c # A field session Setup and the meaning of each check: `docs/real_robot_setup.md`. Log format and readers: -`docs/field_logs.md`. On the field, time is short: run the one command, read its "!!" lines, +`docs/real_robot_setup.md ("Field logs")`. On the field, time is short: run the one command, read its "!!" lines, fix only those. ## At the start @@ -60,4 +60,4 @@ caps are 0.3 m/s and 0.6 rad/s on real robots (balls are lost turning faster). logs and bundles calibration and hardware config. 7. **Write down** what broke and what was measured (a dated note; open follow-ups listed). Bugs seen on the pitch go through the `debug-incident` skill with the field log as the - replay (`docs/field_log_replay.md`). + replay. diff --git a/AGENTS.md b/AGENTS.md index 0763de8d..23ee1995 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -42,7 +42,7 @@ One term per thing; reuse these instead of coining new ones. the cause is the real protection. Not a ranking and not a gate on strategies. The workflow and the bugs found so far: `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure". - **Pitch zones** — defensive / middle / attacking third, left wing / centre / right wing, the - box, danger: defined once, with a diagram, in `docs/pitch_zones.md`. Use those names. + box, danger: defined once, with a diagram, in `docs/signals.md ("Pitch zones")`. Use those names. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). - **Position map / shot map** — on-pitch pictures of a strategy over many matches, drawn by `tools/debug/pitch_maps.py` (and `tools/evaluation/explain.py` for a candidate against the champion), always @@ -108,7 +108,7 @@ One term per thing; reuse these instead of coining new ones. for planner, simulator, vision and hardware work: see the Work areas table above. **Before touching `utama_core/engine/`, `utama_core/tactics/`, `utama_core/strategy/`, -`utama_core/skills/`, or `tools/evaluation/`/`docs/strategies.md`, read +`utama_core/skills/`, or `tools/evaluation/`, read [`docs/STRATEGY_DEVELOPMENT.md`](docs/STRATEGY_DEVELOPMENT.md)** — the tactic-kernel model, referee-restart handling, lessons from past tactic bugs, and the observability tooling (`MatchLog.trace()`, `render_window()`, the strategy catalog) all live there, scoped to @@ -176,16 +176,14 @@ need most: - `docs/referee.md` — `CustomReferee` architecture/usage; its "Known gaps" section tracks genuinely open items (don't assume something is missing without checking there first — it may already be resolved and the surrounding doc just stale). -- `docs/referee_design_decisions.md` — referee rule-by-rule design decisions. -- `docs/roadmap.md` — running list of larger, not-yet-scheduled workstreams; check before - assuming a doc's claim about "not yet built" is still accurate — these drift. +- `docs/referee.md ("Design decisions")` — referee rule-by-rule design decisions. - `docs/signals.md` — every signal we record about how a strategy plays (stalls, fouls, chances created and conceded, ball losses, pass receptions, restarts), grouped by the question it answers, with where it lives in `summary.json`, a reference range and what an off value means. Read it when designing or debugging a strategy, and before adding a metric; they are diagnostics, not objectives. -- `docs/strategies.md` — strategy catalog: core or reserve, description, and real match - results per strategy. +- `pixi run dashboard`, Strategies tab — every strategy: core or reserve, its description (the + module docstring), verdicts, maps and matches, read from the code and `replays/`. - `utama_core/tests/engine/` and `utama_core/tests/run/` — the real tactic-kernel test surface; everywhere else is largely infrastructure (motion planning, vision, controllers) that predates and sits below the kernel model. diff --git a/README.md b/README.md index ee5e70c3..35558e5b 100644 --- a/README.md +++ b/README.md @@ -19,20 +19,20 @@ strategy layer that decides what every robot does. **New here? Write your first strategy: [docs/first_strategy.md](docs/first_strategy.md).** Everything runs in rsim with the in-process referee; grSim, the official GameController and -real robots are optional ([external setup](docs/setup_external.md)). +real robots are optional ([external setup](docs/real_robot_setup.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision)). ## What are you working on? | Task | Start here | |---|---| | Your first strategy | [docs/first_strategy.md](docs/first_strategy.md) | -| Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/strategies.md](docs/strategies.md) | -| Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/debug/find_bugs.py RUN_DIR` for a run's worst problems | +| Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md) | +| Seeing what the robots did, and why | `pixi run dashboard` (every strategy's maps and replays); `tools/debug/find_bugs.py RUN_DIR` for a run's worst problems | | Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md) | | The referee | [docs/referee.md](docs/referee.md) | | Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | | The simulator | [vendor/rSim/FORK_NOTES.md](vendor/rSim/FORK_NOTES.md) | -| Real robots, vision, radio | [utama_core/team_controller/README.md](utama_core/team_controller/README.md), [docs/setup_external.md](docs/setup_external.md) | +| Real robots, vision, radio | [utama_core/team_controller/README.md](utama_core/team_controller/README.md), [docs/real_robot_setup.md, "External tools"](docs/real_robot_setup.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision) | | Which script does what | [docs/tools.md](docs/tools.md) | | Everything else | [docs/README.md](docs/README.md), the index of every doc | @@ -76,7 +76,7 @@ One tick of `StrategyRunner`, from vision, robot and referee data to robot comma ![One tick of StrategyRunner](docs/img/pipeline/one_tick.png) The same tick as a diagram, with every module: [docs/architecture.md](docs/architecture.md). How -vision, robot and referee data become one `Game`: [docs/pipeline_method.md](docs/pipeline_method.md). +vision, robot and referee data become one `Game`: [docs/architecture.md, "Pipeline method"](docs/architecture.md#pipeline-method). ## Contributing @@ -89,4 +89,14 @@ Work on a branch and open a pull request into `main`. A pull request needs: 4. every Copilot comment reviewed (not necessarily accepted); 5. an approval from an assigned reviewer. -Editor setup, pre-commit troubleshooting and the pixi environments: [docs/contributing.md](docs/contributing.md). +Tips: + +- Run `pixi install` again after adding a package (a folder with an `__init__.py`). +- In VS Code, if the run button picks the wrong environment, choose the interpreter by hand + (`Ctrl + Shift + P` → `Select Interpreter`). Format on save with the `Black Formatter` extension. +- When a commit fails the pre-commit checks, the hook has often fixed the files already: stage + them and commit again. +- A strategy branch (`strategy/*`) may change strategy code only + (`tools/dev/check_strategy_branch.py`), so it can't change what it is scored against. +- `CLAUDE.md` is a symlink to `AGENTS.md`: edit `AGENTS.md`. On native Windows without Developer + Mode, fix it with `git config --global core.symlinks true && git checkout -- CLAUDE.md`. diff --git a/docs/README.md b/docs/README.md index 54024677..96eba994 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,41 +1,14 @@ # Docs -Every doc in this folder, by kind. Docs that code comments cite but that were deleted are in git history. New to the repo: the [README](../README.md) first. - -## How to - -- [first_strategy.md](first_strategy.md): start here. Write, watch and evaluate a toy strategy, then let an agent write one. -- [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): writing and evaluating strategies and tactics: the tactic-kernel model, referee restarts, lessons from past tactic bugs, round-robins, observability tools. Read before any strategy-layer change. -- [referee.md](referee.md): the in-process `CustomReferee`: architecture, usage, profiles, and its known gaps. -- [referee_gui.md](referee_gui.md): the referee operator panel in the dashboard. -- [referee_integration.md](referee_integration.md): how referee commands reach robots (`RefereeOverride`) and what each command requires. +New to the repo: the [README](../README.md) first, then [first_strategy.md](first_strategy.md). +Docs that code comments cite but that were deleted are in git history. + +- [first_strategy.md](first_strategy.md): start here. Look around the strategies, then write, watch and evaluate your own. +- [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): the strategy layer and its evaluation: the tactic-kernel model, referee restarts, lessons from past bugs, the debugging tools. +- [tactic_model_design_decisions.md](tactic_model_design_decisions.md): why the strategy layer is shaped as it is, and what was deliberately not built. +- [signals.md](signals.md): every signal recorded about how a strategy plays, and the names of the pitch zones. +- [referee.md](referee.md): the in-process referee, how its commands reach robots, the operator panel, and its rule-by-rule design decisions. - [motion_planning_comparison.md](motion_planning_comparison.md): the motion-planning benchmark and how to read it. -- [motion_planning_results.md](motion_planning_results.md): its latest full run. +- [real_robot_setup.md](real_robot_setup.md): a test day with real robots, the field logs it records, and grSim / GameController / ssl-vision. +- [architecture.md](architecture.md): how the packages depend on each other, and how one tick turns vision, robot and referee data into commands. - [tools.md](tools.md): every script and pixi task, by purpose. -- [visual_guide.md](visual_guide.md): the game drawn on the pitch from real replays (how each strategy plays, one match over time, a restart, the motion planner), what each picture has shown us, and how to draw it. -- [setup_external.md](setup_external.md): grSim, the official GameController and AutoReferee. -- [real_robot_setup.md](real_robot_setup.md): a test day with real robots: ssl-vision on its own laptop, WSL networking and USB, the radio, and the checks before a robot moves. -- [field_logs.md](field_logs.md): real robot game logs: format, record types, calibration analysis, dead-time trimming, and release packaging. -- [contributing.md](contributing.md): editor setup, commits, pull requests and releases. - -## Design rationale - -- [tactic_model_design_decisions.md](tactic_model_design_decisions.md): why the strategy layer (engine, tactics, strategies) is shaped the way it is, and what was deliberately not built. -- [scheduling_math_model.md](scheduling_math_model.md): a mathematical model of tactic scheduling and role allocation, a companion to the above. -- [referee_design_decisions.md](referee_design_decisions.md): rule-by-rule decisions from auditing `CustomReferee` against the SSL rulebook. -- [pipeline_method.md](pipeline_method.md): how vision, robot and referee data are refined into one `Game` state, and one tick from state to robot commands. -- [architecture.md](architecture.md): the one-tick diagram, and the generated package dependency graph with its import-rule check. - -## Current results - -- [strategies.md](strategies.md): the strategy catalog: every strategy, its status, and its latest round-robin results. -- [pitch_zones.md](pitch_zones.md): names for the parts of the pitch (thirds, wings, centre, the box, danger), with a diagram. -- [signals.md](signals.md): every signal recorded about how a strategy plays, grouped by question, with reference ranges and what an off value means. - -## Open work - -- [roadmap.md](roadmap.md): larger open workstreams, and one-line pointers to finished ones. -- [sim_realism.md](sim_realism.md): how far rsim is from real matches, the realism scorecard, and the plan to close the gap with measured, randomized physics. -- [in_house_vision.md](in_house_vision.md): our own vision stack for lab days (per-session tag calibration, tags on robots), the experiments that decide it, and the 2026-10-22 test day's vision findings. -- [field_log_replay.md](field_log_replay.md): design for finding a moment in a field log and rerunning the decision code on its recorded inputs, and the physical setup's own errors (tag yaw and offset, kicker offset, cameras) as per-robot profiles. -- [testing_gaps.md](testing_gaps.md): kinds of testing gap that let bugs through, numbered (code cites them by number). diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index d592b0e2..5814a2b3 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -3,7 +3,7 @@ New to the repo? Start with [first_strategy.md](first_strategy.md); this page is the reference. Context for work under `utama_core/engine/`, `utama_core/tactics/`, `utama_core/skills/`, -`utama_core/strategy/`, or `tools/evaluation/`/`docs/strategies.md`. Assumes you've read the +`utama_core/strategy/`, or `tools/evaluation/`. Assumes you've read the root `AGENTS.md`. Design rationale and rejected alternatives: `docs/tactic_model_design_decisions.md` — read it before proposing a change to the kernel's shape. @@ -228,7 +228,7 @@ pieces in `strategy/pickers.py` rather than re-deriving them: `tests/engine/test_all_strategy_configs.py` picks it up the same way and runs it through the kernel invariants. Give its partitioner pure-function tests in `tests/strategy/test_.py` (a -`Game` built by hand, no rsim), and add a row to `docs/strategies.md`'s table. +`Game` built by hand, no rsim), and give the module a one-line docstring: the dashboard shows it. **Evaluating one,** cheapest first; stop as soon as a step fails: 1. **Tests:** its own, `test_all_strategy_configs.py`, then the full suite `--headless`. @@ -358,8 +358,7 @@ reaches `main` by pull request: from the main checkout first: pixi needs the environment, and the match results store (`replays/match_results/`) is what keeps a match from playing again. 2. Change only `utama_core/strategy/`, `utama_core/tactics/` (new modules only), - `utama_core/tests/strategy/` (tests for your strategy and any tactic you add) and - `docs/strategies.md`. CI fails a `strategy/*` pull request that changes anything else + and `utama_core/tests/strategy/` (tests for your strategy and any tactic you add). CI fails a `strategy/*` pull request that changes anything else (`tools/dev/check_strategy_branch.py`, run from `main`'s copy). Anything else it needs, such as a skill or an engine primitive, is a separate change on an ordinary branch. 3. Leave the opponents as they are on `main`: either add new strategy modules or change exactly one existing strategy, never both, and never @@ -370,7 +369,7 @@ reaches `main` by pull request: no changing attributes of what it imports. CI checks all of this statically, from `main`'s copy of the checker; the reviewer still reads the diff. Tests import pickers from your module directly. -4. Write, test and evaluate it as above, and record the verdict in `docs/strategies.md`. +4. Write, test and evaluate it as above, and put the verdict in the pull request. `git add` new files before `pixi run lint`: it checks tracked files only. Before waiting on an evaluation, read the "X from the match results store, M to play" line it prints: M much larger than your own matches means the store is stale (shared code changed since it was filled). @@ -411,11 +410,11 @@ whoever runs it. slots about every 1.5 s, in pairs of rows at the same tick. It is not pendulum's alone: most strategies that split attack and defence on possession take a tactic for under 1 s and revert about 5 times a minute (the `tactic_thrash` finding, with the numbers per strategy in `tools/debug/match_timeline.py`): - ![pendulum lanes thrashing between attack and defence slots](img/match_timeline/pendulum_100-160.png) + ![pendulum lanes thrashing between attack and defence slots](img/match_timeline/split_shape_100-160.png) - **`render_clip()`** (`analysis/render_clip.py`) — MP4 of a window for humans, ball-following or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. -- **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. +- **`pixi run dashboard`**, Strategies tab — every strategy, core or reserve, its verdicts, maps and matches. - **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`); see [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: `tools/debug/repro_from_replay.py` restarts it from any moment with tracing on. @@ -438,7 +437,7 @@ whoever runs it. colour and robot id only, so every pairing in a run gets the same physics and A/B comparisons stay paired; the same seed replays a match exactly. Settings and draws go into each replay (`columnar_reader.load_sim_noise`) and `summary.json`, and into the match key only when set. - Ranges and their sources are in `tools/evaluation/reference/world.json` (the Phase 1 numbers are in `docs/sim_realism.md`). + Ranges and their sources are in `tools/evaluation/reference/world.json`. - **`tools/debug/replay_trace.py REPLAY.npz T0 T1`** — text trace of a window: referee command and why it changed, ball, nearest robot per side. The first look at a stall or a voided restart. - **`tools/debug/repro_from_replay.py`** — reload a replay's field state at time *t* into a fresh headless @@ -504,7 +503,7 @@ The picture tools (`tools/debug/match_timeline.py`, `tools/debug/restart_picture ball, while the current planner's carrot from those states is the push-out point 0.85 m from the ball. 3. **Find the cause in the code**, from what the trace shows: which tactic or override sent the robot there, and the target, waypoint and obstacles it used. Ask whether the rule was really - broken (real rules, `docs/referee_design_decisions.md`) and whether the check reads it + broken (real rules, `docs/referee.md ("Design decisions")`) and whether the check reads it right. 4. **Fix the cause, with a unit test at the boundary** (CLAUDE.md, Testing), e.g. "a computed target is off the field". That test is the protection, and it does not need the foul to @@ -542,7 +541,7 @@ way whatever the strategy. Moments are captured from replays (`capture`); hand-m | STOP with the ball just out over the goal line: our robot drives into their keeper (field day 2026-10-27) | robot ignoring a robot | the clear-of-the-ball target, clamped back onto the pitch, was 0.23 m from the keeper standing on its line | field-day-20261027 branch: clearing targets keep `_ROBOT_SPACING_M` (2 robot radii + 10 cm) from every robot, moving on round the ball | `test_referee_unit.py` (TestClearingTargetsKeepOffRobots) | The last row matters on real robots only: in sim matches `StrategyRunner` teleports a placed ball -to its target (`docs/referee_design_decisions.md`, Ball placement), so our placer never +to its target (`docs/referee.md ("Design decisions")`, Ball placement), so our placer never runs in a round-robin. Its moment was dropped for that reason: check that a moment's behaviour happens in sim matches at all before keeping it. The placer is still slow (about 5 s round the ball, and the carry curves off line), a real-robot item. @@ -619,7 +618,7 @@ What a converted match holds, and where it differs from a sim replay (the detail `NORMAL_START` and keeps `DIRECT_FREE_*` until the next stoppage. The converter switches it to `NORMAL_START` once the ball has moved 0.05 m, as our referee does. - `.source.json` holds the teams, the final score, the tracker used and the field size. -- Sidecars for measuring physics and vision (sim realism, [sim_realism.md](sim_realism.md)), +- Sidecars for measuring physics and vision (sim realism), not read by any replay tool: `.kicks.json`, every kick the tracker reported (start, kicker, start position, velocity estimates, stop); `.tracker.zip`, per-tick ball and robot visibility and robot angular velocity; with `--raw-vision`, `.vision.zip`, every diff --git a/docs/architecture.md b/docs/architecture.md index 17ed4970..617e3297 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -5,7 +5,7 @@ How the packages under `utama_core/` depend on each other, and how one tick flow ## One tick The flow of one tick of `StrategyRunner`, from vision to robot (module paths under `utama_core/`; the -same steps in words: [README](../README.md#system-design)). [pipeline_method.md](pipeline_method.md) +same steps in words: [README](../README.md#system-design)). [Pipeline method](#pipeline-method) below describes the same path in more detail. ```mermaid @@ -192,3 +192,79 @@ flowchart LR Violations of the import rules (`replay/` never imports `analysis/`): none + +## Pipeline method + +![One tick of StrategyRunner](img/pipeline/one_tick.png) + +Drawn by `docs/img/pipeline/make_one_tick.py`; rerun it when a box's name changes. The same tick as a +Mermaid diagram with every module path: [One tick](#one-tick) above. + +How vision, robot and referee data become one `Game` state, and how one tick turns that +state into robot commands. Everything below runs inside `StrategyRunner` +(`utama_core/run/strategy_runner.py`). + +### Data in + +The referee is one of three sources (`run/referee_source.py`): none, the official +GameController over the network, or `CustomReferee`, which runs in the same process and is what +rsim matches and tournaments use (`docs/referee.md`). + +**Problem.** Combining new data with prior knowledge (e.g. a Kalman filter) kept bloating +`GameFrame` with new functions, and access to past and current state wasn't uniform. + +**Solution.** `Game` holds our best estimate of the true current state and is updated by a +chain of **refiners**: each takes the current game frame and one kind of new data and returns +an updated frame. Later refiners see earlier updates: `RobotInfoRefiner` takes has-ball from our +robots' IR, or infers it from the refined positions for a robot whose IR isn't trusted, and +takes the enemy's from their responses when the sim provides them (both teams in rsim). +Friendly and enemy robots expose the same fields, estimated from different sources. + +- **Multiple cameras** are combined inside `PositionRefiner`. +- **Falling behind:** receivers fill one-slot buffers (`deque(maxlen=1)`), and the main loop + runs at a fixed rate and takes only the latest vision and referee data each tick. +- `GameFrame` is immutable; receivers (network) are separate from refiners, which makes + testing easier. +- `GameHistory` (`utama_core/entities/game/game_history.py`) stores past frames. +- Before the first tick, `GameGater` waits until the frames hold the expected robots and ball. + +The uniform `GameTimeline`/`Predictions` interface (pluggable per-property predictors) from +earlier drafts was never built; predictions are ad hoc per call site. + +#### Inside PositionRefiner + +Camera combining and the Kalman filters (`data_processing/refiners/position.py`, +`data_processing/refiners/filters/kalman.py`). Smoothing and vanished-robot imputation are +separate switches; both run on the same per-robot filters. + +```mermaid +flowchart TD + cams["Raw vision, one RawVisionData per camera"] + comb["CameraCombiner.combine_cameras
_avg_robots per robot id, _combine_balls_by_proximity,
_bounds_check against VisionBounds"] + vd["VisionData
combined robots and balls"] + sw{"smooth_positions?"} + kf["KalmanFilter per robot, KalmanFilterBall
filters/kalman.py"] + imp{"impute_vanished?"} + vanish["_include_vanished_robots
Kalman predict for robots missing from vision"] + game["Game, GameFrame
entities/game/game.py"] + + cams --> comb --> vd --> sw + sw -->|yes| kf --> imp + sw -->|no| imp + imp -->|yes| vanish --> game + imp -->|no| game +``` + +### One tick + +`CustomReferee` steps first (when in-process), then each side refines its frame, the replay +writer and `MatchStats` record it, and `AbstractStrategy.step` runs the strategy layer: +`Strategy.tick` (referee overrides, tactic slots), tactics, skills, then the `MotionController` +(fpp, dwa or trajsample) turns targets into one `RobotCommand` per robot for rsim, grSim or the +real robots. + +In rsim both teams run in one `StrategyRunner`: each side has its own refiners, strategy and +motion controller and steps in turn, alternating which goes first. `MatchStats` and the replay +writer follow one side's frames. The dashboard's vision stream renders the same frames. +`docs/STRATEGY_DEVELOPMENT.md` covers the strategy layer; `docs/motion_planning_comparison.md` +the motion controllers. diff --git a/docs/first_strategy.md b/docs/first_strategy.md index 9b0aa4ed..318ca9bb 100644 --- a/docs/first_strategy.md +++ b/docs/first_strategy.md @@ -20,7 +20,7 @@ You can pick any two strategies: pixi run main riptide terrier ``` -The strategies are listed in [strategies.md](strategies.md). +Step 2 shows every strategy on the dashboard. ## 2. Look around our strategies @@ -212,7 +212,6 @@ You decide what to keep. ## Where to go next -- [strategies.md](strategies.md): every strategy and how it plays. - [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): how strategies and tactics really work. Read it when you want to write a proper tactic. - `utama_core/tactics/`: real tactics to copy from. diff --git a/docs/img/pipeline/make_one_tick.py b/docs/img/pipeline/make_one_tick.py index e513774c..ea983f57 100644 --- a/docs/img/pipeline/make_one_tick.py +++ b/docs/img/pipeline/make_one_tick.py @@ -1,4 +1,4 @@ -"""Draws one_tick.png for docs/pipeline_method.md and the README: one tick of StrategyRunner, from the data +"""Draws one_tick.png for docs/architecture.md ("Pipeline method") and the README: one tick of StrategyRunner, from the data sources to the robots, with the class or module behind each box. pixi run python docs/img/pipeline/make_one_tick.py diff --git a/docs/img/pitch_zones/make_pitch_zones.py b/docs/img/pitch_zones/make_pitch_zones.py index 24cf721d..3b551dd3 100644 --- a/docs/img/pitch_zones/make_pitch_zones.py +++ b/docs/img/pitch_zones/make_pitch_zones.py @@ -1,4 +1,4 @@ -"""Draws pitch_zones.png for docs/pitch_zones.md, from STANDARD_FIELD_DIMS. +"""Draws pitch_zones.png for docs/signals.md ("Pitch zones"), from STANDARD_FIELD_DIMS. pixi run python docs/img/pitch_zones/make_pitch_zones.py """ diff --git a/docs/real_robot_setup.md b/docs/real_robot_setup.md index 4021446e..3009d002 100644 --- a/docs/real_robot_setup.md +++ b/docs/real_robot_setup.md @@ -135,7 +135,7 @@ Set the "Test-day configuration" block of `tools/field/shooting_drill.py`: `FIEL `CAMERA_HALF` (`"full"` when the cameras cover the whole field), each robot's vision and radio ID and working hardware. Then `pixi run python tools/field/shooting_drill.py`, open http://localhost:8080 and go through the Live tab's field check -([referee_gui.md](referee_gui.md#field-check-camera-runs)): every row green or +([referee.md, "Operator panel"](referee.md#operator-panel)): every row green or amber, each robot under its own ID and colour, a ball in each corner inside the area in play, and a robot pushed by hand across the cameras' overlap moving smoothly (a jump there means the two calibrations disagree). Only then Force Start. @@ -276,3 +276,161 @@ far to trust them. An older log is measured again with | Whole image tinted one colour | White balance stuck at an extreme (2800 K): auto, then lock | | `vision_check` sees nothing | Different networks, Wi-Fi multicast, `.wslconfig` not mirrored, or the firewall rule missing | | Dashboard: "Address already in use" | Another dashboard (`pixi run dashboard`) holds 8080: stop it | + +## Field logs + +Recorded on the physical pitch during real robot test days: vision frames, referee commands, +bidirectional radio packets, and session metadata. + +--- + +### 1. File Location & Binary Format + +- **Location**: `replays/field/_real_.log.gz` +- **Specification**: Follows the official RoboCup SSL Game Log format (`SSL_LOG_FILE`), stored compressed with standard `gzip`. +- **Streaming**: Python readers stream `.log.gz` directly without uncompressing: + ```python + from utama_core.replay.ssl_log import read_records + + for ts_ns, msg_type, payload in read_records("replays/field/.log.gz"): + ... + ``` + +#### Record Types + +| Type ID | Name | Contents | +|---|---|---| +| `4` | `VISION_2014` | Raw `SSL_WrapperPacket` from ssl-vision cameras (pixel positions, confidence, detection timestamps). | +| `3` | `REFEREE` | `Referee` state updates (commands, stage, score, team cards). | +| `100` | `RADIO_OUT` | 12-byte packed commands sent to robots over serial radio (forward, left, turn velocities, kick power, dribbler). | +| `101` | `RADIO_IN` | Feedback packets returned by robots (IR ball sensor trigger state). | +| `102` | `RUN_INFO` | Initial session metadata JSON: git commit SHA, dirty flag, vision-to-radio mapping, field bounds. | +| `103` | `NOTE` | Human operator notes entered from the dashboard during testing. | + +--- + +### 2. Analysis & Calibration Tools + +Every field log contains the ground-truth signals needed to evaluate robot hardware: + +#### Robot Calibration (`tools/field/robot_calibration.py`) +Recovers physical dynamics and kicker geometry from a field test: +```bash +pixi run python tools/field/robot_calibration.py replays/field/.log.gz +``` +- **Loop Latency**: Sensing-to-action delay measured between commanded motion and camera-observed velocity (~61–62 ms). +- **Acceleration Limits**: Measured forward acceleration (~4.0–6.0 m/s²) vs. lateral acceleration (~2.7–3.6 m/s²). +- **Kick Characteristics**: Median ball launch velocity, directional offset bias (+2.7°), and bend caused by off-center dribbler contact (~4.2°/cm). +- **Dribbler Retention**: Sustained carry velocity and turn rate caps before the ball escapes (0.3 m/s, 0.6 rad/s). +- **Output**: Writes `.calibration.json`. + +#### Tag Alignment Calibration (`utama_core/analysis/tag_calibration.py`) +Measures optical tag placement relative to the chassis center: +```bash +pixi run python -m utama_core.analysis.tag_calibration replays/field/.log.gz +``` +- Fits circle trajectories during in-place spins to determine `(forward_m, left_m)` offsets. + +#### Proximity & Close Calls (`utama_core/analysis/close_calls.py`) +Scans logs for incidents where robots came closer than 0.25 m: +```bash +pixi run python -m utama_core.analysis.close_calls replays/field/*real*.log.gz +``` + +#### Converting to Replay (`tools/realism/convert_ssl_log.py`) +Converts an SSL game log into our columnar `.npz` + `.pkl` replay format for replay visualization and scenario debugging: +```bash +pixi run python tools/realism/convert_ssl_log.py replays/field/.log.gz --out replays/field/ +``` + +--- + +### 3. Storage & Dataset Management + +Raw field logs accumulate substantial disk space over a testing day. Three built-in tools manage log sizes: + +#### 1. In-Place Compression +Raw `.log` files should be compressed to `.log.gz`: +```bash +pixi run package-field --compress-in-place +``` +Reduces log sizes by **50%–60%** with zero data loss. All analysis tools support `.log.gz` out of the box. + +#### 2. Trimming Idle Time Sectors (`tools/field/trim_idle_log.py`) +Field sessions frequently capture long periods of inactivity where the referee command is `HALT` or `STOP` (e.g. operators manually setting up the ball or discussing tests). Over **55% of field log duration is trailing dead time**: +```bash +# Preview reduction without modifying files +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --dry-run + +# Trim dead stretches and trailing halt in-place +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --in-place +# Or batch trim all field logs: +pixi run trim-field +``` +- Automatically removes idle pauses longer than 5 seconds while keeping 1.0 second safety padding around transitions. +- Fully strips trailing idle time recorded after drills end. +- Typically cuts file size by **65%–75%** while preserving every active drill frame. + +#### 3. Packaging & Distributing (`tools/field/package_logs.py`) +Creates self-contained release archives of field logs and calibration results: +```bash +pixi run package-field +``` +Bundles all `.log.gz` logs, `*.calibration.json`, and hardware profiles into `replays/field_logs_.tar.gz` for team sharing or dataset archival. + +## External tools: grSim, GameController, AutoReferee, SSL Vision + +None of this is needed for everyday work: rsim and the in-process +[`CustomReferee`](referee.md) run everything headless with no external process, and +behave the same across rsim, grSim and real mode. Set these up only to run against grSim, the +official competition software, or real robots. + +### grSim + +1. Go to the [grSim repo](https://github.com/RoboCup-SSL/grSim) and follow its + [installation steps](https://github.com/RoboCup-SSL/grSim/blob/master/INSTALL.md). +2. Change the configuration to the values highlighted below: + + ![grsim_setup](../assets/images/grsim_setup.png) + +3. To run it, execute `./bin/grSim` in the cloned repo. + +### AutoReferee and the GameController + +1. Make sure `grSim` is set up and can be called from a terminal. +2. `git clone` the [AutoReferee repo](https://github.com/TIGERs-Mannheim/AutoReferee) into a + folder named `AutoReferee/` in the repository root. +3. Change `DIV_A` to `DIV_B` in `AutoReferee/config/moduli/moduli.xml`: + + ```xml + + ROBOCUP + DIV_B + + ``` + +4. Get the latest [compiled game controller](https://github.com/RoboCup-SSL/ssl-game-controller/releases/), + rename it to `ssl-game-controller`, and save it in a `ssl-game-controller/` directory in the + repository root. + +Both directories are gitignored. + +#### Starting the external test environment + +Only needed to test against the official referee software; the in-process `CustomReferee` +needs none of this. With grSim, the GameController and AutoReferee set up, start each in its +own terminal from the repository root: + +```bash +grSim +cd ssl-game-controller && ./ssl-game-controller +cd AutoReferee && ./gradlew run +``` + +Then run your own strategy. The GameController's web UI is at http://localhost:8081/#/match +(this repo's dashboard is :8080). + +### SSL Vision and the radio for real robots + +The whole procedure (vision laptop, WSL networking and USB, radio, the checks before a robot +moves) is in [real_robot_setup.md](real_robot_setup.md). diff --git a/docs/referee.md b/docs/referee.md index 2aa245b0..394c7b75 100644 --- a/docs/referee.md +++ b/docs/referee.md @@ -49,7 +49,7 @@ Built in `_build_active_rules` (`custom_referee.py`), in this priority order; de | `KeepOutRule` | `DIRECT_FREE_*`, `PREPARE_KICKOFF_*` | Defending team within 0.5m for 30 consecutive frames: non-stopping, 2 s re-raise, restarts the free kick's 10 s clock (§8.4.3). Not during bare `STOP` or penalties, nor once a free kick is taken (stage 3 of the state machine: the ball moved 0.05m, so it is live). | | `PenaltyTimeLimitRule` | `NORMAL_START`/`FORCE_START` after `PREPARE_PENALTY_*` | Penalty still in play 10 s after its normal start: goal kick for the defenders (§5.3.5). | | `NoProgressRule` | live play | Ball hasn't moved 0.05 m in 10 s: `STOP` then `FORCE_START` where it lies, moved out of the opponent's defense area if it is inside it (`legal_restart_position`, §8.1). The clock waits for the ball to be in play (a `NORMAL_START` restart: 0.05 m of movement or the 10 s auto-in-play) and is held while the ball is inside either defense area. Last in the list, so a real foul on the same tick wins. | -| `PushingRule`, `KeeperHeldBallRule`, `ExcessiveDribblingRule`, `RobotStopSpeedRule`, `CrashingRule`, `DefenseAreaStoppageRule`, `BallPlacementInterferenceRule` | see each rule file | SSL §8.3/8.4 audit (`434ab29`). Rationale per rule: `referee_design_decisions.md`. | +| `PushingRule`, `KeeperHeldBallRule`, `ExcessiveDribblingRule`, `RobotStopSpeedRule`, `CrashingRule`, `DefenseAreaStoppageRule`, `BallPlacementInterferenceRule` | see each rule file | SSL §8.3/8.4 audit (`434ab29`). Rationale per rule: `referee.md ("Design decisions")`. | ## State machine and auto-advance @@ -148,5 +148,245 @@ ball speed, full-episode reset, teams changing ends at half-time, ```bash pixi run pytest utama_core/tests/referee/ --headless pixi run python examples/demo_custom_referee.py # pygame, 6 scripted rule scenes; SPACE pause, R restart, ←/→ skip -pixi run python examples/demo_referee_gui_rsim.py # RSim + dashboard referee tab, see referee_gui.md +pixi run python examples/demo_referee_gui_rsim.py # RSim + dashboard referee tab, see "Operator panel" below ``` + +## How commands reach robots + +How referee commands reach robots, and what each command requires. The original py_trees +integration is gone (BT removed in `087ee4b`, `960662c`, `48affd6`); the current mechanism is +`RefereeOverride` (`utama_core/engine/referee_override.py`, design: §13 of +`tactic_model_design_decisions.md`) driving the `*Step` classes in +`utama_core/referee/actions.py`. + +### Data path + +``` +AutoReferee UDP 224.5.23.1:10003 → RefereeMessageReceiver ─┐ (Real/grSim with the official GC) +CustomReferee.step() ──────────────────────────────────────┴→ ref_buffer (deque maxlen=1) + → StrategyRunner._run_step → RefereeRefiner.refine(game_frame, referee_data) + → game.referee → RefereeOverride (restart/stop commands) or the Strategy (live play) +``` + +In WSL, multicast UDP needs `networkingMode=mirrored` in `.wslconfig`. + +`RefereeData` carries `referee_command`, `stage`, `stage_time_left`, `blue_team`/`yellow_team` +(`TeamInfo`: score, cards, goalkeeper id, fouls, `can_place_ball`), `designated_position`, +`blue_team_on_positive_half`, `next_command`, `current_action_time_remaining`, +`source_identifier`, plus `game_events`, `match_type`, `status_message` — the last three are +excluded from `__eq__` so they don't trigger spurious re-records in `RefereeRefiner`. + +### Required behaviour per command ([SSL rulebook](https://robocup-ssl.github.io/ssl-rules/sslrules.html)) + +| Command | Our robots must | +|---|---| +| `HALT` | Zero velocity (2s braking grace). Highest priority. | +| `STOP` | ≤1.5 m/s, ≥0.5m from ball, ≥0.2m from opponent defense area, no ball contact. | +| `TIMEOUT_*` | Nothing forced; handled as `STOP`. | +| `PREPARE_KICKOFF` ours / theirs | All but the kicker in own half outside the 0.5m centre circle; kicker approaches, no touch. Theirs: everyone in own half outside the circle. | +| `PREPARE_PENALTY` ours / theirs | Kicker to the mark, no touch; others ≥0.4m behind the mark line. Theirs: keeper on own goal line, others ≥0.4m behind the mark. | +| `DIRECT_FREE` ours / theirs | Kicker approaches and may shoot after the ball moves ≥0.05m. Theirs: all ≥0.5m from ball, full speed allowed. | +| `BALL_PLACEMENT` ours / theirs | One robot places the ball at `designated_position` (±0.15m); others ≥0.5m. If `can_place_ball` is False, behave as `STOP`. Theirs: ≥0.5m from ball and target. | +| `NORMAL_START`, `FORCE_START` | Live play — no override; the Strategy runs. | + +Yellow/blue variants are resolved to ours/theirs at tick time against +`game.my_team_is_yellow`, so nothing depends on team colour at construction time. + +### Pre-rewrite baseline (BT priority tree) + +Code comments cite this: the old tree put a referee `Selector` as the first child of every +strategy's root, one `Sequence` per command in priority order — `HALT`, `STOP`, +`TIMEOUT_YELLOW|BLUE` (dispatched to `StopStep`, same as `STOP`), ball placement, kickoff, +penalty, direct free — each `CheckRefereeCommand(...)` → `*Step`, falling through to the +strategy tree on `NORMAL_START`/`FORCE_START`. `RefereeOverride` keeps that command→Step +mapping as a plain class. + +### Open + +- **Ball placement before a free kick.** The rulebook sequence after ball-out is + `STOP → BALL_PLACEMENT_* → DIRECT_FREE_* → NORMAL_START`; `OutOfBoundsRule` still queues + `DIRECT_FREE_*` directly (in sim the ball is teleported instead). Depends on reliable + `BallPlacementOursStep` carrying. +- **Placement carry mechanics.** Single-robot dribble tends to push rather than carry; options + are a dedicated slow "get-behind-ball" approach or the two-robot technique most SSL teams use. +- **Pre-positioning from `next_command`** during `STOP` — an optimisation, not a compliance need. +- **Operator GUI "suggested next step"** based on the current command, so an operator decides + only *when* to advance, not *what*. + +## Operator panel + +The browser operator panel for `CustomReferee` is the dashboard's referee tab +(`utama_core/dashboard/views/referee.py`). Attach it with: + +```python +server = attach_dashboard() # utama_core.dashboard +referee_view.attach(server, referee, profile) # utama_core.dashboard.views.referee +``` + +`examples/demo_referee_gui_rsim.py` does this with RSim, the `human` profile and +`weaver` (constants `PROFILE`, `N_ROBOTS`, `MY_TEAM_IS_YELLOW`, `MY_TEAM_IS_RIGHT` at +the top of the file): + +```bash +pixi run python examples/demo_referee_gui_rsim.py # then open http://localhost:8080 +``` + +The page shows the score, current/next command, stage and time left, `designated_position`, the +field, the active profile and an event log; a button issues each command. + +### Field check (camera runs) + +With vision from a camera (real robots or grSim) the Live tab also shows the field check +(`utama_core/run/field_check.py`), one row per question, red / amber / green: + +| Row | Fails (red) when | Warns (amber) when | +|---|---|---| +| Camera | no vision packet for 0.5 s | | +| Field size | ssl-vision's geometry differs from `full_field_dims` | no geometry packet yet | +| ` ` (each robot we drive) | never seen, lost by vision 0.5 s, or more than 0.3 m outside `field_bounds` | | +| ` radio` (real only) | it answered on the radio, then stopped | it has not answered yet (the firmware may send no feedback) | +| ` ` (any other) | | seen inside `field_bounds` but not configured: our planners cannot see it, often a wrong ID | +| Ball | | not seen, or outside `field_bounds` | + +Before it gets that far, the runner keeps our robots inside `field_bounds` on camera runs +(`utama_core/run/field_fence.py`): each robot's speed towards an edge is capped to what it can +stop from before the line, whatever tactic sent the command, so a robot chasing a ball out of the +camera's area stops at the line. The planners' walls at `field_bounds` are only obstacles to plan +around, and did not stop it (0.5–0.9 m out in grSim before the fence). + +Only the red and amber rows are listed; the green ones fold into an "N ok" line that opens on +click. On real robots any red row forces `HALT`, whatever the command and whether or not the page is +open; the red banner says why. Pressing Force Start while a row is red halts again at once, so +the check is also the pre-start gate. The field is drawn as ssl-vision sees it (+x to the right), +with everything outside `field_bounds` dimmed, so a half-field test shows which half the runner +expects. Space halts; nothing on the keyboard starts the robots. The Kickoff and Free Kick +buttons are hidden when the profile has no rule that sets up a restart (goal detection only). + +### Strategy panel + +A script can let the page change what each side plays, or restart it, without restarting the +run (`utama_core/dashboard/views/strategy.py`): + +```python +strategy_view.attach(server, runner, + choices={"my": {"lead": make_lead, "press": make_press}}, # name -> builds a fresh AbstractStrategy + running={"my": "lead"}) +``` + +The Live tab then lists the choices per side with a Run button; Run on the one running restarts +it. `StrategyRunner.replace_strategy` takes the new strategy at the next tick and only while +halted, so the page refuses otherwise. `tools/field/shooting_drill.py` offers its attacker +and defender tactics this way. + +### Commands and what robots do + +| Button | Command | Use | Robots | +|---|---|---|---| +| Halt | `HALT` | Emergency / unsafe | Zero velocity | +| Stop | `STOP` | Between incidents, pre-match | ≤1.5 m/s, stay ≥0.5m from the ball | +| Normal Start | `NORMAL_START` | Restart formation is in position | Live play | +| Force Start | `FORCE_START` | Stalled play | Live play from the ball's current position (a tactic barrier reset, see `tactic_model_design_decisions.md` §4) | +| Kickoff Y/B | `PREPARE_KICKOFF_*` | Half start, after a goal | Kicker to centre, others to own half | +| Free Kick Y/B | `DIRECT_FREE_*` | Foul by the other team | Kicker to ball, opponents ≥0.5m | +| Penalty Y/B *(advanced)* | `PREPARE_PENALTY_*` | Manual override | Kicker at mark, others behind the line | +| Ball Placement Y/B *(advanced)* | `BALL_PLACEMENT_*` | Manual placement | One robot carries ball to `designated_position` | + +Typical sequences: `Halt → Stop → Kickoff Yellow → Normal Start` to start a half; +`Stop → Free Kick → Normal Start` for a manual free kick. With `human`, nothing auto-advances — +after a goal the referee stays in `STOP` until the operator acts. + +For a physical field, keep every `auto_advance` flag false so robots never start moving until +the operator presses a button. Profile keys, auto-advance triggers and making a custom profile: +above. + +## Design decisions + +Decisions from the audit of `CustomReferee` against the SSL rulebook. Numbers are stable. + +### Resolved + +1. **`human` profile keeps `STOP` after goals** (2026-03-31) — every auto-advance is off in + `human`, so an operator advances each stoppage. `simulation` auto-progresses. +2. **`PrepareKickoffTheirsStep` enforces own half** (2026-03-13) — after radial clearance, each + robot's x is clamped to our half. +3. **Unknown last touch no longer defaults to yellow** — `infer_last_touch_team` + (`rules/last_touch.py`) attributes colour-blind, and `OutOfBoundsRule` leaves the restart + unresolved rather than favouring a colour. +4. **`KeepOutRule`'s violation count doesn't carry over** — `CustomReferee.step()` calls + `rule.reset()` on every command transition. +5. **`BallPlacementTheirsStep` actively clears** (2026-03-13) — robots within 0.55m of the ball + are pushed radially outward, as in `DirectFreeTheirsStep`. Line-segment clearance (ball to + target) is deferred. +6. **`GoalRule` only fires in live play** — no change needed: the ball isn't in play during a + stoppage, so a goal then doesn't count. +7. **Penalty positioning, partial** (2026-03-13) — non-kickers go to the touch line + (y = ±3.0m) behind the mark. Fully off-field placement is deferred until the simulator + supports it. Penalties stay disabled in the built-in profiles. + +### Foul to restart + +Which violation gives which restart, and to whom, as the code does it (`_handle_goal` and +`_handle_foul` in `state_machine.py`). A stopping violation always goes through STOP first; when it +carries a spot, the team that gets the restart places the ball there before the restart. + +```mermaid +flowchart LR + goal["Goal
rules/goal_rule.py"] + ft["Free-kick fouls
out_of_bounds_rule.py (incl. aimless kick), double_touch_rule.py,
keeper_held_ball_rule.py, excessive_dribbling_rule.py,
pushing_rule.py (one side at fault), penalty_time_limit_rule.py"] + pen["Extra defender touches ball in own box
defense_area_rule.py"] + fs["Pushing with similar force, no progress
pushing_rule.py, no_progress_rule.py"] + stop2["2nd Defense Area Stoppage foul
defense_area_stoppage_rule.py"] + nons["Non-stopping: ball speed, crashing, keep-out, attacker in box,
robot stop speed, placement interference, 1st stoppage foul"] + o1["Kick-off for the team that conceded
BALL_PLACEMENT at centre, then PREPARE_KICKOFF"] + o2["Free kick for the other team
BALL_PLACEMENT at spot, then DIRECT_FREE
out of bounds with no known last touch: STOP only"] + o3["Penalty for the attacking team, no foul counter
BALL_PLACEMENT at penalty mark, then PREPARE_PENALTY"] + o4["FORCE_START where the ball lies
no placement, sim teleports the ball"] + o5["HALT; the interrupted restart is queued again on resume"] + o6["Foul counter and cards only
command unchanged"] + + goal -- "goal" --> o1 + goal -- "scorer fouled in last 2 s: invalid_goal" --> o2 + ft --> o2 + pen --> o3 + fs --> o4 + stop2 --> o5 + nons --> o6 +``` + +### Rulebook audit (2026-09-28, Division B) + +Checked against the [SSL rulebook](https://robocup-ssl.github.io/ssl-rules/sslrules.html). +"Sim" rows are deliberate deviations kept for the simulator; the reason is given. + +| Rule | Rulebook | Ours before | Action | +|---|---|---|---| +| Defender Too Close To Ball (§8.4.3) | 0.5 m during an opponent kick-off or free kick; non-stopping; resets the kick timer; 2 s grace per team; no automatic sanction during STOP | Stopped play and re-awarded the restart, also during penalties | Fixed: non-stopping, 2 s re-raise, off during penalties. Only the first foul of a free kick resets its clock: our cards never remove a robot, so a defender parked inside 0.5 m held a free kick for the rest of a match | +| Keeper during a penalty (§5.3.5) | Keeper on the goal line; others 1 m behind the ball; a positioning breach is a human call (§8.3.4), not Defender Too Close | `KeepOutRule` checked every defender, keeper included | Fixed by the row above: `KeepOutRule` no longer runs during penalties, so the keeper question is moot. Our non-kickers now walk round the ball to stand 1 m behind it | +| Attacker Touched Ball In Opponent Defense Area (§8.4.2) | Touching the ball while partly or fully inside; non-stopping | Presence (centre inside) stopped play with a free kick | Fixed: needs a touch, counts partial overlap (`ROBOT_RADIUS`), non-stopping, 2 s re-raise | +| Ball Speed (§8.4.2) | Over 6.5 m/s in 3D; non-stopping | Stopped play, free kick to the other team | Fixed: non-stopping. Gap: still measured on ground (x, y) speed, not 3D | +| Goal validity (§7) | No goal if the scorer committed a non-stopping foul in the last 2 s, or the ball went above 0.15 m | Any ball in the goal scored | Fixed: foul in the last 2 s turns the goal into a goal kick. Gap: ball height is not checked | +| No Progress In Game (§8.1) | 10 s without progress while both teams may play: stop, then force start | Missing | Fixed: `NoProgressRule`; STOP now continues to a queued FORCE_START once robots clear. The clock starts once the ball is in play (after a kickoff/penalty `NORMAL_START` that means 0.05 m of movement or the 10 s auto-in-play; it was firing 10 s after an unmoved restart, 226 of 422 false alarms in real matches). Not counted while the ball is inside either defense area (0 of 506 real calls there) | +| Penalty kick (§5.3.5) | Still in play after 10 s: stopped, no goal, goal kick for the defenders | The normal start turned into open play | Fixed: `PenaltyTimeLimitRule`. Not implemented: the keeper's 90° deflection and ball-moving-backwards endings | +| Ball in play after a free kick (§5.4) | In play 10 s after the free kick command | `DIRECT_FREE_*` waited for the kicker forever | Fixed: `FORCE_START` after 10 s (clock restarted once, by the first Defender Too Close foul) | +| Ball in play after a kick-off (§5.4) | In play 10 s after the kick-off | `NORMAL_START` → `FORCE_START` after 10 s if the ball hasn't moved | Already correct | +| Free-kick position (§5.3.3) | ≥ 0.2 m from all lines and ≥ 1 m from either defense area, else the closest valid spot | 0.65 m from a defense area (planner margin) | Fixed: 1 m. Sim: the spot is pushed out along x only (a square corner), not to the Euclidean closest point, and lines aren't re-clamped for in-field positions | +| Throw-in, goal kick, corner kick (§6.1.1, §6.2.1–2) | Throw-in 0.2 m in from the touch line; goal kick 1 m / 0.2 m; corner kick 0.2 m / 0.2 m, in the corner | Ball placed where it crossed, 0.25 m infield, 0.5 m on both axes near a corner, then kept 1 m off the box | Fixed: over a goal line, a corner kick 0.5 m from both lines or a goal kick 1 m from the goal line, 0.5 m from the touch line, the same spot as every other goal kick (`RefereeGeometry.goal_kick_position`; a disallowed goal or a penalty out of time put it 0.2 m from the touch line) (placing it where it crossed made a free kick 2 m in front of goal: 521 kicks, 150 goals in one round-robin). Sim: 0.5 m, not 0.2 m, from the touch line, and a throw-in stays 0.25 m in; 0.2 m from two lines at once let a drifting ball go straight back out (the corner-loop fix in `OutOfBoundsRule`) | +| Aimless kick (§6.2.3, Div B) | A ball touched by a robot that then crosses the halfway line and the opponent's goal line outside the goal, touching no other robot: free kick for the opponent from where it was kicked | Not implemented: a goal kick in the opponent's corner, so a blind clearance cost nothing (28% of goal kicks led to one at the other end within seconds, tournament_20261005_170958) | Fixed: `OutOfBoundsRule` keeps where the ball was last touched in this spell of play (`last_touch.touching_team`), and restarts from there when the touch was on the far side of the halfway line, strictly (a kick-off from the line itself is not aimless); the spot is kept 0.25 m inside the lines and 1 m off the defense areas like any free kick. `out_of_bounds.aimless_kick`, on in both profiles: we play Division B | +| Free kick stages (§5.3.3) | One free-kick command; the kick puts the ball in play | One free-kick command; `DirectFreeOursStep` takes the kick and the ball moving 0.05 m from where it was when the command began makes it `NORMAL_START` (live play, and `KeepOutRule` stops). Fixed 2026-11-10: the referee also started play 2 s after the kicker came near, before any kick, and the tactics then stood over an unstruck ball. Before, the referee missed the kick and charged a defender the ball rolled onto with keep_out (`free_kick_robot_drives_in_at_start`). Auto-advance profiles only (`direct_free_to_normal`); a human-run referee issues `NORMAL_START` itself | +| Ball placement (§5.2) | The team places the ball | With a simulator controller, `StrategyRunner` teleports the ball to `designated_position` on entry to `BALL_PLACEMENT_*`, then the restart itself follows (only a `STOP` queued for `FORCE_START`, no progress, force-starts) | Sim: kept, so matches don't wait on physical placement. Real mode still places | +| Multiple Defenders (§8.4.1) | A non-keeper entirely inside its own area touching the ball: penalty | More than `max_defenders` (1) with centres inside, one touching | Fixed: the goalkeeper's own touch is exempt. The keeper id comes from the referee data on the frame (`GameFrame.referee`, the team info's `goalkeeper`); with no referee data attached every touch counts. The occupancy proxy (`max_defenders`) is kept | +| Double Touch (§8.2) | Kicker may not touch again before another robot; free kick from the ball position | Same | Already correct | +| Crashing | §8.4.2 | Any contact with closing speeds within 0.3 m/s of each other was a "both at fault" crash, including robots at rest against each other (6694 fouls in 231 matches; 30 of 97 goals then voided by the goal-validity rule) | Fixed: a crash needs > 1.5 m/s projected on the line between the robots; the 0.3 m/s band then compares the robots' own speeds, as TIGERs AutoReferee's `BotCollisionDetector` does. Its 0.1 s brake lookahead is modelled too (each robot's speed less 0.4 m/s, floored at 0, where TIGERs reverses it): without it a round-robin had 226 crashes to TIGERs' 8 over the same frames | +| Pushing, Keeper Held Ball, Excessive Dribbling, Robot Stop Speed, Too Close To Opponent Defense Area, Ball Placement Interference | §8.3–8.4 | Audited in `434ab29` | Already correct; not re-checked beyond thresholds (10 s, 1 m, 1.5 m/s, 0.2 m, 0.5 m, 2 s grace) | +| Match timing (Game Stages) | Two halves of 300 s of playing time with a 300 s half-time; the timer "is paused whenever no team is allowed to manipulate the ball" (stop, halt, kick-off and penalty preparation, ball placement); each half starts with a kick-off; the coin-toss winner chooses the goal it attacks in the first half | The clock was sim time since the stage began, running through every stoppage; nothing ended a half, so it stopped at 0 at 300 s of sim time and stayed there (score-aware strategies, via `is_late_in_half`, played their last-minute mode from 240 s on) | Fixed: the clock runs only under `NORMAL_START`, `FORCE_START` and free kicks; with `auto_advance.end_of_half` (on in `simulation`, off in `human`) the first half ends in a `STOP`, the ball goes to the centre and the team that didn't kick off the first half kicks off the second; the second half ends in `POST_GAME`, after which the referee ignores violations. At half-time the teams change ends (`blue_team_on_positive_half` swaps; `StrategyRunner` follows it). Sim: half-time takes 0 s | +| Boundary Crossing (§8.4.1) | Kicking the ball over the field boundary | Not implemented | Gap: rsim has no boundary wall to kick over | + +### Open + +8. **`TeamInfo` should be a frozen dataclass.** It is mutable, and `RefereeRefiner` stores + `RefereeData` records that referenced the live objects, so a later `increment_score()` + rewrote history and made `__eq__` drop new records. Workaround (2026-04-07): + `GameStateMachine._generate_referee_data()` snapshots with `copy.copy`. Long-term: make it + `@dataclass(frozen=True)` and replace mutations (`increment_score()`, + `parse_referee_packet()`, ...) with `dataclasses.replace()`, including the network referee + path. Deferred because it touches that path. diff --git a/docs/signals.md b/docs/signals.md index 2408eed5..cf201db2 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -5,7 +5,7 @@ when designing or debugging a strategy: find the question, read the signal, comp reference range, and follow "if it's off". Add a signal here when you add one anywhere else. *Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names -(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). +(`split_shape` is now `pendulum`, ...); the old name is under each strategy's name on the dashboard (`RENAMED` in `utama_core/strategy/catalog.py`). Signals are diagnostics, not objectives: use them to explain a result, to find what a strategy does badly, and to notice a shared primitive (reception, carrying, the planner, the referee) @@ -48,7 +48,7 @@ match results store (`replays/match_results/`). predict *losing* in this pool. Territory and attacking-third entries predict nothing. - **Weighted combinations** of match stats: the weights depend on the strategy pool they are fitted on, so a new strategy's score would depend on unrelated strategies. -- **A value model** of the game state (`docs/sim_realism.md`): no more reliable than goals. +- **A value model** of the game state (in git history: `docs/sim_realism.md`): no more reliable than goals. ## Where they come from @@ -199,3 +199,75 @@ Put it where it's cheapest: config_a only. Then add its row here with a reference range from a full round robin (`evaluate.py --all`). + +## Pitch zones + +Names for the parts of the pitch, so that people, agents, docs and code mean the same place. +Every zone is defined from one team's point of view: "defensive" is near that team's own goal, +"left" is on its left as it faces the goal it attacks. Measurements are for the standard 9 × 6 m +field (`STANDARD_FIELD_DIMS`). + +![Pitch zones](img/pitch_zones/pitch_zones.png) + +(Drawn by `docs/img/pitch_zones/make_pitch_zones.py`.) + +### Along the pitch: thirds + +| Name | Where | In code | +|---|---|---| +| **Defensive third** | the 3 m nearest our own goal line | `ball_zone()` returns `"own"`; `MatchStats` robot zone time `"defensive"` | +| **Middle third** | 3 to 6 m from our goal line, either side of halfway | `"mid"` in both | +| **Attacking third** | the 3 m nearest the goal we attack | `ball_zone()` returns `"final"`; `MatchStats` `"attacking"`, `attacking_third_entries` | + +Each third is a third of the pitch length, measured from our own goal line toward the goal we +attack. On the standard field the boundaries are at |x| = 1.5 m. Say "defensive" and +"attacking" rather than "own" and "final"; the code's `own`/`final` are older spellings of the +same thirds. + +**Our half / their half**: either side of the halfway line. + +### Across the pitch: wings and centre + +| Name | Where | +|---|---| +| **Left wing** | the 2 m strip along the touch line on our left as we attack | +| **Centre** | the 2 m strip down the middle, as wide as the box, so it runs straight at both goals | +| **Right wing** | the 2 m strip along the touch line on our right | + +The centre is |y| ≤ 1 m (the box's half width). Left and right turn with the team: for a team +attacking toward +x, its left wing is y > 1 m; for a team attacking toward −x (`my_team_is_right`), +its left wing is y < −1 m. So the two teams' left wings are on opposite touch lines. + +No tactic uses the lanes yet; one that needs them should use these boundaries. + +**Ball side / far side**: the wing the ball is on, and the wing opposite it. When the ball is in +the centre, neither applies. **Weak side** is not the same thing: in `SwitchOfPlayTactic` +(`_weak_side`) it is the half of the pitch, split at y = 0, with fewer opponents in it, wherever +the ball is. + +### Cells + +A third and a strip together name one of nine cells: "attacking left wing", "defensive centre". + +### Areas the rules define + +- **The box**: the defense area, 1 m deep and 2 m wide in front of each goal. At most one + defender (the goalkeeper) may be inside its own box, and attackers may not enter the + opponent's (`referee/rules/defense_area_rule.py`). "Our box" and "their box" are from + the team's point of view. Code calls it the defense area (`FieldDimensions.right_defense_area`). +- **The goal**: 1 m wide. +- **The centre circle**: 0.5 m radius; it matters at kickoffs. + +### Words with a fixed meaning + +- **Danger**: the opponent has possession with the ball in our defensive third in live play. + Possession is the team's: a pass between two opponents, or their shot, stays theirs until we + touch the ball. The signal + `danger_s` counts the seconds of it (`analysis/chances.py`; see [signals.md](signals.md)). + Don't use "danger" for anything else. +- **Clearance condition**: when `ClearBallTactic` clears (`clear_ball.in_danger`): the ball within + 2.6 m of our goal line and an opponent within 1.2 m of it. It is narrower than danger; the function's + name predates this doc. +- **Entry**: the ball crossing into a team's attacking third, whoever touched it last + (`attacking_third_entries`). Once in, it has to come back 0.3 m behind the line before it can + count again. diff --git a/docs/tactic_model_design_decisions.md b/docs/tactic_model_design_decisions.md index 997c9646..a254f143 100644 --- a/docs/tactic_model_design_decisions.md +++ b/docs/tactic_model_design_decisions.md @@ -4,13 +4,12 @@ Why the strategy layer (`utama_core/engine/`, `utama_core/tactics/`, `utama_core/strategy/`) is shaped the way it is. The code is the source of truth for *how*; this file records *why* and what was deliberately not built. The design borrowed vocabulary from Sumatra (TIGERs Mannheim) and OS process scheduling to stress-test -ideas, not as a mandate to copy either's weight. For the general allocation framework see -[`scheduling_math_model.md`](scheduling_math_model.md). +ideas, not as a mandate to copy either's weight. Section numbers are stable because code comments cite them. Gaps are sections merged or removed: §7 (splitting policy) was resolved by §11; §8/§9 (orphan robots, deadlock detection) -are under Deferred; §12/§17 (tactic and config inventories) live in `docs/strategies.md` and -the code. +are under Deferred; §12/§17 (tactic and config inventories) live in +the code (`utama_core/strategy/`, `utama_core/tactics/`). ## Settled diff --git a/docs/tools.md b/docs/tools.md index 4ec18bbc..4d33acee 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -79,7 +79,7 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/debug/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for the pictures in [visual_guide.md](visual_guide.md). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold). `--data PATH`: the position and shot maps' numbers as JSON, no figures (the dashboard runs it once per round and keeps `pitch_maps.json` beside the summary) | +| `tools/debug/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch. `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold). `--data PATH`: the position and shot maps' numbers as JSON, no figures (the dashboard runs it once per round and keeps `pitch_maps.json` beside the summary) | | `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | | `tools/dev/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | @@ -121,15 +121,14 @@ described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). ## Simulator realism Is the simulator close to the real league, and are its physics settings measured? These tools judge -the simulator, not a strategy: none of them is part of strategy development. The plan and the -results are in [sim_realism.md](sim_realism.md). Their inputs are the official logs converted by +the simulator, not a strategy: none of them is part of strategy development. Their inputs are the official logs converted by `tools/realism/convert_ssl_log.py` (its kick and visibility sidecars, see [Real matches](#real-matches)) and the field logs in `replays/field/`. | Script | Purpose | |---|---| -| `tools/realism/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. See [sim_realism.md](sim_realism.md) | -| `utama_core/analysis/physics_ranges.py` | `python -m utama_core.analysis.physics_ranges --real --sim `: physics parameter ranges for the sim-realism plan ([sim_realism.md](sim_realism.md)): ball deceleration by speed and time since a kick, rolling-segment fits, robot speed, acceleration, braking and turn-rate percentiles per robot, and dropped detections, with spreads between matches, robots and teams | +| `tools/realism/realism_scorecard.py` | Our sim against real Division B matches, component by component: attempts per live minute (open play and set pieces), attempt distance, real xG per attempt, finishing, goal rate and keeper saves per xG band, shot outcomes (keeper, defender, wide, post, crossed with no goal), aim outside the posts and miss distance, ball slow-down, kick speed, keeper depth, keeper and nearest-defender reaction time (`utama_core/analysis/realism/reaction.py`), pass line offset and completion (`passes.py`). Each row: the real value and 95% interval, the sim value, and whether it is inside. `--real` rebuilds the committed reference (`utama_core/analysis/realism/real_2025_2026.json`: the real xG model and rows) from converted logs; `--sim RUN_DIR` scores a round-robin against it. Attempts exclude passes and kicks from beyond 6 m. | +| `utama_core/analysis/physics_ranges.py` | `python -m utama_core.analysis.physics_ranges --real --sim `: physics parameter ranges: ball deceleration by speed and time since a kick, rolling-segment fits, robot speed, acceleration, braking and turn-rate percentiles per robot, and dropped detections, with spreads between matches, robots and teams | | `tools/field/field_physics.py` | Measures the world settings from field logs, only from sessions `tools/field/field_sessions.json` allows, and prints how well runs, days and radios agree. | | `tools/field/robot_calibration.py` | A robot's numbers from a recorded field test (`replays/field/*.log`): loop delay, speed gain and acceleration per axis (the sim's move model fitted to the camera's positions), vision noise at rest and missed detections, kick speed. Writes `.calibration.json`. The same log converts to a replay with `tools/realism/convert_ssl_log.py` | @@ -165,8 +164,8 @@ the field logs in `replays/field/`. | `examples/dribble_and_shoot.py` | `score_goal.py`'s robot dribbles a lap of the field, then scores | | `examples/passing_rally.py` | `pass_receive.py`'s pair passing their way along the field in two lanes, turning round `TURN_M` from each end line, for ever (no shots) | | `tools/field/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | -| `tools/field/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([field_logs.md](field_logs.md)) | -| `tools/field/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([field_logs.md](field_logs.md)) | +| `tools/field/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([real_robot_setup.md, "Field logs"](real_robot_setup.md#field-logs)) | +| `tools/field/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([real_robot_setup.md, "Field logs"](real_robot_setup.md#field-logs)) | | `tools/field/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | diff --git a/main.py b/main.py index 060a0adc..9ff1306b 100644 --- a/main.py +++ b/main.py @@ -3,7 +3,7 @@ Run: pixi run main # pendulum vs wolfpack - pixi run main pendulum riptide # any two names from docs/strategies.md + pixi run main pendulum riptide # any two names on the dashboard's Strategies tab pixi run main a.strategy wolfpack # or a .strategy file (tools/dev/build_strategy.py) # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop @@ -25,7 +25,7 @@ def _strategy(name: str) -> AbstractStrategy: try: return load_side(name) except UnknownStrategy as e: - raise SystemExit(f"{e} (docs/strategies.md)") from None + raise SystemExit(f"{e} (the strategies: utama_core/strategy/)") from None def main() -> None: diff --git a/tools/debug/pitch_maps.py b/tools/debug/pitch_maps.py index bd28c2af..df2c54dc 100644 --- a/tools/debug/pitch_maps.py +++ b/tools/debug/pitch_maps.py @@ -427,7 +427,7 @@ def plot_fouls(views, order, labels, path: Path) -> None: def zone_findings(views: list[MatchView], order: list[str], images: Optional[dict[str, str]] = None) -> list[Finding]: """Six descriptive `zone_share` findings per strategy: the share of its in-possession and of its - out-of-possession outfield samples in each third (docs/pitch_zones.md). No threshold: they describe.""" + out-of-possession outfield samples in each third (docs/signals.md ("Pitch zones")). No threshold: they describe.""" third = L / 3 # the thirds' boundaries in the common frame, at x = +-1.5 m out: list[Finding] = [] for name in order: diff --git a/tools/field/shooting_drill.py b/tools/field/shooting_drill.py index 29bafe33..35cc7951 100644 --- a/tools/field/shooting_drill.py +++ b/tools/field/shooting_drill.py @@ -24,7 +24,7 @@ On the dashboard's Live tab, the field check must be all green or amber before Force Start: a red row (robot not seen, outside the camera half, radio lost, wrong field size) halts the -robots at once. See docs/referee_gui.md, "Field check". +robots at once. See docs/referee.md ("Operator panel"), "Field check". Measuring a robot (`--calibrate attacker|defender`): that robot plays fixed moves instead (`tactics/scripted_moves.py`, about 70 s: 10 s still, steps forward and back at 0.3, 0.6 and diff --git a/utama_core/engine/referee_override.py b/utama_core/engine/referee_override.py index a0e10ed6..3336b3fe 100644 --- a/utama_core/engine/referee_override.py +++ b/utama_core/engine/referee_override.py @@ -26,7 +26,7 @@ together under "just freeze", which was wrong for the other two: - STOP's actual rule is stricter than a freeze: "stop in place, AND stay - >= 0.5m from the ball" (`docs/referee_gui.md`). A robot already + >= 0.5m from the ball" (`docs/referee.md ("Operator panel")`). A robot already inside that keep-out radius at the exact instant STOP is entered (e.g. a carrier mid-dribble, or `goalkeep.py`'s own retrieval branch driving the keeper up to a loose ball) has no way to comply by freezing — it is diff --git a/utama_core/tests/analysis/test_pitch_maps.py b/utama_core/tests/analysis/test_pitch_maps.py index 6abe6722..06c737fc 100644 --- a/utama_core/tests/analysis/test_pitch_maps.py +++ b/utama_core/tests/analysis/test_pitch_maps.py @@ -190,7 +190,7 @@ def test_rule_colours_take_fixed_slots_in_rank_order(): def test_zone_findings_are_six_descriptive_shares_per_strategy_in_the_pitch_zone_names(): - # Common frame: the strategy attacks +x, thirds at x = -1.5 and +1.5 m (docs/pitch_zones.md). + # Common frame: the strategy attacks +x, thirds at x = -1.5 and +1.5 m (docs/signals.md ("Pitch zones")). view = pm.MatchView( strategy="a", pos_x=np.array([-2.0, 0.0, 2.0, 2.5]), diff --git a/vendor/rSim/FORK_NOTES.md b/vendor/rSim/FORK_NOTES.md index 25b1506f..e745d318 100644 --- a/vendor/rSim/FORK_NOTES.md +++ b/vendor/rSim/FORK_NOTES.md @@ -5,8 +5,11 @@ Forked at commit: `b413932b7b4bbc0fc399f6a979e4cfcc4f56264f` (tag `v1.2`, the same version this repo's `pixi.toml` pins via `rc-robosim>=1.2,<2` on PyPI). This fork is the physics step of the rsim stack. The diagram of the whole tick, from -`StrategyRunner` through the seeded sim noise to this C++ code and back, is in -[docs/sim_realism.md](../../docs/sim_realism.md#how-one-rsim-tick-is-built). +`StrategyRunner` through the seeded sim noise to this C++ code and back: + +![One rsim tick: the command-side noise, the C++ physics and the vision-side noise](../../docs/img/sim_realism/rsim_tick.png) + +Drawn by `docs/img/sim_realism/make_rsim_tick.py`; rerun it when a name in it changes. ## Why this is here From 6d240552f1cd254ecf63f4726d028df982038a7d Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 12:27:36 +0000 Subject: [PATCH 57/59] docs: tutorials/ for step-by-step pages, docs/ for reference; consistent names; stale facts fixed - tutorials/first_strategy.md (moved, with its screenshots) and tutorials/field_day.md (the setup and test-day steps of real_robot_setup.md). The rest of that file is docs/real_robots.md. - Renamed: STRATEGY_DEVELOPMENT.md -> strategy.md, tactic_model_design_decisions.md -> strategy_design.md, motion_planning_comparison.md -> motion_planning.md. Section numbers kept. - docs/README.md points at tutorials/ first; AGENTS.md keeps the split. - Stale: the referee's "ball placement before a free kick" gap is fixed in code (moved to resolved; the open lists are one Known gaps list); convert_ssl_log keeps raw logs with --keep-raw; `pixi run runs` lists evaluation rounds too; strategy.md says where to see a result (the dashboard). Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 2 +- .claude/skills/debug-incident/SKILL.md | 4 +- .claude/skills/field-session/SKILL.md | 4 +- AGENTS.md | 23 +-- README.md | 15 +- docs/README.md | 15 +- docs/architecture.md | 2 +- .../motion_planning/make_control_schemes.py | 2 +- docs/img/strategy/make_tactic_kernel.py | 2 +- ...nning_comparison.md => motion_planning.md} | 2 +- docs/real_robots.md | 163 ++++++++++++++++++ docs/referee.md | 25 ++- docs/signals.md | 2 +- docs/{STRATEGY_DEVELOPMENT.md => strategy.md} | 11 +- ...design_decisions.md => strategy_design.md} | 0 docs/tools.md | 42 ++--- examples/pass_receive.py | 2 +- examples/save_and_counter.py | 2 +- tools/debug/moments.py | 2 +- tools/debug/plan_snapshot.py | 2 +- tools/debug/plan_trace.py | 2 +- tools/debug/restart_picture.py | 2 +- tools/evaluation/evaluate.py | 2 +- tools/field/field_check.py | 2 +- tools/field/vision_check.py | 4 +- tools/motion_planning_benchmark.py | 4 +- .../field_day.md | 162 +---------------- {docs => tutorials}/first_strategy.md | 2 +- {docs => tutorials}/img/dashboard/replay.png | Bin .../img/dashboard/strategy_page.png | Bin utama_core/dashboard/static/field_canvas.js | 2 +- utama_core/engine/match_stats.py | 2 +- utama_core/replay/fingerprint.py | 2 +- utama_core/replay/scenario.py | 4 +- utama_core/skills/go_to_point.py | 2 +- utama_core/skills/goalkeep.py | 2 +- utama_core/tactics/clear_ball.py | 2 +- .../tests/engine/test_commitment_deadline.py | 2 +- utama_core/tests/replay/test_scenario.py | 2 +- .../tests/strategy/test_first_strategy_doc.py | 4 +- 40 files changed, 267 insertions(+), 259 deletions(-) rename docs/{motion_planning_comparison.md => motion_planning.md} (99%) create mode 100644 docs/real_robots.md rename docs/{STRATEGY_DEVELOPMENT.md => strategy.md} (98%) rename docs/{tactic_model_design_decisions.md => strategy_design.md} (100%) rename docs/real_robot_setup.md => tutorials/field_day.md (70%) rename {docs => tutorials}/first_strategy.md (98%) rename {docs => tutorials}/img/dashboard/replay.png (100%) rename {docs => tutorials}/img/dashboard/strategy_page.png (100%) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index e841be99..0aabe31d 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -6,7 +6,7 @@ description: Write a new strategy or change an existing one, then test it, evalu # Change a strategy The model behind every step (tactics, partitioners, referee restarts, past tactic bugs) is -`docs/STRATEGY_DEVELOPMENT.md`; read its "Writing and evaluating a strategy" and "Strategy +`docs/strategy.md`; read its "Writing and evaluating a strategy" and "Strategy branches" sections first. This skill is the order of the steps and the rules that are easy to forget. diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md index 6ca755fc..786d38c5 100644 --- a/.claude/skills/debug-incident/SKILL.md +++ b/.claude/skills/debug-incident/SKILL.md @@ -8,7 +8,7 @@ description: Take one bad moment in a match (a foul, a stall, a robot thrashing, A foul or failure is a symptom. The cause may be the robot's tactic, the shared referee override, the motion planner, the referee itself, or the check that flagged it: of the first six found this way, two were the referee or the check. The full workflow, with the bugs found -so far, is `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure"; read it for anything +so far, is `docs/strategy.md`, "Debugging a foul or failure"; read it for anything below that is unclear. Inputs: a replay `REPLAY` (`replays/eval_/round_/
_vs_.npz`, or any `.npz`) and a @@ -48,7 +48,7 @@ the sim negates y and heading. The fix is not done without a test that fails before and passes after, pinning the exact boundary (a tolerance, a tie, a target off the field). Prefer a pure unit test over an rsim -fixture. Add a row to the bug table in `docs/STRATEGY_DEVELOPMENT.md` if it is a new kind. +fixture. Add a row to the bug table in `docs/strategy.md` if it is a new kind. ## 5. Optionally keep a moment diff --git a/.claude/skills/field-session/SKILL.md b/.claude/skills/field-session/SKILL.md index 4070a289..36cb26ba 100644 --- a/.claude/skills/field-session/SKILL.md +++ b/.claude/skills/field-session/SKILL.md @@ -5,8 +5,8 @@ description: Run a test day on the real robots, and process what it recorded - c # A field session -Setup and the meaning of each check: `docs/real_robot_setup.md`. Log format and readers: -`docs/real_robot_setup.md ("Field logs")`. On the field, time is short: run the one command, read its "!!" lines, +Setup and the meaning of each check: `tutorials/field_day.md`. Log format and readers: +`docs/real_robots.md ("Field logs")`. On the field, time is short: run the one command, read its "!!" lines, fix only those. ## At the start diff --git a/AGENTS.md b/AGENTS.md index 23ee1995..421639f2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -11,17 +11,18 @@ and is stale — all active strategy work happens here, on top of the tactic-ker ## Work areas -Pick the row for what you are changing and read its doc first. "Doc" is `TODO` where none +Pick the row for what you are changing and read its doc first. `tutorials/` holds step-by-step +pages for people (follow them in order); `docs/` holds the reference (look things up). Keep that split. "Doc" is `TODO` where none exists yet: say so in your change rather than guessing. | Area | Paths | Doc | Notes | |---|---|---|---| -| Strategy / tactics | `utama_core/engine/`, `strategy/`, `tactics/`, `skills/` | `docs/STRATEGY_DEVELOPMENT.md` | Engine changes are rare: a new primitive, not a new strategy | -| Strategy evaluation | `tools/evaluation/`, `utama_core/replay/`, `utama_core/analysis/` | `docs/STRATEGY_DEVELOPMENT.md`, `docs/signals.md` | Change evaluation and strategy in separate commits, so results stay comparable | +| Strategy / tactics | `utama_core/engine/`, `strategy/`, `tactics/`, `skills/` | `docs/strategy.md` | Engine changes are rare: a new primitive, not a new strategy | +| Strategy evaluation | `tools/evaluation/`, `utama_core/replay/`, `utama_core/analysis/` | `docs/strategy.md`, `docs/signals.md` | Change evaluation and strategy in separate commits, so results stay comparable | | Referee | `utama_core/referee/` | `docs/referee.md` | | -| Motion planning | `utama_core/motion_planning/`, `tools/motion_planning_benchmark.py` | `docs/motion_planning_comparison.md` | | +| Motion planning | `utama_core/motion_planning/`, `tools/motion_planning_benchmark.py` | `docs/motion_planning.md` | | | Simulation | `utama_core/simulator/`, `vendor/rSim/` | `vendor/rSim/FORK_NOTES.md` | `vendor/rSim` is the C++ physics fork; `utama_core/simulator` is the Python env on top of it | -| Real robots (radio, vision, controllers) | `utama_core/team_controller/`, `utama_core/data_processing/` | `utama_core/team_controller/README.md` (brief) | | +| Real robots (radio, vision, controllers) | `utama_core/team_controller/`, `utama_core/data_processing/` | `tutorials/field_day.md`, `docs/real_robots.md` | | ## Glossary @@ -40,7 +41,7 @@ One term per thing; reuse these instead of coining new ones. bug, with a check of the right behaviour (`utama_core/tests/moments/*.json`, `tools/debug/moments.py`). A cheap end-to-end check, run in `pixi run test`, that a fixed bug stays fixed; the unit test at the cause is the real protection. Not a ranking and not a gate on strategies. The workflow and - the bugs found so far: `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure". + the bugs found so far: `docs/strategy.md`, "Debugging a foul or failure". - **Pitch zones** — defensive / middle / attacking third, left wing / centre / right wing, the box, danger: defined once, with a diagram, in `docs/signals.md ("Pitch zones")`. Use those names. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). @@ -109,7 +110,7 @@ One term per thing; reuse these instead of coining new ones. **Before touching `utama_core/engine/`, `utama_core/tactics/`, `utama_core/strategy/`, `utama_core/skills/`, or `tools/evaluation/`, read -[`docs/STRATEGY_DEVELOPMENT.md`](docs/STRATEGY_DEVELOPMENT.md)** — the tactic-kernel model, +[`docs/strategy.md`](docs/strategy.md)** — the tactic-kernel model, referee-restart handling, lessons from past tactic bugs, and the observability tooling (`MatchLog.trace()`, `render_window()`, the strategy catalog) all live there, scoped to that half of the repo rather than duplicated here for every task. @@ -121,7 +122,7 @@ after a concrete case forces it — not in anticipation of one. If a change star accumulating multiple new named concepts, stop and check whether that was actually asked for. This is a deliberate, repeatedly-stated project preference, not an oversight to fix: prefer the smallest mechanism that solves the problem actually in front of you. `docs/ -tactic_model_design_decisions.md` documents several concepts explicitly deferred for +strategy_design.md` documents several concepts explicitly deferred for exactly this reason (concurrent-slot priority tuning, `Tactic` min/max robot-count declarations) — check there before reintroducing one of them. @@ -168,11 +169,11 @@ need most: cause with a test), `field-session` (a test day on real robots and its logs). The docs keep the reasons; the skills keep the steps. -- `docs/first_strategy.md` — the beginner tutorial (a toy strategy, then evaluation). Keep it short, +- `tutorials/first_strategy.md` — the beginner tutorial (a toy strategy, then evaluation). Keep it short, simple and runnable: `tests/strategy/test_first_strategy_doc.py` builds its code. -- `docs/STRATEGY_DEVELOPMENT.md` — tactic-kernel model, referee handling, writing a +- `docs/strategy.md` — tactic-kernel model, referee handling, writing a `Tactic`, observability tooling. Read before any strategy-layer change. -- `docs/tactic_model_design_decisions.md` — kernel/Tactic/Partitioner design rationale. +- `docs/strategy_design.md` — kernel/Tactic/Partitioner design rationale. - `docs/referee.md` — `CustomReferee` architecture/usage; its "Known gaps" section tracks genuinely open items (don't assume something is missing without checking there first — it may already be resolved and the surrounding doc just stale). diff --git a/README.md b/README.md index 35558e5b..539598c0 100644 --- a/README.md +++ b/README.md @@ -16,23 +16,24 @@ strategy layer that decides what every robot does. 3. `pixi run test` runs the test suite (add `--headless` when calling pytest directly). 4. `pixi run main` to watch a match in the simulator (Ctrl+C to stop). -**New here? Write your first strategy: [docs/first_strategy.md](docs/first_strategy.md).** +**New here? Write your first strategy: [tutorials/first_strategy.md](tutorials/first_strategy.md).** Everything runs in rsim with the in-process referee; grSim, the official GameController and -real robots are optional ([external setup](docs/real_robot_setup.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision)). +real robots are optional ([external setup](docs/real_robots.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision)). ## What are you working on? | Task | Start here | |---|---| -| Your first strategy | [docs/first_strategy.md](docs/first_strategy.md) | -| Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md) | +| Your first strategy | [tutorials/first_strategy.md](tutorials/first_strategy.md) | +| Writing or changing a strategy, tactic or skill | [docs/strategy.md](docs/strategy.md) | | Seeing what the robots did, and why | `pixi run dashboard` (every strategy's maps and replays); `tools/debug/find_bugs.py RUN_DIR` for a run's worst problems | -| Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md) | +| Judging whether a strategy is better | [docs/strategy.md](docs/strategy.md), [docs/signals.md](docs/signals.md) | | The referee | [docs/referee.md](docs/referee.md) | -| Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | +| Motion planning | [docs/motion_planning.md](docs/motion_planning.md) | | The simulator | [vendor/rSim/FORK_NOTES.md](vendor/rSim/FORK_NOTES.md) | -| Real robots, vision, radio | [utama_core/team_controller/README.md](utama_core/team_controller/README.md), [docs/real_robot_setup.md, "External tools"](docs/real_robot_setup.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision) | +| A test day with real robots | [tutorials/field_day.md](tutorials/field_day.md) | +| Real robots, vision, radio | [utama_core/team_controller/README.md](utama_core/team_controller/README.md), [docs/real_robots.md, "External tools"](docs/real_robots.md#external-tools-grsim-gamecontroller-autoreferee-ssl-vision) | | Which script does what | [docs/tools.md](docs/tools.md) | | Everything else | [docs/README.md](docs/README.md), the index of every doc | diff --git a/docs/README.md b/docs/README.md index 96eba994..3caea196 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,14 +1,15 @@ # Docs -New to the repo: the [README](../README.md) first, then [first_strategy.md](first_strategy.md). -Docs that code comments cite but that were deleted are in git history. +How the code works and why: look things up here. To learn by doing, start with the step-by-step +pages in [tutorials/](../tutorials/): [first_strategy.md](../tutorials/first_strategy.md) (new members +start there) and [field_day.md](../tutorials/field_day.md) (a test day with real robots). Docs that +code comments cite but that were deleted are in git history. -- [first_strategy.md](first_strategy.md): start here. Look around the strategies, then write, watch and evaluate your own. -- [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): the strategy layer and its evaluation: the tactic-kernel model, referee restarts, lessons from past bugs, the debugging tools. -- [tactic_model_design_decisions.md](tactic_model_design_decisions.md): why the strategy layer is shaped as it is, and what was deliberately not built. +- [strategy.md](strategy.md): the strategy layer and its evaluation: the tactic-kernel model, referee restarts, lessons from past bugs, the debugging tools. +- [strategy_design.md](strategy_design.md): why the strategy layer is shaped as it is, and what was deliberately not built. - [signals.md](signals.md): every signal recorded about how a strategy plays, and the names of the pitch zones. - [referee.md](referee.md): the in-process referee, how its commands reach robots, the operator panel, and its rule-by-rule design decisions. -- [motion_planning_comparison.md](motion_planning_comparison.md): the motion-planning benchmark and how to read it. -- [real_robot_setup.md](real_robot_setup.md): a test day with real robots, the field logs it records, and grSim / GameController / ssl-vision. +- [motion_planning.md](motion_planning.md): the motion-planning benchmark and how to read it. +- [real_robots.md](real_robots.md): field logs and the tools that read them; grSim, the GameController and ssl-vision. - [architecture.md](architecture.md): how the packages depend on each other, and how one tick turns vision, robot and referee data into commands. - [tools.md](tools.md): every script and pixi task, by purpose. diff --git a/docs/architecture.md b/docs/architecture.md index 617e3297..f901e438 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -266,5 +266,5 @@ real robots. In rsim both teams run in one `StrategyRunner`: each side has its own refiners, strategy and motion controller and steps in turn, alternating which goes first. `MatchStats` and the replay writer follow one side's frames. The dashboard's vision stream renders the same frames. -`docs/STRATEGY_DEVELOPMENT.md` covers the strategy layer; `docs/motion_planning_comparison.md` +`docs/strategy.md` covers the strategy layer; `docs/motion_planning.md` the motion controllers. diff --git a/docs/img/motion_planning/make_control_schemes.py b/docs/img/motion_planning/make_control_schemes.py index 7c326654..e2f8aa98 100644 --- a/docs/img/motion_planning/make_control_schemes.py +++ b/docs/img/motion_planning/make_control_schemes.py @@ -1,4 +1,4 @@ -"""Draws control_schemes.png for docs/motion_planning_comparison.md: how move() reaches the three control +"""Draws control_schemes.png for docs/motion_planning.md: how move() reaches the three control schemes (fpp, dwa, trajsample) through get_control_scheme, and what each one hands back. pixi run python docs/img/motion_planning/make_control_schemes.py diff --git a/docs/img/strategy/make_tactic_kernel.py b/docs/img/strategy/make_tactic_kernel.py index 834fb62e..8a077efb 100644 --- a/docs/img/strategy/make_tactic_kernel.py +++ b/docs/img/strategy/make_tactic_kernel.py @@ -1,4 +1,4 @@ -"""Draws tactic_kernel.png for docs/STRATEGY_DEVELOPMENT.md ("The tactic-kernel model"): the classes that make up +"""Draws tactic_kernel.png for docs/strategy.md ("The tactic-kernel model"): the classes that make up one team's Strategy, who holds or calls whom, and the path a tick takes from StrategyRunner down to the skills. pixi run python docs/img/strategy/make_tactic_kernel.py diff --git a/docs/motion_planning_comparison.md b/docs/motion_planning.md similarity index 99% rename from docs/motion_planning_comparison.md rename to docs/motion_planning.md index b3ebcc07..af03df3d 100644 --- a/docs/motion_planning_comparison.md +++ b/docs/motion_planning.md @@ -77,7 +77,7 @@ Each tick, `FastPathPlanner._path_to` turns the robot's target into a carrot poi flowchart is that call's decision order. `tools/debug/plan_snapshot.py` draws the carrot and the planner's inputs for one logged tick. `tools/debug/plan_trace.py` runs the same `_path_to` on every tick of a window and draws how the carrot moved against the robot's path, which a single tick cannot show. Robot positions are the replay's, not re-simulated, so it shows what the current planner would -do from each recorded state; the kick-off example is in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), +do from each recorded state; the kick-off example is in [strategy.md](strategy.md), "Debugging a foul or failure". ```mermaid diff --git a/docs/real_robots.md b/docs/real_robots.md new file mode 100644 index 00000000..d6dec0dc --- /dev/null +++ b/docs/real_robots.md @@ -0,0 +1,163 @@ +# Real robots + +The reference for real-robot work: what a field log holds and the tools that read it, and the +external software (grSim, the official GameController, AutoReferee, ssl-vision). The procedure for a +test day is the tutorial [tutorials/field_day.md](../tutorials/field_day.md). + +## Field logs + +Recorded on the physical pitch during real robot test days: vision frames, referee commands, +bidirectional radio packets, and session metadata. + +--- + +### 1. File Location & Binary Format + +- **Location**: `replays/field/_real_.log.gz` +- **Specification**: Follows the official RoboCup SSL Game Log format (`SSL_LOG_FILE`), stored compressed with standard `gzip`. +- **Streaming**: Python readers stream `.log.gz` directly without uncompressing: + ```python + from utama_core.replay.ssl_log import read_records + + for ts_ns, msg_type, payload in read_records("replays/field/.log.gz"): + ... + ``` + +#### Record Types + +| Type ID | Name | Contents | +|---|---|---| +| `4` | `VISION_2014` | Raw `SSL_WrapperPacket` from ssl-vision cameras (pixel positions, confidence, detection timestamps). | +| `3` | `REFEREE` | `Referee` state updates (commands, stage, score, team cards). | +| `100` | `RADIO_OUT` | 12-byte packed commands sent to robots over serial radio (forward, left, turn velocities, kick power, dribbler). | +| `101` | `RADIO_IN` | Feedback packets returned by robots (IR ball sensor trigger state). | +| `102` | `RUN_INFO` | Initial session metadata JSON: git commit SHA, dirty flag, vision-to-radio mapping, field bounds. | +| `103` | `NOTE` | Human operator notes entered from the dashboard during testing. | + +--- + +### 2. Analysis & Calibration Tools + +Every field log contains the ground-truth signals needed to evaluate robot hardware: + +#### Robot Calibration (`tools/field/robot_calibration.py`) +Recovers physical dynamics and kicker geometry from a field test: +```bash +pixi run python tools/field/robot_calibration.py replays/field/.log.gz +``` +- **Loop Latency**: Sensing-to-action delay measured between commanded motion and camera-observed velocity (~61–62 ms). +- **Acceleration Limits**: Measured forward acceleration (~4.0–6.0 m/s²) vs. lateral acceleration (~2.7–3.6 m/s²). +- **Kick Characteristics**: Median ball launch velocity, directional offset bias (+2.7°), and bend caused by off-center dribbler contact (~4.2°/cm). +- **Dribbler Retention**: Sustained carry velocity and turn rate caps before the ball escapes (0.3 m/s, 0.6 rad/s). +- **Output**: Writes `.calibration.json`. + +#### Tag Alignment Calibration (`utama_core/analysis/tag_calibration.py`) +Measures optical tag placement relative to the chassis center: +```bash +pixi run python -m utama_core.analysis.tag_calibration replays/field/.log.gz +``` +- Fits circle trajectories during in-place spins to determine `(forward_m, left_m)` offsets. + +#### Proximity & Close Calls (`utama_core/analysis/close_calls.py`) +Scans logs for incidents where robots came closer than 0.25 m: +```bash +pixi run python -m utama_core.analysis.close_calls replays/field/*real*.log.gz +``` + +#### Converting to Replay (`tools/realism/convert_ssl_log.py`) +Converts an SSL game log into our columnar `.npz` + `.pkl` replay format for replay visualization and scenario debugging: +```bash +pixi run python tools/realism/convert_ssl_log.py replays/field/.log.gz --out replays/field/ +``` + +--- + +### 3. Storage & Dataset Management + +Raw field logs accumulate substantial disk space over a testing day. Three built-in tools manage log sizes: + +#### 1. In-Place Compression +Raw `.log` files should be compressed to `.log.gz`: +```bash +pixi run package-field --compress-in-place +``` +Reduces log sizes by **50%–60%** with zero data loss. All analysis tools support `.log.gz` out of the box. + +#### 2. Trimming Idle Time Sectors (`tools/field/trim_idle_log.py`) +Field sessions frequently capture long periods of inactivity where the referee command is `HALT` or `STOP` (e.g. operators manually setting up the ball or discussing tests). Over **55% of field log duration is trailing dead time**: +```bash +# Preview reduction without modifying files +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --dry-run + +# Trim dead stretches and trailing halt in-place +pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --in-place +# Or batch trim all field logs: +pixi run trim-field +``` +- Automatically removes idle pauses longer than 5 seconds while keeping 1.0 second safety padding around transitions. +- Fully strips trailing idle time recorded after drills end. +- Typically cuts file size by **65%–75%** while preserving every active drill frame. + +#### 3. Packaging & Distributing (`tools/field/package_logs.py`) +Creates self-contained release archives of field logs and calibration results: +```bash +pixi run package-field +``` +Bundles all `.log.gz` logs, `*.calibration.json`, and hardware profiles into `replays/field_logs_.tar.gz` for team sharing or dataset archival. + +## External tools: grSim, GameController, AutoReferee, SSL Vision + +None of this is needed for everyday work: rsim and the in-process +[`CustomReferee`](referee.md) run everything headless with no external process, and +behave the same across rsim, grSim and real mode. Set these up only to run against grSim, the +official competition software, or real robots. + +### grSim + +1. Go to the [grSim repo](https://github.com/RoboCup-SSL/grSim) and follow its + [installation steps](https://github.com/RoboCup-SSL/grSim/blob/master/INSTALL.md). +2. Change the configuration to the values highlighted below: + + ![grsim_setup](../assets/images/grsim_setup.png) + +3. To run it, execute `./bin/grSim` in the cloned repo. + +### AutoReferee and the GameController + +1. Make sure `grSim` is set up and can be called from a terminal. +2. `git clone` the [AutoReferee repo](https://github.com/TIGERs-Mannheim/AutoReferee) into a + folder named `AutoReferee/` in the repository root. +3. Change `DIV_A` to `DIV_B` in `AutoReferee/config/moduli/moduli.xml`: + + ```xml + + ROBOCUP + DIV_B + + ``` + +4. Get the latest [compiled game controller](https://github.com/RoboCup-SSL/ssl-game-controller/releases/), + rename it to `ssl-game-controller`, and save it in a `ssl-game-controller/` directory in the + repository root. + +Both directories are gitignored. + +#### Starting the external test environment + +Only needed to test against the official referee software; the in-process `CustomReferee` +needs none of this. With grSim, the GameController and AutoReferee set up, start each in its +own terminal from the repository root: + +```bash +grSim +cd ssl-game-controller && ./ssl-game-controller +cd AutoReferee && ./gradlew run +``` + +Then run your own strategy. The GameController's web UI is at http://localhost:8081/#/match +(this repo's dashboard is :8080). + +### SSL Vision and the radio for real robots + +The whole procedure (vision laptop, WSL networking and USB, radio, the checks before a robot +moves) is in [field_day.md](../tutorials/field_day.md). diff --git a/docs/referee.md b/docs/referee.md index 394c7b75..ebe1b3a0 100644 --- a/docs/referee.md +++ b/docs/referee.md @@ -134,6 +134,12 @@ again afterwards. - **Last-touch attribution needs contact data for both teams.** Enemy `has_ball` is filled by `RobotInfoRefiner` from sim contact physics (`data_processing/refiners/robot_info.py`). +- **Placement carry mechanics** (real robots; the sim teleports the ball). Single-robot dribble tends to push rather than carry; options + are a dedicated slow "get-behind-ball" approach or the two-robot technique most SSL teams use. +- **Pre-positioning from `next_command`** during `STOP` — an optimisation, not a compliance need. +- **Operator GUI "suggested next step"** based on the current command, so an operator decides + only *when* to advance, not *what*. +- **`TeamInfo` should be a frozen dataclass**: item 8 under Design decisions. Resolved (kept here so nobody re-reports them): the old friendly-first, ≤0.15m proximity last-touch heuristic and its yellow default (replaced by `infer_last_touch_team`), double touch, @@ -141,7 +147,8 @@ ball speed, full-episode reset, teams changing ends at half-time, `bt_nodes` → `debug_status` rename, auto-advance after goals/timeouts, keep-out during bare `STOP`, blue-perspective goal tests, `StrategyRunner` integration tests (`tests/run/test_referee_rsim.py`, `test_ball_placement_rsim.py`), -`force_start_after_goal`. +`force_start_after_goal`, ball placement before a free kick (`_handle_foul` queues +`BALL_PLACEMENT_*` and then the free kick). ## Running @@ -156,7 +163,7 @@ pixi run python examples/demo_referee_gui_rsim.py # RSim + dashboard referee t How referee commands reach robots, and what each command requires. The original py_trees integration is gone (BT removed in `087ee4b`, `960662c`, `48affd6`); the current mechanism is `RefereeOverride` (`utama_core/engine/referee_override.py`, design: §13 of -`tactic_model_design_decisions.md`) driving the `*Step` classes in +`strategy_design.md`) driving the `*Step` classes in `utama_core/referee/actions.py`. ### Data path @@ -201,18 +208,6 @@ penalty, direct free — each `CheckRefereeCommand(...)` → `*Step`, falling th strategy tree on `NORMAL_START`/`FORCE_START`. `RefereeOverride` keeps that command→Step mapping as a plain class. -### Open - -- **Ball placement before a free kick.** The rulebook sequence after ball-out is - `STOP → BALL_PLACEMENT_* → DIRECT_FREE_* → NORMAL_START`; `OutOfBoundsRule` still queues - `DIRECT_FREE_*` directly (in sim the ball is teleported instead). Depends on reliable - `BallPlacementOursStep` carrying. -- **Placement carry mechanics.** Single-robot dribble tends to push rather than carry; options - are a dedicated slow "get-behind-ball" approach or the two-robot technique most SSL teams use. -- **Pre-positioning from `next_command`** during `STOP` — an optimisation, not a compliance need. -- **Operator GUI "suggested next step"** based on the current command, so an operator decides - only *when* to advance, not *what*. - ## Operator panel The browser operator panel for `CustomReferee` is the dashboard's referee tab @@ -285,7 +280,7 @@ and defender tactics this way. | Halt | `HALT` | Emergency / unsafe | Zero velocity | | Stop | `STOP` | Between incidents, pre-match | ≤1.5 m/s, stay ≥0.5m from the ball | | Normal Start | `NORMAL_START` | Restart formation is in position | Live play | -| Force Start | `FORCE_START` | Stalled play | Live play from the ball's current position (a tactic barrier reset, see `tactic_model_design_decisions.md` §4) | +| Force Start | `FORCE_START` | Stalled play | Live play from the ball's current position (a tactic barrier reset, see `strategy_design.md` §4) | | Kickoff Y/B | `PREPARE_KICKOFF_*` | Half start, after a goal | Kicker to centre, others to own half | | Free Kick Y/B | `DIRECT_FREE_*` | Foul by the other team | Kicker to ball, opponents ≥0.5m | | Penalty Y/B *(advanced)* | `PREPARE_PENALTY_*` | Manual override | Kicker at mark, others behind the line | diff --git a/docs/signals.md b/docs/signals.md index cf201db2..1ab55fb7 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -29,7 +29,7 @@ mindmap ## Ranking Strategies are ranked by goals only, through ratings fitted on match margins -(`tools/evaluation/evaluate.py`; `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). +(`tools/evaluation/evaluate.py`; `docs/strategy.md`, "Evaluating a strategy"). Signals explain a result; none of them ranks or is a search objective. Tested and rejected as rankers (2026-10-17, two noisy round-robins of the same 12 strategies with diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/strategy.md similarity index 98% rename from docs/STRATEGY_DEVELOPMENT.md rename to docs/strategy.md index 5814a2b3..f219c57a 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/strategy.md @@ -1,10 +1,10 @@ # Strategy development -New to the repo? Start with [first_strategy.md](first_strategy.md); this page is the reference. +New to the repo? Start with [first_strategy.md](../tutorials/first_strategy.md); this page is the reference. Context for work under `utama_core/engine/`, `utama_core/tactics/`, `utama_core/skills/`, `utama_core/strategy/`, or `tools/evaluation/`. Assumes you've read the -root `AGENTS.md`. Design rationale and rejected alternatives: `docs/tactic_model_design_decisions.md` +root `AGENTS.md`. Design rationale and rejected alternatives: `docs/strategy_design.md` — read it before proposing a change to the kernel's shape. `engine/` is the scheduler/protocol infra; `strategy/` holds the strategies (one module @@ -337,6 +337,8 @@ flowchart TD a "better" can come from shared code changed since: the report adds the candidate against today's champion, same opponents, seeds and colours, no extra matches, where the shared code is the same on both sides. `evaluate.py ` measures shared-code changes alone. +- **Seeing it:** `pixi run dashboard`, Strategies tab: each strategy's verdicts, maps, signals beside + the average, and its matches to replay; Evaluation runs lists every run. - **Promoting** is a decision, not a side effect: change the champion line in `reference/players.json` in a pull request; the next release makes it the reference. - **Pictures** (`tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`): for a candidate, @@ -587,8 +589,9 @@ planner, the referee) is failing every strategy at once. pixi run python -I tools/realism/convert_ssl_log.py --corpus 2022-2026 --jobs 2 --out

-Only the converted files are kept: each raw log (up to 370 MB) is deleted once converted, and a -converted match takes about 35 MB. The published Division B logs for 2022-2026 are 118 +Each raw log (up to 370 MB) is deleted once converted unless `--keep-raw` is given (keep them: +it moves them to `//`, and a later conversion needs no download); a converted match +takes about 35 MB. The published Division B logs for 2022-2026 are 118 matches. What a converted match holds, and where it differs from a sim replay (the details are in diff --git a/docs/tactic_model_design_decisions.md b/docs/strategy_design.md similarity index 100% rename from docs/tactic_model_design_decisions.md rename to docs/strategy_design.md diff --git a/docs/tools.md b/docs/tools.md index 4d33acee..3748f7bd 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -5,7 +5,7 @@ Every script in the repository, by what it is for. Run them from the repository ## Start with these four -New to the repo? You need only these ([first_strategy.md](first_strategy.md) walks through them): +New to the repo? You need only these ([first_strategy.md](../tutorials/first_strategy.md) walks through them): | Command | What it does | |---|---| @@ -46,12 +46,12 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | `main` | `main.py`: watch one match between two strategies in rsim (below) | | `build-planner` | build the C++ fast-path planner (`utama_core/motion_planning/fastpathplanning/cpp`) into `build/fpp` with cmake | | `replay [-n NAME] [-p]` | play a legacy pickle replay `replays/NAME.pkl` in the rSoccer viewer (newest if no name; `-p` step by step). Today's `.npz` replays open in the dashboard instead | -| `runs` | list the tournament runs in `replays/`: start time, commit, matches, stalls, arguments | -| `debug-robots` | keyboard/click teleoperation GUI for real robots over the serial radio (robots chosen by radio ID; [real_robot_setup.md](real_robot_setup.md)) | -| `field-check` | the start of a test day in one command (`tools/field/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([real_robot_setup.md](real_robot_setup.md#each-test-day)) | -| `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | -| `demos` | every dashboard demo from one command (`examples/demos.py`, `--mode rsim` to rehearse, `--demo` the first): one dashboard stays up and the Live tab's Demo panel switches demo while halted (robots stopped, log saved, radio and vision released, the page reloads by itself), sets the first robot, camera half and rules for the next run, runs the field check, and offers teleop by keyboard ([real_robot_setup.md](real_robot_setup.md#running-the-demos)) | -| `calibrate` | measure one real robot from the terminal and write its profile (`tools/field/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([real_robot_setup.md](real_robot_setup.md#5-measuring-a-robot)) | +| `runs` | list the runs in `replays/` (each evaluation round, and older round robins): start time, commit, matches, stalls, arguments | +| `debug-robots` | keyboard/click teleoperation GUI for real robots over the serial radio (robots chosen by radio ID; [field_day.md](../tutorials/field_day.md)) | +| `field-check` | the start of a test day in one command (`tools/field/field_check.py`): vision's cameras, packets per second, field size, ball and lids in view, then `find-robots` with each robot's share of commands answered and its profile; every line "ok" or "!!" ([field_day.md](../tutorials/field_day.md#each-test-day)) | +| `find-robots` | which robots are on the field and the lid each wears (`python -m utama_core.team_controller.controllers.real.find_robots`): each radio that answers turns a little on the spot and back, and the pattern that turned is its lid; prints radio, lid, whether its profile was calibrated on that lid, silent radios and stray patterns; saved for the examples, which check it against vision on start and find again when a lid is missing (`shooting_drill.on_field`, `find_robots.confirm`) ([field_day.md](../tutorials/field_day.md#5-measuring-a-robot)) | +| `demos` | every dashboard demo from one command (`examples/demos.py`, `--mode rsim` to rehearse, `--demo` the first): one dashboard stays up and the Live tab's Demo panel switches demo while halted (robots stopped, log saved, radio and vision released, the page reloads by itself), sets the first robot, camera half and rules for the next run, runs the field check, and offers teleop by keyboard ([field_day.md](../tutorials/field_day.md#running-the-demos)) | +| `calibrate` | measure one real robot from the terminal and write its profile (`tools/field/calibrate_robot.py`, `--radio 0`; finds the robots when not told which): fixed driving moves, then the robot fetches the ball itself for a carry ladder (the fastest it keeps the ball each way) and 10 charged kicks; asks only to roll the ball back; then DONE, its loop delay, speed gain, acceleration, vision noise and kick speed, and its tag offset, kick bend and bias and carry caps written to `utama_core/config/robots/radio_.json`; `--ball-only` repeats the ball part, `--check` tries the new profile against the committed one in alternating blocks ([field_day.md](../tutorials/field_day.md#5-measuring-a-robot)) | ## Worktrees @@ -63,7 +63,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the open candidates: a screen on seeds 1-6 that drops a candidate whose mean paired diff against the reference is <= 0, then the survivors on fresh seeds 101-106, better if a one-sided paired t-test gives p <= 0.05, else undecided (`analysis/ratings.py`). Each round uses one sim-noise seed in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the open candidates: a screen on seeds 1-6 that drops a candidate whose mean paired diff against the reference is <= 0, then the survivors on fresh seeds 101-106, better if a one-sided paired t-test gives p <= 0.05, else undecided (`analysis/ratings.py`). Each round uses one sim-noise seed in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/strategy.md`, "Evaluating a strategy" | | `tools/evaluation/verdict_sim.py` | How often `evaluate.py`'s rule is right, on simulated results (no matches): better / dropped / undecided rates per effect size, correlation and number of opponents. Rerun after changing the rule or `analysis/ratings.py` | | `utama_core/run/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `tools/debug/repro_from_replay.py`, `tools/debug/moments.py`, `tools/debug/debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/dev/build_strategy.py` | `tools/dev/build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | @@ -74,7 +74,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ ## Evaluating strategies -What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), +What these measure and how far to trust each: [strategy.md](strategy.md), [signals.md](signals.md). | Script | Purpose | @@ -87,7 +87,7 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/realism/convert_ssl_log.py` | Official RoboCup SSL game logs to replays in our format, so the analyses run on real matches: given logs, or `--corpus 2022-2026` to download and convert every published Division B match, deleting each raw log once converted (`--keep-raw` keeps it; downloads cut short are resumed; each conversion's memory is capped by `--max-memory-gb`). Also writes sidecars for measuring physics: the tracker's kicks and visibility, and with `--raw-vision` every raw camera detection; `--backfill-extras` adds them to matches already converted. What a converted match holds and its limits: [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md#real-matches) | +| `tools/realism/convert_ssl_log.py` | Official RoboCup SSL game logs to replays in our format, so the analyses run on real matches: given logs, or `--corpus 2022-2026` to download and convert every published Division B match, deleting each raw log once converted (`--keep-raw` keeps it; downloads cut short are resumed; each conversion's memory is capped by `--max-memory-gb`). Also writes sidecars for measuring physics: the tracker's kicks and visibility, and with `--raw-vision` every raw camera detection; `--backfill-extras` adds them to matches already converted. What a converted match holds and its limits: [strategy.md](strategy.md#real-matches) | ## Debugging a match @@ -105,18 +105,18 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or | Script | Purpose | |---|---| -| `tools/debug/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its matches in a round), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `tools/debug/moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its matches in a round), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `tools/debug/moments.py fouls`). Read-only. See [strategy.md](strategy.md), "Debugging a foul or failure" | | `tools/debug/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | -| `tools/debug/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | +| `tools/debug/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [strategy.md](strategy.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | | `tools/debug/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | -| `tools/debug/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/debug/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Referee handling" | -| `tools/debug/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | -| `tools/debug/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `tools/debug/find_bugs.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/debug/plan_snapshot.py` | Picture of what the fast-path planner decided for one robot on one tick: `REPLAY.npz --t S --robot ID [--target X Y] [--side enemy]` runs the planner's `_path_to` on the replay's field state and draws the pitch around the robot: every robot with its id and radius, the ball and its keep-out circle, each clearance ring, the target, the carrot returned, and the referee command and distances. `--full-pitch` shows the whole pitch; with no `--target` the robot's position 0.5 s later stands in. Read-only. See [strategy.md](strategy.md), "Debugging a foul or failure" | +| `tools/debug/restart_picture.py` | Picture of where the referee override sends every friendly robot for one restart: `REPLAY.npz --t S [--side enemy]`, or `--all-restarts` for one small panel per restart command in the replay's referee sidecar (at most 8). Runs `RefereeOverride.tick` for the replay's command and draws each robot's commanded target with its role (kicker, placer, keeper), the ball and its 0.8 m keep-out, the placement spot and the other team faded. A robot whose target is inside the keep-out or a defence area it must avoid is flagged in red, with the text box. Read-only. `--findings PATH`: `target_in_keep_out`, `keep_out_short` (the 1 cm stop deadband) and `target_in_defense_area` for every restart in the match, each occurrence, without drawing (`restart_findings(replay, side)`). See [strategy.md](strategy.md), "Referee handling" | +| `tools/debug/plan_trace.py` | The fast-path planner over a time window: `REPLAY.npz --t0 S --t1 S --robot ID [--side enemy] [--target X Y] [--step 0.1] [--lookahead 0.5] [--json]` runs the planner's `_path_to` on every sampled tick and draws one PNG: the robot's path coloured by time with each tick's carrot joined to it, the ball path, the keep-out circle and clearance rings at the end, and time panels for robot-to-ball distance, robot-to-carrot length, speed and the referee command. Without `--target` each tick's target is the robot's position `--lookahead` s later. Robot positions are the replay's, not re-simulated: it shows what the current planner would do from each recorded state. Read-only; `--json` prints the per-tick rows. `--findings PATH` writes one `parked` or `pushed_out` finding per run of at least 1 s (`PARKED_MIN_S`) of short carrot with the target far. See [strategy.md](strategy.md), "Debugging a foul or failure" | +| `tools/debug/moments.py` | Regression moments (`utama_core/tests/moments/`): `capture REPLAY --t S [--out PATH]` writes a moment from a replay (starting points: `tools/debug/find_bugs.py RUN_DIR --fouls`), `play JSON [--seed N \| --seeds 0-4] [--against REF] [--events] [--strategy FILE.py:FACTORY]` plays one and prints what broke its checks (a seed table, the same moment at another commit, its events, a scratch strategy). See [strategy.md](strategy.md), "Debugging a foul or failure" | | `tools/debug/debug_match.py` | One ad hoc match between two strategies for tactic debugging; `--dump-ticks` writes per-tick poses and commanded targets | Library helpers for the same job (`render_window`, `render_clip`, `MatchLog.trace()`) are -described in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). +described in [strategy.md](strategy.md). ## Simulator realism @@ -142,7 +142,7 @@ the field logs in `replays/field/`. | Script | Purpose | |---|---| -| `tools/motion_planning_benchmark.py` | The motion planners (`fpp`, `dwa`, `trajsample`) on fixed headless rsim scenarios; `--figures DIR` also writes trajectory and summary PNGs; see [motion_planning_comparison.md](motion_planning_comparison.md) | +| `tools/motion_planning_benchmark.py` | The motion planners (`fpp`, `dwa`, `trajsample`) on fixed headless rsim scenarios; `--figures DIR` also writes trajectory and summary PNGs; see [motion_planning.md](motion_planning.md) | ## Demos and external environments @@ -163,9 +163,9 @@ the field logs in `replays/field/`. | `examples/score_goal.py` | One robot, no opponent, takes the ball and scores, on a real robot (or `--mode rsim`); also a demo in `pixi run demos` | | `examples/dribble_and_shoot.py` | `score_goal.py`'s robot dribbles a lap of the field, then scores | | `examples/passing_rally.py` | `pass_receive.py`'s pair passing their way along the field in two lanes, turning round `TURN_M` from each end line, for ever (no shots) | -| `tools/field/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([real_robot_setup.md](real_robot_setup.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | -| `tools/field/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([real_robot_setup.md, "Field logs"](real_robot_setup.md#field-logs)) | -| `tools/field/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([real_robot_setup.md, "Field logs"](real_robot_setup.md#field-logs)) | +| `tools/field/vision_check.py` | Does ssl-vision's multicast reach this machine: sender, packets per second per camera, detections and the field size, in 5 s with no radio or runner. The first check of a test day ([field_day.md](../tutorials/field_day.md)). `--guided ball` (or `"blue 2"`): each camera's error on 9 known spots, saved as a baseline | +| `tools/field/trim_idle_log.py` | Cuts long HALT/STOP dead time out of a field log (`replays/field/.log.gz`, `--dry-run` first, `--in-place`) ([real_robots.md, "Field logs"](real_robots.md#field-logs)) | +| `tools/field/package_logs.py` | Small archives to share: a tournament's results without the large `.npz` arrays, or field logs compressed with their calibration files ([real_robots.md, "Field logs"](real_robots.md#field-logs)) | | `tools/field/ssl-vision-lab-field.patch` | Not a script: adds a **Lab Field** preset (our 3 m x 2.25 m field, two cameras) to an ssl-vision checkout; `git apply` it there and rebuild | | `utama_core/analysis/close_calls.py` | Where two robots came within 0.25 m of each other in field logs (`replays/field/*.log`): how near, how fast they were closing, and the referee command in force; only the robots the run drove, `--tag` per robot. `python -m utama_core.analysis.close_calls replays/field/*real*.log` | | `examples/planner_ab.py` | Two robots swap ends head on and cross, again and again, in blocks alternating the planner (fpp, trajsample): contacts, close calls, nearest approach and time per planner; every block a game log. The field A/B of the motion planners | diff --git a/examples/pass_receive.py b/examples/pass_receive.py index 2ff9f29f..81c60d50 100644 --- a/examples/pass_receive.py +++ b/examples/pass_receive.py @@ -21,7 +21,7 @@ dashboard. Ctrl+C sends stop commands to the robots before exiting. The Live tab's Strategy panel can stand either robot still ("still") or restart it ("pass_receive"), while halted. - The field check on the Live tab must be all green or amber before Force Start, as in - `tools/field/shooting_drill.py` (docs/real_robot_setup.md, "Each test day"). + `tools/field/shooting_drill.py` (tutorials/field_day.md, "Each test day"). Why two teams: the robots wear different pattern colours (yellow 1, blue 0), and a runner team is one colour: there is no way to map a blue pattern into the yellow team. So each robot is its diff --git a/examples/save_and_counter.py b/examples/save_and_counter.py index 66053e50..31014e21 100644 --- a/examples/save_and_counter.py +++ b/examples/save_and_counter.py @@ -26,7 +26,7 @@ ball back and Force Start. Both goals must be in view (`CAMERA_HALF = "full"`). - Every mode starts in HALT; Ctrl+C sends stop commands to the robots before exiting. The Live tab's Strategy panel can stand either robot still or restart it, while halted. The field - check must be all green or amber before Force Start (docs/real_robot_setup.md). + check must be all green or amber before Force Start (tutorials/field_day.md). """ import sys diff --git a/tools/debug/moments.py b/tools/debug/moments.py index 05ed243d..69053374 100644 --- a/tools/debug/moments.py +++ b/tools/debug/moments.py @@ -1,6 +1,6 @@ """Regression moments: one field state that reproduced a bug, replayed for a few seconds against every strategy it concerns, with a check of what our robots must do instead. The workflow (find, -reproduce, fix the cause with a unit test, keep the moment) is in docs/STRATEGY_DEVELOPMENT.md, +reproduce, fix the cause with a unit test, keep the moment) is in docs/strategy.md, "Debugging a foul or failure". A moment is a JSON file in `utama_core/tests/moments/` (`test_moments.py` plays each one): diff --git a/tools/debug/plan_snapshot.py b/tools/debug/plan_snapshot.py index a8442dc2..81cfbbdf 100644 --- a/tools/debug/plan_snapshot.py +++ b/tools/debug/plan_snapshot.py @@ -11,7 +11,7 @@ no `--target`, the robot's own position 0.5 s later stands in for it, and the text box says so. Use it when a robot does something odd near an obstacle or a keep-out zone (see -docs/STRATEGY_DEVELOPMENT.md, "Debugging a foul or failure"). The picture is one tick: pair it with +docs/strategy.md, "Debugging a foul or failure"). The picture is one tick: pair it with `tools/debug/replay_trace.py` for the timeline. """ diff --git a/tools/debug/plan_trace.py b/tools/debug/plan_trace.py index a76df0a5..e278c50b 100644 --- a/tools/debug/plan_trace.py +++ b/tools/debug/plan_trace.py @@ -12,7 +12,7 @@ stand-in `tools/debug/plan_snapshot.py` uses; the figure says so. `--json` prints the per-sample rows. Use it when a robot's behaviour near an obstacle or keep-out zone unfolds over time, where one -`plan_snapshot` tick cannot show it (see docs/STRATEGY_DEVELOPMENT.md, "Debugging a foul or failure"). +`plan_snapshot` tick cannot show it (see docs/strategy.md, "Debugging a foul or failure"). """ from __future__ import annotations diff --git a/tools/debug/restart_picture.py b/tools/debug/restart_picture.py index 844d979d..ba4fcb44 100644 --- a/tools/debug/restart_picture.py +++ b/tools/debug/restart_picture.py @@ -20,7 +20,7 @@ Use it when a restart goes wrong: robots inside the keep-out, a kicker that never reaches the ball, a placer or defender parked in the wrong place. Filter on the findings first, open the picture to understand -them. See docs/STRATEGY_DEVELOPMENT.md, "Referee handling". +them. See docs/strategy.md, "Referee handling". """ from __future__ import annotations diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 68978c8c..ca820d09 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -10,7 +10,7 @@ --all every strategy in the catalog plays, not only the core How it works (players, rounds, the verdict, the match results store, the output folder): -docs/STRATEGY_DEVELOPMENT.md, "Evaluating a strategy". For a beginner: docs/first_strategy.md, step 8. +docs/strategy.md, "Evaluating a strategy". For a beginner: tutorials/first_strategy.md, step 8. Matches play in parallel (CPUs minus one, at most 12). A match the store (replays/match_results/) holds is never played again. A match that crashes is reported (`failed` in summary.json and report.json) and diff --git a/tools/field/field_check.py b/tools/field/field_check.py index d533291a..43ab8a97 100644 --- a/tools/field/field_check.py +++ b/tools/field/field_check.py @@ -38,7 +38,7 @@ def vision_lines(heard: dict, seconds: float) -> list[str]: """`listen`'s result as checklist lines.""" if not heard["senders"]: - return [f"!! vision: nothing on {MULTICAST_GROUP}:{VISION_PORT} (docs/real_robot_setup.md, 'Vision')"] + return [f"!! vision: nothing on {MULTICAST_GROUP}:{VISION_PORT} (tutorials/field_day.md, 'Vision')"] lines = [] for camera, n in sorted(heard["per_camera"].items()): hz = n / seconds diff --git a/tools/field/vision_check.py b/tools/field/vision_check.py index c1b34b01..8114cef4 100644 --- a/tools/field/vision_check.py +++ b/tools/field/vision_check.py @@ -1,7 +1,7 @@ # ruff: noqa: E402 """Does ssl-vision's multicast reach this machine? Listens for a few seconds, with no radio or runner, and prints who sent it, packets per second per camera, what was detected and the field -size ssl-vision announces. The first check on a test day (`docs/real_robot_setup.md`). +size ssl-vision announces. The first check on a test day (`tutorials/field_day.md`). Each robot and ball is also listed where each camera puts it (mean over the run) and, when several cameras see it, the largest gap between them: cameras whose calibrations agree are a few @@ -135,7 +135,7 @@ def check(seconds: float) -> None: sock = _socket() heard = listen(sock, seconds) if not heard["senders"]: - print(f"Nothing on {MULTICAST_GROUP}:{VISION_PORT} in {seconds:.0f} s: see docs/real_robot_setup.md, 'Vision'.") + print(f"Nothing on {MULTICAST_GROUP}:{VISION_PORT} in {seconds:.0f} s: see tutorials/field_day.md, 'Vision'.") sys.exit(1) print(f"From: {', '.join(sorted(heard['senders']))}") per_camera = heard["per_camera"] diff --git a/tools/motion_planning_benchmark.py b/tools/motion_planning_benchmark.py index 2eb33ab4..d4fec373 100644 --- a/tools/motion_planning_benchmark.py +++ b/tools/motion_planning_benchmark.py @@ -782,7 +782,7 @@ def __init__(self, scenario: Scenario, record_trace: bool = False): # controller commanded. Suppress `max_speed_mps`/ # `max_observed_acceleration_mps2` (and therefore `speed_limit_exceeded`) # for a short settling window per teleported robot -- the same - # estimator-transient caveat docs/motion_planning_comparison.md + # estimator-transient caveat docs/motion_planning.md # already documents for acceleration applies here too. self._settling_until_tick: dict[RobotKey, int] = {} # Measured directly (see the comment above): the simulator's @@ -961,7 +961,7 @@ def result(self) -> dict: # A real physical limit (RSIM_PARAMS.MAX_VEL, plus measurement # tolerance) is a hard pass/fail gate, unlike acceleration: observed # acceleration is reconstructed from filtered simulator velocity and - # can include estimator transients (see docs/motion_planning_comparison.md), + # can include estimator transients (see docs/motion_planning.md), # so it stays diagnostic-only rather than gating `passed`. speed_limit_exceeded = self.max_speed_mps > RSIM_PARAMS.MAX_VEL + SPEED_LIMIT_TOLERANCE return { diff --git a/docs/real_robot_setup.md b/tutorials/field_day.md similarity index 70% rename from docs/real_robot_setup.md rename to tutorials/field_day.md index 3009d002..75e59fe3 100644 --- a/docs/real_robot_setup.md +++ b/tutorials/field_day.md @@ -1,4 +1,4 @@ -# Real robots: setting up and checking vision and radio +# A field day with real robots The procedure for a test day with real robots: ssl-vision on its own Linux laptop sending vision over the network, and our stack on a Windows laptop in WSL with the radio dongle. Each part is @@ -135,7 +135,7 @@ Set the "Test-day configuration" block of `tools/field/shooting_drill.py`: `FIEL `CAMERA_HALF` (`"full"` when the cameras cover the whole field), each robot's vision and radio ID and working hardware. Then `pixi run python tools/field/shooting_drill.py`, open http://localhost:8080 and go through the Live tab's field check -([referee.md, "Operator panel"](referee.md#operator-panel)): every row green or +([referee.md, "Operator panel"](../docs/referee.md#operator-panel)): every row green or amber, each robot under its own ID and colour, a ball in each corner inside the area in play, and a robot pushed by hand across the cameras' overlap moving smoothly (a jump there means the two calibrations disagree). Only then Force Start. @@ -277,160 +277,4 @@ far to trust them. An older log is measured again with | `vision_check` sees nothing | Different networks, Wi-Fi multicast, `.wslconfig` not mirrored, or the firewall rule missing | | Dashboard: "Address already in use" | Another dashboard (`pixi run dashboard`) holds 8080: stop it | -## Field logs - -Recorded on the physical pitch during real robot test days: vision frames, referee commands, -bidirectional radio packets, and session metadata. - ---- - -### 1. File Location & Binary Format - -- **Location**: `replays/field/_real_.log.gz` -- **Specification**: Follows the official RoboCup SSL Game Log format (`SSL_LOG_FILE`), stored compressed with standard `gzip`. -- **Streaming**: Python readers stream `.log.gz` directly without uncompressing: - ```python - from utama_core.replay.ssl_log import read_records - - for ts_ns, msg_type, payload in read_records("replays/field/.log.gz"): - ... - ``` - -#### Record Types - -| Type ID | Name | Contents | -|---|---|---| -| `4` | `VISION_2014` | Raw `SSL_WrapperPacket` from ssl-vision cameras (pixel positions, confidence, detection timestamps). | -| `3` | `REFEREE` | `Referee` state updates (commands, stage, score, team cards). | -| `100` | `RADIO_OUT` | 12-byte packed commands sent to robots over serial radio (forward, left, turn velocities, kick power, dribbler). | -| `101` | `RADIO_IN` | Feedback packets returned by robots (IR ball sensor trigger state). | -| `102` | `RUN_INFO` | Initial session metadata JSON: git commit SHA, dirty flag, vision-to-radio mapping, field bounds. | -| `103` | `NOTE` | Human operator notes entered from the dashboard during testing. | - ---- - -### 2. Analysis & Calibration Tools - -Every field log contains the ground-truth signals needed to evaluate robot hardware: - -#### Robot Calibration (`tools/field/robot_calibration.py`) -Recovers physical dynamics and kicker geometry from a field test: -```bash -pixi run python tools/field/robot_calibration.py replays/field/.log.gz -``` -- **Loop Latency**: Sensing-to-action delay measured between commanded motion and camera-observed velocity (~61–62 ms). -- **Acceleration Limits**: Measured forward acceleration (~4.0–6.0 m/s²) vs. lateral acceleration (~2.7–3.6 m/s²). -- **Kick Characteristics**: Median ball launch velocity, directional offset bias (+2.7°), and bend caused by off-center dribbler contact (~4.2°/cm). -- **Dribbler Retention**: Sustained carry velocity and turn rate caps before the ball escapes (0.3 m/s, 0.6 rad/s). -- **Output**: Writes `.calibration.json`. - -#### Tag Alignment Calibration (`utama_core/analysis/tag_calibration.py`) -Measures optical tag placement relative to the chassis center: -```bash -pixi run python -m utama_core.analysis.tag_calibration replays/field/.log.gz -``` -- Fits circle trajectories during in-place spins to determine `(forward_m, left_m)` offsets. - -#### Proximity & Close Calls (`utama_core/analysis/close_calls.py`) -Scans logs for incidents where robots came closer than 0.25 m: -```bash -pixi run python -m utama_core.analysis.close_calls replays/field/*real*.log.gz -``` - -#### Converting to Replay (`tools/realism/convert_ssl_log.py`) -Converts an SSL game log into our columnar `.npz` + `.pkl` replay format for replay visualization and scenario debugging: -```bash -pixi run python tools/realism/convert_ssl_log.py replays/field/.log.gz --out replays/field/ -``` - ---- - -### 3. Storage & Dataset Management - -Raw field logs accumulate substantial disk space over a testing day. Three built-in tools manage log sizes: - -#### 1. In-Place Compression -Raw `.log` files should be compressed to `.log.gz`: -```bash -pixi run package-field --compress-in-place -``` -Reduces log sizes by **50%–60%** with zero data loss. All analysis tools support `.log.gz` out of the box. - -#### 2. Trimming Idle Time Sectors (`tools/field/trim_idle_log.py`) -Field sessions frequently capture long periods of inactivity where the referee command is `HALT` or `STOP` (e.g. operators manually setting up the ball or discussing tests). Over **55% of field log duration is trailing dead time**: -```bash -# Preview reduction without modifying files -pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --dry-run - -# Trim dead stretches and trailing halt in-place -pixi run python tools/field/trim_idle_log.py replays/field/.log.gz --in-place -# Or batch trim all field logs: -pixi run trim-field -``` -- Automatically removes idle pauses longer than 5 seconds while keeping 1.0 second safety padding around transitions. -- Fully strips trailing idle time recorded after drills end. -- Typically cuts file size by **65%–75%** while preserving every active drill frame. - -#### 3. Packaging & Distributing (`tools/field/package_logs.py`) -Creates self-contained release archives of field logs and calibration results: -```bash -pixi run package-field -``` -Bundles all `.log.gz` logs, `*.calibration.json`, and hardware profiles into `replays/field_logs_.tar.gz` for team sharing or dataset archival. - -## External tools: grSim, GameController, AutoReferee, SSL Vision - -None of this is needed for everyday work: rsim and the in-process -[`CustomReferee`](referee.md) run everything headless with no external process, and -behave the same across rsim, grSim and real mode. Set these up only to run against grSim, the -official competition software, or real robots. - -### grSim - -1. Go to the [grSim repo](https://github.com/RoboCup-SSL/grSim) and follow its - [installation steps](https://github.com/RoboCup-SSL/grSim/blob/master/INSTALL.md). -2. Change the configuration to the values highlighted below: - - ![grsim_setup](../assets/images/grsim_setup.png) - -3. To run it, execute `./bin/grSim` in the cloned repo. - -### AutoReferee and the GameController - -1. Make sure `grSim` is set up and can be called from a terminal. -2. `git clone` the [AutoReferee repo](https://github.com/TIGERs-Mannheim/AutoReferee) into a - folder named `AutoReferee/` in the repository root. -3. Change `DIV_A` to `DIV_B` in `AutoReferee/config/moduli/moduli.xml`: - - ```xml - - ROBOCUP - DIV_B - - ``` - -4. Get the latest [compiled game controller](https://github.com/RoboCup-SSL/ssl-game-controller/releases/), - rename it to `ssl-game-controller`, and save it in a `ssl-game-controller/` directory in the - repository root. - -Both directories are gitignored. - -#### Starting the external test environment - -Only needed to test against the official referee software; the in-process `CustomReferee` -needs none of this. With grSim, the GameController and AutoReferee set up, start each in its -own terminal from the repository root: - -```bash -grSim -cd ssl-game-controller && ./ssl-game-controller -cd AutoReferee && ./gradlew run -``` - -Then run your own strategy. The GameController's web UI is at http://localhost:8081/#/match -(this repo's dashboard is :8080). - -### SSL Vision and the radio for real robots - -The whole procedure (vision laptop, WSL networking and USB, radio, the checks before a robot -moves) is in [real_robot_setup.md](real_robot_setup.md). +What the field logs hold and the external tools (grSim, GameController, ssl-vision): [docs/real_robots.md](../docs/real_robots.md). diff --git a/docs/first_strategy.md b/tutorials/first_strategy.md similarity index 98% rename from docs/first_strategy.md rename to tutorials/first_strategy.md index 318ca9bb..edff8ff6 100644 --- a/docs/first_strategy.md +++ b/tutorials/first_strategy.md @@ -212,7 +212,7 @@ You decide what to keep. ## Where to go next -- [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): how strategies and tactics really work. +- [strategy.md](../docs/strategy.md): how strategies and tactics really work. Read it when you want to write a proper tactic. - `utama_core/tactics/`: real tactics to copy from. - `utama_core/skills/`: every skill a robot can use. diff --git a/docs/img/dashboard/replay.png b/tutorials/img/dashboard/replay.png similarity index 100% rename from docs/img/dashboard/replay.png rename to tutorials/img/dashboard/replay.png diff --git a/docs/img/dashboard/strategy_page.png b/tutorials/img/dashboard/strategy_page.png similarity index 100% rename from docs/img/dashboard/strategy_page.png rename to tutorials/img/dashboard/strategy_page.png diff --git a/utama_core/dashboard/static/field_canvas.js b/utama_core/dashboard/static/field_canvas.js index bc9f79d9..3e95c36b 100644 --- a/utama_core/dashboard/static/field_canvas.js +++ b/utama_core/dashboard/static/field_canvas.js @@ -513,7 +513,7 @@ class FieldCanvas { } // The intended receive point itself, whether or not the receiver has // reached it yet — the whole point of tracing this is to see when the - // two diverge (the exact silent-aim bug class STRATEGY_DEVELOPMENT.md + // two diverge (the exact silent-aim bug class strategy.md // warns intercept_point() can produce). const tx = toX(passTarget.x), ty = toY(passTarget.y); ctx.strokeStyle = FIELD_COLORS.ball; diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index 170cab9d..4734cc93 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -87,7 +87,7 @@ # held continuously for longer than this many sim seconds without # auto-advancing back to a live command. A real kickoff/free-kick/ball- # placement ceremony resolves in a few seconds; this is a generous margin -# above that, not a tight tolerance -- see docs/STRATEGY_DEVELOPMENT.md's +# above that, not a tight tolerance -- see docs/strategy.md's # Observability section for the matches this was built to catch. _RESTART_STALL_SECONDS = 15.0 # COMMITTED_FROZEN: the ball has moved less than this many metres... diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index f0cce7c6..9f0c0261 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -1,7 +1,7 @@ """Fingerprints of the code a match runs, so a deterministic rsim result can be reused. An rsim match is a pure function of the code each side runs, the pairing and the run -settings (`docs/STRATEGY_DEVELOPMENT.md`, "Determinism"). This module names that code: +settings (`docs/strategy.md`, "Determinism"). This module names that code: - `strategy_fingerprint(config)`: one player, a strategy in the catalog or a `.strategy` file: every repo module its code imports (function-level imports included, the shared diff --git a/utama_core/replay/scenario.py b/utama_core/replay/scenario.py index 28383637..0f493be7 100644 --- a/utama_core/replay/scenario.py +++ b/utama_core/replay/scenario.py @@ -40,8 +40,8 @@ Known limitations, stated here once rather than re-derived by every caller: - **Tactic `mem` is not in the replay.** Every `Tactic`'s internal per-slot - state (phase, committed targets, timers — see `docs/STRATEGY_DEVELOPMENT. - md`'s "Writing a Tactic") lives only in the live kernel `Strategy` + state (phase, committed targets, timers — see `docs/strategy.md`'s + "Writing a Tactic") lives only in the live kernel `Strategy` process, never serialized to the replay. A repro therefore always starts with **fresh tactic state** — the kernel re-partitions robots from scratch on the first tick after the scenario is applied, which may not diff --git a/utama_core/skills/go_to_point.py b/utama_core/skills/go_to_point.py index 7e6a1588..3679d38f 100644 --- a/utama_core/skills/go_to_point.py +++ b/utama_core/skills/go_to_point.py @@ -6,7 +6,7 @@ that needs to hold a specific orientation while stationary (e.g. facing a pass target, not the ball) must call `move()` directly with an explicit `target_oren` instead. This has bitten more than one tactic (see -`docs/STRATEGY_DEVELOPMENT.md`'s "Writing a Tactic" section) — grep every +`docs/strategy.md`'s "Writing a Tactic" section) — grep every `go_to_point(` call in a new tactic and check whether orientation actually matters at that call site. """ diff --git a/utama_core/skills/goalkeep.py b/utama_core/skills/goalkeep.py index e498d117..723a7a2e 100644 --- a/utama_core/skills/goalkeep.py +++ b/utama_core/skills/goalkeep.py @@ -1,7 +1,7 @@ """`goalkeep` — position the goalkeeper on the goal line to cover the predicted shot. Called directly on robot 0 (pinned outside the kernel scheduler — see -`docs/STRATEGY_DEVELOPMENT.md`'s "Single-writer partition invariant"), not +`docs/strategy.md`'s "Single-writer partition invariant"), not wrapped in a `Tactic`. The keeper's target y-position on the goal line is `predict_ball_pos_at_x`'s intercept when available, adjusted to account for one or two outfield defenders standing between the ball and goal (so the diff --git a/utama_core/tactics/clear_ball.py b/utama_core/tactics/clear_ball.py index f34e5cf6..2fa6e57d 100644 --- a/utama_core/tactics/clear_ball.py +++ b/utama_core/tactics/clear_ball.py @@ -297,7 +297,7 @@ def _trace( phase: str, command: Optional[RobotCommand], ) -> None: - """Per-tick mechanism trace (see STRATEGY_DEVELOPMENT.md's observability + """Per-tick mechanism trace (see strategy.md's observability section). `match_log` is None on tournament/CI runs, so this is a no-op there and stays in permanently.""" if ctx.match_log is None: diff --git a/utama_core/tests/engine/test_commitment_deadline.py b/utama_core/tests/engine/test_commitment_deadline.py index e5dca0bf..3d15a1d3 100644 --- a/utama_core/tests/engine/test_commitment_deadline.py +++ b/utama_core/tests/engine/test_commitment_deadline.py @@ -5,7 +5,7 @@ and `game.ball` off whatever it's given) plus a stub `Tactic` whose `is_committed()` always returns `True` — the exact "missing release path" shape behind the 42 "match freeze" bug-fix commits this mechanism responds -to (see `docs/tactic_model_design_decisions.md` §3/§15's "open item"). +to (see `docs/strategy_design.md` §3/§15's "open item"). The deadline overrides `_choose_partition`'s pinning decision only — it does not change `Tactic.is_committed()` semantics (still `True` throughout every diff --git a/utama_core/tests/replay/test_scenario.py b/utama_core/tests/replay/test_scenario.py index 64a34643..d385570a 100644 --- a/utama_core/tests/replay/test_scenario.py +++ b/utama_core/tests/replay/test_scenario.py @@ -1,7 +1,7 @@ """Tests for `utama_core.replay.scenario` (replay-to-repro reconstruction). See `utama_core/replay/scenario.py`'s module docstring for why this module -exists and `docs/STRATEGY_DEVELOPMENT.md`'s Observability section for how it +exists and `docs/strategy.md`'s Observability section for how it fits alongside `MatchLog`/`render_window`/the stall watchdog. """ diff --git a/utama_core/tests/strategy/test_first_strategy_doc.py b/utama_core/tests/strategy/test_first_strategy_doc.py index ec8e1886..115ce3f6 100644 --- a/utama_core/tests/strategy/test_first_strategy_doc.py +++ b/utama_core/tests/strategy/test_first_strategy_doc.py @@ -1,4 +1,4 @@ -"""The tutorial's strategy (docs/first_strategy.md) still builds, so a new member's first paste works.""" +"""The tutorial's strategy (tutorials/first_strategy.md) still builds, so a new member's first paste works.""" import re from pathlib import Path @@ -6,7 +6,7 @@ from utama_core.engine.strategy import Strategy -DOC = Path(__file__).resolve().parents[3] / "docs" / "first_strategy.md" +DOC = Path(__file__).resolve().parents[3] / "tutorials" / "first_strategy.md" def test_the_tutorial_strategy_builds(): From e5fbd8bcbdd9bc7676a2f02ac8e12799dbeafa53 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 13:39:38 +0000 Subject: [PATCH 58/59] docs: what was learned, where everyone can read it Notes that only the agent's private memory held, now in the docs: - strategy.md: "Tried and rejected" (eight paired-drill experiments and one shipped), "Known open bugs" (the keeper ignores a slow ball rolling through its box, left open as a first task), what the 118 real matches showed, and why evaluation needs many matches. - real_robots.md: "Our robots": one kick power, kick bend, weak dribbler and carry caps, motion delay and acceleration, lid vs radio, vision over Wi-Fi. - referee.md: the lone-defender gap and the shadow run over real matches. - AGENTS.md: evaluation at 2 m/s and one kick power, on purpose; rsim differs across CPUs. - tools.md: worktrees share replays/. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 9 ++++++++- docs/real_robots.md | 26 ++++++++++++++++++++++++- docs/referee.md | 4 ++++ docs/strategy.md | 47 +++++++++++++++++++++++++++++++++++++++++++++ docs/tools.md | 2 +- 5 files changed, 85 insertions(+), 3 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 421639f2..ccf92c7f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -71,7 +71,10 @@ One term per thing; reuse these instead of coining new ones. - **World / robot capability** — simulator settings fall into two kinds: the world (ball friction, vision noise and dropouts, latency) comes from measurements; robot capability (kick, dribbler, motors) is assumed good at league level, and real robots' shortfalls are compensated - in the control layer. The test: would better robots change it? `tools/evaluation/reference/ + in the control layer. The test: would better robots change it? Two decisions follow: evaluation runs + robots at 2 m/s, the speed we are building toward, not today's 1 m/s; and kicks have one power, + as our kicker does, so no variable-kick settings in sim or skills. What we measured on our robots: + `docs/real_robots.md`, "Our robots". `tools/evaluation/reference/ world.json`, `robots.json`; field sessions in `tools/field/field_sessions.json`. - **Situation / goal sources** — a situation starts when a restart goes live or a side wins the ball in open play; the goal sources (`utama_core/analysis/goal_sources.py`) gives each goal to @@ -147,6 +150,10 @@ declarations) — check there before reintroducing one of them. `test_bang_bang_edge_cases.py`'s `_seeds_with_known_defect`), so a fix shows as XPASS and a regression elsewhere fails. Don't chase rsim-only dribble test failures as if they were kernel bugs; verify on grsim if genuinely unsure. +- rsim is deterministic on one machine but not across CPUs (the planner's numba kernels are compiled + `fastmath` for the host), so CI plays a slightly different game. Don't assert outcomes of + multi-second rsim games: assert invariants, or write a pure unit test. A CI-only rsim failure is + CPU numerics first. - Before trusting any test result (yours or another agent's), prefer independently re-running it and reading real output over trusting a self-report — this codebase has been touched by both humans and agents, and a claimed "all tests pass" is only as diff --git a/docs/real_robots.md b/docs/real_robots.md index d6dec0dc..96146400 100644 --- a/docs/real_robots.md +++ b/docs/real_robots.md @@ -1,9 +1,33 @@ # Real robots -The reference for real-robot work: what a field log holds and the tools that read it, and the +The reference for real-robot work: what we know about our robots, what a field log holds and the tools that read it, and the external software (grSim, the official GameController, AutoReferee, ssl-vision). The procedure for a test day is the tutorial [tutorials/field_day.md](../tutorials/field_day.md). +## Our robots + +What we have measured on our two robots (radio 0 and radio 1), from field logs of 2026-10-27 to +10-29. Each robot's numbers live in `utama_core/config/robots/radio_.json`, written by +`pixi run calibrate`; they apply on real robots only (the sim assumes league-level robots, see +"World / robot capability" in `AGENTS.md`). + +- **The kicker has one power.** A full kick leaves at about 2.2 m/s on radio 0 (the sim kicks at + about 5). Strength varies with charge and battery; don't chase it. No variable-power settings + in sim or skills until the hardware has it. +- **Kicks bend with where the ball sits on the dribbler:** about 4 degrees per cm off centre on + radio 0, 1 on radio 1, plus a small bias. Passes and shots correct for it (`kick_bend_deg_per_cm`, + `kick_bias_deg`). +- **The dribbler is weak.** Robots lose the ball when they turn or move sideways or backwards with + it, so `move()` caps carrying at 0.3 m/s and 0.6 rad/s on real robots. A first guess: tune it on + the field (`pixi run calibrate` has a carry ladder). +- **Motion:** about 79 ms from command to motion; turns about 9% faster than commanded; sideways + acceleration about 1.8 m/s^2 against about 5 forwards. +- **The lid is not the robot.** A robot is its radio (motors, kicker, dribbler); the patterned lid + can be swapped. `pixi run find-robots` pairs them. +- **Vision over Wi-Fi is patchy.** Over a phone hotspot, packets arrived bunched and lost and the + field check kept halting. When a run halts on vision gaps, check how the laptop gets vision before + touching code. + ## Field logs Recorded on the physical pitch during real robot test days: vision frames, referee commands, diff --git a/docs/referee.md b/docs/referee.md index ebe1b3a0..f0ccada5 100644 --- a/docs/referee.md +++ b/docs/referee.md @@ -140,6 +140,10 @@ again afterwards. - **Operator GUI "suggested next step"** based on the current command, so an operator decides only *when* to advance, not *what*. - **`TeamInfo` should be a frozen dataclass**: item 8 under Design decisions. +- **A lone defender touching the ball in its box, keeper outside, is not called**: `DefenseAreaRule` + only looks once more than `max_defenders` robots are inside. Found by running every rule over the + 118 official Division B matches (2026-10-12): ball out and goals agree with the officials about + 95% of the time; the three bugs it found are fixed. Resolved (kept here so nobody re-reports them): the old friendly-first, ≤0.15m proximity last-touch heuristic and its yellow default (replaced by `infer_last_touch_team`), double touch, diff --git a/docs/strategy.md b/docs/strategy.md index f219c57a..e5b0c5c3 100644 --- a/docs/strategy.md +++ b/docs/strategy.md @@ -314,6 +314,9 @@ flowchart TD - **confirm**, fresh seeds 101-106, on their diffs alone: the same drop rule, then **better** if a one-sided paired t-test gives p <= ALPHA (0.05), else **undecided** (not clearly better: drop it). + Why so many matches: one match's goal difference varies by about 3 goals between seeds (measured + 2026-10-12), so a 1-goal edge needs about 36 matches per pairing to show; paired diffs cancel much + of that. Only fresh seeds accept, so a candidate chosen because it looked good on seeds 1-6, or fitted to them, is not accepted on that luck. "Dropped" means not promising, not worse: an equal strategy is dropped at the first look about half the time. ROUNDS and ALPHA are provisional: ROUNDS is to be set @@ -567,6 +570,35 @@ original numpy paths, byte-identical to before (`8c191eea`); the evaluation's wo all inherit it. The two modes agree to 1e-9 per call but matches diverge after the first differing tick, so a baseline recorded in one mode is only comparable with a candidate run in the same mode. +## Tried and rejected + +Ideas that look obvious from the signals and cost a day to disprove. Each was measured with paired +drills: the same moments from one run's replays, replayed with one side changed. Don't re-propose one +without new evidence (field data, a changed world), and add yours here when you reject one. + +| Idea | Result | Date | +|---|---|---| +| Sprint at a contested ball (`go_to_ball`: within 1.2 m, an enemy within 0.6 m of it) | **Shipped**: +7 points of possession on free balls, +7 more on balls an enemy holds | 2026-11-10 | +| Face the ball before closing; line up in front of the enemy's dribbler; widen the sprint; carry speed and acceleration caps in sim | No gain over the sprint alone | 2026-11-10 | +| Receiver retreats as the ball arrives (a "cushion"); first-time shots | No gain below 5 m/s; receivers 10-20° off the ball's line caught 7% | 2026-11-09 | +| Brake harder when receiving | No gain. Most missed receptions are the kick noise in `robots.json`, chosen to match real pass completion: by design | 2026-11-10 | +| Faster free kicks (taker sprints) | Kick 1.5 s sooner, but passes received 92 → 75: an enemy is still crossing the lane | 2026-11-10 | +| Pass early when pressed (an enemy closing within 0.35-0.5 m) | Possession −9 to −12 points, more free kicks against: a 5 m/s kick reaches a mate 1 m away before they can adjust | 2026-11-10 | +| Clear towards the touch line instead of upfield | Fewer free kicks against in our half, more overall, less possession, same goals | 2026-11-10 | +| 1.5 m minimum distance for the restart pass (open play keeps 1.5 m, restarts 0.7 m) | No difference | 2026-11-10 | +| rsim's faster ODE solver (`dWorldQuickStep`) | 23% faster matches, but a robot driving sideways drifts 18-24 cm over 3 m | 2026-10-10 | + +Two facts behind several of these: passes under 1.5 m are half of all passes and only 28% are +received (1.5-3.5 m: about 50%); and a pass whose line passes within 4 cm of the receiver's centre is +caught 82-97% of the time, beyond 4 cm under 30%. + +## Known open bugs + +- **The keeper ignores a slow ball rolling through its own box.** `skills/goalkeep.py` fetches a + ball in the box only below `_RETRIEVE_BALL_SPEED` (0.3 m/s); a ball rolling slower than a shot but + faster than that, wide of the goal, is watched until it goes out. Seen in the v2.6.0 replays, + `pendulum_vs_wolfpack` at 3:52 (wolfpack's keeper). Left open on purpose as a first task. + ## Reading a round Every `evaluate.py` run prints round 1's sections and writes each round's data to @@ -634,3 +666,18 @@ What a converted match holds, and where it differs from a sim replay (the detail `INDIRECT_FREE_*`. The corpus above starts in 2022. The scenario bench (retired 2026-10-17) replayed 10 s starts harvested from replays; to look at one point in a replay use `tools/debug/repro_from_replay.py --t `, and to pin a failure there add a regression moment ("Debugging a foul or failure", above), and `analysis/goal_sources.py` lists a replay's situations and goals. + +### What real matches showed (2026-10) + +From the 118 converted Division B matches, against our sim at the time. The scripts are outside the +repo (`~/dev/ssl/xg-analysis/`); the full write-up is in git history (`docs/sim_realism.md`, deleted +2026-11-13). + +- Real matches have about 3-4 goals and about 40 free kicks; most goals come from the ball won in + open play, about 19% from set pieces. Real matches are live only about 15% of the time. +- Shot totals and finishing roughly matched the sim's, but only because differences cancel: sim + keepers saved twice as often, and sim shots went wide far less often. Judge realism by component + (keeper reaction, ball slow-down, kick noise), never by goal totals. +- A value model fitted on real matches (who scores within 10 s; AUC 0.82 on held-out years) did not + rank strategies with fewer matches than goals do. xG failed as a ranker too (`docs/signals.md`, + "Ranking"). diff --git a/docs/tools.md b/docs/tools.md index 3748f7bd..136dd478 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -57,7 +57,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Script | Purpose | |---|---| -| `tools/dev/setup_worktree.sh` | Run inside a git worktree: links `.pixi` to the main checkout's and copies the gitignored compiled `.so` extensions (planner, rsim). Idempotent; one line per action | +| `tools/dev/setup_worktree.sh` | Run inside a git worktree: links `.pixi` to the main checkout's and copies the gitignored compiled `.so` extensions (planner, rsim). Idempotent; one line per action. Symlink `replays` too, so the worktree shares the match results store; run one evaluation at a time per laptop | ## Playing matches From ebbf523993d9066bfccd966d03ff76ce4d851479 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Fri, 13 Nov 2026 13:47:03 +0000 Subject: [PATCH 59/59] skills: in .agents/skills for any agent; .claude/skills is a symlink The playbooks were already plain Markdown; only their place tied them to Claude Code. AGENTS.md, which every agent reads, now lists them with when to use each, and the tutorial's last step names no particular agent. Co-Authored-By: Claude Opus 5.5 --- .../skills/change-strategy/SKILL.md | 0 .../skills/debug-incident/SKILL.md | 0 .../skills/explain-result/SKILL.md | 0 .../skills/field-session/SKILL.md | 0 .claude/skills | 1 + .gitignore | 5 +++-- AGENTS.md | 20 ++++++++++++++----- README.md | 5 +++-- docs/strategy.md | 4 ++-- docs/tools.md | 2 +- tutorials/first_strategy.md | 9 +++++---- 11 files changed, 30 insertions(+), 16 deletions(-) rename {.claude => .agents}/skills/change-strategy/SKILL.md (100%) rename {.claude => .agents}/skills/debug-incident/SKILL.md (100%) rename {.claude => .agents}/skills/explain-result/SKILL.md (100%) rename {.claude => .agents}/skills/field-session/SKILL.md (100%) create mode 120000 .claude/skills diff --git a/.claude/skills/change-strategy/SKILL.md b/.agents/skills/change-strategy/SKILL.md similarity index 100% rename from .claude/skills/change-strategy/SKILL.md rename to .agents/skills/change-strategy/SKILL.md diff --git a/.claude/skills/debug-incident/SKILL.md b/.agents/skills/debug-incident/SKILL.md similarity index 100% rename from .claude/skills/debug-incident/SKILL.md rename to .agents/skills/debug-incident/SKILL.md diff --git a/.claude/skills/explain-result/SKILL.md b/.agents/skills/explain-result/SKILL.md similarity index 100% rename from .claude/skills/explain-result/SKILL.md rename to .agents/skills/explain-result/SKILL.md diff --git a/.claude/skills/field-session/SKILL.md b/.agents/skills/field-session/SKILL.md similarity index 100% rename from .claude/skills/field-session/SKILL.md rename to .agents/skills/field-session/SKILL.md diff --git a/.claude/skills b/.claude/skills new file mode 120000 index 00000000..2b7a412b --- /dev/null +++ b/.claude/skills @@ -0,0 +1 @@ +../.agents/skills \ No newline at end of file diff --git a/.gitignore b/.gitignore index 7c77de50..8a0b0514 100644 --- a/.gitignore +++ b/.gitignore @@ -208,9 +208,10 @@ benchmark_results/ # local agent-tool config dirs .codex/ -.agents/ +.agents/* +!.agents/skills/ .claude/* -!.claude/skills/ +!.claude/skills .vscode diff --git a/AGENTS.md b/AGENTS.md index ccf92c7f..78a20085 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -84,6 +84,20 @@ One term per thing; reuse these instead of coining new ones. - **Situation rates** — how often each situation type happens per team per live minute, from real Division B matches or our matches (`goal_sources --rates PATH`). +## Skills + +Step-by-step playbooks for the jobs that chain several scripts, in `.agents/skills//SKILL.md` +(plain Markdown with a `name`/`description` header; `.claude/skills` is a symlink to the folder). +When a task matches one, read that file and follow it, whatever agent you are. The docs keep the +reasons; the skills keep the steps. + +| Skill | Use it to | +|---|---| +| `change-strategy` | write or change a strategy, test it, evaluate it against the champion, promote it | +| `explain-result` | explain how a strategy plays and why it won or lost, from an evaluation's replays | +| `debug-incident` | take one bad moment in a match from symptom to a fixed cause with a regression test | +| `field-session` | run a test day on the real robots and process its logs | + ## Repo map - `utama_core/engine/` — the scheduler/protocol infra: `Strategy`, `Tactic`, `TickContext`, @@ -170,11 +184,7 @@ declarations) — check there before reintroducing one of them. `docs/README.md` indexes every doc by kind and `docs/tools.md` every script; the ones agents need most: -- `.claude/skills/` — four step-by-step playbooks over those scripts (plain Markdown, readable by - any agent): `change-strategy` (write, test, evaluate and promote a strategy), `explain-result` (how - a strategy plays, why it won or lost), `debug-incident` (one bad moment, from symptom to a fixed - cause with a test), `field-session` (a test day on real robots and its logs). The docs keep the - reasons; the skills keep the steps. +- `.agents/skills/` — step-by-step playbooks over those scripts (see "Skills" below). - `tutorials/first_strategy.md` — the beginner tutorial (a toy strategy, then evaluation). Keep it short, simple and runnable: `tests/strategy/test_first_strategy_doc.py` builds its code. diff --git a/README.md b/README.md index 539598c0..fc49c6f8 100644 --- a/README.md +++ b/README.md @@ -99,5 +99,6 @@ Tips: them and commit again. - A strategy branch (`strategy/*`) may change strategy code only (`tools/dev/check_strategy_branch.py`), so it can't change what it is scored against. -- `CLAUDE.md` is a symlink to `AGENTS.md`: edit `AGENTS.md`. On native Windows without Developer - Mode, fix it with `git config --global core.symlinks true && git checkout -- CLAUDE.md`. +- `CLAUDE.md` is a symlink to `AGENTS.md`, and `.claude/skills` to `.agents/skills`: edit the + targets. On native Windows without Developer + Mode, fix it with `git config --global core.symlinks true && git checkout -- CLAUDE.md .claude/skills`. diff --git a/docs/strategy.md b/docs/strategy.md index e5b0c5c3..5d3ab8d0 100644 --- a/docs/strategy.md +++ b/docs/strategy.md @@ -172,7 +172,7 @@ Lessons from bugs that recurred (mostly `SwitchOfPlayTactic`, `tactics/switch_of ## Writing and evaluating a strategy -The steps from branch to pull request, as a checklist: the `change-strategy` skill (`.claude/skills/`). +The steps from branch to pull request, as a checklist: the `change-strategy` skill (`.agents/skills/`). A strategy is a combination of existing tactics plus a partitioner that decides how many robots each gets. Most new strategies need no new tactic. When one does, add it as a new module in @@ -453,7 +453,7 @@ whoever runs it. A foul or failure seen in a match is a symptom: the cause may be the robot, the shared referee override, the planner, the referee itself, or the check that flagged it. Of the first six found this way (table below), two were the referee or the check, not the robot. The steps alone, as a -checklist, are the `debug-incident` skill (`.claude/skills/`); this section keeps the reasons and the bugs found. +checklist, are the `debug-incident` skill (`.agents/skills/`); this section keeps the reasons and the bugs found. Start with `tools/debug/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind and the pictured findings. Filter `findings.jsonl` on the kind you care about, open that finding's picture to see what it diff --git a/docs/tools.md b/docs/tools.md index 136dd478..d267078a 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -20,7 +20,7 @@ Everything below is for specialists. Pick the tool by the question you have. -For the four jobs that chain several of them, follow a skill in `.claude/skills/`: `change-strategy`, `explain-result`, +For the four jobs that chain several of them, follow a skill in `.agents/skills/`: `change-strategy`, `explain-result`, `debug-incident`, `field-session`. | Question | Tool | diff --git a/tutorials/first_strategy.md b/tutorials/first_strategy.md index edff8ff6..5133da1e 100644 --- a/tutorials/first_strategy.md +++ b/tutorials/first_strategy.md @@ -198,12 +198,13 @@ and its matches, beside the strategies you looked at in step 2. ## 10. Now let an agent write one -You know how a strategy works now. A coding agent (like Claude Code) can write and test new ones -much faster. This repo has a step-by-step guide for agents: the `change-strategy` skill. +You know how a strategy works now. A coding agent (Claude Code, Codex, Cursor or another) can write and +test new ones much faster. This repo has step-by-step guides for agents in `.agents/skills/`; the one +for strategies is `change-strategy`. -Open Claude Code in the repo and ask, for example: +Open your agent in the repo and ask, for example: -> Use the change-strategy skill. Make a new strategy where two robots always defend near our goal +> Follow the change-strategy skill (.agents/skills/change-strategy/SKILL.md). Make a new strategy where two robots always defend near our goal > and three attack. The agent makes the branch, writes the strategy, runs the tests and asks you before it runs

o(6u*z0B_grRJQOeA}tXNGypI;U*YQ-W7RpAh`N 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 Ok!vRW#6uL?5i^!PWyKS6)ey)ewj<$0 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 %GyzI3AOned)?k=yBr4E<&ecKU?TUYi`Qm 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 z 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 X!V-3mdwLxoARjp?2(&0}9Q=O(VzMdU diff --git a/docs/img/signals/positions_defence.png b/docs/img/signals/positions_defence.png deleted file mode 100644 index 089d08db0f0375b90f144bcccf4c8d8931ebcac0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 299742 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%0DspfcS~$&$eoL_ec} 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

AbvD)UvWtzsha8u~SNKke=~FAk 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 diff --git a/docs/signals.md b/docs/signals.md index 575f0777..8f1ad223 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -49,25 +49,25 @@ match results store (`replays/match_results/`). ## Where they come from -Every saved `tools/evaluation/round_robin.py` run prints its sections and writes the same data to -`replays//summary.json`: +Every `tools/evaluation/evaluate.py` run prints round 1's sections and writes each round's data to +`replays/eval_/round_/summary.json` (round 1's also in `report.json`; older round-robins: +`replays/tournament_/summary.json`, with `standings` and `ratings` too): | Printed section | `summary.json` key | Computed by | |---|---|---| -| Standings, STRATEGIES | `standings`, `strategies[*]` | `MatchStats` (live, every match) | +| STRATEGIES | `strategies[*]` | `MatchStats` (live, every match) | | LOSS KINDS, BALL LOSSES, `passes:` line | `strategies[*].real_loss_kinds_as_a`, `ball_losses` (tables in `ball_losses.md`) | `analysis/turnover_breakdown.py` | | CHANCES | `strategies[*].chances`, `pass_progress_m`, `forward_pass_share` | `analysis/chances.py` | -| None (in `summary.json` only) | `ratings` | `analysis/ratings.py` ([Ranking](#ranking)) | | FOULS | `fouls` | `MatchStats` | -| STALLS | `stalled_match_count`, `stall_incidents`, per-match `stats.stall_events` | `MatchStats` stall watchdog | +| STALLS | `stall_incidents`, `stalls_checked` (matches each strategy was checked in, as config_a), per-match `stats.stall_events` | `MatchStats` stall watchdog | | RESTARTS | `restarts` | `analysis/restart_outcomes.py` | | — | `results[*].stats` | per-match `MatchStats`, everything above per match | | — | `run` | git commit, dirty flag, argv: compare runs only at clean commits | **Figures:** [`signal_report.md`](signal_report.md) draws the main signals for the latest full -round-robin (`tools/signal_report.py ` regenerates them), with notes on what stands out. +round robin (`tools/signal_report.py ` regenerates them), with notes on what stands out. -**Offline only** (not in a round-robin's output): `tools/metric_correlation.py ...` +**Offline only** (not in `evaluate.py`'s output): `tools/metric_correlation.py ...` replays a run at 10 Hz for the signals marked *offline* below, and `python -m utama_core.analysis.goal_sources ` writes the goal sources ([Where do goals come from?](#where-do-goals-come-from)). @@ -86,7 +86,7 @@ Check these first: a broken strategy's other signals mean nothing. | Signal | Where | Meaning | Reference | If it's off | |---|---|---|---|---| -| Stalls | STALLS; `stats.stall_events` | `RESTART_STALL`: a restart held > 15 s, with a one-line diagnosis. `COMMITTED_FROZEN`: ball moved < 5 cm for > 10 s in live play while a slot was committed, with who holds the ball | 10 of 231 matches | A bug to fix before anything else. Rerun with `round_robin.py --pair A B`, look with `tools/replay_trace.py` and `render_window()` | +| Stalls | STALLS; `stats.stall_events` | `RESTART_STALL`: a restart held > 15 s, with a one-line diagnosis. `COMMITTED_FROZEN`: ball moved < 5 cm for > 10 s in live play while a slot was committed, with who holds the ball | 10 of 231 matches | A bug to fix before anything else. Restart it from its replay with `tools/repro_from_replay.py`, look with `tools/replay_trace.py` and `render_window()` | | Possession backstop | `results[*].possession_backstop` | possession pinned 100/0 with the ball barely moving: a freeze the watchdog missed | 0 | Same as a stall | | Restarts not taken | RESTARTS; `restarts.by_kind[*].outcomes` | a kickoff, free kick or penalty `voided`, `timeout`, `stopped_before_kick` instead of `taken` | free kicks: 3414 taken of 3467 | The taker can't reach or kick the ball: restart positioning, a planner clamp, a keep-out circle | | Fouls by rule | FOULS; `fouls` | every foul by rule, then strategy/tactic of the offending robot | per strategy 6.3 (`chameleon`) · 7.9 · 23.3 (`three_slot`); run: out_of_bounds 2938, excessive_dribbling 448, defense_area 310, crashing 307 | One tactic dominating a rule is its bug: dribbling too far, entering the box, driving into robots | @@ -196,11 +196,11 @@ in game terms, and say what to do when it's off; correlation with results is not Put it where it's cheapest: - a count the match can keep as it plays: `MatchStats` (`engine/match_stats.py`). Changing it - changes every match's fingerprint, so the next round-robin plays everything again; + changes every match's fingerprint, so the next evaluation plays everything again; - anything else derived from replays, both sides: `ChanceTracker` (`analysis/chances.py`), fed from the replay pass the ball-loss breakdown already makes. Cached records keep the analysis they were stored with: delete the store to refresh them (`utama_core/replay/match_results.py`); - needing the intentions log (which tactic, which robot's role): `analysis/turnover_breakdown.py`, config_a only. -Then add its row here with a reference range from a full round-robin. +Then add its row here with a reference range from a full round robin (`evaluate.py --all`). diff --git a/docs/strategies.md b/docs/strategies.md index 91dcd0d5..1ca57c6d 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -1,45 +1,46 @@ # Strategy catalog -Every strategy in `utama_core/strategy/` (one module each, named after the strategy), whether a -round-robin plays it, and the latest results. +Every strategy in `utama_core/strategy/` (one module each, named after the strategy), whether it +is core or reserve, and the latest results. Run: -- `pixi run python tools/evaluation/round_robin.py [name ...]` — full-match round-robin (two halves of 300 s of playing time) over every config (or the - named ones). Common flags: `--strict`, `--pair A B` (one match); `--help` lists all. +- `pixi run python tools/evaluation/evaluate.py` — one round robin of the core, two reserve and the + champion at the last release: stalls and signals (`--all` plays every strategy). - `pixi run python tools/evaluation/evaluate.py ` — judges a candidate against the champion - of the reference opponents (`tools/evaluation/reference/opponents.json`). The way to judge a strategy. + at the last release. The way to judge a strategy. `--help` lists the flags. - `pixi run python tools/debug_match.py --strategy --opponent [--dump-ticks PATH]` — one instrumented matchup. -rsim is deterministic: re-running an identical pair gives an identical result. Variance comes -only from `--both-sides`, side/kickoff cells, or `--fuzz-restarts`. - -**In the round-robin**, in order of the 2026-10-10 standings (below). A round-robin with no -strategies named plays these. - -| Strategy | Description | -|---|---| -| `pendulum` | `LeadAndSupportTactic` + `ShadowAndMarkTactic`, split by possession edge. | -| `riptide` | Give-and-go attack, press on the ball, `BlockShapeTactic` screen; 3/2 with possession hysteresis. | -| `chameleon` | `riptide` plus a late-half scoreline shift (protect a lead / chase). | -| `terrier` | `GiveAndGoTactic` + `PressAndContainTactic`, possession-edge split. | -| `breakwater` | `firebreak` plus `weaver`'s final-third overload. | -| `wolfpack` | Same pair as `terrier`, fixed 80/20 attack-heavy split ignoring possession. | -| `weaver` | `tiki_taka`, handing off to `DecoyOverloadTactic`'s duet in the final third. | -| `ricochet` | Whole pool runs `GiveAndGoTactic`, no defense slot. | -| `avalanche` | 4-robot overload/switch attack + 1 block, built to outnumber tiki_taka's shadow line. | -| `tripwire` | `riptide`, but an all-in press when the ball is lost in our own third. | -| `mirage` | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | -| `firebreak` | `riptide` postures plus an own-third `ClearBallTactic` danger-clearance valve. | +rsim is deterministic: re-running an identical match gives an identical result. Variance comes +from the seeded sim noise: `evaluate.py`'s round k plays with seed k. + +**The catalog.** Core strategies play every round of `evaluate.py`; reserve ones rotate in, two per +round (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results +below were played under the old names (column "Was"), which `catalog.RENAMED` still loads. + +| Strategy | Was | Role | Description | +|---|---|---|---| +| `avalanche` | `overload_press` | core | 4-robot overload/switch attack + 1 block, built to outnumber a shadow line. | +| `breakwater` | `clear_press_plus` | core | `firebreak` plus `weaver`'s final-third overload. | +| `mirage` | `decoy_and_overload` | core | `DecoyOverloadTactic` (min 2) + `ShadowAndMarkTactic`, fixed 50/50. | +| `pendulum` | `split_shape` | core | `LeadAndSupportTactic` + `ShadowAndMarkTactic`, split by possession edge. | +| `wolfpack` | `high_press` | core | Same pair as `terrier`, fixed 80/20 attack-heavy split ignoring possession. | +| `chameleon` | `score_aware_counter_flow` | reserve | `riptide` plus a late-half scoreline shift (protect a lead / chase). | +| `firebreak` | `clear_danger` | reserve | `riptide` postures plus an own-third `ClearBallTactic` danger-clearance valve. | +| `ricochet` | `give_and_go_solo` | reserve | Whole pool runs `GiveAndGoTactic`, no defense slot. | +| `riptide` | `counter_flow` | reserve | Give-and-go attack, press on the ball, `BlockShapeTactic` screen; 3/2 with possession hysteresis. | +| `terrier` | `press_and_pass` | reserve | `GiveAndGoTactic` + `PressAndContainTactic`, possession-edge split. | +| `tripwire` | `press_trigger_flow` | reserve | `riptide`, but an all-in press when the ball is lost in our own third. | +| `weaver` | `tiki_taka_plus` | reserve | Short passing, handing off to `DecoyOverloadTactic`'s duet in the final third. | **Deleted** (2026-11-12): the ten strategies retired on 2026-10-10 (`tiki_taka`, `counter_press`, `high_line_zone`, `three_slot`, `switch_of_play`, `low_block`, `zone_fluid`, `score_aware_zone_flow`, `overload_flow`, `shadow_switch`), because nobody knew whether they still worked. Git history keeps them. -`default`: Everyone runs `PassAndShootTactic`; only 2 robots are ever commanded (see bugs). Excluded from round-robin discovery. +`default`: Everyone runs `PassAndShootTactic`; only 2 robots are ever commanded (see bugs). Excluded from the catalog `evaluate.py` plays. -Strategies are judged with `evaluate.py` against the reference opponents (`tools/evaluation/reference/`) +Strategies are judged with `evaluate.py` against the champion at the last release (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). The round-robin results below are a snapshot of the catalog, not the verdict on any one strategy. @@ -84,9 +85,9 @@ bugs" refer to them — read them with `git log -p -- docs/strategies.md`. Still ## Updating this file -- New strategy → add a row with a one-line description to the round-robin table. +- New strategy → add a row with a one-line description to the table (it starts as reserve). - New tournament → replace the matching results table (one table per tournament type) and record the run directory; don't append narrative. Findings belong in commit messages. - Strategy abandoned after losing → delete its module and its row. -- Only single matches (`--pair`), no round-robin → put them in the pull request, not here: this - file holds round-robin and full-match results only. +- Only single matches, no evaluation → put them in the pull request, not here: this + file holds round-robin and evaluation results only. diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 68848374..08c9bf67 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -1,6 +1,6 @@ # Strategy tools: one question, one tool -Design note, agreed after two review rounds; status updated 2026-11-11. It says which tool answers which question, what +Design note, agreed after two review rounds; status updated 2026-11-12. It says which tool answers which question, what is planned and in what order, and what is still undecided. Items marked **planned** do not exist yet. The current tools are in [tools.md](tools.md), and the "Which tool?" table there links back here. @@ -16,7 +16,7 @@ links back here. `tools/repro_from_replay.py`, `tools/moments.py` and `main.py`. Now they all build their referee and runner in `tools/sim_setup.py`. Before step 5 only `match.py` loaded `.strategy` files (`utama_core/bundle/`), so the other four - could not run a frozen baseline. + could not run a `.strategy` file. ## The question, the tool @@ -24,9 +24,9 @@ links back here. | Question | Tool | Status | |---|---|---| -| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | -| Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | -| Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | +| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with how many matches checked them; `--strict` fails on one | Today | +| Is it better? | `tools/evaluation/evaluate.py CANDIDATE`: paired against the champion at the last release. The only verdict | Today | +| Does everything still run, after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core, two reserve and the reference (28 matches), with stalls and signals. `--all` plays every strategy, occasionally | Today | | What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py` (`--fouls` for our side's fouls), then the picture tools. find_bugs finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal sources (`utama_core/analysis/goal_sources.py`) | Today | | Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | | Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | @@ -34,8 +34,9 @@ links back here. Notes on the table: -- A round-robin answers "is the whole catalog healthy?". `evaluate.py` answers "is this candidate - stronger than the champion?". Keep the two apart in the docs and in the output. +- One tool plays matches: `evaluate.py`. Its round 1 is a round robin, which answers "is the + catalog healthy?" (stalls, signals); its later rounds answer "is this candidate stronger than the + champion at the last release?". The verdict is goals; nothing else ranks. - "Look closely" tools explain a result. They never judge one. ## The screen (dropped) @@ -59,15 +60,16 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: 1. **Fix `main.py`'s import.** Done: it loads strategies through `strategy/catalog.py`. Its runner set-up is still one of the five hand-built ones above. 2. **This note and the docs.** `docs/strategy_tools_plan.md`, the "Which tool?" table in - `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the round-robin's "taken from" counts. + `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the "from the match results store" counts. 3. **Stalls in the match results.** Done. Stalls are recorded in `replays/match_results/`, and `evaluate.py` reports them with coverage: how many of the matches it used were checked for stalls. The stall watchdog covers config_a only, so coverage is partial. A match whose stats were not collected counts as **unknown, not clean**. -4. **`round_robin.py --vs-champion`.** Done. One match per strategy against the champion, plus - the champion against the first reference opponent, under reference noise seed 2 by default. - `evaluate.py` puts the side under test second in even rounds, so each (strategy, champion) - match is its round-2 fixture (not with `--frozen`, whose opponents are packed files). +4. **One tool for matches.** Done 2026-11-12: `round_robin.py` merged into `evaluate.py`. Round 1 is + a round robin of the core strategies, two reserve rotated by seed and the reference (the champion at + the last release, a `.strategy` file); later rounds play only undecided candidates. No held-out + opponents, no `--vs-champion`, no standings. The strategies were renamed the same day + (`catalog.RENAMED`). 5. **One shared match and runner construction** for every tool. `tools/sim_setup.py` has `load_side` (a catalog name, a `.strategy` file or `PATH.py:FUNCTION`), `sim_referee` (the referee, its kickoff team and seeded restart fuzzing) and `sim_runner` (the rsim `StrategyRunner`). `repro_from_replay.py`, `moments.py`, @@ -81,11 +83,9 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: and `--against` no longer uses a dated folder. Every step that changes shared code follows the rule in `docs/STRATEGY_DEVELOPMENT.md`: batch -such changes, and run one round-robin at the end. +such changes, and run one evaluation at the end. -## Names considered (undecided) +## Names -- **Scan replays**: `scan_replays.py` or `find_bugs.py`. Undecided. `find_bugs.py` stays until then. -- **Evaluate**: `challenge` or `compare` for the `evaluate.py` family. Undecided. - -Nothing above is decided by a name. Pick the name when the tool is merged, not before. +Decided 2026-11-12: `find_bugs.py` (was `triage.py`), goal sources (was the goal ledger), and +`evaluate.py` for the one match tool. diff --git a/docs/tools.md b/docs/tools.md index b5734c09..60a53b4b 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -11,9 +11,9 @@ says why the tools are split this way. | Question | Tool | |---|---| -| Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` and the round-robin report them | -| Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion. The only verdict. Add `--held-out` before promoting | -| Does everything still run after a shared-code change? | `tools/evaluation/round_robin.py --vs-champion`: one match per strategy against the champion (12). The full round-robin (66) only occasionally. A round-robin is not an evaluation | +| Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` reports them with how many matches checked them | +| Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion at the last release. The only verdict | +| Does everything still run after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core, two reserve and the reference (28 matches); `--all` for the whole catalog, occasionally | | What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | @@ -48,13 +48,12 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every strategy in the catalog (12 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the match results store. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; A match the store already holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played: automatic, with no flag, so only matches whose code changed play. To play every match again, delete the store. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | -| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the match results store `replays/match_results/` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; a match whose stats were not collected counts as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies, two reserve rotated by seed (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, later rounds play only the undecided candidates' matches until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | -| `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | -| `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | -| `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for the two above, with the set-up from `tools/sim_setup.py` (not run directly) | -| `tools/evaluation/sim_settings.py` | Not a script: loads the reference opponents and the simulated world and robots (`tools/evaluation/reference/opponents.json`, `world.json`, `robots.json`) for `evaluate.py` and `round_robin.py --sim-noise reference[:seed]`. Kept in `reference/` so a new champion does not rerun every cached match | +| `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | +| `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | +| `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `tools/sim_setup.py` (not run directly) | +| `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | ## Evaluating strategies @@ -64,14 +63,14 @@ What these measure and how far to trust each: [STRATEGY_DEVELOPMENT.md](STRATEGY | Script | Purpose | |---|---| -| `tools/signal_report.py` | Figures of a round-robin's strategy signals for [signal_report.md](signal_report.md) | +| `tools/signal_report.py` | Figures of a run's strategy signals (an `evaluate.py` round dir) for [signal_report.md](signal_report.md) | | `tools/pitch_maps.py` | Where each strategy's robots stand, shoots and fouls, drawn on the pitch, for [signal_report.md](signal_report.md#on-the-pitch). `--findings PATH`: six descriptive `zone_share` facts per strategy (its in- and out-of-possession samples in each third; no threshold) | | `utama_core/analysis/goal_sources.py` | `python -m utama_core.analysis.goal_sources `: every goal attributed to the situation that started its play (a restart, or the ball won in open play, by third); per strategy, situations per match × P(goal) = goals per match, scored and conceded. Reads only the replay and its referee file, so it runs on converted official logs too. `--rates` writes the situation rates per team per live minute. See [signals.md](signals.md#where-do-goals-come-from) | | `tools/check_strategy_branch.py` | CI check on `strategy/*` pull requests: the branch must not change the evaluation or its opponents | ### Validation studies -These check how far cheap metrics agree with round-robin results. They do not judge a strategy: use `evaluate.py`. +These check how far cheap metrics agree with match results. They do not judge a strategy: use `evaluate.py`. | Script | Purpose | |---|---| @@ -99,7 +98,7 @@ Fields: `tool`, `kind`, `replay` (path or null), `side` (`friendly`, `enemy` or | Script | Purpose | |---|---| -| `tools/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its round-robin matches, every other round in an evaluation), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | +| `tools/find_bugs.py` | **Start here.** `RUN_DIR [--strategy NAME] [--matches 3] [--restarts] [--out DIR] [--max-pictures 8] [--workers 2]`: each strategy's N worst matches by goal difference, among those it played as config_a (the side with an intentions log: about half its matches in a round), every flagged problem with its numbers (`tactic_thrash`, `stall`, and with `--restarts` the `target_in_keep_out` / `keep_out_short` / `target_in_defense_area` restart flags), the top K drawn with the picture tool for that kind. Writes `OUT/index.md` (read first), `OUT/findings.jsonl` and `OUT/pictures/`; default OUT is `RUN_DIR/find_bugs/`. `--restarts` is slow (about 45 s a match). `--fouls` instead lists our side's fouls with the referee command then active and the restart side (`--rule`, `--skip-own-restart`, `--by strategy,rule` for counts, `--include-stoppages` for out_of_bounds, `--json`; until 2026-11-11 `moments.py fouls`). Read-only. See [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md), "Debugging a foul or failure" | | `tools/replay_trace.py` | Text trace of a replay window: referee commands, ball, nearest robot per side. `--events` lists the window's kicks (with the nearest robot as kicker), possession changes, referee changes and fouls, one line each; `--json` writes rows or events as JSON. The first thing to run on a stall, a voided restart or a foul | | `tools/match_timeline.py` | One match window as swimlanes: `REPLAY.npz T0 T1 [--side friendly\|enemy]`. Referee command band, one lane per robot coloured by its tactic (ticks at switches, strip where it had the ball), distance of each robot to the ball, and goals, fouls and shots on top; prints switches per minute and the longest tactic span per robot. Use it for thrashing and everyone-chasing-the-ball; example in [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md). `--findings PATH`: one `tactic_thrash` per robot at or above `FLIP_BACKS_PER_MIN` (2) flip-backs per minute of live play (a tactic held under 1 s, then reverted; raw switch rate is not the signal, most strategies switch 10-25 times a minute by design); `timeline_findings(replay, t0, t1, side)` computes it without drawing | | `tools/repro_from_replay.py` | Load a replay's field state at a timestamp into a fresh headless rsim match and tick forward with tracing on. Plays with the replay's own sim noise by default (`--sim-noise none` for noiseless, `--sim-noise PATH` for another). `--summary ROBOT_IDS` prints each listed robot's tactic, position, distance to the ball, referee command and traced target every 0.25 s; `--trace-out` JSONL row kinds are in `--help` | diff --git a/main.py b/main.py index 6c00139f..150334d3 100644 --- a/main.py +++ b/main.py @@ -8,7 +8,7 @@ # the rsim window opens; the dashboard is at http://localhost:8080; Ctrl+C to stop Yellow (the first strategy) starts on the right and kicks off. For many matches with -results, use `tools/evaluation/round_robin.py`. +results, use `tools/evaluation/evaluate.py`. """ import argparse diff --git a/tools/debug_match.py b/tools/debug_match.py index dea2da7d..8c433363 100644 --- a/tools/debug_match.py +++ b/tools/debug_match.py @@ -131,7 +131,7 @@ def main() -> None: default=None, help=( "If set, also accumulate and write the same possession/shots/ball-travel " - "summary round_robin.py records (utama_core.engine.match_stats.MatchStats) to " + "summary evaluate.py records (utama_core.engine.match_stats.MatchStats) to " "this path. Off by default since most debugging sessions only care about the " "match_log/trace output, not aggregate stats." ), diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 7a46c3e0..56261112 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -1,119 +1,158 @@ -"""evaluate.py — is a candidate strategy better than the champion? As few matches as that takes. +"""evaluate.py — how the strategies play, and whether a candidate beats the champion at the last release. Run: - pixi run python tools/evaluation/evaluate.py CANDIDATE [CANDIDATE ...] [flags] - - --opponents PATH the champion, opponents and held-out opponents (default - tools/evaluation/reference/opponents.json). The sim is always the reference - world and robots (reference/world.json, reference/robots.json) - --held-out play the held-out opponents instead (the check before promoting) - --baseline NAME compare against this strategy instead of the champion: a new version - against the one it changes. The baseline takes the champion's role, the - champion joins the opponents, and a baseline among the opponents leaves them - --frozen REF judge today's code against the past: the champion and every opponent are - played from `.strategy` files of git commit REF (built once, kept in - replays/eval/frozen/), the candidates from the working tree. The check for a - change to shared code, which otherwise moves both sides of every match - --max-rounds N rounds before a candidate is called undecided (default 6) - --max-workers N matches at once (default 8) - --explain also write on-pitch pictures of each candidate against the champion to - replays/eval/explain/_/ (positions, shots, fouls and a - summary; see tools/evaluation/explain.py). Explains the verdict, never - changes it. Off by default; the matches are kept until it has run. + pixi run python tools/evaluation/evaluate.py [CANDIDATE ...] [flags] + +With no candidate it plays one round: a round robin of the players, the health check (stalls, fouls, +every signal). With candidates (strategy names, played from the working tree, or `.strategy` files) +it plays rounds until each candidate is decided. + + --at REF the reference is the champion as it was at git commit REF (default: the latest + release tag), played from a `.strategy` file built once into replays/eval/frozen/ + --compare-with NAME the reference is NAME instead (a strategy in the working tree, or a .strategy + file): a new version against the one it changes + --all every strategy in the catalog plays, not only the core and two reserve + --max-rounds N rounds before a candidate is called undecided (default 6) + --max-workers N matches at once (default 12; 1 plays in this process) + --strict exit non-zero if any match of the run stalled + --fuzz-restarts SEED inject seeded random legal restarts (custom_referee/restart_fuzzer.py); + --fuzz-interval LO HI sets the gap in sim seconds (default 25 45) + --control-scheme NAME planner for every robot (fpp, trajsample, ...; default fpp) + --explain also write on-pitch pictures of each candidate against the reference to + replays/eval/explain/_/ (tools/evaluation/explain.py) + +Players +------- +`reference/players.json` names the champion and the core strategies, which play every round. Every +other strategy in the catalog is reserve: two of them play each round, rotated by the round's seed +(diversity without playing all twelve every time); `--all` plays them all. The reference (the champion +at the last release) plays every round too. It is a frozen file, so a change to shared code moves the +candidates and the working-tree strategies, never the reference. + +Rounds +------ +Round k plays under sim-noise seed k (the reference world and robots, reference/world.json and +robots.json). Round 1 plays every pair of players once, candidates included. Later rounds play only the +undecided candidates' matches: each against the reference and the round's opponents, and the reference +against those opponents. In every match the candidate (then the reference) is config_a in odd rounds and +config_b in even ones, so a candidate and the reference meet each opponent with the same colour and +noise. Matches are 1200 s of sim time at most (two 300 s halves of playing time, `MAX_MATCH_SECONDS`). How it decides -------------- -Matches are played in rounds. In round k each candidate plays every opponent and the champion -once, and the champion plays every opponent, all with sim-noise seed k, so the candidate and the -champion meet the same opponents under the same noise. The candidate is config_a in odd rounds -and config_b in even ones. - -After each round the candidate is compared with the champion on paired matches -(`ratings.paired_difference`): its goal difference minus the champion's against the same -opponent with the same seed and colour, from every match in the match results store -(`replay/match_results.py`: this run's, earlier runs', round-robins'), plus their head-to-head matches. Paired results share -the opponent and the noise, so their difference cancels much of it: all of it for identical -code, little for unrelated strategies; the spread is estimated from the differences themselves. -P(candidate stronger than champion) decides: +After each round each candidate is compared with the reference on paired matches +(`ratings.paired_difference`): its goal difference minus the reference's against the same opponent with +the same seed and colour, plus their head-to-head matches. P(candidate stronger than reference): - **better** once P >= PROMOTE (0.99), - **worse** once P <= DROP (0.2), - **undecided** after `--max-rounds`: not clearly better, which for a search means drop it. -Thresholds come from simulating the rule (match noise SD 1.9 goals, six opponents, 6 rounds, -paired results correlated 0 to 1): two equal strategies are called "better" at most 3% of the -time. Unrelated strategies (correlation 0): one goal per match worse is dropped after ~2 rounds, -one goal better found 61% of the time, half a goal better 20%. A small change to a strategy -(correlation ~0.9): one goal better found every time in ~3 rounds, half a goal better 55%. -Strengths printed at the end come from the ratings over all matches (`analysis/ratings.py`). - -Stalls (the stall watchdog's `StallEvent`s, see `engine/match_stats.py`) are reported for -post-analysis only: each candidate's and the champion's stalls, and how many of their matches -were checked (the watchdog covers config_a only; a match whose stats were not collected counts as -unchecked). They never change a verdict or stop a run. - -A fixture already in the match results store is never played again, so the champion's matches are -played once per seed and reused by every candidate. Replays are not kept: a match is a pure function -of its fixture, so `round_robin.py --pair A B --sim-noise reference:` plays it again. - -Promoting is a decision, not a side effect: a candidate called better should pass `--held-out` -(it must not lose clearly to opponents never used for selection) before you set it as the -champion by hand in `reference/opponents.json`. +Thresholds come from simulating the rule (match noise SD 1.9 goals, six opponents, 6 rounds, paired +results correlated 0 to 1): two equal strategies are called "better" at most 3% of the time. Unrelated +strategies: one goal per match worse is dropped after ~2 rounds, one goal better found 61% of the time. +A small change to a strategy (correlation ~0.9): one goal better found every time in ~3 rounds. + +Signals and stalls are reported, never judged on: they explain a result (docs/signals.md). The stall +watchdog watches config_a only, so the report says how many matches each strategy was checked in. + +Matches the match results store holds (replays/match_results/, `replay/match_results.py`) are taken from +it, not played: after a change to one strategy only its matches play. Delete that folder to replay all. + +Writes replays/eval_/: `report.json` (verdicts, round 1's signals), and per round `round_/` +with each played match's replay, intention log and stats (`_vs_.*`), `summary.json` and +`ball_losses.md` — the layout tools/find_bugs.py, tools/pitch_maps.py and goal_sources read. + +Promoting is a decision, not a side effect: set the champion by hand in reference/players.json. """ from __future__ import annotations +import os + +# One thread per match process: several matches run at once. +for _var in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS"): + os.environ.setdefault(_var, "1") + import argparse +import dataclasses +import itertools import json -import os -import shutil +import subprocess import sys from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait from datetime import datetime, timezone from pathlib import Path +from typing import Optional REPO_ROOT = Path(__file__).resolve().parents[2] if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools.evaluation.match import _short_name # noqa: E402 -from tools.evaluation.round_robin import ( # noqa: E402 - MAX_MATCH_SECONDS, - _resolve_config_names, - _run_metadata, - play_and_record, +from tools.evaluation.match import ( # noqa: E402 + _CONFIG_NAMES, + TICKS_PER_SECOND, + _short_name, + run_match, ) -from tools.evaluation.sim_settings import ( # noqa: E402 - DEFAULT_OPPONENTS, - load_opponents, - reference_noise, +from tools.evaluation.sim_settings import load_players, reference_noise # noqa: E402 +from utama_core.analysis import ( # noqa: E402 + ratings, + restart_outcomes, + turnover_breakdown, ) -from utama_core.analysis import ratings # noqa: E402 -from utama_core.bundle.strategy_file import frozen # noqa: E402 +from utama_core.analysis.strategy_table import strategy_table # noqa: E402 +from utama_core.bundle.strategy_file import SUFFIX, frozen # noqa: E402 from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 from utama_core.replay import match_results # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise # noqa: E402 +from utama_core.strategy import catalog # noqa: E402 PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 +RESERVE_PER_ROUND = 2 FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results - - -def round_fixtures(candidates: list[str], champion: str, opponents: list[str], k: int) -> list[tuple[str, str, int]]: - """Round `k`'s (config_a, config_b, seed): each candidate against every opponent and the - champion, and the champion against every opponent; the side under test is config_a in odd - rounds.""" +# A full match: two halves of 300 s of playing time, the clock stopped whenever no team may play the +# ball, about 710-870 s of sim time. This only caps a match that can't reach full time. +MAX_MATCH_SECONDS = 1200.0 + + +# --- who plays what --------------------------------------------------------------------------- + + +def round_players(core: list[str], reserve: list[str], k: int, everyone: bool = False) -> list[str]: + """The strategies of round `k`: the core, and `RESERVE_PER_ROUND` reserve rotated by `k`.""" + if everyone or not reserve: + return [*core, *reserve] + picks = [reserve[(RESERVE_PER_ROUND * (k - 1) + i) % len(reserve)] for i in range(RESERVE_PER_ROUND)] + return list(dict.fromkeys([*core, *picks])) + + +def round_fixtures( + k: int, candidates: list[str], reference: str, opponents: list[str], full: bool +) -> list[tuple[str, str, int]]: + """Round `k`'s (config_a, config_b, seed). `full`: every pair of candidates, reference and + opponents; otherwise each candidate against the reference and every opponent, and the reference + against every opponent. The earlier of the two in (candidates, reference, opponents) order is + config_a in odd rounds, so candidates and reference face each opponent with the same colour.""" + order = list(dict.fromkeys([*candidates, reference, *opponents])) + rank = {n: i for i, n in enumerate(order)} + if full: + pairs = list(itertools.combinations(order, 2)) + else: + pairs = [(c, o) for c in candidates for o in [reference, *opponents]] + [(reference, o) for o in opponents] out = [] - for side in [*candidates, champion]: - rivals = opponents if side == champion else [*opponents, champion] - for o in rivals: - out.append((side, o, k) if k % 2 else (o, side, k)) + for x, y in pairs: + if x == y: + continue + first, second = sorted((x, y), key=rank.__getitem__) + out.append((first, second, k) if k % 2 else (second, first, k)) return list(dict.fromkeys(out)) -def verdict(p_better: float, rounds: int, max_rounds: int) -> str | None: +def verdict(p_better: float, rounds: int, max_rounds: int) -> Optional[str]: """The candidate's verdict after `rounds` rounds, or None to play another.""" if p_better >= PROMOTE: return "better" @@ -122,220 +161,306 @@ def verdict(p_better: float, rounds: int, max_rounds: int) -> str | None: return "undecided" if rounds >= max_rounds else None -def play(a: str, b: str, seed: int, noise: dict, run_dir: Path, keep: bool, fps: dict, env: str, source: str) -> dict: - """One fixture's stored record, played as a round-robin's match is (`round_robin.play_and_record`). - Its replay files are deleted unless `keep` (`--explain` reads them).""" - return play_and_record( - a, - b, - a_fp=fps[a], - b_fp=fps[b], - env=env, - seed=seed, - source=source, - run_dir=run_dir, - keep_files=keep, - match_tag_suffix=f"_s{seed}", - duration_seconds=MAX_MATCH_SECONDS, - sim_noise=SimNoise.from_dict({**noise, "seed": seed}), - ) +def resolve_names(requested: list[str]) -> list[str]: + """Strategy names (today's or old ones) in catalog order, then `.strategy` files as given.""" + files = [n for n in requested if n.endswith(SUFFIX)] + wanted = {catalog.current_name(n) for n in requested if n not in files} + names = [n for n in _CONFIG_NAMES if n in wanted] + if unknown := wanted - set(names): + raise SystemExit(f"Unknown strategy name(s): {sorted(unknown)}. Available: {sorted(_CONFIG_NAMES)}") + return names + files -def stall_coverage(ledger: dict, fps: dict, side: str) -> dict: - """Stalls `side` was checked for over the stored matches at current code: the watchdog only - watches config_a, so a match counts as checked when `side` was config_a and its record - has a stall record (None, an older line, is unknown). `total` counts every match of `side`.""" - checked, total, stalls = 0, 0, [] - for e in ledger.values(): - if side not in (e["a"], e["b"]): - continue - if e["a_fp"] != fps.get(e["a"]) or e["b_fp"] != fps.get(e["b"]): - continue - total += 1 - if e["a"] != side or e.get("stalls") is None: +def latest_release() -> str: + """The latest release tag reachable from HEAD.""" + return _git("describe", "--tags", "--abbrev=0") or "HEAD" + + +def at_ref(name: str, ref: str) -> str: + """Strategy `name` as it was at `ref`, as a `.strategy` file's path (built once, then kept). An + older commit may know the strategy by its old name (`catalog.RENAMED`).""" + for n in [name, *(old for old, new in catalog.RENAMED.items() if new == name)]: + try: + return frozen(n, ref, FROZEN_DIR).as_posix() + except ValueError: continue - checked += 1 - stalls += [{"a": e["a"], "b": e["b"], "seed": e["seed"], **s} for s in e["stalls"]] - return {"checked": checked, "total": total, "stalls": stalls} + raise SystemExit(f"no strategy {name} (or an old name of it) at {ref}") -def stall_lines(cov: dict, name: str) -> list[str]: - """The printed stall report for one side's `stall_coverage`.""" - head = f"stalls checked in {cov['checked']} of {cov['total']} {name} matches (watchdog covers config_a only): " - if not cov["checked"]: - return [head + "unknown"] - if not cov["stalls"]: - return [head + "none"] - lines = [head + str(len(cov["stalls"]))] - for s in cov["stalls"]: - diagnosis = f" -- {s['diagnosis']}" if s.get("diagnosis") else "" - lines.append( - f" {_short_name(s['a'])} vs {_short_name(s['b'])} seed {s['seed']}: " - f"{s['kind']} at t={s['sim_time']:.1f}s{diagnosis}" - ) - return lines +# --- playing ---------------------------------------------------------------------------------- + + +def analyse_replay(npz: Path) -> tuple[list[dict], dict]: + """A played match's restart episodes and ball-loss record, from its replay. Kept out of `match.py` + (the environment's entry point), so changing an analysis replays no match.""" + return restart_outcomes.analyse_match(npz), turnover_breakdown.analyse_match(str(npz)) + + +def tag(a: str, b: str) -> str: + """A match's file stem in a round directory.""" + return f"{_short_name(a)}_vs_{_short_name(b)}" + + +def play_and_record( + config_a: str, config_b: str, *, a_fp: str, b_fp: str, env: str, seed: Optional[int], source: str, + run_dir: Path, **run_kwargs, +) -> dict: # fmt: skip + """Play one match into `run_dir` and return its stored record (`match_results.record`), with its + replay analysed. `run_kwargs` go to `match.run_match`.""" + result = run_match(config_a, config_b, run_dir=run_dir, **run_kwargs) + restarts = losses = None + npz = Path(run_dir) / f"{tag(config_a, config_b)}.npz" + if npz.exists(): # no replay: crashed before it was written + restarts, losses = analyse_replay(npz) + return match_results.record( + env, a_fp, b_fp, dataclasses.asdict(result), seed=seed, source=source, restarts=restarts, losses=losses + ) + + +def result_row(rec: dict, a: str, b: str, reused: bool) -> dict: + """A record as a `summary.json` result, under this run's names for the two players.""" + winner = a if rec["score_a"] > rec["score_b"] else b if rec["score_b"] > rec["score_a"] else "draw" + return { + "config_a": a, + "config_b": b, + "score_a": rec["score_a"], + "score_b": rec["score_b"], + "winner": winner, + "seed": rec["seed"], + "stats": rec["stats"], + "possession_backstop": possession_backstop(rec["stats"]), + "reused": reused, + } + + +def possession_backstop(stats: Optional[dict]) -> bool: + """A stall the watchdog missed: possession pinned at 100/0 with the ball barely moving.""" + if not stats: + return False + poss = stats.get("possession_pct") or {} + pinned = {poss.get("friendly"), poss.get("enemy")} == {0.0, 1.0} + return pinned and (stats.get("ball_travel_m") or 0.0) < 1.0 + + +# --- the run ---------------------------------------------------------------------------------- def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("candidates", nargs="+") - parser.add_argument("--opponents", type=Path, default=DEFAULT_OPPONENTS) - parser.add_argument("--held-out", action="store_true") - parser.add_argument("--baseline") - parser.add_argument("--frozen", metavar="REF", help="champion and opponents from this git commit (see above)") + parser.add_argument("candidates", nargs="*") + parser.add_argument("--at", metavar="REF") + parser.add_argument("--compare-with", metavar="NAME") + parser.add_argument("--all", action="store_true") parser.add_argument("--max-rounds", type=int, default=MAX_ROUNDS) - parser.add_argument("--max-workers", type=int, default=min(8, max(1, (os.cpu_count() or 1) - 1))) - parser.add_argument("--explain", action="store_true", help="also write on-pitch pictures per candidate (see above)") + parser.add_argument("--max-workers", type=int, default=min(12, max(1, (os.cpu_count() or 1) - 1))) + parser.add_argument("--strict", action="store_true") + parser.add_argument("--fuzz-restarts", type=int, metavar="SEED") + parser.add_argument("--fuzz-interval", type=float, nargs=2, metavar=("LO", "HI"), default=(25.0, 45.0)) + parser.add_argument("--control-scheme", default="fpp") + parser.add_argument("--explain", action="store_true") + parser.add_argument("--players", type=Path, help=argparse.SUPPRESS) # tests: another players.json return parser -def main() -> None: - args = build_parser().parse_args() +def main(argv: Optional[list[str]] = None) -> None: + args = build_parser().parse_args(argv) + if args.at and args.compare_with: + raise SystemExit("--at and --compare-with both choose the reference: give one") + setup = load_players(args.players) if args.players else load_players() + core = resolve_names(setup["core"]) + reserve = [n for n in _CONFIG_NAMES if n not in core] + if args.compare_with: + reference = resolve_names([args.compare_with])[0] + else: + reference = at_ref(resolve_names([setup["champion"]])[0], args.at or latest_release()) + candidates = [c for c in resolve_names(args.candidates) if c != reference] - reference = load_opponents(args.opponents) - champion = _resolve_config_names([args.baseline or reference["champion"]])[0] - opponents = _resolve_config_names(reference["held_out"] if args.held_out else reference["opponents"]) - reference_champion = _resolve_config_names([reference["champion"]])[0] - if champion != reference_champion: - opponents.append(reference_champion) # against a baseline, the champion is one more opponent - opponents = [o for o in opponents if o != champion] # a baseline among the opponents leaves its seat - if args.frozen: - champion, *opponents = [frozen(n, args.frozen, FROZEN_DIR).as_posix() for n in [champion, *opponents]] - candidates = [c for c in _resolve_config_names(args.candidates) if c != champion] noise = SimNoise.from_dict(reference_noise()).to_dict() noise.pop("seed", None) - + env_args = { + "duration_seconds": MAX_MATCH_SECONDS, + "sim_noise": noise, + "control_scheme": args.control_scheme, + "fuzz_seed": args.fuzz_restarts, + "fuzz_interval_s": tuple(args.fuzz_interval), + } graph = CodeGraph() - env = match_results.environment(graph, duration_seconds=MAX_MATCH_SECONDS, sim_noise=noise) + env = match_results.environment(graph, **env_args) store = match_results.open_store(REPLAY_BASE_PATH) - fps = {n: graph.strategy_fingerprint(n)[:16] for n in {*candidates, champion, *opponents}} + everyone = {*candidates, reference, *core, *reserve} + fps = {n: graph.strategy_fingerprint(n)[:16] for n in everyone} for c in list(candidates): - twin = next((r for r in [champion, *opponents] if fps[r] == fps[c]), None) - if twin is not None: - print(f"{_short_name(c)} is skipped: it is the same code as {_short_name(twin)}") + if fps[c] == fps[reference]: + print(f"{_short_name(c)} is skipped: it is the same code as the reference {_short_name(reference)}") candidates.remove(c) - def fixture_id(f: tuple[str, str, int]) -> str: - a, b, seed = f - return match_results.fixture_id(env, fps[a], fps[b], seed) - run_id = datetime.now(timezone.utc).strftime("eval_%Y%m%d_%H%M%S") - run_dir = Path(REPLAY_BASE_PATH) / run_id # replay files must sit directly under replays/ - run_dir.mkdir(parents=True, exist_ok=True) - print( - f"{'Held-out opponents' if args.held_out else 'Opponents'}: " - f"{'baseline' if args.baseline else 'champion'} {_short_name(champion)}; " - f"opponents {', '.join(_short_name(o) for o in opponents)}; environment {env}\n" - ) + run_dir = Path(REPLAY_BASE_PATH) / run_id + print(f"Reference {_short_name(reference)}; core {', '.join(_short_name(n) for n in core)}; environment {env}") + + def still_current(a: str, b: str) -> bool: + """Store a played match only if the code it ran is still the code on disk.""" + now = CodeGraph() + return match_results.environment(now, **env_args) == env and all( + now.strategy_fingerprint(n)[:16] == fps[n] for n in (a, b) + ) + run_kwargs = { + "duration_seconds": MAX_MATCH_SECONDS, + "control_scheme": args.control_scheme, + "fuzz_seed": args.fuzz_restarts, + "fuzz_interval_s": tuple(args.fuzz_interval), + } open_ = list(candidates) report: dict[str, dict] = {} + rounds: list[dict] = [] + opponents_so_far: set[str] = set() played = reused = 0 - with ProcessPoolExecutor(max_workers=args.max_workers) as executor: + executor = ProcessPoolExecutor(max_workers=args.max_workers) if args.max_workers > 1 else None + try: for k in range(1, args.max_rounds + 1): - if not open_: + if k > 1 and not open_: break - ledger = store.load(env, fps=fps) - todo = [f for f in round_fixtures(open_, champion, opponents, k) if fixture_id(f) not in ledger] - reused += len(round_fixtures(open_, champion, opponents, k)) - len(todo) - futures = {executor.submit(play, *f, noise, run_dir, args.explain, fps, env, run_id): f for f in todo} - while futures: - done, _ = wait(futures, return_when=FIRST_COMPLETED) - for future in done: - a, b, seed = futures.pop(future) - result = future.result() - store.put(result) - played += 1 - print( - f" round {k}: {_short_name(a):<24} {result['score_a']} - {result['score_b']} {_short_name(b)}", - flush=True, - ) - - fit = _fit(store, env, fps, {*open_, champion, *opponents}) - ledger = _up_to_round(store.load(env, fps=fps), k) - for c in list(open_): - margin, sd = ratings.paired_difference(*paired(ledger, fps, c, champion, opponents), fit.noise_sd) - p = ratings.p_positive(margin, sd) - v = verdict(p, k, args.max_rounds) - print(f"after round {k}: {_short_name(c):<28} P(better) {p:.2f} margin {margin:+.2f} ± {sd:.2f}") - if v is not None: - open_.remove(c) - report[c] = {"verdict": v, "rounds": k, "p_better": round(p, 3), "margin": round(margin, 2)} - report[c]["margin_sd"] = round(sd, 2) - print() + opponents = [p for p in round_players(core, reserve, k, args.all) if p not in candidates and p != reference] + opponents_so_far |= set(opponents) + fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents, full=k == 1) + round_dir = run_dir / f"round_{k}" + round_dir.mkdir(parents=True, exist_ok=True) + recs: dict[tuple[str, str], tuple[dict, bool]] = {} + todo = [] + for a, b, seed in fixtures: + rec = store.get(env, match_results.fixture_id(env, fps[a], fps[b], seed)) + if rec is None: + todo.append((a, b, seed)) + else: + recs[(a, b)] = (rec, True) + reused += len(recs) + print( + f"\nRound {k}: {len(fixtures)} matches, {len(recs)} from the match results store, {len(todo)} to play" + ) + + def finish(a: str, b: str, rec: dict) -> None: + nonlocal played + played += 1 + recs[(a, b)] = (rec, False) + if still_current(a, b): + store.put(rec) + else: + print(f" {tag(a, b)} not stored: its code changed while the run played", flush=True) + print( + f" round {k}: {_short_name(a):<24} {rec['score_a']} - {rec['score_b']} {_short_name(b)}", + flush=True, + ) + + def submit(a: str, b: str, seed: int) -> tuple: + kw = dict(a_fp=fps[a], b_fp=fps[b], env=env, seed=seed, source=run_id, run_dir=round_dir) + kw.update(run_kwargs, sim_noise=SimNoise.from_dict({**noise, "seed": seed})) + return a, b, kw + + if executor is None: + for a, b, kw in (submit(*f) for f in todo): + finish(a, b, play_and_record(a, b, **kw)) + else: + futures = { + executor.submit(play_and_record, a, b, **kw): (a, b) for a, b, kw in (submit(*f) for f in todo) + } + while futures: + done, _ = wait(futures, return_when=FIRST_COMPLETED) + for future in done: + finish(*futures.pop(future), future.result()) + + rows = [result_row(rec, a, b, was_reused) for (a, b), (rec, was_reused) in recs.items()] + names = sorted({n for pair in recs for n in pair}) + summary = {"run_id": f"{run_id}/round_{k}", "round": k, "seed": k, "config_names": names} + summary["results"] = sorted(rows, key=lambda r: (r["config_a"], r["config_b"])) + summary.update(signals(summary, {pair: rec for pair, (rec, _) in recs.items()}, round_dir)) + (round_dir / "summary.json").write_text(json.dumps(summary, indent=2)) + rounds.append(summary) + + if candidates: + fit = _fit(store, env, fps, {*open_, reference, *opponents_so_far}) + ledger = _up_to_round(store.load(env, fps=fps), k) + for c in list(open_): + diffs, h2h = paired(ledger, fps, c, reference, sorted(opponents_so_far)) + margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) + p = ratings.p_positive(margin, sd) + print(f"after round {k}: {_short_name(c):<28} P(better) {p:.2f} margin {margin:+.2f} ± {sd:.2f}") + if (v := verdict(p, k, args.max_rounds)) is not None: + open_.remove(c) + report[c] = {"verdict": v, "rounds": k, "p_better": round(p, 3), "margin": round(margin, 2)} + report[c]["margin_sd"] = round(sd, 2) + finally: + if executor is not None: + executor.shutdown(cancel_futures=True) + if args.explain: - _explain(run_dir, run_id, candidates, champion) - shutil.rmtree(run_dir, ignore_errors=True) # this run's own scratch dir; results are in the match results store + _explain(run_dir, run_id, candidates, reference) - final = _fit(store, env, fps, {*candidates, champion, *opponents}) + health = rounds[0] + print_signals(health, f"{run_id}/round_1") ledger = store.load(env, fps=fps) - print(f"Verdicts ({played} matches played, {reused} reused from the match results):") + if candidates: + print(f"\nVerdicts against {_short_name(reference)} ({played} matches played, {reused} from the store):") for c in candidates: r = report[c] print( f" {_short_name(c):<28} {r['verdict'].upper():<10} P(better) {r['p_better']:.2f} " f"margin {r['margin']:+.2f} ± {r['margin_sd']:.2f} goals/match after {r['rounds']} round(s)" ) - r["per_opponent"] = _per_opponent(_up_to_round(ledger, r["rounds"]), fps, c, champion, opponents) - r["stalls"] = stall_coverage(_up_to_round(ledger, r["rounds"]), fps, c) - print(f" {'opponent':<26} {'candidate GD':>12} {'champion GD':>12} {'matches':>8} (same seed and colour)") + upto = _up_to_round(ledger, r["rounds"]) + r["per_opponent"] = _per_opponent(upto, fps, c, reference, sorted(opponents_so_far)) + r["stalls"] = stall_coverage(upto, fps, c) + print(f" {'opponent':<26} {'candidate GD':>12} {'reference GD':>12} {'matches':>8} (same seed and colour)") for o, row in r["per_opponent"].items(): name = o if o == "head-to-head" else _short_name(o) print(f" {name:<26} {row['candidate']:>+12} {row['champion']:>+12} {row['matches']:>8}") for line in stall_lines(r["stalls"], "candidate"): print(f" {line}") - if r["verdict"] == "better" and not args.held_out and not args.frozen: - print( - f" -> next: evaluate.py {_short_name(c)} --held-out, then set it as champion in reference/opponents.json" - ) - champion_stalls = None - if candidates: - rounds = max(report[c]["rounds"] for c in candidates) - champion_stalls = stall_coverage(_up_to_round(ledger, rounds), fps, champion) - for line in stall_lines(champion_stalls, "champion"): - print(line) - print("\nStrengths (goals per match, ± SD):") - for n in sorted(final.names, key=lambda n: -final.strength(n)[0]): - m, sd = final.strength(n) - print(f" {_short_name(n):<28} {m:+.2f} ± {sd:.2f}") - - out = Path(REPLAY_BASE_PATH) / "eval" / "reports" / f"{run_id}.json" - out.parent.mkdir(parents=True, exist_ok=True) + + out = run_dir / "report.json" out.write_text( json.dumps( { "run_id": run_id, "run": _run_metadata(), - "opponents": str(args.opponents), - "held_out": args.held_out, - "frozen": args.frozen, + "reference": reference, + "core": core, "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": args.max_rounds}, "candidates": report, - "champion_stalls": champion_stalls, - "strengths": {n: final.strength(n) for n in final.names}, - "noise_sd": final.noise_sd, + "rounds": [{"round": s["round"], "matches": len(s["results"])} for s in rounds], + "signals": {k: v for k, v in health.items() if k not in ("results",)}, }, indent=2, ) ) print(f"\nReport: {out.relative_to(REPO_ROOT) if out.is_relative_to(REPO_ROOT) else out}") + stalled = [ + r for s in rounds for r in s["results"] if (r["stats"] or {}).get("stall_events") or r["possession_backstop"] + ] + if args.strict and stalled: + raise SystemExit(f"--strict: {len(stalled)} match(es) stalled") + -def _explain(run_dir: Path, run_id: str, candidates: list[str], champion: str) -> None: - """`--explain`: pictures of each candidate against the champion, from this run's kept matches. - Runs before the scratch dir is removed; a failure is printed and never loses the verdicts.""" +def _explain(run_dir: Path, run_id: str, candidates: list[str], reference: str) -> None: + """`--explain`: pictures of each candidate against the reference, from this run's matches. + A failure is printed and never loses the verdicts.""" from tools.evaluation import explain # matplotlib: imported only when asked for for c in candidates: out = Path(REPLAY_BASE_PATH) / "eval" / "explain" / f"{_short_name(c)}_{run_id}" try: - explain.explain(run_dir, c, champion, out) - print(f"explain: {_short_name(c)} vs {_short_name(champion)} written to {out}") + for round_dir in sorted(run_dir.glob("round_*")): + explain.explain(round_dir, c, reference, out / round_dir.name) + print(f"explain: {_short_name(c)} vs {_short_name(reference)} written to {out}") except Exception as exc: # noqa: BLE001 - the pictures are optional; the verdicts are not print(f"explain: {_short_name(c)} failed ({type(exc).__name__}: {exc}); verdicts are unaffected") +# --- the verdict's arithmetic ----------------------------------------------------------------- + + def _fit(store: match_results.MatchResults, env: str, fps: dict[str, str], players: set[str]) -> ratings.Ratings: """Ratings over every stored match in `env` between `players` at their current code.""" matches = [ @@ -365,33 +490,338 @@ def _margins(ledger: dict, fps: dict, side: str, o: str) -> dict[tuple, int]: return out -def paired(ledger: dict, fps: dict, candidate: str, champion: str, opponents: list[str]) -> tuple[list, list]: - """The candidate's goal difference minus the champion's against each opponent, over the - matches both played with the same seed and colour, and the candidate's margins against the - champion: `ratings.paired_difference`'s inputs.""" +def paired(ledger: dict, fps: dict, candidate: str, reference: str, opponents: list[str]) -> tuple[list, list]: + """The candidate's goal difference minus the reference's against each opponent, over the matches + both played with the same seed and colour, and the candidate's margins against the reference: + `ratings.paired_difference`'s inputs.""" diffs = [] for o in opponents: - c, ch = _margins(ledger, fps, candidate, o), _margins(ledger, fps, champion, o) - diffs += [c[k] - ch[k] for k in sorted(set(c) & set(ch))] - return diffs, list(_margins(ledger, fps, candidate, champion).values()) + c, ref = _margins(ledger, fps, candidate, o), _margins(ledger, fps, reference, o) + diffs += [c[k] - ref[k] for k in sorted(set(c) & set(ref))] + return diffs, list(_margins(ledger, fps, candidate, reference).values()) -def _per_opponent(ledger: dict, fps: dict, candidate: str, champion: str, opponents: list[str]) -> dict: - """Goal difference against each opponent, the candidate's and the champion's, over the - matches both played with the same seed and colour (so the two columns face the same noise).""" +def _per_opponent(ledger: dict, fps: dict, candidate: str, reference: str, opponents: list[str]) -> dict: + """Goal difference against each opponent, the candidate's and the reference's, over the matches + both played with the same seed and colour (so the two columns face the same noise).""" rows = {} for o in opponents: - c, ch = _margins(ledger, fps, candidate, o), _margins(ledger, fps, champion, o) - common = sorted(set(c) & set(ch)) + c, ref = _margins(ledger, fps, candidate, o), _margins(ledger, fps, reference, o) + common = sorted(set(c) & set(ref)) rows[o] = { "candidate": sum(c[k] for k in common), - "champion": sum(ch[k] for k in common), + "champion": sum(ref[k] for k in common), "matches": len(common), } - h2h = _margins(ledger, fps, candidate, champion) + h2h = _margins(ledger, fps, candidate, reference) rows["head-to-head"] = {"candidate": sum(h2h.values()), "champion": -sum(h2h.values()), "matches": len(h2h)} return rows +def stall_coverage(ledger: dict, fps: dict, side: str) -> dict: + """Stalls `side` was checked for over the stored matches at current code: the watchdog only + watches config_a, so a match counts as checked when `side` was config_a and its record + has a stall record (None, an older line, is unknown). `total` counts every match of `side`.""" + checked, total, stalls = 0, 0, [] + for e in ledger.values(): + if side not in (e["a"], e["b"]): + continue + if e["a_fp"] != fps.get(e["a"]) or e["b_fp"] != fps.get(e["b"]): + continue + total += 1 + if e["a"] != side or e.get("stalls") is None: + continue + checked += 1 + stalls += [{"a": e["a"], "b": e["b"], "seed": e["seed"], **s} for s in e["stalls"]] + return {"checked": checked, "total": total, "stalls": stalls} + + +def stall_lines(cov: dict, name: str) -> list[str]: + """The printed stall report for one side's `stall_coverage`.""" + head = f"stalls checked in {cov['checked']} of {cov['total']} {name} matches (watchdog covers config_a only): " + if not cov["checked"]: + return [head + "unknown"] + if not cov["stalls"]: + return [head + "none"] + lines = [head + str(len(cov["stalls"]))] + for s in cov["stalls"]: + diagnosis = f" -- {s['diagnosis']}" if s.get("diagnosis") else "" + lines.append( + f" {_short_name(s['a'])} vs {_short_name(s['b'])} seed {s['seed']}: " + f"{s['kind']} at t={s['sim_time']:.1f}s{diagnosis}" + ) + return lines + + +# --- signals ---------------------------------------------------------------------------------- + + +def signals(summary: dict, by_tag: dict[tuple[str, str], dict], round_dir: Optional[Path]) -> dict: + """A round's signals (docs/signals.md) from its `summary["results"]` and their stored records + (by (config_a, config_b) under this run's names): restarts, ball losses, the per-strategy table, + fouls, stalls and how many matches checked them.""" + rows = summary["results"] + out: dict = {} + restarts = [e for r in rows for e in (by_tag.get((r["config_a"], r["config_b"]), {}).get("restarts") or [])] + out["restarts"] = restart_outcomes.summarise(restarts) + losses = { + tag(r["config_a"], r["config_b"]): {**rec["losses"], "match": tag(r["config_a"], r["config_b"])} + for r in rows + if (rec := by_tag.get((r["config_a"], r["config_b"]))) and rec.get("losses") is not None + } + real_losses = chances = None + if losses: + ordered = [losses[t] for t in sorted(losses)] + out["ball_losses"] = turnover_breakdown.breakdown(ordered) + if round_dir is not None: + report = turnover_breakdown.report(summary["run_id"], ordered, summary) + (round_dir / "ball_losses.md").write_text(report) + real_losses = {t: turnover_breakdown.real_loss_kinds(r) for t, r in losses.items()} + chances = {t: r["chances"] for t, r in losses.items() if "chances" in r} + out["strategies"] = strategy_table(rows, real_losses, chances or {}) + out["fouls"] = foul_table(rows) + out["stall_incidents"] = stall_incidents(rows) + out["stalls_checked"] = { + n: { + "checked": sum(1 for r in rows if r["config_a"] == n and r["stats"] is not None), + "matches": sum(1 for r in rows if n in (r["config_a"], r["config_b"])), + } + for n in summary["config_names"] + } + return out + + +def stall_incidents(results: list[dict]) -> list[dict]: + """Stall events over `summary.json`-shaped `results`, with deterministic duplicates merged: the + same kind, onset tick and duration tick in matches that share a strategy is one freeze seen + against two opponents that hadn't diverged yet (rsim is deterministic), not two separate + problems. In order of first appearance.""" + incidents: list[dict] = [] + by_key: dict[tuple, dict] = {} + for r in results: + t = tag(r["config_a"], r["config_b"]) + for e in (r.get("stats") or {}).get("stall_events") or []: + ticks = (e["kind"], round(e["sim_time"] * TICKS_PER_SECOND), round(e["duration_s"] * TICKS_PER_SECOND)) + keys = [(name, *ticks) for name in (r["config_a"], r["config_b"])] + incident = next((by_key[k] for k in keys if k in by_key), None) + if incident is None: + incident = {"kind": e["kind"], "sim_time": e["sim_time"], "duration_s": e["duration_s"], "matches": []} + incidents.append(incident) + if t not in incident["matches"]: + incident["matches"].append(t) + for k in keys: + by_key.setdefault(k, incident) + return incidents + + +def foul_table(results: list[dict]) -> dict[str, dict]: + """Every logged foul (`MatchStats.fouls`, both sides) by rule, then by "strategy/tactic" of the + offending robot. `inferred` counts fouls whose rule only named a team, attributed to that side's + robot nearest the ball.""" + table: dict[str, dict] = {} + for r in results: + for foul in (r.get("stats") or {}).get("fouls") or []: + strategy = _short_name(r["config_a"] if foul["side"] == "friendly" else r["config_b"]) + row = table.setdefault(foul["rule"], {"total": 0, "inferred": 0, "by_tactic": {}}) + row["total"] += 1 + row["inferred"] += bool(foul["inferred"]) + key = f"{strategy}/{foul['tactic'] or 'unknown'}" + row["by_tactic"][key] = row["by_tactic"].get(key, 0) + 1 + for row in table.values(): + row["by_tactic"] = dict(sorted(row["by_tactic"].items(), key=lambda kv: -kv[1])) + return dict(sorted(table.items(), key=lambda kv: -kv[1]["total"])) + + +def print_signals(summary: dict, run_label: str) -> None: + """The printed health check: stalls with their coverage, then every signal table.""" + rows = summary["results"] + stalled = [r for r in rows if (r["stats"] or {}).get("stall_events")] + backstop = [r for r in rows if r["possession_backstop"] and r not in stalled] + checked = summary["stalls_checked"] + print(f"\nSTALLS in round 1: {len(stalled)} match(es), {len(summary['stall_incidents'])} distinct incident(s)") + print( + " checked as config_a (the watchdog watches config_a only): " + + ", ".join(f"{_short_name(n)} {c['checked']}/{c['matches']}" for n, c in checked.items()) + ) + for r in stalled: + for e in r["stats"]["stall_events"]: + tactics = f" tactics={e['tactic_ids']}" if e.get("tactic_ids") else "" + diagnosis = f" -- {e['diagnosis']}" if e.get("diagnosis") else "" + print( + f" {tag(r['config_a'], r['config_b']):<50} {e['kind']:<17} onset t={e['sim_time']:.1f}s " + f"referee={e.get('referee_command')}{tactics}{diagnosis}" + ) + for r in backstop: + poss = r["stats"]["possession_pct"] + print( + f" {tag(r['config_a'], r['config_b']):<50} {'POSSESSION_BACKSTOP':<17} " + f"possession {poss['friendly']:.0%}/{poss['enemy']:.0%} ball_travel {r['stats']['ball_travel_m']:.2f}m" + ) + _print_restarts(summary["restarts"]) + if "ball_losses" in summary: + _print_ball_losses(summary["ball_losses"], run_label) + _print_strategy_table(summary["strategies"]) + _print_loss_kinds(summary["strategies"]) + _print_chances(summary["strategies"]) + _print_foul_table(summary["fouls"]) + _print_motion_planning_table(summary["strategies"]) + + +def _print_restarts(restarts: dict) -> None: + if not restarts["restarts"]: + return + print( + f"\nRESTARTS: {restarts['restarts']}, {restarts['reached_normal_start'] / restarts['restarts']:.0%} " + "reached NORMAL_START" + ) + for kind, row in restarts["by_kind"].items(): + outcomes = ", ".join(f"{k} {n}" for k, n in row["outcomes"].items()) + print(f" {kind:<16} {row['n']:>4} reached {row['reached_normal_start'] / row['n']:>4.0%} {outcomes}") + + +def _print_foul_table(table: dict[str, dict]) -> None: + if not table: + return + print("\nFOULS (both sides; top strategy/tactic of the offending robot; * = rule named only a team):") + for rule, row in table.items(): + top = ", ".join(f"{k} {c}" for k, c in list(row["by_tactic"].items())[:4]) + star = "*" if row["inferred"] else "" + print(f" {rule + star:<30} {row['total']:>5} {top}") + + +def _print_strategy_table(table: dict[str, dict]) -> None: + print("\nSTRATEGIES (per match; losses = real ball losses, as config_a only):") + print( + f" {'strategy':<32} {'W-D-L':>9} {'GF':>5} {'GA':>5} {'shots':>6} {'passes':>7} {'entries':>8} {'fouls':>6} {'losses':>7} {'stalled':>8}" + ) + for name, t in sorted(table.items()): + n = max(1, t["matches"]) + losses = f"{t['real_losses_as_a'] / t['matches_as_a']:.1f}" if t["matches_as_a"] else "-" + print( + f" {_short_name(name):<32} {t['wins']:>3}-{t['draws']}-{t['losses']:<3} {t['goals_for'] / n:>5.2f} " + f"{t['goals_against'] / n:>5.2f} {t['shots'] / n:>6.2f} {t['completed_passes'] / n:>7.1f} " + f"{t['attacking_third_entries'] / n:>8.1f} {t['fouls'] / n:>6.1f} {losses:>7} {t['stalled']:>8}" + ) + + +def _print_loss_kinds(table: dict[str, dict]) -> None: + """Real ball losses per match as config_a, by kind: where each strategy gives the ball away.""" + rows = {name: t for name, t in table.items() if t["matches_as_a"]} + if not rows: + return + totals: dict[str, int] = {} + for t in rows.values(): + for kind, n in t["real_loss_kinds_as_a"].items(): + totals[kind] = totals.get(kind, 0) + n + kinds = sorted(totals, key=lambda k: -totals[k]) + short = { + "shot_saved_or_blocked": "shot_saved", + "ball_out_after_kick": "out_kick", + "ball_out_other": "out_other", + "pass_intercepted": "intercepted", + "loose_ball_lost": "loose_lost", + } + print("\nLOSS KINDS (real ball losses per match as config_a, by kind; see ball_losses.md):") + print(f" {'strategy':<32} " + " ".join(f"{short.get(k, k)[:11]:>11}" for k in kinds)) + for name, t in sorted(rows.items(), key=lambda kv: -kv[1]["real_losses_as_a"] / kv[1]["matches_as_a"]): + n = t["matches_as_a"] + print( + f" {_short_name(name):<32} " + " ".join(f"{t['real_loss_kinds_as_a'].get(k, 0) / n:>11.2f}" for k in kinds) + ) + + +def _print_chances(table: dict[str, dict]) -> None: + """Chances created and conceded per strategy, both sides (`analysis.chances`).""" + rows = {name: t for name, t in table.items() if t["chances"]["matches"]} + if not rows: + return + + def pct(v: Optional[float]) -> str: + return f"{v:.0%}" if v is not None else "-" + + def num(v: Optional[float]) -> str: + return f"{v:.1f}" if v is not None else "-" + + print( + "\nCHANCES (both sides; conv = goals per shot, open = goal mouth unblocked at the shot, " + "regain>shot = open-play regains shot from within 10 s, danger = s/match the enemy held " + "the ball in our defensive third, fk>shot = free kicks shot from within 10 s, " + "progress = m gained per completed pass):" + ) + print( + f" {'strategy':<28} {'shots':>6} {'conv':>5} {'dist':>5} {'open':>5} {'save':>5} {'open vs':>7} " + f"{'regain>shot':>11} {'secs':>5} {'danger':>6} {'fk>shot':>7} {'progress':>8} {'fwd':>4}" + ) + for name, t in sorted(rows.items()): + c = t["chances"] + print( + f" {_short_name(name):<28} {c['shots'] / c['matches']:>6.1f} {pct(c['conversion']):>5} " + f"{num(c['shot_distance_m']):>5} {pct(c['shot_open_goal']):>5} {pct(c['save_rate']):>5} " + f"{pct(c['faced_open_goal']):>7} {pct(c['regain_to_shot']):>11} {num(c['regain_to_shot_s']):>5} " + f"{num(c['danger_s_per_match']):>6} {pct(c['free_kick_to_shot']):>7} " + f"{num(t['pass_progress_m']):>8} {pct(t['forward_pass_share']):>4}" + ) + + +def _print_motion_planning_table(table: dict[str, dict]) -> None: + if not any(t.get("worst_clearance_m") is not None or t.get("robot_overlap_ticks", 0) > 0 for t in table.values()): + return + print( + "\nMOTION PLANNING (per match averages; tm_coll = teammate overlap s (incidents), " + "total_coll = all overlap s (incidents), near_miss = near miss s <5cm, min_clr = worst clearance):" + ) + print(f" {'strategy':<32} {'tm_coll':>18} {'total_coll':>20} {'near_miss':>11} {'min_clr':>10}") + for name, t in sorted(table.items()): + n = max(1, t["matches"]) + tm = f"{t.get('teammate_overlap_ticks', 0) / n / TICKS_PER_SECOND:.2f}s ({t.get('teammate_overlap_incidents', 0) / n:.1f})" + tot = f"{t.get('robot_overlap_ticks', 0) / n / TICKS_PER_SECOND:.2f}s ({t.get('robot_overlap_incidents', 0) / n:.1f})" + near = t.get("near_miss_ticks", 0) / n / TICKS_PER_SECOND + wc = t.get("worst_clearance_m") + clr = f"{wc * 100:.1f} cm" if wc is not None else "-" + print(f" {_short_name(name):<32} {tm:>18} {tot:>20} {near:>10.2f}s {clr:>10}") + + +def _print_ball_losses(b: dict, run_label: str) -> None: + def top(counts: dict[str, int], k: int = 5) -> str: + return ", ".join(f"{name} {c}" for name, c in list(counts.items())[:k]) or "none" + + print( + f"\nBALL LOSSES (config_a side): {b['real_losses']} real ({b['real_losses_per_match']}/match; " + f"{b['raw_turnovers']} raw MatchStats turnovers)" + ) + print(f" by kind: {top(b['by_kind'])}") + print(f" fouls: {top(b['fouls_by_rule'])}") + print(f" by tactic: {top(b['by_tactic'])}") + rec = b.get("receptions") + if rec and rec["passes"]: + print( + f" passes: {top(rec['by_outcome'])}; {rec['catch_rate'] or 0:.0%} of reachable caught, " + f"missed median facing off {rec['missed']['median_facing_off_deg']} deg" + ) + print(f" full breakdown: replays/{run_label}/ball_losses.md") + + +# --- run metadata ----------------------------------------------------------------------------- + + +def _git(*args: str) -> Optional[str]: + try: + out = subprocess.run(["git", *args], capture_output=True, text=True, check=True, cwd=REPO_ROOT) + except (OSError, subprocess.CalledProcessError): + return None + return out.stdout.strip() + + +def _run_metadata() -> dict: + """What produced this run: enough to reproduce it or line it up against another.""" + status = _git("status", "--porcelain", "--untracked-files=no") + return { + "git_commit": _git("rev-parse", "HEAD"), + "git_dirty": bool(status) if status is not None else None, + "argv": sys.argv[1:], + "started_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"), + } + + if __name__ == "__main__": main() diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index d1b4412f..d75a6fac 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -1,7 +1,7 @@ """match.py — shared match-construction/running mechanics for the -evaluation drivers (`round_robin.py`, `evaluate.py`). +evaluation driver (`evaluate.py`). -Why this exists: `round_robin.py`'s `run_match` and the since-retired +Why this exists: `evaluate.py`'s `run_match` and the since-retired `full_match_tournament.py`'s `run_match_cell` were ~80% identical code (build two strategies from their names, construct a referee with the right kickoff-team/initial-command, wire up match_log/stats/replay paths, @@ -92,7 +92,7 @@ def _stats_to_dict(stats) -> dict: @dataclass class MatchResult: """One match's outcome. `a_is_right`/`a_kicks_off` default to the - `round_robin.py`'s fixed convention (config_a starts on the right and + `evaluate.py`'s fixed convention (config_a starts on the right and kicks off the first half; with halves the teams change ends at half-time). """ diff --git a/tools/evaluation/reference/opponents.json b/tools/evaluation/reference/opponents.json deleted file mode 100644 index e892f2e6..00000000 --- a/tools/evaluation/reference/opponents.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "note": "Chosen 2026-10-17 from the 12 strategies of tournament_20261016_201213 for spread of styles, not standings. Change it only on purpose: ratings are comparable within one set of opponents.", - "champion": "pendulum", - "opponents": [ - "firebreak", - "mirage", - "riptide", - "wolfpack", - "weaver", - "terrier" - ], - "held_out": [ - "avalanche", - "chameleon", - "ricochet" - ] -} diff --git a/tools/evaluation/reference/players.json b/tools/evaluation/reference/players.json new file mode 100644 index 00000000..cecffaac --- /dev/null +++ b/tools/evaluation/reference/players.json @@ -0,0 +1,5 @@ +{ + "note": "evaluate.py's players. The champion is the reference at the last release: promote a strategy by changing this line in a PR. The core plays every round; every other strategy in the catalog is reserve, two rotated in per round. Core chosen 2026-11-12 to cover every tactic the strategies use.", + "champion": "pendulum", + "core": ["pendulum", "breakwater", "avalanche", "mirage", "wolfpack"] +} diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py deleted file mode 100644 index 94616418..00000000 --- a/tools/evaluation/round_robin.py +++ /dev/null @@ -1,911 +0,0 @@ -"""round_robin.py (formerly smoke_tournament.py, before that tournament.py) — Round-robin every -strategy (`utama_core/strategy/catalog.py`) against every other, one full match per pair -(two halves, see `MAX_MATCH_SECONDS` below). This is the whole-catalog health and stall check; -a single strategy is judged with `evaluate.py`. - -Match construction (build strategies, referee, StrategyRunner, kickoff -ceremony, run_dir file layout) lives in `match.py`. - -Run: - pixi run python tools/evaluation/round_robin.py [config ...] [flags] - -Configs are short names (`pendulum`); none means every strategy in the catalog. Flags: - --pair A B one match, A as config_a - --vs-champion the day-to-day health check: one match per active strategy against the - champion (reference/opponents.json), plus champion vs the first opponent; - --sim-noise defaults to reference:2: evaluate.py's round 2 puts the side - under test second, so (strategy, champion) are its champion-row fixtures - and are taken from the match results store. Not with --pair - (no flag) a match the match results store holds (replays/match_results/, - `replay/match_results.py`) is taken from it, not played; delete that - folder to play every match again - --strict fail on any stall - --stop-at-first-stall stop the run at the first stall - --both-sides play each pair twice, sides swapped - --control-scheme NAME planner (fpp, trajsample, ...) - --fuzz-restarts SEED inject random legal restarts; --fuzz-interval LO HI sets the gap - --sim-noise SPEC seeded sim noise for every match: reference[:seed] (reference/world.json - and robots.json), or a SimNoise as inline JSON or a file - --match-seconds S match length in sim seconds (default 1200) - --max-workers N, --sequential, --no-save, -v/--verbose, -h/--help - -What this does --------------- -Headless rsim, no external process required. For each distinct pair of the -strategies `utama_core/strategy/catalog.py` finds (one `strategy/.py` each), -runs one `StrategyRunner` match (6v6: 1 goalkeeper + 5 outfield robots per -side — enough for every factory's minimum, including the `min_attack=2` -configs), -steps it until `CustomReferee` calls full time, and records the final -score from its scoreboard. - -Deliberately the smallest mechanism that answers "how do these configs do -against each other": a for-loop over `StrategyRunner` matches and a plain -tally, not a new `Tournament`/`Runner` class, no bracketing/seeding. Round- -robin (every pair once) rather than anything more elaborate — there are only -`C(n, 2)` pairs for the current catalog size, all of which comfortably fit -in one run. See `docs/roadmap.md`'s "Multi-strategy / tournament evaluation -infra" section for why this stays this small: the kernel's -`Strategy`/`Tactic`/`Partitioner` primitives already solve the "many things -owning dynamic robot subsets" problem this would otherwise need to -reinvent — a tournament script is purely a driver on top of -`StrategyRunner`'s existing `opp_strategy` support, not a new mechanism. - -Every run records the full observability stack (structured intention log, -aggregate stats, replay trail — see `utama_core.engine.match_log`/ -`match_stats`, `utama_core.replay`) per match under -`replays/tournament_/`, plus one `summary.json` for the whole -run — on by default, since it's cheap and is what a tournament run is -usually for. Pass `--no-save` for a quick throwaway run (e.g. a smoke test -of a code change) that doesn't need the trace kept afterward — replays in -particular can be tens to hundreds of MB per match, and a `--no-save` run -that's forgotten about is exactly how `replays/` silently filled up with -unreferenced gigabytes before (cleaned up 2026-08-26; see -`docs/STRATEGY_DEVELOPMENT.md`'s Observability section). `--verbose`/`-v` -also prints a possession/shots/ball-travel line per match as it completes, -independent of `--no-save`. - -`--both-sides` plays each pair twice — once with each config as -`config_a` (yellow, defending the right goal in the first half per `run_match`'s -hardcoded `my_team_is_yellow=True, my_team_is_right=True`; the teams change ends at -half-time) — instead of -once. This isn't a repeat: the sim's initial formation and every -`my_team_is_right`-relative geometry call (`enemy_goal_line`, defense-area -clamps, etc.) genuinely differ by side, so re-running the exact same pair -gives a byte-identical result (fixed initial formation, no RNG source that -varies run to run) while swapping which config plays which side gives a -real second data point per pair — the smallest available source of -variance reduction without inventing a noise model. Off by default since it -doubles match count. -""" - -from __future__ import annotations - -import os - -# Prevent multi-process thread oversubscription across OpenBLAS, MKL, OpenMP, NumExpr -os.environ.setdefault("OMP_NUM_THREADS", "1") -os.environ.setdefault("OPENBLAS_NUM_THREADS", "1") -os.environ.setdefault("MKL_NUM_THREADS", "1") -os.environ.setdefault("NUMEXPR_NUM_THREADS", "1") - -import dataclasses -import itertools -import json -import subprocess -import sys -from concurrent.futures import ProcessPoolExecutor, as_completed -from datetime import datetime, timezone -from pathlib import Path -from typing import Optional - -REPO_ROOT = Path(__file__).resolve().parents[2] -if str(REPO_ROOT) not in sys.path: - sys.path.insert(0, str(REPO_ROOT)) - -from tools.evaluation.match import ( # noqa: F401 -- re-exported for callers importing this module - _CONFIG_NAMES, - N_OUTFIELD, - OUTFIELD_ROBOT_IDS, - TICKS_PER_SECOND, - MatchResult, - _short_name, - _stats_to_dict, - run_match, -) -from tools.evaluation.sim_settings import load_opponents, sim_noise_from_spec -from utama_core.analysis import ratings, restart_outcomes, turnover_breakdown -from utama_core.analysis.strategy_table import strategy_table -from utama_core.bundle.strategy_file import SUFFIX -from utama_core.config.settings import REPLAY_BASE_PATH -from utama_core.replay import match_results -from utama_core.replay.fingerprint import CodeGraph -from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise -from utama_core.strategy.catalog import current_name, plain_name - -# A full match, as the rulebook has it: two halves of 300 s of playing time, the clock stopped -# whenever no team may play the ball (`custom_referee/state_machine.py`), so about 710 s of -# sim time (785 s in two measured matches, tournament_20261006_111922). config_a starts on the -# right and kicks off the first half; at half-time the teams change ends and config_b kicks -# off the second. Without `--both-sides` each pair plays once. Shorter matches rank differently: 65s matches were -# 55% draws, and 16 of 40 full matches (replays/tournament_20261003_102921) changed -# result after 180s, enough to reorder the top of the table. rsim is deterministic, so -# a short match is exactly the start of the full one; it just stops before it's decided. -# This only caps a match that can't reach full time (most took under 870 s of sim time). -MAX_MATCH_SECONDS = 1200.0 - - -def analyse_replay(npz: Path) -> tuple[list[dict], dict]: - """A played match's restart episodes and ball-loss record, from its replay. Kept out of - `match.py` (the environment's entry point), so changing an analysis replays no match; a stored - record keeps the analysis it was stored with (delete the store to refresh them).""" - return restart_outcomes.analyse_match(npz), turnover_breakdown.analyse_match(str(npz)) - - -def play_and_record( - config_a: str, - config_b: str, - *, - a_fp: str, - b_fp: str, - env: str, - seed: Optional[int], - source: str, - run_dir: Optional[Path] = None, - keep_files: bool = True, - match_tag_suffix: str = "", - **run_kwargs, -) -> dict: - """Play one match and return its record (`match_results.record`): the one place the tools play a - match for the store, so the round-robin and `evaluate.py` store the same thing. `run_kwargs` go to - `match.run_match`. With a `run_dir` the replay is analysed (restarts, ball losses) and, unless - `keep_files`, its files are deleted afterwards.""" - a_is_right = run_kwargs.get("a_is_right", True) - a_kicks_off = run_kwargs.get("a_kicks_off", True) - result = run_match(config_a, config_b, run_dir=run_dir, match_tag_suffix=match_tag_suffix, **run_kwargs) - restarts = losses = None - if run_dir is not None: - run_dir = Path(run_dir) - tag = f"{_short_name(config_a)}_vs_{_short_name(config_b)}{match_tag_suffix}" - npz = run_dir / f"{tag}.npz" - if npz.exists(): # no replay: crashed before it was written - restarts, losses = analyse_replay(npz) - if not keep_files: - for f in run_dir.glob(f"{tag}.*"): - f.unlink() - return match_results.record( - env, - a_fp, - b_fp, - dataclasses.asdict(result), - seed=seed, - source=source, - restarts=restarts, - losses=losses, - a_is_right=a_is_right, - a_kicks_off=a_kicks_off, - ) - - -def result_of(rec: dict, config_a: str, config_b: str) -> MatchResult: - """A stored or just-played record as a `MatchResult`, under this run's names for the two players.""" - return MatchResult( - config_a=config_a, - config_b=config_b, - score_a=rec["score_a"], - score_b=rec["score_b"], - a_is_right=rec["a_is_right"], - a_kicks_off=rec["a_kicks_off"], - stats=rec["stats"], - ) - - -def vs_champion_pairs(config_names: list[str], champion: str, first_opponent: str) -> list[tuple[str, str]]: - """`--vs-champion` fixtures: each other config as config_a against the champion as config_b, - then the champion as config_a against `first_opponent`. evaluate.py puts the side under test - second in even rounds, so with the default seed 2 each (strategy, champion) is its champion-row - fixture for a reference opponent; (champion, first_opponent) at seed 2 is not one of them.""" - if champion not in config_names: - raise ValueError(f"--vs-champion needs the champion {champion!r} among the configs") - if first_opponent not in config_names or first_opponent == champion: - raise ValueError(f"--vs-champion needs the first opponent {first_opponent!r} among the configs") - return [(name, champion) for name in sorted(config_names) if name != champion] + [(champion, first_opponent)] - - -def main() -> None: - # Optional CLI args: config names (plain, or the old `build__kernel_strategy` - # form, which `catalog.plain_name` still accepts) to run instead of the full auto-discovered - # catalog — useful for a quick check of one or two configs without - # waiting on every pair, e.g. `python tools/evaluation/round_robin.py default - # low_block`. `--sequential` forces the old one-process-at-a-time loop - # (useful for debugging a specific match without pool noise); otherwise - # matches run in a process pool since each `run_match` call is fully - # self-contained (its own StrategyRunner, its own rSim subprocess, no - # shared state with any other match) — this is the "many independent - # matches" case, not the harder "parallelize robots within one match" - # case (shared per-tick obstacle state, GIL-bound Python, would need its - # own design). No args keeps today's behaviour: every config, once each. - # `--max-workers N` caps the pool size, e.g. to leave headroom on a shared - # machine — os.cpu_count() ignores CPU affinity/cgroup limits, so a - # `taskset`-restricted run would otherwise still size the pool for all - # cores and oversubscribe. - # `--pair A B` plays just that one fixture, A as config_a. - # `--both-sides` plays every pair twice, once with each config on each - # side — see the module docstring for why this is real variance - # reduction rather than a duplicate match. - # `--control-scheme NAME` runs every match with that motion-control scheme - # (e.g. `fpp`, `dwa`, `trajsample` — see - # utama_core.motion_planning.src.common.control_schemes) on both sides - # instead of StrategyRunner's default `fpp`. This script compares - # strategies against each other, not planners against each other, so - # there's a single scheme per run rather than a per-side override. - # `--verbose`/`-v` prints each match's possession/shots/ball-travel line - # alongside the score. The full observability stack (intention log, full - # stats JSON, replay trail — see `utama_core.engine.match_log`/ - # `match_stats`, `utama_core.replay`) is recorded by default, under - # `replays/tournament_/`: it's cheap per match and is the - # point of running a tournament at all — a bare win/loss tally without - # the trace behind it was exactly what made the earlier scoreless-match - # investigations start from zero every time. `--no-save` skips all of - # it (no run_dir created, no summary.json) for a throwaway smoke-test - # run that doesn't need to be analyzed afterward. - # `--fuzz-restarts SEED` swaps in `RestartFuzzingReferee` for every match - # in this run (see docs/custom_referee.md's "Restart fuzzing" section / - # `utama_core/custom_referee/restart_fuzzer.py`), injecting extra - # seeded-random legal restarts during live play so referee auto-advance - # paths get exercised far more often than natural play alone triggers - # them. `--fuzz-interval LO HI` sets the sim-second gap range between - # injections (default 25-45s); both are recorded in summary.json - # (`fuzz_seed`/`fuzz_interval_s`, null when off) so a fuzzed run is - # reproducible from the summary alone. - # `--stop-at-first-stall` exits as soon as any match records a - # `StallEvent`, instead of finishing all `C(n, 2)` pairs — for iterating - # on a stall fix without waiting ~40 minutes for the full round-robin; - # rsim is deterministic, so the first stall found for a given - # catalog/seed/control-scheme reproduces the same way every run. Implies - # `--strict`. In pool mode, in-flight matches still finish (their cost is - # already sunk) but no further matches are submitted. - # A match the match results store holds (`replay/match_results.py`) is taken from it instead of - # played, whenever nothing it runs has changed since it was stored (its fixture: the environment, - # both fingerprints, the sides and the seed). rsim is deterministic, so the stored result is what - # the match would play. After a change to one strategy only its matches play. - args = sys.argv[1:] - if "-h" in args or "--help" in args: - print(__doc__) - return - sequential = "--sequential" in args - args = [a for a in args if a != "--sequential"] - verbose = "--verbose" in args or "-v" in args - args = [a for a in args if a not in ("--verbose", "-v")] - both_sides = "--both-sides" in args - args = [a for a in args if a != "--both-sides"] - # `--vs-champion`: the day-to-day health check (see the module docstring), one match per - # active strategy against the champion instead of every pair. - vs_champion = "--vs-champion" in args - args = [a for a in args if a != "--vs-champion"] - if vs_champion and "--pair" in args: - raise SystemExit("--vs-champion and --pair don't combine: --pair plays one named fixture") - max_workers_override: int | None = None - if "--max-workers" in args: - idx = args.index("--max-workers") - max_workers_override = int(args[idx + 1]) - args = args[:idx] + args[idx + 2 :] - no_save = "--no-save" in args - args = [a for a in args if a != "--no-save"] - # `--strict` exits non-zero when any match in this run recorded a stall - # event (see the STALLS section below) — for CI/pre-merge gating, so a - # stall regression fails the run instead of only showing up if someone - # reads the printed section or summary.json by hand. - strict = "--strict" in args - args = [a for a in args if a != "--strict"] - # `--stop-at-first-stall` exits the round-robin as soon as any match - # records a `StallEvent`, instead of running all `C(n, 2)` pairs — for - # iterating on a stall fix, where the other ~230 matches add nothing - # once one reproduction is in hand (rsim is deterministic, so the first - # stall found for a given catalog/seed/control-scheme is stable across - # runs). Implies `--strict`, since the point of stopping early is to - # fail fast, not to keep going and report success. Standings/STALLS - # output below still reflects however many matches actually ran. - stop_at_first_stall = "--stop-at-first-stall" in args - args = [a for a in args if a != "--stop-at-first-stall"] - strict = strict or stop_at_first_stall - if stop_at_first_stall and no_save: - # Stall detection reads `MatchResult.stats`, which is only populated - # when `run_match` gets a `stats_path` — i.e. never under `--no-save` - # (see `run_match`'s `extra_kwargs` construction). Combined with - # `--no-save`, `_stalled()` would be unconditionally False for every - # match, so this run-forever's fast-exit would silently never fire — - # worse than a no-op, since it would look like a clean run. `--strict` - # alone has this same gap but degrades to "did nothing", which is - # already documented above; `--stop-at-first-stall`'s entire point is - # to fire, so make the misuse loud instead. - raise SystemExit("--stop-at-first-stall requires stats collection; drop --no-save") - control_scheme = "fpp" - if "--control-scheme" in args: - idx = args.index("--control-scheme") - control_scheme = args[idx + 1] - args = args[:idx] + args[idx + 2 :] - # `--fuzz-restarts SEED` runs every match with `RestartFuzzingReferee` - # instead of plain `CustomReferee`, injecting extra seeded-random legal - # restarts during live play (see docs/custom_referee.md's "Restart - # fuzzing" section / restart_fuzzer.py). Same seed -> identical injection - # schedule (kind, team, sim time), so a run is reproducible. - fuzz_seed: Optional[int] = None - if "--fuzz-restarts" in args: - idx = args.index("--fuzz-restarts") - fuzz_seed = int(args[idx + 1]) - args = args[:idx] + args[idx + 2 :] - # `--fuzz-interval LO HI` sets the (sim-second) gap range between - # injections when `--fuzz-restarts` is on. Default 25-45s: about 17 - # injections over a full match, not the 8-20s range in - # RestartFuzzingReferee's own docstring, which is a stress-test example, - # not a sane default for a normal round-robin. - fuzz_interval_s: tuple[float, float] = (25.0, 45.0) - if "--fuzz-interval" in args: - idx = args.index("--fuzz-interval") - fuzz_interval_s = (float(args[idx + 1]), float(args[idx + 2])) - args = args[:idx] + args[idx + 3 :] - - # `--sim-noise SPEC` plays every match with the same seeded latency, kick speed and direction - # noise, ball friction, per-robot motion limits and vision noise: `reference` or `reference:` - # (`reference/world.json` and `robots.json`), or a `SimNoise` as inline JSON or a path to a JSON - # file, e.g. '{"seed": 1, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.3}' - # (field list in `SimNoise`'s docstring). Every pairing gets the same - # draws (they depend on colour and robot id, not strategy), so standings stay paired. - sim_noise: Optional[SimNoise] = None - if "--sim-noise" in args: - idx = args.index("--sim-noise") - sim_noise = sim_noise_from_spec(args[idx + 1]) - args = args[:idx] + args[idx + 2 :] - elif vs_champion: - # evaluate.py's round-2 champion fixtures (see vs_champion_pairs), so these matches are the store's - # fixtures and count toward the champion's rating. - sim_noise = sim_noise_from_spec("reference:2") - print("--vs-champion: --sim-noise not given, using reference:2 (evaluate.py's round-2 champion fixtures)") - sim_noise_dict = sim_noise.to_dict() if sim_noise is not None else None - - match_seconds = MAX_MATCH_SECONDS - if "--match-seconds" in args: - idx = args.index("--match-seconds") - match_seconds = float(args[idx + 1]) - args = args[:idx] + args[idx + 2 :] - - # `--pair A B` plays exactly one fixture, A as config_a (yellow, right side - # and kickoff in the first half) -- e.g. to rerun one stalled match from a round-robin, which - # reproduces exactly since rsim is deterministic. - pair: Optional[tuple[str, str]] = None - if "--pair" in args: - idx = args.index("--pair") - pair = (args[idx + 1], args[idx + 2]) - args = args[:idx] + args[idx + 3 :] - if args: - raise SystemExit(f"--pair takes no other config names: {args}") - - if pair is not None: - config_names = _resolve_config_names(list(pair)) - pairs = [tuple(_resolve_config_names([name])[0] for name in pair)] - else: - if args: - config_names = _resolve_config_names(args) - if len(config_names) < 2: - raise SystemExit("Need at least 2 configs to play a round-robin.") - else: - config_names = list(_CONFIG_NAMES) - - if vs_champion: - reference = load_opponents() - champion, first_opponent = ( - _resolve_config_names([reference["champion"]])[0], - _resolve_config_names([reference["opponents"][0]])[0], - ) - try: - base_pairs = vs_champion_pairs(config_names, champion, first_opponent) - except ValueError as e: - raise SystemExit(str(e)) - else: - base_pairs = list(itertools.combinations(sorted(config_names), 2)) - # --both-sides plays (a, b) and (b, a) as distinct fixtures — see the - # module docstring for why this is a real second data point (side- - # dependent geometry) rather than a duplicate, unlike naively re-running - # the same pair (which is byte-identical: fixed initial formation, no - # varying RNG source). - pairs = [(a, b) for a, b in base_pairs] + ([(b, a) for a, b in base_pairs] if both_sides else []) - - run_id = datetime.now(timezone.utc).strftime("tournament_%Y%m%d_%H%M%S") - run_dir: Optional[Path] = None - if not no_save: - run_dir = REPLAY_BASE_PATH / run_id - run_dir.mkdir(parents=True, exist_ok=True) - - all_pairs = pairs - - graph = CodeGraph() - env_args = { - "duration_seconds": match_seconds, - "sim_noise": sim_noise_dict, - "control_scheme": control_scheme, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": fuzz_interval_s, - } - env = match_results.environment(graph, **env_args) - fps = {name: graph.strategy_fingerprint(name)[:16] for name in config_names} - seed = sim_noise_dict.get("seed") if sim_noise_dict else None - store = match_results.open_store(REPLAY_BASE_PATH) - hits: dict[tuple[str, str], dict] = {} - for a, b in pairs: - if (rec := store.get(env, match_results.fixture_id(env, fps[a], fps[b], seed))) is not None: - hits[(a, b)] = rec - pairs = [p for p in pairs if p not in hits] - - print( - f"Round-robin: {len(config_names)} configs, {len(all_pairs)} matches" + (" (both sides)" if both_sides else "") - ) - print(f"{len(hits)} taken from {store.root} (not played), {len(pairs)} to play") - print(f"{N_OUTFIELD + 1}v{N_OUTFIELD + 1}, two 300 s halves of playing time per match, headless rsim") - if no_save: - print("--no-save: not recording replay/intention-log/stats for this run") - else: - print(f"Recording to replays/{run_id}/ (per-match replay, intention log, stats)") - if not sequential: - default_workers = min(12, max(1, (os.cpu_count() or 1) - 1)) - n_workers = max(1, min(len(pairs), max_workers_override or default_workers)) - print(f"Running {n_workers} matches concurrently (--sequential to disable)\n") - else: - print("Running sequentially\n") - - results: list[MatchResult] = [] - wins: dict[str, int] = {name: 0 for name in config_names} - draws: dict[str, int] = {name: 0 for name in config_names} - - def _stats_line(result: MatchResult) -> str: - if not result.stats: - return "" - s = result.stats - poss = s["possession_pct"] - shots = s["shots"] - return ( - f" possession {poss['friendly']:.0%}/{poss['enemy']:.0%} " - f"shots {shots['friendly']}-{shots['enemy']} " - f"ball_travel {s['ball_travel_m']:.1f}m " - f"turnovers {s['turnovers']} completed_passes {s['completed_passes']} " - f"attacking_third_entries {s['attacking_third_entries']}" - ) - - def _stalled(result: MatchResult) -> bool: - return bool(result.stats and result.stats.get("stall_events")) - - def _record(result: MatchResult) -> None: - results.append(result) - if result.winner == "draw": - draws[result.config_a] += 1 - draws[result.config_b] += 1 - else: - wins[result.winner] += 1 - print( - f"{result.config_a:<40} {result.score_a} - {result.score_b} " - f"{result.config_b:<40} winner={result.winner}", - flush=True, - ) - if verbose: - line = _stats_line(result) - if line: - print(line, flush=True) - - # The records of this run's matches, taken and played, by pair: the end of the run reads their - # restart and ball-loss analyses from here. - recs: dict[tuple[str, str], dict] = dict(hits) - - def _still_current(pair: tuple[str, str]) -> bool: - """A played match is stored only if the code it ran is still the code on disk: an edit made - while the run played would otherwise be stored under the fingerprints it started with.""" - now = CodeGraph() - return match_results.environment(now, **env_args) == env and all( - now.strategy_fingerprint(n)[:16] == fps[n] for n in pair - ) - - def _finish(rec: dict) -> MatchResult: - pair = (rec["a"], rec["b"]) - recs[pair] = rec - if run_dir is not None: - if _still_current(pair): - store.put(rec) - else: - print(f"--- {_tag(pair)} not stored: its code changed while the run played", flush=True) - result = result_of(rec, *pair) - _record(result) - return result - - for (a, b), rec in hits.items(): - _record(result_of(rec, a, b)) - - play_kwargs = { - "env": env, - "seed": seed, - "source": run_id, - "run_dir": run_dir, - "keep_files": True, - "duration_seconds": match_seconds, - "control_scheme": control_scheme, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": fuzz_interval_s, - "sim_noise": sim_noise, - } - if sequential: - for a, b in pairs: - result = _finish(play_and_record(a, b, a_fp=fps[a], b_fp=fps[b], **play_kwargs)) - if stop_at_first_stall and _stalled(result): - tag = f"{_short_name(result.config_a)}_vs_{_short_name(result.config_b)}" - print(f"\n--stop-at-first-stall: stopping after {tag}", flush=True) - break - else: - # Matches complete out of submission order under a process pool — - # printed as they finish rather than buffered back into pair order, - # since waiting to preserve order would throttle everything to the - # slowest in-flight match. Final standings are still sorted, so the - # only user-visible reordering is the interleaved progress log. - with ProcessPoolExecutor(max_workers=n_workers) as pool: - futures = [pool.submit(play_and_record, a, b, a_fp=fps[a], b_fp=fps[b], **play_kwargs) for a, b in pairs] - for future in as_completed(futures): - result = _finish(future.result()) - if stop_at_first_stall and _stalled(result): - tag = f"{_short_name(result.config_a)}_vs_{_short_name(result.config_b)}" - print( - f"\n--stop-at-first-stall: stopping after {tag} " - "(in-flight matches still finish; not resubmitted)", - flush=True, - ) - for fut in futures: - fut.cancel() - break - - print("\nStandings (wins, draws):") - for name in sorted(config_names, key=lambda n: (-wins[n], -draws[n])): - print(f" {name:<40} {wins[name]}W {draws[name]}D") - - # STALLS: every match that recorded a `StallEvent` (see - # `utama_core.engine.match_stats`'s RESTART_STALL/COMMITTED_FROZEN - # watchdogs), plus a heuristic backstop for anything the watchdog itself - # missed — possession pinned at 100%/0% with almost no ball movement is - # exactly the signature a stalled match showed before this watchdog - # existed (see this module's/`match_stats.py`'s docs). Both are printed - # together since they answer the same question ("did this run stall - # anywhere") and both go into summary.json per match either way. - def _match_tag_of(r: MatchResult) -> str: - return f"{_short_name(r.config_a)}_vs_{_short_name(r.config_b)}" - - stalled_matches: list[tuple[MatchResult, list[dict]]] = [] - backstop_matches: list[MatchResult] = [] - for r in results: - if not r.stats: - continue - events = r.stats.get("stall_events") or [] - if events: - stalled_matches.append((r, events)) - poss = r.stats.get("possession_pct") or {} - pinned = (poss.get("friendly") == 1.0 and poss.get("enemy") == 0.0) or ( - poss.get("friendly") == 0.0 and poss.get("enemy") == 1.0 - ) - if pinned and (r.stats.get("ball_travel_m") or 0.0) < 1.0: - backstop_matches.append(r) - - stalled_match_ids = {id(r) for r, _ in stalled_matches} - incidents = stall_incidents([{"config_a": r.config_a, "config_b": r.config_b, "stats": r.stats} for r in results]) - if stalled_matches or backstop_matches: - print(f"\nSTALLS: {len(stalled_matches)} match(es), {len(incidents)} distinct incident(s)") - for r, events in stalled_matches: - for e in events: - tactic_str = f" tactics={e['tactic_ids']}" if e["tactic_ids"] else "" - diagnosis = f" -- {e['diagnosis']}" if e.get("diagnosis") else "" - print( - f" {_match_tag_of(r):<50} {e['kind']:<17} onset t={e['sim_time']:.1f}s " - f"referee={e['referee_command']}{tactic_str}{diagnosis}" - ) - for r in backstop_matches: - if id(r) in stalled_match_ids: - continue - poss = r.stats["possession_pct"] - print( - f" {_match_tag_of(r):<50} {'POSSESSION_BACKSTOP':<17} " - f"possession {poss['friendly']:.0%}/{poss['enemy']:.0%} " - f"ball_travel {r.stats['ball_travel_m']:.2f}m" - ) - else: - print("\nSTALLS: none") - - backstop_match_ids = {id(r) for r in backstop_matches} - summary = { - "run_id": run_id, - "run": _run_metadata(), - "config_names": sorted(config_names), - "control_scheme": control_scheme, - "max_match_seconds": match_seconds, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": list(fuzz_interval_s) if fuzz_seed is not None else None, - "sim_noise": sim_noise_dict, - "results": [ - { - "config_a": r.config_a, - "config_b": r.config_b, - "score_a": r.score_a, - "score_b": r.score_b, - "winner": r.winner, - "stats": r.stats, - "possession_backstop": id(r) in backstop_match_ids, - "reused": (r.config_a, r.config_b) in hits, - } - for r in results - ], - "standings": {name: {"wins": wins[name], "draws": draws[name]} for name in config_names}, - "stalled_match_count": len(stalled_matches), - "stall_incidents": incidents, - "possession_backstop_match_count": len(backstop_matches), - } - real_losses_by_match: Optional[dict[str, dict[str, int]]] = None - chances_by_match: dict[str, dict] = {} - if run_dir is not None: - summary_path = run_dir / "summary.json" - with open(summary_path, "w") as f: - json.dump(summary, f, indent=2) - # RESTARTS: what became of every restart -- taken, or voided/stopped/timed out. - restarts_by_match = {_tag(p): r["restarts"] for p, r in recs.items() if r["restarts"] is not None} - summary["restarts"] = restart_outcomes.summarise( - [e for m in sorted(restarts_by_match) for e in restarts_by_match[m]] - ) - _print_restarts(summary["restarts"]) - # BALL LOSSES: how the friendly side (config_a) gave the ball away, by kind, foul rule - # and tactic — `MatchStats.turnovers` alone is mostly two robots on one ball flipping - # "nearest robot". Analysed as each match was played (`analyse_replay`). - losses = sorted((r["losses"] for r in recs.values() if r["losses"] is not None), key=lambda r: r["match"]) - if losses: # no replays saved (e.g. every match crashed): nothing to break down - summary["ball_losses"] = turnover_breakdown.breakdown(losses) - (run_dir / "ball_losses.md").write_text(turnover_breakdown.report(run_id, losses, summary)) - _print_ball_losses(summary["ball_losses"], run_id) - real_losses_by_match = {r["match"]: turnover_breakdown.real_loss_kinds(r) for r in losses} - # Records stored before chances were measured have none: their matches are left out. - chances_by_match = {r["match"]: r["chances"] for r in losses if "chances" in r} - - summary["strategies"] = strategy_table(summary["results"], real_losses_by_match, chances_by_match) - _print_strategy_table(summary["strategies"]) - summary["ratings"] = _ratings(summary["results"]) - _print_loss_kinds(summary["strategies"]) - _print_chances(summary["strategies"]) - summary["fouls"] = foul_table(summary["results"]) - _print_foul_table(summary["fouls"]) - _print_motion_planning_table(summary["strategies"]) - if run_dir is not None: - with open(summary_path, "w") as f: - json.dump(summary, f, indent=2) - print(f"\nFull results + stats: replays/{run_id}/summary.json") - - if strict and (stalled_matches or backstop_matches): - raise SystemExit( - f"--strict: {len(stalled_matches)} match(es) with stall events, " - f"{len(backstop_matches)} match(es) flagged by the possession backstop" - ) - - -def _tag(pair: tuple[str, str]) -> str: - """A match's file stem in a run directory (`match.run_match`'s `match_tag`).""" - return f"{_short_name(pair[0])}_vs_{_short_name(pair[1])}" - - -def _resolve_config_names(requested_names: list[str]) -> list[str]: - """The strategies named, in catalog order, then any `.strategy` files as given.""" - files = [name for name in requested_names if name.endswith(SUFFIX)] - requested = {current_name(name) for name in requested_names if name not in files} - config_names = [name for name in _CONFIG_NAMES if name in requested] - unmatched = requested - set(config_names) - if unmatched: - raise SystemExit(f"Unknown config name(s): {sorted(unmatched)}. Available: {sorted(_CONFIG_NAMES)}") - return config_names + files - - -def _run_metadata() -> dict: - """What produced this run: enough to reproduce it or line it up against another.""" - - def git(*args: str) -> Optional[str]: - try: - out = subprocess.run(["git", *args], capture_output=True, text=True, check=True, cwd=Path(__file__).parent) - except (OSError, subprocess.CalledProcessError): - return None - return out.stdout.strip() - - status = git("status", "--porcelain", "--untracked-files=no") - return { - "git_commit": git("rev-parse", "HEAD"), - "git_dirty": bool(status) if status is not None else None, - "argv": sys.argv[1:], - "started_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"), - } - - -def stall_incidents(results: list[dict]) -> list[dict]: - """Stall events over `summary.json`-shaped `results`, with deterministic duplicates - merged: the same kind, onset tick and duration tick in matches that share a strategy - is one freeze seen against two opponents that hadn't diverged yet (rsim is - deterministic), not two separate problems. In order of first appearance.""" - incidents: list[dict] = [] - by_key: dict[tuple, dict] = {} - for r in results: - tag = f"{_short_name(r['config_a'])}_vs_{_short_name(r['config_b'])}" - for e in (r.get("stats") or {}).get("stall_events") or []: - ticks = (e["kind"], round(e["sim_time"] * TICKS_PER_SECOND), round(e["duration_s"] * TICKS_PER_SECOND)) - keys = [(name, *ticks) for name in (r["config_a"], r["config_b"])] - incident = next((by_key[k] for k in keys if k in by_key), None) - if incident is None: - incident = {"kind": e["kind"], "sim_time": e["sim_time"], "duration_s": e["duration_s"], "matches": []} - incidents.append(incident) - if tag not in incident["matches"]: - incident["matches"].append(tag) - for k in keys: - by_key.setdefault(k, incident) - return incidents - - -def _print_restarts(restarts: dict) -> None: - if not restarts["restarts"]: - return - print( - f"\nRESTARTS: {restarts['restarts']}, {restarts['reached_normal_start'] / restarts['restarts']:.0%} " - "reached NORMAL_START" - ) - for kind, row in restarts["by_kind"].items(): - outcomes = ", ".join(f"{k} {n}" for k, n in row["outcomes"].items()) - print(f" {kind:<16} {row['n']:>4} reached {row['reached_normal_start'] / row['n']:>4.0%} {outcomes}") - - -def foul_table(results: list[dict]) -> dict[str, dict]: - """Every logged foul (`MatchStats.fouls`, both sides) by rule, then by - "strategy/tactic" of the offending robot. `inferred` counts fouls whose rule only - named a team, attributed to that side's robot nearest the ball.""" - table: dict[str, dict] = {} - for r in results: - for foul in (r.get("stats") or {}).get("fouls") or []: - strategy = _short_name(r["config_a"] if foul["side"] == "friendly" else r["config_b"]) - row = table.setdefault(foul["rule"], {"total": 0, "inferred": 0, "by_tactic": {}}) - row["total"] += 1 - row["inferred"] += bool(foul["inferred"]) - key = f"{strategy}/{foul['tactic'] or 'unknown'}" - row["by_tactic"][key] = row["by_tactic"].get(key, 0) + 1 - for row in table.values(): - row["by_tactic"] = dict(sorted(row["by_tactic"].items(), key=lambda kv: -kv[1])) - return dict(sorted(table.items(), key=lambda kv: -kv[1]["total"])) - - -def _print_foul_table(table: dict[str, dict]) -> None: - if not table: - return - print("\nFOULS (both sides; top strategy/tactic of the offending robot; * = rule named only a team):") - for rule, row in table.items(): - top = ", ".join(f"{k} {c}" for k, c in list(row["by_tactic"].items())[:4]) - star = "*" if row["inferred"] else "" - print(f" {rule + star:<30} {row['total']:>5} {top}") - - -def _print_strategy_table(table: dict[str, dict]) -> None: - print("\nSTRATEGIES (per match; losses = real ball losses, as config_a only):") - print( - f" {'strategy':<32} {'W-D-L':>9} {'GF':>5} {'GA':>5} {'shots':>6} {'passes':>7} {'entries':>8} {'fouls':>6} {'losses':>7} {'stalled':>8}" - ) - for name, t in sorted(table.items(), key=lambda kv: (-kv[1]["wins"], -kv[1]["draws"])): - n = max(1, t["matches"]) - losses = f"{t['real_losses_as_a'] / t['matches_as_a']:.1f}" if t["matches_as_a"] else "-" - print( - f" {_short_name(name):<32} {t['wins']:>3}-{t['draws']}-{t['losses']:<3} {t['goals_for'] / n:>5.2f} " - f"{t['goals_against'] / n:>5.2f} {t['shots'] / n:>6.2f} {t['completed_passes'] / n:>7.1f} " - f"{t['attacking_third_entries'] / n:>8.1f} {t['fouls'] / n:>6.1f} {losses:>7} {t['stalled']:>8}" - ) - - -def _ratings(results: list[dict]) -> dict[str, dict[str, float]]: - """Each config's strength from goal margins, with its SD (`analysis.ratings`).""" - fit = ratings.fit([(r["config_a"], r["config_b"], r["score_a"] - r["score_b"]) for r in results]) - return {n: dict(zip(("strength", "sd"), (round(v, 2) for v in fit.strength(n)))) for n in fit.names} - - -def _print_loss_kinds(table: dict[str, dict]) -> None: - """Real ball losses per match as config_a, by kind: where each strategy gives the ball away.""" - rows = {name: t for name, t in table.items() if t["matches_as_a"]} - if not rows: - return - totals: dict[str, int] = {} - for t in rows.values(): - for kind, n in t["real_loss_kinds_as_a"].items(): - totals[kind] = totals.get(kind, 0) + n - kinds = sorted(totals, key=lambda k: -totals[k]) - short = { - "shot_saved_or_blocked": "shot_saved", - "ball_out_after_kick": "out_kick", - "ball_out_other": "out_other", - "pass_intercepted": "intercepted", - "loose_ball_lost": "loose_lost", - } - print("\nLOSS KINDS (real ball losses per match as config_a, by kind; see ball_losses.md):") - print(f" {'strategy':<32} " + " ".join(f"{short.get(k, k)[:11]:>11}" for k in kinds)) - for name, t in sorted(rows.items(), key=lambda kv: -kv[1]["real_losses_as_a"] / kv[1]["matches_as_a"]): - n = t["matches_as_a"] - print( - f" {_short_name(name):<32} " + " ".join(f"{t['real_loss_kinds_as_a'].get(k, 0) / n:>11.2f}" for k in kinds) - ) - - -def _print_chances(table: dict[str, dict]) -> None: - """Chances created and conceded per strategy, both sides (`analysis.chances`).""" - rows = {name: t for name, t in table.items() if t["chances"]["matches"]} - if not rows: - return - - def pct(v: Optional[float]) -> str: - return f"{v:.0%}" if v is not None else "-" - - def num(v: Optional[float]) -> str: - return f"{v:.1f}" if v is not None else "-" - - print( - "\nCHANCES (both sides; conv = goals per shot, open = goal mouth unblocked at the shot, " - "regain>shot = open-play regains shot from within 10 s, danger = s/match the enemy held " - "the ball in our defensive third, fk>shot = free kicks shot from within 10 s, " - "progress = m gained per completed pass):" - ) - print( - f" {'strategy':<28} {'shots':>6} {'conv':>5} {'dist':>5} {'open':>5} {'save':>5} {'open vs':>7} " - f"{'regain>shot':>11} {'secs':>5} {'danger':>6} {'fk>shot':>7} {'progress':>8} {'fwd':>4}" - ) - for name, t in sorted(rows.items(), key=lambda kv: (-kv[1]["wins"], -kv[1]["draws"])): - c = t["chances"] - print( - f" {_short_name(name):<28} {c['shots'] / c['matches']:>6.1f} {pct(c['conversion']):>5} " - f"{num(c['shot_distance_m']):>5} {pct(c['shot_open_goal']):>5} {pct(c['save_rate']):>5} " - f"{pct(c['faced_open_goal']):>7} {pct(c['regain_to_shot']):>11} {num(c['regain_to_shot_s']):>5} " - f"{num(c['danger_s_per_match']):>6} {pct(c['free_kick_to_shot']):>7} " - f"{num(t['pass_progress_m']):>8} {pct(t['forward_pass_share']):>4}" - ) - - -def _print_motion_planning_table(table: dict[str, dict]) -> None: - has_motion = any( - t.get("worst_clearance_m") is not None or t.get("robot_overlap_ticks", 0) > 0 for t in table.values() - ) - if not has_motion: - return - print( - "\nMOTION PLANNING (per match averages; tm_coll = teammate overlap s (incidents), " - "total_coll = all overlap s (incidents), near_miss = near miss s <5cm, min_clr = worst clearance):" - ) - print(f" {'strategy':<32} {'tm_coll':>18} {'total_coll':>20} {'near_miss':>11} {'min_clr':>10}") - for name, t in sorted(table.items(), key=lambda kv: (-kv[1]["wins"], -kv[1]["draws"])): - n = max(1, t["matches"]) - tm_coll_s = (t.get("teammate_overlap_ticks", 0) / n) / TICKS_PER_SECOND - tm_inc = t.get("teammate_overlap_incidents", 0) / n - total_coll_s = (t.get("robot_overlap_ticks", 0) / n) / TICKS_PER_SECOND - tot_inc = t.get("robot_overlap_incidents", 0) / n - near_miss_s = (t.get("near_miss_ticks", 0) / n) / TICKS_PER_SECOND - wc = t.get("worst_clearance_m") - min_clr_str = f"{wc * 100:.1f} cm" if wc is not None else "-" - tm_str = f"{tm_coll_s:.2f}s ({tm_inc:.1f})" - tot_str = f"{total_coll_s:.2f}s ({tot_inc:.1f})" - print(f" {_short_name(name):<32} {tm_str:>18} {tot_str:>20} {near_miss_s:>10.2f}s {min_clr_str:>10}") - - -def _print_ball_losses(b: dict, run_id: str) -> None: - def top(counts: dict[str, int], k: int = 5) -> str: - return ", ".join(f"{name} {c}" for name, c in list(counts.items())[:k]) or "none" - - print( - f"\nBALL LOSSES (config_a side): {b['real_losses']} real ({b['real_losses_per_match']}/match; " - f"{b['raw_turnovers']} raw MatchStats turnovers)" - ) - print(f" by kind: {top(b['by_kind'])}") - print(f" fouls: {top(b['fouls_by_rule'])}") - print(f" by tactic: {top(b['by_tactic'])}") - rec = b.get("receptions") - if rec and rec["passes"]: - print( - f" passes: {top(rec['by_outcome'])}; {rec['catch_rate'] or 0:.0%} of reachable caught, " - f"missed median facing off {rec['missed']['median_facing_off_deg']} deg" - ) - print(f" full breakdown: replays/{run_id}/ball_losses.md") - - -if __name__ == "__main__": - main() diff --git a/tools/evaluation/sim_settings.py b/tools/evaluation/sim_settings.py index ef89c53f..3b6b5561 100644 --- a/tools/evaluation/sim_settings.py +++ b/tools/evaluation/sim_settings.py @@ -1,6 +1,6 @@ -"""What the reference evaluation plays: the opponents, and the simulated world and robots. +"""What the reference evaluation plays: the players, and the simulated world and robots. -`reference/opponents.json` is who a candidate is judged against. `reference/world.json` is the +`reference/players.json` names the champion and the core strategies (`evaluate.py`). `reference/world.json` is the measured world, `reference/robots.json` the robots, assumed good. They live in a subdirectory because `replay/fingerprint.py` hashes data files beside `match.py`: choosing a new champion must not rerun every cached match. World and robots enter the matches together as one `SimNoise`. @@ -14,15 +14,14 @@ from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise REFERENCE_DIR = Path(__file__).with_name("reference") -DEFAULT_OPPONENTS = REFERENCE_DIR / "opponents.json" -_REFERENCE_SPEC = "reference" +DEFAULT_PLAYERS = REFERENCE_DIR / "players.json" def _values(name: str) -> dict: return json.loads((REFERENCE_DIR / f"{name}.json").read_text())["values"] -def load_opponents(path: Path = DEFAULT_OPPONENTS) -> dict: +def load_players(path: Path = DEFAULT_PLAYERS) -> dict: return json.loads(Path(path).read_text()) @@ -32,11 +31,3 @@ def reference_noise(seed: int = 0) -> dict: both = set(world) & set(robots) assert not both, f"set in both world.json and robots.json: {sorted(both)}" return {**world, **robots, "seed": seed} - - -def sim_noise_from_spec(spec: str) -> SimNoise: - """`round_robin.py --sim-noise`'s argument: `reference`, `reference:`, a JSON file or inline JSON.""" - name, _, seed = spec.partition(":") - if name == _REFERENCE_SPEC: - return SimNoise.from_dict(reference_noise(int(seed) if seed else 0)) - return SimNoise.from_dict(json.loads(Path(spec).read_text() if Path(spec).is_file() else spec)) diff --git a/tools/metric_correlation.py b/tools/metric_correlation.py index 44eee8c2..59bb2b1b 100644 --- a/tools/metric_correlation.py +++ b/tools/metric_correlation.py @@ -12,7 +12,7 @@ Purpose ------- -`docs/strategies.md` and `round_robin.py` already tell us who won each match, but a +`docs/strategies.md` and `evaluate.py` already tell us who won each match, but a full 65s round-robin match is expensive to run inside an agent loop that's iterating on a single strategy change. If some cheap per-match "proxy" metric (possession, territory, shots, ...) reliably predicts match outcome, a much shorter scenario @@ -32,7 +32,7 @@ frame's `friendly_robots`/`ball` are recorded from `config_a`'s perspective (`ReplayMetadata.my_team_is_yellow=True` in every file checked), so "friendly" in a frame or in `.stats.json` always means `config_a`. Side is a real effect in -this sim (see `round_robin.py`'s `--both-sides` docstring), so every metric below is +this sim, so every metric below is reported both as a per-side value and as an a-minus-b differential, and side is kept as an explicit covariate in the logistic fit (part A) rather than assumed away. diff --git a/tools/moments.py b/tools/moments.py index e30a875a..0985966c 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -212,7 +212,7 @@ def save(m: Moment, path: Optional[Path] = None) -> Path: def catalog() -> list[str]: """The round-robin's strategies: every strategy in the catalog.""" - from tools.evaluation.round_robin import _CONFIG_NAMES + from tools.evaluation.match import _CONFIG_NAMES return list(_CONFIG_NAMES) diff --git a/tools/package_logs.py b/tools/package_logs.py index 1df7162d..ebaa110b 100644 --- a/tools/package_logs.py +++ b/tools/package_logs.py @@ -16,6 +16,7 @@ import argparse import gzip +import re import shutil import sys import tarfile @@ -27,8 +28,11 @@ def find_latest_tournament(replays_dir: Path) -> Optional[Path]: - """Find the most recent tournament_* directory in replays_dir.""" - runs = sorted(replays_dir.glob("tournament_*")) + """The most recent run directory in replays_dir: an evaluate.py round or an older round-robin.""" + runs = sorted( + [*replays_dir.glob("tournament_*"), *replays_dir.glob("eval_*/round_*")], + key=lambda p: re.sub(r"^\D*", "", p.relative_to(replays_dir).as_posix()), + ) return runs[-1] if runs else None diff --git a/tools/repro_from_replay.py b/tools/repro_from_replay.py index 2f2d3957..41bcdabd 100644 --- a/tools/repro_from_replay.py +++ b/tools/repro_from_replay.py @@ -1,8 +1,8 @@ """repro_from_replay.py — reload a replay's field state at a given timestamp into a fresh headless rsim match, and tick forward with match_log tracing on. -Why this exists: finding a stall today means running a 231-match round-robin -(`round_robin.py`), spotting a suspicious match, then tracing its replay +Why this exists: finding a stall today means running an evaluation +(`evaluate.py`), spotting a suspicious match, then tracing its replay (`render_window`/`load_frames_in_range`) to find the stall window. Once the window is known (e.g. "ball frozen from t=264s"), reproducing it previously meant replaying the *whole* match from t=0 in a fresh run just to get back diff --git a/utama_core/analysis/chances.py b/utama_core/analysis/chances.py index c6c1fcd0..f2d0855c 100644 --- a/utama_core/analysis/chances.py +++ b/utama_core/analysis/chances.py @@ -2,7 +2,7 @@ `turnover_breakdown.analyse_match` feeds every replay frame to a `ChanceTracker`, so this costs no extra pass over the replay. Its record is under `chances` in each match's ball-loss -record; `round_robin.py` totals it per strategy (`side_totals`, `rates`) into +record; `evaluate.py` totals it per strategy (`side_totals`, `rates`) into `summary.json`'s `strategies[*].chances`. Unlike the ball-loss breakdown, everything here is measured for both sides: it needs positions and possession, not the intentions log. diff --git a/utama_core/analysis/list_runs.py b/utama_core/analysis/list_runs.py index d1a1c8ec..68e570ca 100644 --- a/utama_core/analysis/list_runs.py +++ b/utama_core/analysis/list_runs.py @@ -1,6 +1,6 @@ """List the tournament runs under ./replays (`pixi run runs`). -One line per `replays/tournament_*` directory, oldest first: when it started, the +One line per run directory (`replays/tournament_*`, and `replays/eval_*/round_*` from evaluate.py), oldest first: when it started, the git commit it ran on (`*` if the tree was dirty), how many matches finished, how many stalled, and its command-line arguments -- all read from the run's `summary.json`. A run still in progress, or from before a field existed, shows `-` @@ -8,14 +8,21 @@ """ import json +import re from pathlib import Path from utama_core.config.settings import REPLAY_BASE_PATH +def _started(run: str) -> str: + """A run's name from its timestamp on, so both kinds of run sort oldest first.""" + return re.sub(r"^\D*", "", run) + + def run_rows(replays_dir: Path) -> list[dict]: rows = [] - for run_dir in sorted(replays_dir.glob("tournament_*")): + runs = [*replays_dir.glob("tournament_*"), *replays_dir.glob("eval_*/round_*")] + for run_dir in sorted(runs, key=lambda p: _started(p.relative_to(replays_dir).as_posix())): if not run_dir.is_dir(): continue try: @@ -28,7 +35,7 @@ def run_rows(replays_dir: Path) -> list[dict]: argv = run.get("argv") rows.append( { - "run": run_dir.name, + "run": run_dir.relative_to(replays_dir).as_posix(), "started": run.get("started_utc", "-"), "commit": (commit[:8] + ("*" if run.get("git_dirty") else "")) if commit else "-", "matches": len(results) if isinstance(results, list) else "-", diff --git a/utama_core/analysis/restart_outcomes.py b/utama_core/analysis/restart_outcomes.py index b094438b..09bb20e4 100644 --- a/utama_core/analysis/restart_outcomes.py +++ b/utama_core/analysis/restart_outcomes.py @@ -1,6 +1,6 @@ """What became of every restart in a tournament run: taken, or why not. -`round_robin.py` runs this after every saved run and writes `summary()` into +`evaluate.py` runs this after every saved run and writes `summary()` into `summary.json` under `restarts`. Found necessary 2026-09-28: 8 of 19 penalties in a full round-robin were never taken (the ball was never placed, then keep-out voided them) and no existing signal showed it. diff --git a/utama_core/analysis/strategy_table.py b/utama_core/analysis/strategy_table.py index f1bd40a1..dd124f99 100644 --- a/utama_core/analysis/strategy_table.py +++ b/utama_core/analysis/strategy_table.py @@ -2,7 +2,7 @@ Lives in `utama_core` so the analysis code can rebuild a `summary.json`'s `strategies` table without importing the `tools/` scripts (which are not part of the installed package). -`tools/evaluation/round_robin.py` re-exports it. +`tools/evaluation/evaluate.py` prints it. """ from __future__ import annotations diff --git a/utama_core/analysis/turnover_breakdown.py b/utama_core/analysis/turnover_breakdown.py index 61c85cae..18376c54 100644 --- a/utama_core/analysis/turnover_breakdown.py +++ b/utama_core/analysis/turnover_breakdown.py @@ -1,6 +1,6 @@ """Breakdown of *how* the friendly team loses the ball, over a tournament run's replays. -`round_robin.py` runs this after every saved run: headline numbers go into +`evaluate.py` runs this after every saved run: headline numbers go into `summary.json` under `ball_losses`, the full report into `ball_losses.md` beside it. For an existing run: diff --git a/utama_core/dashboard/views/tournament.py b/utama_core/dashboard/views/tournament.py index c0b43cf4..d14202b5 100644 --- a/utama_core/dashboard/views/tournament.py +++ b/utama_core/dashboard/views/tournament.py @@ -1,5 +1,5 @@ """Tournament view — reads `replays//summary.json` written by -`round_robin.py` and exposes it to the dashboard. +`evaluate.py` and exposes it to the dashboard. Fully standalone: no coupling to a running match or `StrategyRunner`. Just a `GET /tournament/runs` route returning every run's full summary inline @@ -33,7 +33,10 @@ def _load_runs() -> List[dict]: return [] summaries = [] - for summary_path in REPLAY_BASE_PATH.glob("*/summary.json"): + # Older round-robins: replays/tournament_/summary.json; evaluate.py: one per round, + # replays/eval_/round_/summary.json. + paths = [*REPLAY_BASE_PATH.glob("*/summary.json"), *REPLAY_BASE_PATH.glob("eval_*/round_*/summary.json")] + for summary_path in paths: try: with open(summary_path) as f: summary = json.load(f) @@ -52,7 +55,7 @@ def _short(config: str) -> str: def _replay_path(run_dir: Path, result: dict) -> Optional[str]: - """The result's replay, relative to `REPLAY_BASE_PATH`: `round_robin.py` writes + """The result's replay, relative to `REPLAY_BASE_PATH`: `evaluate.py` writes `_vs_.npz`. Older runs (the retired `ladder.py`, `full_match_tournament.py`) wrote side and kickoff tags, `_vs__` (as `.pkl` for the latter).""" stem = f"{_short(result['config_a'])}_vs_{_short(result['config_b'])}" diff --git a/utama_core/engine/match_stats.py b/utama_core/engine/match_stats.py index bc69a8fe..b7684469 100644 --- a/utama_core/engine/match_stats.py +++ b/utama_core/engine/match_stats.py @@ -25,7 +25,7 @@ time, so the ball genuinely never "freezes" even though nothing useful is happening — see `_maybe_record_no_progress_possession`'s docstring for the live match this was found in). All three are pure observations recorded -for post-match reporting (see `round_robin.py`'s "STALLS" section) — +for post-match reporting (see `evaluate.py`'s "STALLS" section) — nothing here reads back into or alters gameplay. `turnovers`/`completed_passes`/`attacking_third_entries` (friendly-side) and @@ -299,7 +299,7 @@ class MatchStats: # the GiveAndGoTactic bug would have shown up as here. # # Kept as plain per-pass lists, not pre-aggregated into a mean/median -- - # post-match tooling (`round_robin.py`, `tools/metric_correlation.py`, + # post-match tooling (`evaluate.py`, `tools/metric_correlation.py`, # dashboards) can compute whatever summary statistic it wants from the # raw distribution; deciding that here would throw away information # (e.g. a bimodal distribution -- mostly fine passes plus a handful of diff --git a/utama_core/replay/match_results.py b/utama_core/replay/match_results.py index 0a9a1059..62c67967 100644 --- a/utama_core/replay/match_results.py +++ b/utama_core/replay/match_results.py @@ -3,9 +3,9 @@ An rsim match is deterministic, so its result is a function of its fixture: the environment (the shared code and machine, the match length, the planner, the sim noise without its seed and the restart fuzzing), both players' code fingerprints (`fingerprint.py`), their sides and the noise -seed. `tools/evaluation/match.py`'s `play_and_record` plays a fixture and returns its record; the -callers (`round_robin.py`, `evaluate.py`) look a fixture up first and play it only when the store -does not hold it, then store the record. Reuse is automatic: there is no flag. A player whose code +seed. `tools/evaluation/evaluate.py`'s `play_and_record` plays a fixture and returns its record; +`evaluate.py` looks a fixture up first and plays it only when the store +does not hold it, then stores the record. Reuse is automatic: there is no flag. A player whose code changed has new fingerprints, so only its matches play again. Layout: one JSON file per fixture, under its environment: `replays/match_results//.json`. diff --git a/utama_core/tests/bundle/test_strategy_file.py b/utama_core/tests/bundle/test_strategy_file.py index 76c4cded..959e98d8 100644 --- a/utama_core/tests/bundle/test_strategy_file.py +++ b/utama_core/tests/bundle/test_strategy_file.py @@ -7,7 +7,7 @@ import pytest -from tools.evaluation import match, round_robin +from tools.evaluation import evaluate, match from utama_core.bundle import archive, host, strategy_file, wire from utama_core.config.enums import Mode from utama_core.engine.abstract_strategy import AbstractStrategy @@ -312,7 +312,7 @@ def test_the_runner_reads_the_same_from_a_bundled_strategy_as_from_the_same_stra def test_a_strategy_file_is_named_like_any_strategy(): - names = round_robin._resolve_config_names(["pendulum", "replays/x@abc.strategy"]) + names = evaluate.resolve_names(["split_shape", "replays/x@abc.strategy"]) # an old name works too assert names == [STRATEGY, "replays/x@abc.strategy"] diff --git a/utama_core/tests/dashboard/test_tournament_view.py b/utama_core/tests/dashboard/test_tournament_view.py index 74074471..f9f1e04d 100644 --- a/utama_core/tests/dashboard/test_tournament_view.py +++ b/utama_core/tests/dashboard/test_tournament_view.py @@ -15,7 +15,7 @@ def _write_run(root, results): def test_each_match_carries_the_path_of_its_replay_when_the_file_exists(tmp_path, monkeypatch): - # round_robin.py names a replay "_vs_.npz"; the dashboard must not guess + # evaluate.py names a replay "_vs_.npz"; the dashboard must not guess # another runner's naming and link to a file that isn't there run = _write_run( tmp_path, diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 581a57c5..341312bc 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -3,20 +3,35 @@ from tools.evaluation import evaluate -def test_round_fixtures_pair_candidate_and_champion_on_the_same_opponents_and_seed(): - fixtures = evaluate.round_fixtures(["c"], "ch", ["o1", "o2"], 1) - assert set(fixtures) == {("c", "o1", 1), ("c", "o2", 1), ("c", "ch", 1), ("ch", "o1", 1), ("ch", "o2", 1)} +def test_round_one_is_every_pair_once_and_later_rounds_only_the_candidates_matches(): + full = evaluate.round_fixtures(1, ["c"], "ref", ["o1", "o2"], full=True) + assert len(full) == 6 and {f[2] for f in full} == {1} + assert ("o1", "o2", 1) in full + later = evaluate.round_fixtures(2, ["c"], "ref", ["o1", "o2"], full=False) + assert set(later) == {("ref", "c", 2), ("o1", "c", 2), ("o2", "c", 2), ("o1", "ref", 2), ("o2", "ref", 2)} -def test_round_fixtures_swap_sides_in_even_rounds(): - assert ("o1", "c", 2) in evaluate.round_fixtures(["c"], "ch", ["o1"], 2) - assert ("ch", "c", 2) in evaluate.round_fixtures(["c"], "ch", ["o1"], 2) +def test_candidate_and_reference_meet_each_opponent_with_the_same_colour(): + for k in (1, 2, 3): + fixtures = evaluate.round_fixtures(k, ["c"], "ref", ["o"], full=k == 1) + c_is_a = ("c", "o", k) in fixtures + assert c_is_a == (k % 2 == 1) + assert (("ref", "o", k) in fixtures) == c_is_a -def test_two_candidates_share_the_champions_fixtures(): - fixtures = evaluate.round_fixtures(["c1", "c2"], "ch", ["o1"], 1) - assert fixtures.count(("ch", "o1", 1)) == 1 - assert ("c1", "c2", 1) not in fixtures +def test_two_candidates_share_the_references_fixtures_and_meet_only_in_round_one(): + later = evaluate.round_fixtures(3, ["c1", "c2"], "ref", ["o1"], full=False) + assert later.count(("ref", "o1", 3)) == 1 + assert not any({"c1", "c2"} == {a, b} for a, b, _ in later) + assert ("c1", "c2", 1) in evaluate.round_fixtures(1, ["c1", "c2"], "ref", ["o1"], full=True) + + +def test_reserve_rotates_two_per_round_and_all_plays_everyone(): + core, reserve = ["a", "b"], ["r1", "r2", "r3"] + assert evaluate.round_players(core, reserve, 1) == ["a", "b", "r1", "r2"] + assert evaluate.round_players(core, reserve, 2) == ["a", "b", "r3", "r1"] + assert evaluate.round_players(core, reserve, 5, everyone=True) == core + reserve + assert evaluate.round_players(core, ["r1"], 1) == ["a", "b", "r1"] # one reserve is not played twice def test_verdict_thresholds_are_inclusive_and_cap_rounds(): @@ -64,11 +79,13 @@ def test_a_verdict_after_round_k_ignores_later_seeds_already_in_the_ledger(): assert list(evaluate._up_to_round(ledger, 1)) == ["1"] -def test_the_reference_opponents_load(): - from tools.evaluation.sim_settings import load_opponents +def test_the_players_load_and_the_core_is_in_the_catalog(): + from tools.evaluation.match import _CONFIG_NAMES + from tools.evaluation.sim_settings import load_players - reference = load_opponents() - assert reference["champion"] and reference["opponents"] and reference["held_out"] + players = load_players() + assert players["champion"] in players["core"] + assert set(players["core"]) <= set(_CONFIG_NAMES) def test_the_reference_world_and_robots_make_one_valid_sim_noise(): @@ -98,14 +115,6 @@ def test_the_reference_sim_does_not_draw_robot_motor_limits(): assert not SimNoise.from_dict(reference_noise()).motion_limits -def test_sim_noise_spec_forms(): - from tools.evaluation.sim_settings import sim_noise_from_spec - - assert sim_noise_from_spec("reference").seed == 0 - assert sim_noise_from_spec("reference:7").seed == 7 - assert sim_noise_from_spec('{"seed": 2, "kick_speed_sd": 0.3}').kick_speed_sd == 0.3 - - FPS = {"c": "fc", "o": "fo", "ch": "fch"} diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py new file mode 100644 index 00000000..0df167a1 --- /dev/null +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -0,0 +1,148 @@ +"""`evaluate.py` end to end with matches, fingerprints and the catalog stubbed: which matches each round +plays, what the match results store saves them from, and what the flags change. + +A player's fingerprint is its name plus a version number, so "editing" a strategy is bumping its +version. `tests/replay/test_match_results.py` covers the store itself. +""" + +from __future__ import annotations + +import json + +import pytest + +from tools.evaluation import evaluate +from tools.evaluation.match import MatchResult +from utama_core.replay import match_results + +CORE = ["a", "b"] +RESERVE = ["r1", "r2", "r3"] + + +class _Graph: + def __init__(self, rig): + self.rig = rig + + def base_fingerprint(self, entries): + return "base" + + def strategy_fingerprint(self, name): + return f"{self.rig.version[name]}-{name}" # version first: the tool keeps 16 characters + + +@pytest.fixture +def rig(tmp_path, monkeypatch): + rig = type("Rig", (), {})() + rig.played, rig.kwargs = [], [] + rig.version = {n: 0 for n in [*CORE, *RESERVE, "c"]} + rig.stats = {} # (a, b) -> stats of that match + rig.on_play = None + + def fake_run_match(a, b, run_dir=None, **kwargs): + rig.played.append((a, b, kwargs["sim_noise"].seed)) + rig.kwargs.append(kwargs) + if rig.on_play is not None: + rig.on_play() + return MatchResult(config_a=a, config_b=b, score_a=1, score_b=0, stats=rig.stats.get((a, b), {"x": 1})) + + players = tmp_path / "players.json" + players.write_text(json.dumps({"champion": "a", "core": CORE})) + monkeypatch.setattr(evaluate, "run_match", fake_run_match) + monkeypatch.setattr(evaluate, "REPLAY_BASE_PATH", tmp_path) + monkeypatch.setattr(evaluate, "CodeGraph", lambda: _Graph(rig)) + monkeypatch.setattr(evaluate, "_CONFIG_NAMES", [*CORE, *RESERVE, "c"]) + + def run(*argv): + rig.played.clear() + rig.kwargs.clear() + evaluate.main(["--players", str(players), "--max-workers", "1", *argv]) + (run_dir,) = sorted(tmp_path.glob("eval_*"))[-1:] + return run_dir + + rig.run = run + rig.store = match_results.open_store(tmp_path) + return rig + + +def test_with_no_candidate_one_round_plays_every_pair_of_the_round_players(rig): + run_dir = rig.run("--compare-with", "a") + + # core a, b; reserve r1, r2 in round 1 (c and r3 wait for another seed); a is also the reference + assert sorted((x, y) for x, y, _ in rig.played) == [ + ("a", "b"), + ("a", "r1"), + ("a", "r2"), + ("b", "r1"), + ("b", "r2"), + ("r1", "r2"), + ] + assert {seed for *_, seed in rig.played} == {1} + summary = json.loads((run_dir / "round_1" / "summary.json").read_text()) + assert len(summary["results"]) == 6 and "strategies" in summary + assert not (run_dir / "round_2").exists() + assert json.loads((run_dir / "report.json").read_text())["candidates"] == {} + + +def test_a_second_run_plays_nothing_and_after_an_edit_only_that_strategys_matches_play(rig): + rig.run("--compare-with", "a") + rig.run("--compare-with", "a") + assert rig.played == [] + + rig.version["r1"] += 1 + rig.run("--compare-with", "a") + assert sorted((x, y) for x, y, _ in rig.played) == [("a", "r1"), ("b", "r1"), ("r1", "r2")] + + +def test_later_rounds_play_only_the_candidates_and_references_matches_with_sides_swapped(rig): + run_dir = rig.run("c", "--compare-with", "a", "--max-rounds", "2") + + round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] + assert round_2 # equal results: undecided after round 1 + assert all("c" in pair or "a" in pair for pair in round_2) + assert ("r3", "c") in round_2 and ("r3", "a") in round_2 # round 2's reserve; c and a are config_b + assert ("a", "c") in round_2 + report = json.loads((run_dir / "report.json").read_text()) + assert report["candidates"]["c"]["verdict"] == "undecided" + assert report["candidates"]["c"]["rounds"] == 2 + + +def test_strict_fails_a_run_with_a_stall_and_reports_it(rig): + rig.stats[("a", "b")] = {"stall_events": [{"kind": "RESTART_STALL", "sim_time": 5.0, "duration_s": 9.0}]} + with pytest.raises(SystemExit, match="1 match"): + rig.run("--compare-with", "a", "--strict") + rig.run("--compare-with", "a") # without --strict the same (now stored) stall only reports + + +def test_fuzzing_reaches_every_match_and_is_its_own_environment(rig): + rig.run("--compare-with", "a") + rig.run("--compare-with", "a", "--fuzz-restarts", "7", "--fuzz-interval", "10", "20") + + assert len(rig.played) == 6 # a fuzzed run reuses no unfuzzed match + assert all(kw["fuzz_seed"] == 7 and kw["fuzz_interval_s"] == (10.0, 20.0) for kw in rig.kwargs) + assert len(list(rig.store.root.iterdir())) == 2 + + +def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): + def edit(): + rig.version["r2"] = 9 + + rig.on_play = edit + rig.run("--compare-with", "a") + + stored = {(r["a"], r["b"]) for r in map(json.loads, map(lambda p: p.read_text(), rig.store.root.rglob("*.json")))} + assert ("a", "b") in stored + assert not any("r2" in pair for pair in stored) + + +def test_at_ref_falls_back_to_the_name_a_strategy_had_at_that_commit(monkeypatch, tmp_path): + built = [] + + def fake_frozen(name, ref, directory): + built.append(name) + if name != "split_shape": + raise ValueError(f"no strategy {name}") + return tmp_path / f"{name}@abc.strategy" + + monkeypatch.setattr(evaluate, "frozen", fake_frozen) + assert evaluate.at_ref("pendulum", "v2.5.0").endswith("split_shape@abc.strategy") + assert built == ["pendulum", "split_shape"] diff --git a/utama_core/tests/engine/test_tournament_summary.py b/utama_core/tests/engine/test_evaluate_signals.py similarity index 93% rename from utama_core/tests/engine/test_tournament_summary.py rename to utama_core/tests/engine/test_evaluate_signals.py index a8d1f822..9369e8cc 100644 --- a/utama_core/tests/engine/test_tournament_summary.py +++ b/utama_core/tests/engine/test_evaluate_signals.py @@ -1,4 +1,4 @@ -from tools.evaluation.round_robin import foul_table, stall_incidents +from tools.evaluation.evaluate import foul_table, stall_incidents from utama_core.analysis.strategy_table import strategy_table @@ -145,12 +145,3 @@ def test_one_deterministic_freeze_against_two_opponents_is_one_incident(): ["overload_flow_vs_low_block"], ] assert incidents[0]["kind"] == "COMMITTED_FROZEN" - - -def test_ratings_table_ranks_by_goal_margin_with_an_sd(): - from tools.evaluation.round_robin import _ratings - - table = _ratings([_result("x", "y", 3, 0), _result("y", "z", 2, 0), _result("x", "z", 4, 1)]) - x, z = table["x"], table["z"] - assert x["strength"] > table["y"]["strength"] > z["strength"] - assert x["sd"] > 0 diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index a9febd46..a38d8248 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -55,7 +55,7 @@ def _referee(score_yellow, score_blue): def _write_match(run_dir, a, b, score_a, score_b, seed=None): """A three-tick match, config_a (yellow, friendly) scoring `score_a`; the team with the ball is - always the friendly one. Written the way `evaluate.py`/`round_robin.py` name their files.""" + always the friendly one. Written the way `evaluate.py` names their files.""" stem = f"{pm.sr.short(a)}_vs_{pm.sr.short(b)}" + ("" if seed is None else f"_s{seed}") path = run_dir / f"{stem}.npz" cfg = ColumnarReplayWriterConfig(replay_name=stem, overwrite_existing=True, checkpoint_every_s=0) diff --git a/utama_core/tests/engine/test_tournament_cli_args.py b/utama_core/tests/engine/test_tournament_cli_args.py deleted file mode 100644 index bbf6b47c..00000000 --- a/utama_core/tests/engine/test_tournament_cli_args.py +++ /dev/null @@ -1,213 +0,0 @@ -"""Tests for `round_robin.py`'s hand-rolled -`--fuzz-restarts`/`--fuzz-interval` CLI parsing (see `docs/STRATEGY_DEVELOPMENT.md`). -`round_robin.py` has no `argparse` — flags are parsed by -scanning `sys.argv` directly inside `main()` — so these tests monkeypatch -`sys.argv` and stub out `run_match` (never actually running a match/simulator) -to check the flags are parsed and threaded through correctly. -""" - -from __future__ import annotations - -import json - -import pytest - -from tools.evaluation import round_robin as tournament - - -class _Graph: - """Stands in for CodeGraph: the store needs only the fingerprints' names.""" - - def base_fingerprint(self, entries): - return "base" - - def strategy_fingerprint(self, name): - return f"fp-{name}" - - -@pytest.fixture(autouse=True) -def _no_real_fingerprints(monkeypatch, tmp_path): - """Every test here runs with a fake CodeGraph and its own replay folder, so the match results - store is written under tmp_path.""" - monkeypatch.setattr(tournament, "CodeGraph", _Graph) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - - -def _stub_result(config_a_name, config_b_name, **_kwargs): - return tournament.MatchResult(config_a=config_a_name, config_b=config_b_name, score_a=1, score_b=0, stats=None) - - -def test_fuzz_restarts_and_interval_parsed_and_passed_to_run_match(tmp_path, monkeypatch): - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **kwargs): - calls.append( - { - "config_a": config_a_name, - "config_b": config_b_name, - "fuzz_seed": kwargs.get("fuzz_seed"), - "fuzz_interval_s": kwargs.get("fuzz_interval_s"), - } - ) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr( - "sys.argv", - [ - "tournament.py", - "--sequential", - "--fuzz-restarts", - "7", - "--fuzz-interval", - "5", - "10", - "pendulum", - "weaver", - ], - ) - - tournament.main() - - assert len(calls) == 1 - assert calls[0]["fuzz_seed"] == 7 - assert calls[0]["fuzz_interval_s"] == (5.0, 10.0) - - # summary.json must record the seed/interval for reproducibility. - run_dirs = list(tmp_path.glob("tournament_*")) - assert len(run_dirs) == 1 - summary = json.loads((run_dirs[0] / "summary.json").read_text()) - assert summary["fuzz_seed"] == 7 - assert summary["fuzz_interval_s"] == [5.0, 10.0] - - -def test_fuzz_restarts_off_by_default(tmp_path, monkeypatch): - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **kwargs): - calls.append({"fuzz_seed": kwargs.get("fuzz_seed"), "fuzz_interval_s": kwargs.get("fuzz_interval_s")}) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr( - "sys.argv", - [ - "tournament.py", - "--sequential", - "pendulum", - "weaver", - ], - ) - - tournament.main() - - assert len(calls) == 1 - assert calls[0]["fuzz_seed"] is None - # Default interval is still threaded through even when fuzzing is off. - assert calls[0]["fuzz_interval_s"] == (25.0, 45.0) - - run_dirs = list(tmp_path.glob("tournament_*")) - summary = json.loads((run_dirs[0] / "summary.json").read_text()) - assert summary["fuzz_seed"] is None - assert summary["fuzz_interval_s"] is None - # The run's matches go to the match results store under REPLAY_BASE_PATH, so a test run never - # writes into the real one. - (path,) = (tmp_path / "match_results").rglob("*.json") - assert json.loads(path.read_text())["source"] == run_dirs[0].name - - -def test_pair_plays_exactly_that_one_pairing_in_the_given_order(tmp_path, monkeypatch): - """`--pair a b` replays one fixture (e.g. to diagnose a stall) with a as config_a, - not the sorted order a round-robin over those two configs would use.""" - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **_kwargs): - calls.append((config_a_name, config_b_name)) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "weaver", "pendulum"]) - - tournament.main() - - assert calls == [("weaver", "pendulum")] - - -def test_help_prints_usage_and_plays_nothing(monkeypatch, capsys): - # `--help` used to be taken for a config name, so it failed instead of listing the flags. - def _no_match(*_args, **_kwargs): - raise AssertionError("--help must not play a match") - - monkeypatch.setattr(tournament, "run_match", _no_match) - for flag in ("--help", "-h"): - monkeypatch.setattr("sys.argv", ["round_robin.py", flag]) - tournament.main() - out = capsys.readouterr().out - assert "--pair A B" in out and "replays/match_results/" in out - - -def test_no_configs_plays_every_pair_in_the_catalog_and_named_configs_play_only_their_pair(tmp_path, monkeypatch): - calls = [] - - def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): - calls.append((config_a_name, config_b_name)) - return _stub_result(config_a_name, config_b_name) - - names = ["a", "b", "c"] - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "_CONFIG_NAMES", names) - - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save"]) - tournament.main() - assert sorted(calls) == [("a", "b"), ("a", "c"), ("b", "c")] - - calls.clear() - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "c"]) - tournament.main() - assert calls == [("a", "c")] - - -def test_sim_noise_parsed_and_passed_to_run_match_and_summary(tmp_path, monkeypatch): - from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise - - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **kwargs): - calls.append(kwargs.get("sim_noise")) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr( - "sys.argv", - [ - "tournament.py", - "--sequential", - "--sim-noise", - '{"seed": 3, "latency_s": [0.05, 0.1], "kick_speed_sd": 0.2}', - "pendulum", - "weaver", - ], - ) - - tournament.main() - - assert calls == [SimNoise(seed=3, latency_s=(0.05, 0.1), kick_speed_sd=0.2)] - (summary_path,) = tmp_path.glob("tournament_*/summary.json") - assert json.loads(summary_path.read_text())["sim_noise"]["seed"] == 3 - - -def test_match_seconds_is_part_of_the_environment_so_each_length_has_its_own_results(tmp_path, monkeypatch): - # A shortened run's matches must not be taken for full-length ones: each match length is its own - # environment in the store, and the length is recorded in the summary. - monkeypatch.setattr(tournament, "run_match", _stub_result) - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "pendulum", "weaver"]) - tournament.main() - (summary_path,) = tmp_path.glob("tournament_*/summary.json") - assert json.loads(summary_path.read_text())["max_match_seconds"] == 300.0 - - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "pendulum", "weaver"]) - tournament.main() - - envs = sorted((tmp_path / "match_results").iterdir()) - assert len(envs) == 2 - assert all(len(list(env.glob("*.json"))) == 1 for env in envs) diff --git a/utama_core/tests/engine/test_tournament_reuse.py b/utama_core/tests/engine/test_tournament_reuse.py deleted file mode 100644 index becbf1da..00000000 --- a/utama_core/tests/engine/test_tournament_reuse.py +++ /dev/null @@ -1,141 +0,0 @@ -"""Round-robin reuse: a match the match results store holds is taken from it, not played. - -Matches, fingerprints and the replay analyses are stubbed: a config's fingerprint is its name -plus a version number, so "editing" a config is bumping its version. `tests/replay/test_fingerprint.py` -covers the real fingerprints and `tests/replay/test_match_results.py` the store. -""" - -from __future__ import annotations - -import json - -import pytest - -from tools.evaluation import round_robin as tournament -from utama_core.replay import match_results - -_CONFIGS = ["weaver", "terrier", "wolfpack"] - - -class _Graph: - """Stands in for CodeGraph: fingerprints follow the rig's versions.""" - - def __init__(self, rig): - self.rig = rig - - def base_fingerprint(self, entries): - return "base" - - def strategy_fingerprint(self, name): - return f"{self.rig.version[name]}-{name}" # version first: the tool keeps 16 characters - - -@pytest.fixture -def rig(tmp_path, monkeypatch): - rig = type("Rig", (), {})() - rig.played = [] - rig.version = {c: 0 for c in _CONFIGS} - rig.score = {} # pair -> score_a, to make a replay disagree with its stored record - rig.on_play = None - - def fake_run_match(a, b, run_dir=None, match_tag_suffix="", **_kwargs): - rig.played.append((a, b)) - if run_dir is not None: - (run_dir / f"{a}_vs_{b}{match_tag_suffix}.npz").write_bytes(b"") - if rig.on_play is not None: - rig.on_play() - return tournament.MatchResult(config_a=a, config_b=b, score_a=rig.score.get((a, b), 1), score_b=0, stats={}) - - def fake_analyse(npz): - return [], {"match": npz.name[: -len(".npz")], "turnovers": []} - - monkeypatch.setattr(tournament, "run_match", fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "CodeGraph", lambda: _Graph(rig)) - monkeypatch.setattr(tournament, "analyse_replay", fake_analyse) - monkeypatch.setattr(tournament, "_print_ball_losses", lambda *a: None) - monkeypatch.setattr(tournament.turnover_breakdown, "breakdown", lambda losses: {}) - monkeypatch.setattr(tournament.turnover_breakdown, "report", lambda *a: "") - monkeypatch.setattr(tournament.turnover_breakdown, "real_loss_kinds", lambda r: {}) - - def run(*flags): - rig.played.clear() - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", *flags, *_CONFIGS]) - tournament.main() - (summary_path,) = sorted(tmp_path.glob("tournament_*/summary.json"))[-1:] - return json.loads(summary_path.read_text()) - - rig.run = run - rig.store = match_results.open_store(tmp_path) - return rig - - -def test_a_second_run_takes_every_stored_match_and_reports_the_same_results(rig): - first = rig.run() - second = rig.run() - - assert rig.played == [] - assert all(r["reused"] for r in second["results"]) - assert not any(r["reused"] for r in first["results"]) - key = lambda r: (r["config_a"], r["config_b"]) # noqa: E731 - strip = lambda rs: sorted(({k: v for k, v in r.items() if k != "reused"} for r in rs), key=key) # noqa: E731 - assert strip(second["results"]) == strip(first["results"]) - assert second["standings"] == first["standings"] - - -def test_after_one_config_changes_only_its_matches_play(rig): - rig.run() - rig.version["weaver"] += 1 - - rig.run() - - assert sorted(rig.played) == [ - ("terrier", "weaver"), - ("weaver", "wolfpack"), - ] - - -def test_a_stored_match_keeps_the_restarts_and_losses_its_replay_gave(rig, monkeypatch): - losses = {"match": "x", "turnovers": [{"kind": "pass"}]} - monkeypatch.setattr(tournament, "analyse_replay", lambda npz: ([], losses)) - rig.run() - rig.played.clear() - - rig.run() - - assert rig.played == [] - stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] - assert len(stored) == 3 and all(r["losses"] == losses and r["restarts"] == [] for r in stored) - - -def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): - # Editing wolfpack during the first match leaves that match's code as it was, so it is stored. - # The two wolfpack matches finish under changed code, so neither is stored. - def edit(): - rig.version["wolfpack"] = 9 - - rig.on_play = edit - - rig.run() - - stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] - assert [(r["a"], r["b"]) for r in stored] == [("terrier", "weaver")] - - -def test_a_no_save_run_plays_and_stores_nothing(rig, monkeypatch): - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", *_CONFIGS]) - tournament.main() - - assert len(rig.played) == 3 - assert not list(rig.store.root.rglob("*.json")) - - -def test_a_run_with_other_match_seconds_plays_every_match_again(rig, monkeypatch): - rig.run() - rig.played.clear() - - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--match-seconds", "300", *_CONFIGS]) - tournament.main() - - assert len(rig.played) == 3 - assert len(list(rig.store.root.iterdir())) == 2 # one environment per match length diff --git a/utama_core/tests/engine/test_tournament_vs_champion.py b/utama_core/tests/engine/test_tournament_vs_champion.py deleted file mode 100644 index 271e1001..00000000 --- a/utama_core/tests/engine/test_tournament_vs_champion.py +++ /dev/null @@ -1,119 +0,0 @@ -"""Tests for `round_robin.py --vs-champion`: the day-to-day health check, one match per active -strategy against the champion (see `docs/STRATEGY_DEVELOPMENT.md`). Pure, no sim: `run_match` is -stubbed and the catalog, retired set and opponents file are faked. -""" - -from __future__ import annotations - -import json - -import pytest - -from tools.evaluation import round_robin as tournament -from tools.evaluation.sim_settings import sim_noise_from_spec - - -class _Graph: - """Stands in for CodeGraph: the config names here are not strategies.""" - - def base_fingerprint(self, entries): - return "base" - - def strategy_fingerprint(self, name): - return f"fp-{name}" - - -@pytest.fixture(autouse=True) -def _no_real_fingerprints(monkeypatch): - monkeypatch.setattr(tournament, "CodeGraph", _Graph) - - -def _stub_result(config_a_name, config_b_name, **_kwargs): - return tournament.MatchResult(config_a=config_a_name, config_b=config_b_name, score_a=1, score_b=0, stats=None) - - -def test_vs_champion_pairs_is_every_other_config_against_the_champion_then_champion_vs_first_opponent(): - names = ["b", "champ", "a", "d"] - - assert tournament.vs_champion_pairs(names, "champ", "a") == [ - ("a", "champ"), - ("b", "champ"), - ("d", "champ"), - ("champ", "a"), - ] - - -def test_vs_champion_pairs_plays_the_champion_only_as_config_b_except_its_own_match(): - pairs = tournament.vs_champion_pairs(["a", "b", "champ"], "champ", "b") - - assert [a for a, b in pairs if a == "champ"] == ["champ"] - assert all(b == "champ" for a, b in pairs if a != "champ") - - -def test_vs_champion_pairs_refuses_a_missing_champion_or_first_opponent(): - with pytest.raises(ValueError, match="champion"): - tournament.vs_champion_pairs(["a", "b"], "champ", "a") - with pytest.raises(ValueError, match="first opponent"): - tournament.vs_champion_pairs(["a", "champ"], "champ", "b") - - -def test_vs_champion_plays_active_strategies_against_champion_with_reference_seed_one(tmp_path, monkeypatch, capsys): - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **kwargs): - calls.append((config_a_name, config_b_name, kwargs.get("sim_noise"))) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "b", "champ"]) - monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a", "b"]}) - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--vs-champion"]) - - tournament.main() - - seeded = sim_noise_from_spec("reference:2") - assert calls == [("a", "champ", seeded), ("b", "champ", seeded), ("champ", "a", seeded)] - assert "reference:2" in capsys.readouterr().out - # Same conditions as evaluate.py's round-2 champion fixtures, so the store keeps these matches as those fixtures. - stored = [json.loads(p.read_text()) for p in (tmp_path / "match_results").rglob("*.json")] - assert len(stored) == 3 and {r["seed"] for r in stored} == {2} - # Output still lands in replays/tournament_, which downstream tools read. - assert list(tmp_path.glob("tournament_*/summary.json")) - - -def test_noise_is_not_defaulted_outside_vs_champion_and_an_explicit_spec_wins(tmp_path, monkeypatch): - calls = [] - - def _fake_run_match(config_a_name, config_b_name, **kwargs): - calls.append(kwargs.get("sim_noise")) - return _stub_result(config_a_name, config_b_name) - - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "champ"]) - monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a"]}) - - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", "a", "champ"]) - tournament.main() - assert calls == [None] - - calls.clear() - monkeypatch.setattr( - "sys.argv", - ["round_robin.py", "--sequential", "--vs-champion", "--sim-noise", "reference:7"], - ) - tournament.main() - assert calls == [sim_noise_from_spec("reference:7"), sim_noise_from_spec("reference:7")] - - -def test_vs_champion_with_pair_is_an_error_and_plays_nothing(tmp_path, monkeypatch): - def _no_match(*_args, **_kwargs): - raise AssertionError("--vs-champion with --pair must not play a match") - - monkeypatch.setattr(tournament, "run_match", _no_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--vs-champion", "--pair", "a", "b"]) - - with pytest.raises(SystemExit, match="--vs-champion and --pair"): - tournament.main() From 89cd19b47999e8c6d3aa8192db2bb19fabd2cea8 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 17:23:36 +0000 Subject: [PATCH 21/59] tools: evaluate.py plays the core only; the reserve joins with --all The verdict compares candidate and reference against the same opponents, so it needs no reserve rotation; the wider field is an occasional --all run. Round 1 is 15 matches (five core and the reference), a later round 9 per candidate. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 4 +-- docs/STRATEGY_DEVELOPMENT.md | 12 +++---- docs/strategies.md | 8 ++--- docs/strategy_tools_plan.md | 4 +-- docs/tools.md | 4 +-- tools/evaluation/evaluate.py | 20 ++++------- tools/evaluation/reference/players.json | 2 +- utama_core/tests/engine/test_evaluate.py | 8 ----- utama_core/tests/engine/test_evaluate_run.py | 36 +++++++++----------- 9 files changed, 40 insertions(+), 58 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 966b8fc6..a58463da 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,8 +32,8 @@ One term per thing; reuse these instead of coining new ones. every signal, in `replays/eval_/round_1/summary.json`. Older runs of the deleted `round_robin.py` are `replays/tournament_/`. W-D-L there is a signal, never a verdict: there are no standings. - **Core / reserve strategies** — the core (`tools/evaluation/reference/players.json`) plays every - round; every other strategy in the catalog is reserve, two rotated in per round by its seed (`--all` - plays them all), for a diverse field without playing twelve every time. + round; every other strategy in the catalog is reserve and plays only in an occasional `--all` run, + for a wider field. The verdict needs only fixed opponents, the same for candidate and reference. - **Motion planning benchmark** — `tools/motion_planning_benchmark.py`: the planner alone on fixed scenarios. Unrelated to any strategy. - **Moment / regression moment** — a field state (captured from a replay) that reproduced a diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index f4d5221d..c9bc4b91 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -264,7 +264,7 @@ goals, under the realistic sim noise? ```mermaid flowchart TD - p["Players: core (reference/players.json) + 2 reserve rotated by seed
+ the reference: the champion at the last release, a .strategy file"] + p["Players: core (reference/players.json); --all: every strategy
+ the reference: the champion at the last release, a .strategy file"] r1["Round 1, noise seed 1: every pair once, candidates included
signals and stalls of every player"] rk["Round k, seed k: only undecided candidates'
matches, and the reference's against the same opponents"] st["Every match stored in the match results
replays/match_results/"] @@ -282,9 +282,8 @@ flowchart TD ``` - **Players** (`tools/evaluation/reference/players.json`): the champion and the core strategies, - which play every round. Every other strategy in the catalog is reserve: two play each round, rotated - by the round's seed, so the field stays diverse without twelve strategies every round (`--all` - plays them all). The simulated world and robots are `world.json` and `robots.json` in the same + which play every round. Every other strategy in the catalog is reserve and plays only with `--all`, + an occasional run for a wider field (for example before a release). The simulated world and robots are `world.json` and `robots.json` in the same folder (`sim_settings.py` loads them). - **The reference** is the champion as it was at the latest release tag (`--at REF` for another commit), played from a `.strategy` file built once into `replays/eval/frozen/`. A change to shared @@ -324,8 +323,9 @@ flowchart TD from the store have no replay, so the pictures cover only what was played. Example (`explain.py replays/eval_/round_1 pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) -- **Cost.** Round 1 with nothing stored is 28 matches (8 players) of up to 1200 s, roughly 30-40 min on - 12 workers; a later round is about 2 x 7 matches per candidate. A clearly worse candidate is decided +- **Cost.** Round 1 with nothing stored is 15 matches (the five core and the reference, every pair once) + of up to 1200 s, roughly 20 min on 12 workers; a later round is 9 matches per candidate (candidate + vs reference, and each against the four other core strategies). `--all` makes round 1 66 matches. A clearly worse candidate is decided after 1-2 rounds. ### Strategy branches diff --git a/docs/strategies.md b/docs/strategies.md index 1ca57c6d..5b00c64b 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -5,8 +5,8 @@ is core or reserve, and the latest results. Run: -- `pixi run python tools/evaluation/evaluate.py` — one round robin of the core, two reserve and the - champion at the last release: stalls and signals (`--all` plays every strategy). +- `pixi run python tools/evaluation/evaluate.py` — one round robin of the core and the champion + at the last release: stalls and signals (`--all` plays every strategy). - `pixi run python tools/evaluation/evaluate.py ` — judges a candidate against the champion at the last release. The way to judge a strategy. `--help` lists the flags. - `pixi run python tools/debug_match.py --strategy
--opponent [--dump-ticks PATH]` — one @@ -15,8 +15,8 @@ Run: rsim is deterministic: re-running an identical match gives an identical result. Variance comes from the seeded sim noise: `evaluate.py`'s round k plays with seed k. -**The catalog.** Core strategies play every round of `evaluate.py`; reserve ones rotate in, two per -round (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results +**The catalog.** Core strategies play every round of `evaluate.py`; reserve ones play only with +`--all` (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results below were played under the old names (column "Was"), which `catalog.RENAMED` still loads. | Strategy | Was | Role | Description | diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 08c9bf67..84787b38 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -26,7 +26,7 @@ links back here. |---|---|---| | Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with how many matches checked them; `--strict` fails on one | Today | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`: paired against the champion at the last release. The only verdict | Today | -| Does everything still run, after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core, two reserve and the reference (28 matches), with stalls and signals. `--all` plays every strategy, occasionally | Today | +| Does everything still run, after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches), with stalls and signals. `--all` plays every strategy, occasionally | Today | | What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py` (`--fouls` for our side's fouls), then the picture tools. find_bugs finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal sources (`utama_core/analysis/goal_sources.py`) | Today | | Keep a fixed bug fixed? | A unit test at the cause. For restart and placement geometry, a regression moment, which is already part of `pixi run test`. `tools/moments.py` writes new ones | Today | | Look closely at one thing? | `tools/repro_from_replay.py`, the picture tools, `tools/debug_match.py` | Today | @@ -66,7 +66,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: stall watchdog covers config_a only, so coverage is partial. A match whose stats were not collected counts as **unknown, not clean**. 4. **One tool for matches.** Done 2026-11-12: `round_robin.py` merged into `evaluate.py`. Round 1 is - a round robin of the core strategies, two reserve rotated by seed and the reference (the champion at + a round robin of the core strategies and the reference (the champion at the last release, a `.strategy` file); later rounds play only undecided candidates. No held-out opponents, no `--vs-champion`, no standings. The strategies were renamed the same day (`catalog.RENAMED`). diff --git a/docs/tools.md b/docs/tools.md index 60a53b4b..97c0e5d0 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -13,7 +13,7 @@ says why the tools are split this way. |---|---| | Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` reports them with how many matches checked them | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion at the last release. The only verdict | -| Does everything still run after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core, two reserve and the reference (28 matches); `--all` for the whole catalog, occasionally | +| Does everything still run after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches); `--all` for the whole catalog, occasionally | | What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | @@ -48,7 +48,7 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies, two reserve rotated by seed (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, later rounds play only the undecided candidates' matches until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, later rounds play only the undecided candidates' matches until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 56261112..9a974504 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -11,7 +11,8 @@ release tag), played from a `.strategy` file built once into replays/eval/frozen/ --compare-with NAME the reference is NAME instead (a strategy in the working tree, or a .strategy file): a new version against the one it changes - --all every strategy in the catalog plays, not only the core and two reserve + --all every strategy in the catalog plays, not only the core (occasionally, for a + wider field) --max-rounds N rounds before a candidate is called undecided (default 6) --max-workers N matches at once (default 12; 1 plays in this process) --strict exit non-zero if any match of the run stalled @@ -24,8 +25,8 @@ Players ------- `reference/players.json` names the champion and the core strategies, which play every round. Every -other strategy in the catalog is reserve: two of them play each round, rotated by the round's seed -(diversity without playing all twelve every time); `--all` plays them all. The reference (the champion +other strategy in the catalog is reserve: it plays only with `--all`, an occasional run for a wider +field (the verdict needs only fixed opponents, the same for candidate and reference). The reference (the champion at the last release) plays every round too. It is a frozen file, so a change to shared code moves the candidates and the working-tree strategies, never the reference. @@ -112,7 +113,6 @@ PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 -RESERVE_PER_ROUND = 2 FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results # A full match: two halves of 300 s of playing time, the clock stopped whenever no team may play the # ball, about 710-870 s of sim time. This only caps a match that can't reach full time. @@ -122,14 +122,6 @@ # --- who plays what --------------------------------------------------------------------------- -def round_players(core: list[str], reserve: list[str], k: int, everyone: bool = False) -> list[str]: - """The strategies of round `k`: the core, and `RESERVE_PER_ROUND` reserve rotated by `k`.""" - if everyone or not reserve: - return [*core, *reserve] - picks = [reserve[(RESERVE_PER_ROUND * (k - 1) + i) % len(reserve)] for i in range(RESERVE_PER_ROUND)] - return list(dict.fromkeys([*core, *picks])) - - def round_fixtures( k: int, candidates: list[str], reference: str, opponents: list[str], full: bool ) -> list[tuple[str, str, int]]: @@ -268,7 +260,7 @@ def main(argv: Optional[list[str]] = None) -> None: raise SystemExit("--at and --compare-with both choose the reference: give one") setup = load_players(args.players) if args.players else load_players() core = resolve_names(setup["core"]) - reserve = [n for n in _CONFIG_NAMES if n not in core] + reserve = [n for n in _CONFIG_NAMES if n not in core] if args.all else [] if args.compare_with: reference = resolve_names([args.compare_with])[0] else: @@ -321,7 +313,7 @@ def still_current(a: str, b: str) -> bool: for k in range(1, args.max_rounds + 1): if k > 1 and not open_: break - opponents = [p for p in round_players(core, reserve, k, args.all) if p not in candidates and p != reference] + opponents = [p for p in [*core, *reserve] if p not in candidates and p != reference] opponents_so_far |= set(opponents) fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents, full=k == 1) round_dir = run_dir / f"round_{k}" diff --git a/tools/evaluation/reference/players.json b/tools/evaluation/reference/players.json index cecffaac..aa4d4bf3 100644 --- a/tools/evaluation/reference/players.json +++ b/tools/evaluation/reference/players.json @@ -1,5 +1,5 @@ { - "note": "evaluate.py's players. The champion is the reference at the last release: promote a strategy by changing this line in a PR. The core plays every round; every other strategy in the catalog is reserve, two rotated in per round. Core chosen 2026-11-12 to cover every tactic the strategies use.", + "note": "evaluate.py's players. The champion is the reference at the last release: promote a strategy by changing this line in a PR. The core plays every round; every other strategy in the catalog is reserve, played only with --all. Core chosen 2026-11-12 to cover every tactic the strategies use.", "champion": "pendulum", "core": ["pendulum", "breakwater", "avalanche", "mirage", "wolfpack"] } diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 341312bc..6e618da7 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -26,14 +26,6 @@ def test_two_candidates_share_the_references_fixtures_and_meet_only_in_round_one assert ("c1", "c2", 1) in evaluate.round_fixtures(1, ["c1", "c2"], "ref", ["o1"], full=True) -def test_reserve_rotates_two_per_round_and_all_plays_everyone(): - core, reserve = ["a", "b"], ["r1", "r2", "r3"] - assert evaluate.round_players(core, reserve, 1) == ["a", "b", "r1", "r2"] - assert evaluate.round_players(core, reserve, 2) == ["a", "b", "r3", "r1"] - assert evaluate.round_players(core, reserve, 5, everyone=True) == core + reserve - assert evaluate.round_players(core, ["r1"], 1) == ["a", "b", "r1"] # one reserve is not played twice - - def test_verdict_thresholds_are_inclusive_and_cap_rounds(): assert evaluate.verdict(evaluate.PROMOTE, 1, 6) == "better" assert evaluate.verdict(evaluate.DROP, 1, 6) == "worse" diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index 0df167a1..e288d3e7 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -15,7 +15,7 @@ from tools.evaluation.match import MatchResult from utama_core.replay import match_results -CORE = ["a", "b"] +CORE = ["a", "b", "d"] RESERVE = ["r1", "r2", "r3"] @@ -64,33 +64,31 @@ def run(*argv): return rig -def test_with_no_candidate_one_round_plays_every_pair_of_the_round_players(rig): +def test_with_no_candidate_one_round_plays_every_pair_of_the_core(rig): run_dir = rig.run("--compare-with", "a") - # core a, b; reserve r1, r2 in round 1 (c and r3 wait for another seed); a is also the reference - assert sorted((x, y) for x, y, _ in rig.played) == [ - ("a", "b"), - ("a", "r1"), - ("a", "r2"), - ("b", "r1"), - ("b", "r2"), - ("r1", "r2"), - ] + # the core a, b, d; a is also the reference; the reserve r1, r2, r3 and c play only with --all + assert sorted((x, y) for x, y, _ in rig.played) == [("a", "b"), ("a", "d"), ("b", "d")] assert {seed for *_, seed in rig.played} == {1} summary = json.loads((run_dir / "round_1" / "summary.json").read_text()) - assert len(summary["results"]) == 6 and "strategies" in summary + assert len(summary["results"]) == 3 and "strategies" in summary assert not (run_dir / "round_2").exists() assert json.loads((run_dir / "report.json").read_text())["candidates"] == {} +def test_all_adds_every_other_strategy_in_the_catalog(rig): + rig.run("--compare-with", "a", "--all") + assert len(rig.played) == 7 * 6 // 2 # a, b, d, r1, r2, r3, c: every pair once + + def test_a_second_run_plays_nothing_and_after_an_edit_only_that_strategys_matches_play(rig): rig.run("--compare-with", "a") rig.run("--compare-with", "a") assert rig.played == [] - rig.version["r1"] += 1 + rig.version["d"] += 1 rig.run("--compare-with", "a") - assert sorted((x, y) for x, y, _ in rig.played) == [("a", "r1"), ("b", "r1"), ("r1", "r2")] + assert sorted((x, y) for x, y, _ in rig.played) == [("a", "d"), ("b", "d")] def test_later_rounds_play_only_the_candidates_and_references_matches_with_sides_swapped(rig): @@ -99,8 +97,8 @@ def test_later_rounds_play_only_the_candidates_and_references_matches_with_sides round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] assert round_2 # equal results: undecided after round 1 assert all("c" in pair or "a" in pair for pair in round_2) - assert ("r3", "c") in round_2 and ("r3", "a") in round_2 # round 2's reserve; c and a are config_b - assert ("a", "c") in round_2 + # each opponent against both c and a, now as config_a; opponents never meet each other again + assert sorted(round_2) == [("a", "c"), ("b", "a"), ("b", "c"), ("d", "a"), ("d", "c")] report = json.loads((run_dir / "report.json").read_text()) assert report["candidates"]["c"]["verdict"] == "undecided" assert report["candidates"]["c"]["rounds"] == 2 @@ -117,21 +115,21 @@ def test_fuzzing_reaches_every_match_and_is_its_own_environment(rig): rig.run("--compare-with", "a") rig.run("--compare-with", "a", "--fuzz-restarts", "7", "--fuzz-interval", "10", "20") - assert len(rig.played) == 6 # a fuzzed run reuses no unfuzzed match + assert len(rig.played) == 3 # a fuzzed run reuses no unfuzzed match assert all(kw["fuzz_seed"] == 7 and kw["fuzz_interval_s"] == (10.0, 20.0) for kw in rig.kwargs) assert len(list(rig.store.root.iterdir())) == 2 def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): def edit(): - rig.version["r2"] = 9 + rig.version["d"] = 9 rig.on_play = edit rig.run("--compare-with", "a") stored = {(r["a"], r["b"]) for r in map(json.loads, map(lambda p: p.read_text(), rig.store.root.rglob("*.json")))} assert ("a", "b") in stored - assert not any("r2" in pair for pair in stored) + assert not any("d" in pair for pair in stored) def test_at_ref_falls_back_to_the_name_a_strategy_had_at_that_commit(monkeypatch, tmp_path): From ce7145a77ec75efa15978ce4afec2c11c0440cb9 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 17:27:46 +0000 Subject: [PATCH 22/59] tools: every evaluate.py round is the same round robin The match results store already skips every match whose code is unchanged, so a later round that plays only the candidates' matches saved nothing once the store is warm: it was one more rule to explain. Every round now plays every pair once under its seed; only the undecided candidates stay after round 1. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 4 +-- docs/STRATEGY_DEVELOPMENT.md | 27 ++++++++------- docs/strategy_tools_plan.md | 8 ++--- docs/tools.md | 2 +- tools/evaluation/evaluate.py | 36 +++++++------------- utama_core/tests/engine/test_evaluate.py | 22 +++++------- utama_core/tests/engine/test_evaluate_run.py | 13 +++---- 7 files changed, 49 insertions(+), 63 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index a58463da..7cf3a438 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -54,8 +54,8 @@ One term per thing; reuse these instead of coining new ones. - **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate stronger than the reference, the champion at the last release (`--at REF`, or `--compare-with NAME`)? Round k plays under sim-noise seed k in the simulated world and robots - (`tools/evaluation/reference/world.json`, `robots.json`): round 1 a round robin, later rounds only the - undecided candidates' matches, decided on paired results (candidate and reference against the same + (`tools/evaluation/reference/world.json`, `robots.json`): every round the same round robin, repeated + while a candidate is undecided, decided on paired results (candidate and reference against the same opponent under the same noise, `analysis/ratings.py`) and stopping once the answer is clear. Every match goes to the match results store (`replays/match_results/`, `replay/match_results.py`); a match the store holds is never played again. Promoting is a one-line change to `players.json` in a PR. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index c9bc4b91..b539e76a 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -265,19 +265,19 @@ goals, under the realistic sim noise? ```mermaid flowchart TD p["Players: core (reference/players.json); --all: every strategy
+ the reference: the champion at the last release, a .strategy file"] - r1["Round 1, noise seed 1: every pair once, candidates included
signals and stalls of every player"] - rk["Round k, seed k: only undecided candidates'
matches, and the reference's against the same opponents"] + r1["Round k, noise seed k: every pair once
(only the undecided candidates stay after round 1)"] + st0{"in the match results?"} st["Every match stored in the match results
replays/match_results/"] d{"P(candidate stronger), paired
with the reference's results"} b["better: P >= 0.99
promote by hand in players.json"] w["worse: P <= 0.2
drop it"] u["undecided after 6 rounds
drop it"] - p --> r1 --> d - r1 -.-> st - rk -.-> st + p --> r1 --> st0 + st0 -- "yes: reuse" --> d + st0 -- "no: play, then store" --> st --> d d -- "P >= 0.99" --> b d -- "P <= 0.2" --> w - d -- "neither, rounds left" --> rk --> d + d -- "neither, rounds left: k + 1" --> r1 d -- "neither, no rounds left" --> u ``` @@ -292,9 +292,10 @@ flowchart TD referee and simulator are today's for both sides. An older commit may know the champion by its old name (`catalog.RENAMED`); that is found. `--compare-with NAME` compares against NAME instead: a new version against the one it changes. -- **Rounds.** Round k plays with noise seed k. Round 1 plays every pair of players once. Later rounds - play only the undecided candidates: each against the reference and the round's opponents, and the - reference against the same opponents. The candidate (then the reference) is config_a in odd rounds +- **Rounds.** Every round is the same round robin, every pair of players once, under noise seed k; + after round 1 only the undecided candidates stay. The match results store makes it cheap: a match + whose code is unchanged is never played again, so a run plays only the matches of edited strategies + (and of a seed never played before). The candidate (then the reference) is config_a in odd rounds and config_b in even ones, so both meet each opponent in the same colour under the same noise (the noise is drawn per colour and robot, so one seed can favour a colour by half a goal). - **The decision** (`ratings.paired_difference`): the candidate's goal difference against each @@ -323,10 +324,10 @@ flowchart TD from the store have no replay, so the pictures cover only what was played. Example (`explain.py replays/eval_/round_1 pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) -- **Cost.** Round 1 with nothing stored is 15 matches (the five core and the reference, every pair once) - of up to 1200 s, roughly 20 min on 12 workers; a later round is 9 matches per candidate (candidate - vs reference, and each against the four other core strategies). `--all` makes round 1 66 matches. A clearly worse candidate is decided - after 1-2 rounds. +- **Cost.** A round is 15 matches (five core and the reference, plus one per extra candidate pair) of + up to 1200 s, roughly 20 min on 12 workers, when nothing is stored. Once stored, editing one strategy + replays only its 5 matches per round; a change to shared code replays everything. `--all` makes a + round 66 matches. A clearly worse candidate is decided after 1-2 rounds. ### Strategy branches diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 84787b38..367a69b3 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -34,9 +34,9 @@ links back here. Notes on the table: -- One tool plays matches: `evaluate.py`. Its round 1 is a round robin, which answers "is the - catalog healthy?" (stalls, signals); its later rounds answer "is this candidate stronger than the - champion at the last release?". The verdict is goals; nothing else ranks. +- One tool plays matches: `evaluate.py`. Each round is a round robin under a new noise seed; the + first answers "is the catalog healthy?" (stalls, signals), and rounds continue until "is this + candidate stronger than the champion at the last release?" is clear. The verdict is goals; nothing else ranks. - "Look closely" tools explain a result. They never judge one. ## The screen (dropped) @@ -67,7 +67,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: collected counts as **unknown, not clean**. 4. **One tool for matches.** Done 2026-11-12: `round_robin.py` merged into `evaluate.py`. Round 1 is a round robin of the core strategies and the reference (the champion at - the last release, a `.strategy` file); later rounds play only undecided candidates. No held-out + the last release, a `.strategy` file); later rounds repeat it under new seeds while a candidate is undecided. No held-out opponents, no `--vs-champion`, no standings. The strategies were renamed the same day (`catalog.RENAMED`). 5. **One shared match and runner construction** for every tool. `tools/sim_setup.py` has `load_side` (a diff --git a/docs/tools.md b/docs/tools.md index 97c0e5d0..0f1adb18 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -48,7 +48,7 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, later rounds play only the undecided candidates' matches until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 9a974504..890f7c1f 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -33,9 +33,10 @@ Rounds ------ Round k plays under sim-noise seed k (the reference world and robots, reference/world.json and -robots.json). Round 1 plays every pair of players once, candidates included. Later rounds play only the -undecided candidates' matches: each against the reference and the round's opponents, and the reference -against those opponents. In every match the candidate (then the reference) is config_a in odd rounds and +robots.json). Every round is the same round robin: every pair of players once, under seed k. Only the +candidates still undecided stay in later rounds. Nothing is played twice: the match results store holds +every match whose code is unchanged, so a run plays only the matches of edited strategies, and of a +seed not played before. In every match the candidate (then the reference) is config_a in odd rounds and config_b in even ones, so a candidate and the reference meet each opponent with the same colour and noise. Matches are 1200 s of sim time at most (two 300 s halves of playing time, `MAX_MATCH_SECONDS`). @@ -122,26 +123,15 @@ # --- who plays what --------------------------------------------------------------------------- -def round_fixtures( - k: int, candidates: list[str], reference: str, opponents: list[str], full: bool -) -> list[tuple[str, str, int]]: - """Round `k`'s (config_a, config_b, seed). `full`: every pair of candidates, reference and - opponents; otherwise each candidate against the reference and every opponent, and the reference - against every opponent. The earlier of the two in (candidates, reference, opponents) order is - config_a in odd rounds, so candidates and reference face each opponent with the same colour.""" +def round_fixtures(k: int, candidates: list[str], reference: str, opponents: list[str]) -> list[tuple[str, str, int]]: + """Round `k`'s (config_a, config_b, seed): every pair of candidates, reference and opponents once. + The store holds every match whose code is unchanged, so only the matches of edited strategies, or + of a seed not played before, are actually played. The earlier of the two in (candidates, + reference, opponents) order is config_a in odd rounds, so candidates and reference face each + opponent with the same colour.""" order = list(dict.fromkeys([*candidates, reference, *opponents])) - rank = {n: i for i, n in enumerate(order)} - if full: - pairs = list(itertools.combinations(order, 2)) - else: - pairs = [(c, o) for c in candidates for o in [reference, *opponents]] + [(reference, o) for o in opponents] - out = [] - for x, y in pairs: - if x == y: - continue - first, second = sorted((x, y), key=rank.__getitem__) - out.append((first, second, k) if k % 2 else (second, first, k)) - return list(dict.fromkeys(out)) + pairs = itertools.combinations(order, 2) + return [(x, y, k) if k % 2 else (y, x, k) for x, y in pairs] def verdict(p_better: float, rounds: int, max_rounds: int) -> Optional[str]: @@ -315,7 +305,7 @@ def still_current(a: str, b: str) -> bool: break opponents = [p for p in [*core, *reserve] if p not in candidates and p != reference] opponents_so_far |= set(opponents) - fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents, full=k == 1) + fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents) round_dir = run_dir / f"round_{k}" round_dir.mkdir(parents=True, exist_ok=True) recs: dict[tuple[str, str], tuple[dict, bool]] = {} diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 6e618da7..0ac18196 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -3,29 +3,23 @@ from tools.evaluation import evaluate -def test_round_one_is_every_pair_once_and_later_rounds_only_the_candidates_matches(): - full = evaluate.round_fixtures(1, ["c"], "ref", ["o1", "o2"], full=True) - assert len(full) == 6 and {f[2] for f in full} == {1} - assert ("o1", "o2", 1) in full - later = evaluate.round_fixtures(2, ["c"], "ref", ["o1", "o2"], full=False) - assert set(later) == {("ref", "c", 2), ("o1", "c", 2), ("o2", "c", 2), ("o1", "ref", 2), ("o2", "ref", 2)} +def test_every_round_is_every_pair_once_under_its_seed(): + for k in (1, 2): + fixtures = evaluate.round_fixtures(k, ["c"], "ref", ["o1", "o2"]) + assert len(fixtures) == 6 and {f[2] for f in fixtures} == {k} + assert {frozenset(f[:2]) for f in fixtures} == { + frozenset(p) for p in [("c", "ref"), ("c", "o1"), ("c", "o2"), ("ref", "o1"), ("ref", "o2"), ("o1", "o2")] + } def test_candidate_and_reference_meet_each_opponent_with_the_same_colour(): for k in (1, 2, 3): - fixtures = evaluate.round_fixtures(k, ["c"], "ref", ["o"], full=k == 1) + fixtures = evaluate.round_fixtures(k, ["c"], "ref", ["o"]) c_is_a = ("c", "o", k) in fixtures assert c_is_a == (k % 2 == 1) assert (("ref", "o", k) in fixtures) == c_is_a -def test_two_candidates_share_the_references_fixtures_and_meet_only_in_round_one(): - later = evaluate.round_fixtures(3, ["c1", "c2"], "ref", ["o1"], full=False) - assert later.count(("ref", "o1", 3)) == 1 - assert not any({"c1", "c2"} == {a, b} for a, b, _ in later) - assert ("c1", "c2", 1) in evaluate.round_fixtures(1, ["c1", "c2"], "ref", ["o1"], full=True) - - def test_verdict_thresholds_are_inclusive_and_cap_rounds(): assert evaluate.verdict(evaluate.PROMOTE, 1, 6) == "better" assert evaluate.verdict(evaluate.DROP, 1, 6) == "worse" diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index e288d3e7..46faa313 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -91,14 +91,15 @@ def test_a_second_run_plays_nothing_and_after_an_edit_only_that_strategys_matche assert sorted((x, y) for x, y, _ in rig.played) == [("a", "d"), ("b", "d")] -def test_later_rounds_play_only_the_candidates_and_references_matches_with_sides_swapped(rig): +def test_a_later_round_is_the_same_round_robin_under_the_next_seed_with_colours_swapped(rig): run_dir = rig.run("c", "--compare-with", "a", "--max-rounds", "2") - round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] - assert round_2 # equal results: undecided after round 1 - assert all("c" in pair or "a" in pair for pair in round_2) - # each opponent against both c and a, now as config_a; opponents never meet each other again - assert sorted(round_2) == [("a", "c"), ("b", "a"), ("b", "c"), ("d", "a"), ("d", "c")] + round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] # equal results: undecided after round 1 + assert sorted(round_2) == [("a", "c"), ("b", "a"), ("b", "c"), ("d", "a"), ("d", "b"), ("d", "c")] + + rig.version["c"] += 1 # edit the candidate: only its matches play again, in both rounds + rig.run("c", "--compare-with", "a", "--max-rounds", "2") + assert all("c" in (x, y) for x, y, _ in rig.played) and len(rig.played) == 6 report = json.loads((run_dir / "report.json").read_text()) assert report["candidates"]["c"]["verdict"] == "undecided" assert report["candidates"]["c"]["rounds"] == 2 From 2278fca5a78d4111cca1e934903dc12499699b76 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 17:44:04 +0000 Subject: [PATCH 23/59] tools: evaluate.py keeps three flags: candidates, --at, --all With every round the same round robin and the store choosing what plays, the rest had no job: --compare-with (a second way to pick the reference), --max-rounds (fixed at 6), --max-workers (CPUs - 1, at most 12), --strict (no CI used it; the report lists every stall), --fuzz-restarts/--fuzz-interval (referee bug hunting, not evaluation; the fuzzer stays in sim_setup), --control-scheme (planners are compared by motion_planning_benchmark), and --explain (explain.py runs on any run dir). Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 6 +- docs/STRATEGY_DEVELOPMENT.md | 19 +++-- docs/custom_referee.md | 4 +- docs/strategy_tools_plan.md | 2 +- docs/tools.md | 4 +- docs/visual_guide.md | 10 ++- tools/evaluation/evaluate.py | 76 ++++---------------- utama_core/tests/engine/test_evaluate_run.py | 40 ++++------- utama_core/tests/engine/test_explain.py | 17 +---- 9 files changed, 50 insertions(+), 128 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 7cf3a438..4c09c0f1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -45,15 +45,15 @@ One term per thing; reuse these instead of coining new ones. box, danger: defined once, with a diagram, in `docs/pitch_zones.md`. Use those names. - **Catch rate** — a diagnostic (share of reachable passes received), never a gate (±4–8 pts between runs). - **Position map / shot map** — on-pitch pictures of a strategy over many matches, drawn by - `tools/pitch_maps.py` (and `evaluate.py --explain` for a candidate against the champion), always + `tools/pitch_maps.py` (and `tools/evaluation/explain.py` for a candidate against the champion), always turned so the strategy attacks right. Position map: a heatmap of where the outfield robots stand in live play, with the ball and without it, plus each robot's mean position. Shot map: every shot at the spot it was struck from, own and conceded. They explain how a strategy plays; never a ranking. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. - **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate - stronger than the reference, the champion at the last release (`--at REF`, or `--compare-with - NAME`)? Round k plays under sim-noise seed k in the simulated world and robots + stronger than the reference, the champion at the last release (`--at REF` for another + release)? Round k plays under sim-noise seed k in the simulated world and robots (`tools/evaluation/reference/world.json`, `robots.json`): every round the same round robin, repeated while a candidate is undecided, decided on paired results (candidate and reference against the same opponent under the same noise, `analysis/ratings.py`) and stopping once the answer is clear. Every diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index b539e76a..a35d899f 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -290,8 +290,7 @@ flowchart TD code (skills, tactics, motion, engine) therefore moves the candidates and the working-tree strategies, never the reference. A bundled match equals the same match run normally, frame for frame; the referee and simulator are today's for both sides. An older commit may know the champion by its old - name (`catalog.RENAMED`); that is found. `--compare-with NAME` compares against NAME instead: a new - version against the one it changes. + name (`catalog.RENAMED`); that is found. - **Rounds.** Every round is the same round robin, every pair of players once, under noise seed k; after round 1 only the undecided candidates stay. The match results store makes it cheap: a match whose code is unchanged is never played again, so a run plays only the matches of edited strategies @@ -310,17 +309,16 @@ flowchart TD far better against one opponent and worse against the rest is a matchup, not a better strategy. - **Stalls** are reported, never judged on. The watchdog watches config_a only (`run/strategy_runner.py` records stats for config_a), so the report says in how many matches each - strategy was checked; "unknown" means none was. `--strict` exits non-zero on any stall, for CI. + strategy was checked; "unknown" means none was. - **Output.** `replays/eval_/report.json` (verdicts, per-opponent tables, round 1's signals) and per round `round_/`: each played match's replay, intention log and stats as `
_vs_.*`, `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` read. Matches taken from the store have no replay in the run. - **Promoting** is a decision, not a side effect: change the champion line in `reference/players.json` in a pull request; the next release makes it the reference. -- **Pictures** (`evaluate.py --explain`, `tools/evaluation/explain.py`): for each candidate, +- **Pictures** (`tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`): for a candidate, where both strategies' robots stand with and without the ball, their shots for and against, - their fouls by rule, and a `summary.json` of the numbers behind them, written to - `replays/eval/explain/_/`. They explain a verdict and never make one; matches taken + their fouls by rule, and a `summary.json` of the numbers behind them, written to DIR. They explain a verdict and never make one; matches taken from the store have no replay, so the pictures cover only what was played. Example (`explain.py replays/eval_/round_1 pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) @@ -358,7 +356,7 @@ reaches `main` by pull request: 5. Open a draft pull request into `main` with the evaluation result. An agent never merges: a person reviews and merges. Several branches can be worked on at once, each in its own worktree; they share -`replays/match_results/`. `evaluate.py` uses 12 workers (`--max-workers N` to change it), so +`replays/match_results/`. `evaluate.py` uses one worker fewer than the CPUs (at most 12), so concurrent runs split the machine's cores and each takes longer; a machine with more cores runs more of them at once. How to organise a search (how many in parallel, which ideas) is up to whoever runs it. @@ -396,8 +394,7 @@ whoever runs it. or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. - **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. -- **`tools/evaluation/evaluate.py`** — every match run (`--all`, `--max-workers N`, `--strict`, - `--fuzz-restarts SEED`, `--fuzz-interval LO HI`, `--control-scheme NAME`); see +- **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`); see [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: `tools/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and @@ -407,11 +404,11 @@ whoever runs it. `RESTART_STALL` (a restart/stoppage command held >15s) and `COMMITTED_FROZEN` (ball moved <5cm for >10s in live play while a slot is committed). Each `RESTART_STALL` carries a one-line `diagnosis` (ball in goal / past a line, taker not closing on the ball, taker at the ball but - not kicking). The tournament prints a STALLS section, writes it to `summary.json`, and `--strict` exits non-zero on any stall; a + not kicking). The tournament prints a STALLS section, and writes it to `summary.json`; a possession-pinned backstop flags what the watchdog misses. - **Restart fuzzing** (`custom_referee/restart_fuzzer.py`) — injects legal restarts at seeded-random times to exercise auto-advance paths; same seed and interval reproduce the - schedule. Details: `docs/custom_referee.md`. + schedule. No tool turns it on today (`sim_setup.sim_referee(fuzz_seed=...)`). Details: `docs/custom_referee.md`. - **Sim noise** (`rsoccer_simulator/src/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded command latency per robot, kick speed and direction noise (a per-robot offset plus kick-to-kick spread), two-phase ball friction (slide after a kick, then roll), per-robot diff --git a/docs/custom_referee.md b/docs/custom_referee.md index b377a17b..f32cf0bf 100644 --- a/docs/custom_referee.md +++ b/docs/custom_referee.md @@ -138,8 +138,8 @@ public `set_command` path an operator uses, so a stall it exposes is a real one. deterministic, so this is how an evaluation explores new restart geometries. Kinds: ball placement → `DIRECT_FREE_*` (position ≥0.25m infield, ≥0.2m from both defense areas), `PREPARE_KICKOFF_*`, and `STOP` → `FORCE_START`. `referee.injections` records each one; with a -`MatchLog` attached, they are traced as `restart_fuzzer_injection`. Used by -`evaluate.py --fuzz-restarts SEED`. +`MatchLog` attached, they are traced as `restart_fuzzer_injection`. No tool turns it on today (`evaluate.py --fuzz-restarts` was removed on +2026-11-12): pass `fuzz_seed` to `tools/sim_setup.sim_referee` to use it. ```python referee = RestartFuzzingReferee.from_profile_name("simulation", seed=1, interval_s=(8.0, 20.0), diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 367a69b3..05b0dec1 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -24,7 +24,7 @@ links back here. | Question | Tool | Status | |---|---|---| -| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with how many matches checked them; `--strict` fails on one | Today | +| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with how many matches checked them | Today | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`: paired against the champion at the last release. The only verdict | Today | | Does everything still run, after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches), with stalls and signals. `--all` plays every strategy, occasionally | Today | | What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py` (`--fouls` for our side's fouls), then the picture tools. find_bugs finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal sources (`utama_core/analysis/goal_sources.py`) | Today | diff --git a/docs/tools.md b/docs/tools.md index 0f1adb18..84aa3a25 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -48,10 +48,10 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF`, `--compare-with NAME`); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking; `--strict` fails on a stall, `--fuzz-restarts SEED` injects restarts. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). `--explain` also writes pictures of each candidate against the reference to `replays/eval/explain/` (`tools/evaluation/explain.py`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | -| `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | +| `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | | `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `tools/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the players and the simulated world and robots (`tools/evaluation/reference/players.json`, `world.json`, `robots.json`) for `evaluate.py`. Kept in `reference/` so a new champion does not rerun every stored match | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | diff --git a/docs/visual_guide.md b/docs/visual_guide.md index bba55900..ac979ef8 100644 --- a/docs/visual_guide.md +++ b/docs/visual_guide.md @@ -21,7 +21,7 @@ so the studied strategy attacks right. Zone names (defensive third, the box, ... difference, among those it played as config_a), collects every problem the tools flag (tactic flip-backs, stalls, and with `--restarts` illegal restart targets), and draws the worst few with the picture for that kind. Read its `index.md` first: each problem's numbers, then the picture path. About 20 s a match -(a minute with `--restarts`); `evaluate.py --explain` runs it on the candidate's two worst matches. +(a minute with `--restarts`). A stall it found in `pendulum` against `weaver`: from 783 to 786 s, four of our robots oscillate with the ball frozen. The picture is the match timeline around it, recorded data only: @@ -89,13 +89,11 @@ The rest of the strategy report, as numbers: [signal_report.md](signal_report.md ![candidate against champion, positions](img/explain/positions.png) The same maps for just two strategies, a candidate and the champion, side by side on one colour scale; -`evaluate.py --explain` draws them (with shots, fouls and a `summary.json`) before an evaluation removes -its replays. This example is drawn from the round-robin: `pendulum` holds 37% of its possession in the +`tools/evaluation/explain.py` draws them (with shots, fouls and a `summary.json`). This example is drawn from the round-robin: `pendulum` holds 37% of its possession in the attacking half against `breakwater`'s 65%, yet takes 21.9 shots a match against 6.3, and commits twice the fouls (10.0 against 4.7 a match, mostly ball held in the defense area and crashing). -Draw: `tools/evaluation/evaluate.py CANDIDATE --explain`, or `tools/evaluation/explain.py RUN_DIR -CANDIDATE CHAMPION --out DIR` on any run dir. +Draw: `tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR` on any run dir. ## 3. One match over time @@ -191,7 +189,7 @@ Draw: `pixi run python tools/plan_trace.py REPLAY.npz --t0 S --t1 S --robot ID [ | Question | Picture | |---|---| | How does this strategy play, overall? | pitch maps (1) | -| Why did the candidate win or lose against the champion? | `--explain` (2) | +| Why did the candidate win or lose against the champion? | `explain.py` (2) | | What were the robots doing in this stretch of a match? Thrashing, everyone chasing the ball? | match timeline (3) | | Where did the referee override put us at this restart, and was it legal? | restart picture (4) | | Is the planner itself good at driving, with no strategy involved? | benchmark (5) | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 890f7c1f..0402a9b0 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -9,18 +9,11 @@ --at REF the reference is the champion as it was at git commit REF (default: the latest release tag), played from a `.strategy` file built once into replays/eval/frozen/ - --compare-with NAME the reference is NAME instead (a strategy in the working tree, or a .strategy - file): a new version against the one it changes --all every strategy in the catalog plays, not only the core (occasionally, for a wider field) - --max-rounds N rounds before a candidate is called undecided (default 6) - --max-workers N matches at once (default 12; 1 plays in this process) - --strict exit non-zero if any match of the run stalled - --fuzz-restarts SEED inject seeded random legal restarts (custom_referee/restart_fuzzer.py); - --fuzz-interval LO HI sets the gap in sim seconds (default 25 45) - --control-scheme NAME planner for every robot (fpp, trajsample, ...; default fpp) - --explain also write on-pitch pictures of each candidate against the reference to - replays/eval/explain/_/ (tools/evaluation/explain.py) + +Matches play in parallel, one fewer than the CPUs (at most 12). To explain a result: find_bugs.py, +goal_sources, pitch_maps.py and explain.py on the run's round folders. Players ------- @@ -48,7 +41,7 @@ - **better** once P >= PROMOTE (0.99), - **worse** once P <= DROP (0.2), -- **undecided** after `--max-rounds`: not clearly better, which for a search means drop it. +- **undecided** after `MAX_ROUNDS` (6) rounds: not clearly better, which for a search means drop it. Thresholds come from simulating the rule (match noise SD 1.9 goals, six opponents, 6 rounds, paired results correlated 0 to 1): two equal strategies are called "better" at most 3% of the time. Unrelated @@ -114,6 +107,7 @@ PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 +WORKERS = min(12, max(1, (os.cpu_count() or 1) - 1)) # 1 plays in this process (tests) FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results # A full match: two halves of 300 s of playing time, the clock stopped whenever no team may play the # ball, about 710-870 s of sim time. This only caps a match that can't reach full time. @@ -231,30 +225,17 @@ def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("candidates", nargs="*") parser.add_argument("--at", metavar="REF") - parser.add_argument("--compare-with", metavar="NAME") parser.add_argument("--all", action="store_true") - parser.add_argument("--max-rounds", type=int, default=MAX_ROUNDS) - parser.add_argument("--max-workers", type=int, default=min(12, max(1, (os.cpu_count() or 1) - 1))) - parser.add_argument("--strict", action="store_true") - parser.add_argument("--fuzz-restarts", type=int, metavar="SEED") - parser.add_argument("--fuzz-interval", type=float, nargs=2, metavar=("LO", "HI"), default=(25.0, 45.0)) - parser.add_argument("--control-scheme", default="fpp") - parser.add_argument("--explain", action="store_true") parser.add_argument("--players", type=Path, help=argparse.SUPPRESS) # tests: another players.json return parser def main(argv: Optional[list[str]] = None) -> None: args = build_parser().parse_args(argv) - if args.at and args.compare_with: - raise SystemExit("--at and --compare-with both choose the reference: give one") setup = load_players(args.players) if args.players else load_players() core = resolve_names(setup["core"]) reserve = [n for n in _CONFIG_NAMES if n not in core] if args.all else [] - if args.compare_with: - reference = resolve_names([args.compare_with])[0] - else: - reference = at_ref(resolve_names([setup["champion"]])[0], args.at or latest_release()) + reference = at_ref(resolve_names([setup["champion"]])[0], args.at or latest_release()) candidates = [c for c in resolve_names(args.candidates) if c != reference] noise = SimNoise.from_dict(reference_noise()).to_dict() @@ -262,9 +243,9 @@ def main(argv: Optional[list[str]] = None) -> None: env_args = { "duration_seconds": MAX_MATCH_SECONDS, "sim_noise": noise, - "control_scheme": args.control_scheme, - "fuzz_seed": args.fuzz_restarts, - "fuzz_interval_s": tuple(args.fuzz_interval), + "control_scheme": "fpp", + "fuzz_seed": None, + "fuzz_interval_s": (25.0, 45.0), } graph = CodeGraph() env = match_results.environment(graph, **env_args) @@ -287,20 +268,15 @@ def still_current(a: str, b: str) -> bool: now.strategy_fingerprint(n)[:16] == fps[n] for n in (a, b) ) - run_kwargs = { - "duration_seconds": MAX_MATCH_SECONDS, - "control_scheme": args.control_scheme, - "fuzz_seed": args.fuzz_restarts, - "fuzz_interval_s": tuple(args.fuzz_interval), - } + run_kwargs = {k: v for k, v in env_args.items() if k != "sim_noise"} open_ = list(candidates) report: dict[str, dict] = {} rounds: list[dict] = [] opponents_so_far: set[str] = set() played = reused = 0 - executor = ProcessPoolExecutor(max_workers=args.max_workers) if args.max_workers > 1 else None + executor = ProcessPoolExecutor(max_workers=WORKERS) if WORKERS > 1 else None try: - for k in range(1, args.max_rounds + 1): + for k in range(1, MAX_ROUNDS + 1): if k > 1 and not open_: break opponents = [p for p in [*core, *reserve] if p not in candidates and p != reference] @@ -367,7 +343,7 @@ def submit(a: str, b: str, seed: int) -> tuple: margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) p = ratings.p_positive(margin, sd) print(f"after round {k}: {_short_name(c):<28} P(better) {p:.2f} margin {margin:+.2f} ± {sd:.2f}") - if (v := verdict(p, k, args.max_rounds)) is not None: + if (v := verdict(p, k, MAX_ROUNDS)) is not None: open_.remove(c) report[c] = {"verdict": v, "rounds": k, "p_better": round(p, 3), "margin": round(margin, 2)} report[c]["margin_sd"] = round(sd, 2) @@ -375,9 +351,6 @@ def submit(a: str, b: str, seed: int) -> tuple: if executor is not None: executor.shutdown(cancel_futures=True) - if args.explain: - _explain(run_dir, run_id, candidates, reference) - health = rounds[0] print_signals(health, f"{run_id}/round_1") ledger = store.load(env, fps=fps) @@ -408,7 +381,7 @@ def submit(a: str, b: str, seed: int) -> tuple: "reference": reference, "core": core, "environment": env, - "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": args.max_rounds}, + "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": MAX_ROUNDS}, "candidates": report, "rounds": [{"round": s["round"], "matches": len(s["results"])} for s in rounds], "signals": {k: v for k, v in health.items() if k not in ("results",)}, @@ -418,27 +391,6 @@ def submit(a: str, b: str, seed: int) -> tuple: ) print(f"\nReport: {out.relative_to(REPO_ROOT) if out.is_relative_to(REPO_ROOT) else out}") - stalled = [ - r for s in rounds for r in s["results"] if (r["stats"] or {}).get("stall_events") or r["possession_backstop"] - ] - if args.strict and stalled: - raise SystemExit(f"--strict: {len(stalled)} match(es) stalled") - - -def _explain(run_dir: Path, run_id: str, candidates: list[str], reference: str) -> None: - """`--explain`: pictures of each candidate against the reference, from this run's matches. - A failure is printed and never loses the verdicts.""" - from tools.evaluation import explain # matplotlib: imported only when asked for - - for c in candidates: - out = Path(REPLAY_BASE_PATH) / "eval" / "explain" / f"{_short_name(c)}_{run_id}" - try: - for round_dir in sorted(run_dir.glob("round_*")): - explain.explain(round_dir, c, reference, out / round_dir.name) - print(f"explain: {_short_name(c)} vs {_short_name(reference)} written to {out}") - except Exception as exc: # noqa: BLE001 - the pictures are optional; the verdicts are not - print(f"explain: {_short_name(c)} failed ({type(exc).__name__}: {exc}); verdicts are unaffected") - # --- the verdict's arithmetic ----------------------------------------------------------------- diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index 46faa313..9d277ecf 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -51,11 +51,14 @@ def fake_run_match(a, b, run_dir=None, **kwargs): monkeypatch.setattr(evaluate, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr(evaluate, "CodeGraph", lambda: _Graph(rig)) monkeypatch.setattr(evaluate, "_CONFIG_NAMES", [*CORE, *RESERVE, "c"]) + monkeypatch.setattr(evaluate, "WORKERS", 1) # in this process, so the stubs apply + monkeypatch.setattr(evaluate, "at_ref", lambda name, ref: name) # the reference: the core's own "a" + monkeypatch.setattr(evaluate, "latest_release", lambda: "v0") def run(*argv): rig.played.clear() rig.kwargs.clear() - evaluate.main(["--players", str(players), "--max-workers", "1", *argv]) + evaluate.main(["--players", str(players), *argv]) (run_dir,) = sorted(tmp_path.glob("eval_*"))[-1:] return run_dir @@ -65,7 +68,7 @@ def run(*argv): def test_with_no_candidate_one_round_plays_every_pair_of_the_core(rig): - run_dir = rig.run("--compare-with", "a") + run_dir = rig.run() # the core a, b, d; a is also the reference; the reserve r1, r2, r3 and c play only with --all assert sorted((x, y) for x, y, _ in rig.played) == [("a", "b"), ("a", "d"), ("b", "d")] @@ -77,56 +80,41 @@ def test_with_no_candidate_one_round_plays_every_pair_of_the_core(rig): def test_all_adds_every_other_strategy_in_the_catalog(rig): - rig.run("--compare-with", "a", "--all") + rig.run("--all") assert len(rig.played) == 7 * 6 // 2 # a, b, d, r1, r2, r3, c: every pair once def test_a_second_run_plays_nothing_and_after_an_edit_only_that_strategys_matches_play(rig): - rig.run("--compare-with", "a") - rig.run("--compare-with", "a") + rig.run() + rig.run() assert rig.played == [] rig.version["d"] += 1 - rig.run("--compare-with", "a") + rig.run() assert sorted((x, y) for x, y, _ in rig.played) == [("a", "d"), ("b", "d")] -def test_a_later_round_is_the_same_round_robin_under_the_next_seed_with_colours_swapped(rig): - run_dir = rig.run("c", "--compare-with", "a", "--max-rounds", "2") +def test_a_later_round_is_the_same_round_robin_under_the_next_seed_with_colours_swapped(rig, monkeypatch): + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + run_dir = rig.run("c") round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] # equal results: undecided after round 1 assert sorted(round_2) == [("a", "c"), ("b", "a"), ("b", "c"), ("d", "a"), ("d", "b"), ("d", "c")] rig.version["c"] += 1 # edit the candidate: only its matches play again, in both rounds - rig.run("c", "--compare-with", "a", "--max-rounds", "2") + rig.run("c") assert all("c" in (x, y) for x, y, _ in rig.played) and len(rig.played) == 6 report = json.loads((run_dir / "report.json").read_text()) assert report["candidates"]["c"]["verdict"] == "undecided" assert report["candidates"]["c"]["rounds"] == 2 -def test_strict_fails_a_run_with_a_stall_and_reports_it(rig): - rig.stats[("a", "b")] = {"stall_events": [{"kind": "RESTART_STALL", "sim_time": 5.0, "duration_s": 9.0}]} - with pytest.raises(SystemExit, match="1 match"): - rig.run("--compare-with", "a", "--strict") - rig.run("--compare-with", "a") # without --strict the same (now stored) stall only reports - - -def test_fuzzing_reaches_every_match_and_is_its_own_environment(rig): - rig.run("--compare-with", "a") - rig.run("--compare-with", "a", "--fuzz-restarts", "7", "--fuzz-interval", "10", "20") - - assert len(rig.played) == 3 # a fuzzed run reuses no unfuzzed match - assert all(kw["fuzz_seed"] == 7 and kw["fuzz_interval_s"] == (10.0, 20.0) for kw in rig.kwargs) - assert len(list(rig.store.root.iterdir())) == 2 - - def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): def edit(): rig.version["d"] = 9 rig.on_play = edit - rig.run("--compare-with", "a") + rig.run() stored = {(r["a"], r["b"]) for r in map(json.loads, map(lambda p: p.read_text(), rig.store.root.rglob("*.json")))} assert ("a", "b") in stored diff --git a/utama_core/tests/engine/test_explain.py b/utama_core/tests/engine/test_explain.py index a38d8248..62bd10b8 100644 --- a/utama_core/tests/engine/test_explain.py +++ b/utama_core/tests/engine/test_explain.py @@ -1,13 +1,13 @@ """`tools/evaluation/explain.py` on a synthetic run dir of real columnar replays: the side assignment (a candidate's numbers come from its own matches, against any opponent), the goals from the final -referee state, the paired goal difference, the four files, and `evaluate.py --explain` off by default.""" +referee state, the paired goal difference and the four files.""" import json import pytest from tools import pitch_maps as pm -from tools.evaluation import evaluate, explain +from tools.evaluation import explain from utama_core.entities.data.referee import RefereeData from utama_core.entities.data.vector import Vector2D, Vector3D from utama_core.entities.game import Ball, GameFrame, Robot @@ -134,16 +134,3 @@ def test_paired_difference_uses_same_opponent_seed_and_colour(run_dir, tmp_path) def test_explain_refuses_when_a_side_has_no_replay(run_dir, tmp_path): with pytest.raises(FileNotFoundError): explain.explain(run_dir, "nobody", CHAMP, tmp_path / "out", workers=1) - - -def test_evaluate_explain_is_off_by_default(): - assert evaluate.build_parser().parse_args(["x"]).explain is False - assert evaluate.build_parser().parse_args(["x", "--explain"]).explain is True - - -def test_an_explain_failure_never_escapes(monkeypatch, tmp_path): - def boom(*args, **kwargs): - raise RuntimeError("no replays") - - monkeypatch.setattr(explain, "explain", boom) - evaluate._explain(tmp_path, "eval_test", [CAND], CHAMP) # must print and return, not raise From b5629db16622bd2d8232cb76be3f8ae32abf3b05 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 17:48:22 +0000 Subject: [PATCH 24/59] tools: a round folder holds every match of its round The store now records where each played match's files are; a run that reuses a match links them into its own round folder under this run's names, so find_bugs, explain, pitch_maps and goal_sources see the whole round, not only what this run played. Two runs started in the same second no longer share a folder. Co-Authored-By: Claude Opus 5.5 --- docs/STRATEGY_DEVELOPMENT.md | 6 ++--- tools/evaluation/evaluate.py | 28 +++++++++++++++++--- tools/evaluation/explain.py | 2 +- utama_core/replay/match_results.py | 6 ++++- utama_core/tests/engine/test_evaluate_run.py | 20 ++++++++++++++ 5 files changed, 54 insertions(+), 8 deletions(-) diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index a35d899f..081d3ba4 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -313,13 +313,13 @@ flowchart TD - **Output.** `replays/eval_/report.json` (verdicts, per-opponent tables, round 1's signals) and per round `round_/`: each played match's replay, intention log and stats as `_vs_.*`, `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` - read. Matches taken from the store have no replay in the run. + read. A match taken from the store is linked in (symlinks) from the run that played it, so a + round folder holds all of its matches; one played before 2026-11-12, or whose run was deleted, has none. - **Promoting** is a decision, not a side effect: change the champion line in `reference/players.json` in a pull request; the next release makes it the reference. - **Pictures** (`tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`): for a candidate, where both strategies' robots stand with and without the ball, their shots for and against, - their fouls by rule, and a `summary.json` of the numbers behind them, written to DIR. They explain a verdict and never make one; matches taken - from the store have no replay, so the pictures cover only what was played. Example + their fouls by rule, and a `summary.json` of the numbers behind them, written to DIR. They explain a verdict and never make one. Example (`explain.py replays/eval_/round_1 pendulum breakwater --out ...`): ![Where two strategies' robots stand, with and without the ball](img/explain/positions.png) - **Cost.** A round is 15 matches (five core and the reference, plus one per extra candidate pair) of diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 0402a9b0..04fce876 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -184,13 +184,32 @@ def play_and_record( """Play one match into `run_dir` and return its stored record (`match_results.record`), with its replay analysed. `run_kwargs` go to `match.run_match`.""" result = run_match(config_a, config_b, run_dir=run_dir, **run_kwargs) - restarts = losses = None + restarts = losses = replay = None npz = Path(run_dir) / f"{tag(config_a, config_b)}.npz" if npz.exists(): # no replay: crashed before it was written restarts, losses = analyse_replay(npz) + replay = Path(os.path.relpath(npz.with_suffix(""), REPLAY_BASE_PATH)).as_posix() return match_results.record( - env, a_fp, b_fp, dataclasses.asdict(result), seed=seed, source=source, restarts=restarts, losses=losses - ) + env, a_fp, b_fp, dataclasses.asdict(result), seed=seed, source=source, restarts=restarts, losses=losses, + replay=replay, + ) # fmt: skip + + +def link_replay(rec: dict, round_dir: Path, a: str, b: str) -> bool: + """Link a reused match's files (replay, stats, intentions) into this round's folder under this + run's names, so every reader of a round folder sees all of its matches. False if the record has + no replay or its files were deleted.""" + if not rec.get("replay"): + return False + stem = Path(REPLAY_BASE_PATH) / rec["replay"] + files = sorted(stem.parent.glob(f"{stem.name}.*")) + if not any(f.suffix == ".npz" for f in files): + return False + for f in files: + link = round_dir / f"{tag(a, b)}{f.name[len(stem.name):]}" + if not link.exists(): + link.symlink_to(os.path.relpath(f, round_dir)) + return True def result_row(rec: dict, a: str, b: str, reused: bool) -> dict: @@ -258,6 +277,8 @@ def main(argv: Optional[list[str]] = None) -> None: candidates.remove(c) run_id = datetime.now(timezone.utc).strftime("eval_%Y%m%d_%H%M%S") + while (Path(REPLAY_BASE_PATH) / run_id).exists(): # two runs started in the same second + run_id += "b" run_dir = Path(REPLAY_BASE_PATH) / run_id print(f"Reference {_short_name(reference)}; core {', '.join(_short_name(n) for n in core)}; environment {env}") @@ -292,6 +313,7 @@ def still_current(a: str, b: str) -> bool: todo.append((a, b, seed)) else: recs[(a, b)] = (rec, True) + link_replay(rec, round_dir, a, b) reused += len(recs) print( f"\nRound {k}: {len(fixtures)} matches, {len(recs)} from the match results store, {len(todo)} to play" diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index ba060c4d..2b43a2f2 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -193,7 +193,7 @@ def explain(run_dir, candidate: str, champion: str, out_dir, workers: int = 2) - "paired": paired_rows(matches, cand, champ), "fouls_rules_shown": pm.top_rules(views), "notes": ( - "Matches are those in the run dir; fixtures taken from the match results store have no replay here. " + "Matches are those in the run dir; a match reused from the store is a link to the run that played it. " "Positions and fouls exclude the goalkeeper and out-of-bounds (as pitch_maps.py)." ), } diff --git a/utama_core/replay/match_results.py b/utama_core/replay/match_results.py index 62c67967..35079883 100644 --- a/utama_core/replay/match_results.py +++ b/utama_core/replay/match_results.py @@ -107,9 +107,12 @@ def record( losses: Optional[dict], a_is_right: bool = True, a_kicks_off: bool = True, + replay: Optional[str] = None, ) -> dict: """The stored record of one played match. `result` is a `match.MatchResult` as a dict; `restarts` - and `losses` are the replay analyses (None when the replay was not kept to analyse).""" + and `losses` are the replay analyses (None when the replay was not kept to analyse). `replay` is + where its files are, a stem relative to the replay base directory (`eval_/round_/a_vs_b`), + so a later run that reuses the match can link them into its own round folder.""" stats = result.get("stats") or {} shots = stats.get("shots") or {} rec = { @@ -131,6 +134,7 @@ def record( "stats": result.get("stats"), "restarts": restarts, "losses": losses, + "replay": replay, } return json.loads(json.dumps(rec)) # the shape it reads back in, tuples as lists diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index 9d277ecf..cdb7c807 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -133,3 +133,23 @@ def fake_frozen(name, ref, directory): monkeypatch.setattr(evaluate, "frozen", fake_frozen) assert evaluate.at_ref("pendulum", "v2.5.0").endswith("split_shape@abc.strategy") assert built == ["pendulum", "split_shape"] + + +def test_a_reused_match_is_linked_into_the_new_rounds_folder_from_the_run_that_played_it(rig, monkeypatch): + def run_match_writing_files(a, b, run_dir=None, **kwargs): + rig.played.append((a, b, kwargs["sim_noise"].seed)) + for suffix in (".npz", ".stats.json"): + (run_dir / f"{evaluate.tag(a, b)}{suffix}").write_text(a + b) + return MatchResult(config_a=a, config_b=b, score_a=1, score_b=0, stats={"x": 1}) + + monkeypatch.setattr(evaluate, "run_match", run_match_writing_files) + monkeypatch.setattr(evaluate, "analyse_replay", lambda npz: (None, None)) + first = rig.run() + rig.version["d"] += 1 + second = rig.run() + + assert sorted((x, y) for x, y, _ in rig.played) == [("a", "d"), ("b", "d")] + linked = second / "round_1" / "a_vs_b.npz" + assert linked.is_symlink() and linked.resolve() == (first / "round_1" / "a_vs_b.npz").resolve() + assert (second / "round_1" / "a_vs_b.stats.json").read_text() == "ab" + assert len(list((second / "round_1").glob("*.npz"))) == 3 # every match of the round, played or reused From d4acc2c75b424006dd012db2d92aaa7d86b5957c Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 17:50:27 +0000 Subject: [PATCH 25/59] skills: explain-result, debug-incident, field-session Three playbooks in .claude/skills/ over the existing scripts, which stay in tools/: how a strategy plays and why it won or lost (find_bugs, goal sources, pitch maps, explain); one bad moment from symptom to a fixed cause with a test (replay_trace, repro_from_replay, the planner pictures, moments); a test day on real robots and its logs (field-check, calibrate, trim, field_physics). .claude/skills/ is committed; the rest of .claude/ stays ignored. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/debug-incident/SKILL.md | 72 ++++++++++++++++++++++++++ .claude/skills/explain-result/SKILL.md | 65 +++++++++++++++++++++++ .claude/skills/field-session/SKILL.md | 63 ++++++++++++++++++++++ .gitignore | 3 +- AGENTS.md | 5 ++ docs/tools.md | 3 ++ 6 files changed, 210 insertions(+), 1 deletion(-) create mode 100644 .claude/skills/debug-incident/SKILL.md create mode 100644 .claude/skills/explain-result/SKILL.md create mode 100644 .claude/skills/field-session/SKILL.md diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md new file mode 100644 index 00000000..4ee9c248 --- /dev/null +++ b/.claude/skills/debug-incident/SKILL.md @@ -0,0 +1,72 @@ +--- +name: debug-incident +description: Take one bad moment in a match (a foul, a stall, a robot thrashing, driving into the ball at a restart, a strange path near an obstacle) from symptom to a fixed cause with a regression test. Use when find_bugs.py or a replay shows a specific incident, or the user points at a time in a match. Not for "why did this strategy lose" in general (that is the explain-result skill). +--- + +# Debug one incident + +A foul or failure is a symptom. The cause may be the robot's tactic, the shared referee +override, the motion planner, the referee itself, or the check that flagged it: of the first +six found this way, two were the referee or the check. The full workflow, with the bugs found +so far, is `docs/STRATEGY_DEVELOPMENT.md`, "Debugging a foul or failure"; read it for anything +below that is unclear. + +Inputs: a replay `REPLAY` (`replays/eval_/round_/_vs_.npz`, or any `.npz`) and a +time `S` in seconds. In a parallel worktree, run `tools/setup_worktree.sh` first. + +## 1. Find it + +`pixi run python tools/find_bugs.py ROUND_DIR --strategy NAME` → `find_bugs/index.md`, then +filter `find_bugs/findings.jsonl` on the kind you care about. Open the finding's picture, +then confirm with the numbers in its message. Only the friendly side (config_a) is checked. + +## 2. Look at it + +Pick the tool by the question; each picture tool takes `--findings` to write its flags as JSON. + +| Question | Command | +|---|---| +| What happened in this window, in text? | `tools/replay_trace.py REPLAY T0 T1` (`--events`: kicks, possession, referee changes, fouls) | +| Which tactic was each robot in, and what was it aiming at? | `tools/repro_from_replay.py REPLAY --t S --summary IDS` (replays the state with tracing on, prints tactic, position, target every 0.25 s) | +| Swimlanes: referee, each robot's tactic, distance to ball | `tools/match_timeline.py REPLAY T0 T1 --side friendly` | +| Where did the referee override send everyone at this restart? Legal? | `tools/restart_picture.py REPLAY --t S` (`--all-restarts`, `--side enemy`) | +| What did the planner decide on this tick? | `tools/plan_snapshot.py REPLAY --t S --robot ID --target X Y` (`--side enemy`) | +| How did the plan evolve over a few seconds? | `tools/plan_trace.py REPLAY --t0 S --t1 S --robot ID [--target X Y]` | +| Run a fresh short match with my own traces | `tools/debug_match.py --strategy A --opponent B --duration 60 --stop-on-goal`, with `ctx.match_log.trace(...)` calls added in the tactic | + +All run as `pixi run python tools/.py ...`. Never conclude from a picture alone. + +## 3. Find the cause in the code + +From the trace: which tactic or override sent the robot there, with which target, waypoint +and obstacles. Then ask whether the rule was really broken (`docs/custom_referee_design_decisions.md`) +and whether the check reads it right. Frame trap: rsim stores y negated; anything written into +the sim negates y and heading. + +## 4. Fix it, with a unit test at the boundary + +The fix is not done without a test that fails before and passes after, pinning the exact +boundary (a tolerance, a tie, a target off the field). Prefer a pure unit test over an rsim +fixture. Add a row to the bug table in `docs/STRATEGY_DEVELOPMENT.md` if it is a new kind. + +## 5. Optionally keep a moment + +Only when a field state alone decides the behaviour (restart and placement geometry under the +referee override); open-play fouls almost never reproduce from a captured state. + +``` +pixi run python tools/moments.py capture REPLAY --t S --name NAME --check CHECK --note "..." +pixi run python tools/moments.py play utama_core/tests/moments/NAME.json --seeds 0-4 +``` + +It must fail on at least 4 of 5 seeds before the fix. If the fix is not in the same change, +set `"known_failure": ""` (a strict xfail). Moments pin shared-code bugs; they are not a +gate on strategies. + +## Rules + +- A shared-code fix (skills, tactics, planner, referee) changes every strategy: batch such + fixes and evaluate once at the end, and ask before starting any `evaluate.py` run. +- Determinism: replaying the same fixture gives the same match. If a rerun differs, suspect + module-level state in a tactic or skill not keyed by team and cleared at match start. +- Don't chase rsim-only dribble failures as kernel bugs. diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md new file mode 100644 index 00000000..f2f6e4dd --- /dev/null +++ b/.claude/skills/explain-result/SKILL.md @@ -0,0 +1,65 @@ +--- +name: explain-result +description: Explain how a strategy plays and why it won, lost or came out undecided, from the replays of an evaluate.py run (or an older round robin). Use after an evaluation, when asked "why did it lose?", "how does X play?", "where do its goals come from?", or before changing a strategy to see what to change. Never use it to rank strategies; goals in evaluate.py's verdict are the only ranking. +--- + +# Explain a result + +Every tool here reads a **round folder**: `replays/eval_/round_/` (older round robins: +`replays/tournament_/`). A round folder holds all of its matches as `_vs_.*`: those +the run played, and links to those it reused from the match results store. `config_a` (the +name before `_vs_`) is the friendly side, the only side with an intentions log. + +Nothing here judges. A signal explains a result; fewer ball losses or more shots is not +"better" on its own (`docs/signals.md`, "Ranking"). Report what the numbers show and what +they suggest changing, never a new ranking. + +## Steps, cheapest first + +1. **Read the run's own report** (no tool to run). + `replays/eval_/report.json`: per candidate the verdict, P(better), margin ± SD, and + `per_opponent` (candidate's and reference's goal difference against each opponent, same seed + and colour). Which opponents moved the margin? `round_1/summary.json` has every signal and + the stall coverage. Look up any signal in `docs/signals.md`: where it lives, its reference + range, and what an off value usually means. + +2. **Is something broken?** `pixi run python tools/find_bugs.py ROUND_DIR --strategy NAME` + (about 20 s a match; `--restarts` adds restart geometry, a minute a match). Open + `find_bugs/index.md` first: the worst matches, findings by kind, a picture each. Our fouls by + rule: `--fouls --by strategy,rule`. A stall, thrash or foul is a bug, not a style: hand it to + the `debug-incident` skill. + +3. **Where do goals come from?** + `pixi run python -m utama_core.analysis.goal_sources ROUND_DIR --out /tmp/gs.json`. + Goals per match = Σ over situation types (restart or ball won, by third) of situations per + match × P(goal). Tells whether a change should create more situations, convert better, or + allow fewer. Situation names: AGENTS.md glossary and `docs/signals.md`, "Where do goals come + from?". + +4. **How does it play, on the pitch?** + - One strategy against the field: `pixi run python tools/pitch_maps.py ROUND_DIR --out DIR` + (positions with and without the ball, shots, fouls; every panel turned so the strategy + attacks right). + - A candidate against the champion, side by side on one scale: + `pixi run python tools/evaluation/explain.py ROUND_DIR CANDIDATE REFERENCE --out DIR` + (`positions.png`, `shots.png`, `fouls.png`, `summary.json`). REFERENCE is the name as + `report.json` gives it (a frozen file is named by its stem, e.g. `split_shape@cffe3a28`). + - The whole field, for a doc figure: `pixi run python tools/signal_report.py ROUND_DIR`. + - The signals marked *offline* in `docs/signals.md` (replays the run at 10 Hz, slow): + `pixi run python tools/metric_correlation.py ROUND_DIR --out /tmp/offline.md`. + Zones: use the names in `docs/pitch_zones.md` (defensive / middle / attacking third, wings, box). + +5. **Write it up** in a few lines: the verdict and margin; which opponents decided it; the + two or three signals or pictures that explain it, with numbers; any bug found (handed to + `debug-incident`); what to try next. Look at every picture before citing it. + +## Traps + +- A round has 15 matches (more with `--all`); one strategy is config_a in only some of them, so + friendly-side analyses (intentions, stalls) cover those only. `summary.json`'s + `stalls_checked` says how many. +- Matches from before 2026-11-12, or whose original run folder was deleted, have no replay to + link: tools then see fewer matches than the round lists. Say so when numbers look thin. +- Catch rate moves ±4–8 points between identical runs: never a reason on its own. +- `ball_travel` is not a quality signal. +- Don't start new matches to explain a result; if more data is needed, ask first. diff --git a/.claude/skills/field-session/SKILL.md b/.claude/skills/field-session/SKILL.md new file mode 100644 index 00000000..b2a3535a --- /dev/null +++ b/.claude/skills/field-session/SKILL.md @@ -0,0 +1,63 @@ +--- +name: field-session +description: Run a test day on the real robots, and process what it recorded - checking vision and radio, pairing robots with lids, calibrating a robot, then trimming, measuring and packaging the field logs. Use when the user is at the field, sets up real robots, sees dropouts or a robot misbehaving on the pitch, or brings back field logs. Not for simulated matches. +--- + +# A field session + +Setup and the meaning of each check: `docs/real_robot_setup.md`. Log format and readers: +`docs/field_logs.md`. On the field, time is short: run the one command, read its "!!" lines, +fix only those. + +## At the start + +1. `pixi run field-check` (radios 0-7; `--radios 0 1` for fewer). It checks vision for 2 s + (cameras, packets per second, field size, ball, lids), then finds the robots: each radio + turns ~70° on the spot (keep 15 cm clear), the lid that turned is its, with the share of + commands answered and whether its profile was calibrated on that lid. Every line is "ok" or + "!!". It cannot see batteries or kicker charge. +2. On a "!!": + - **Vision quiet or dropping**: check the network link before any code. Multicast over a + 2.4 GHz phone hotspot dropped frames on 2026-10-29. `pixi run python tools/vision_check.py + --seconds 5` listens alone; `--guided ball` checks cameras against 9 known spots. + - **Under 80% of commands answered**: range, interference or a flat battery. + - **Lid swapped**: `pixi run find-robots`, and calibrate again (the profile's tag offset + belongs to the lid). + +## Measuring a robot + +`pixi run calibrate --radio N` (65 s of driving, then the robot fetches a ball for the carry +ladder and kicks). It writes `config/robots/radio_.json`; `--check` compares with the +committed profile, `--ball-only` redoes the ball part. Commit a new profile only when it +repeats. Known numbers: ~79 ms loop delay, sideways acceleration well below forward; carry +caps are 0.3 m/s and 0.6 rad/s on real robots (balls are lost turning faster). + +## Things not to chase on the day + +- Kick strength varies (battery, charge, many causes). The kicker is fixed power and holds its + charge ~30 s; `team_controller/src/controllers/real/kicker_charge.py` keeps it up in play. +- Kick bend comes from the ball's offset on the dribbler (fitted per radio). +- The sim does not model a robot's shortfalls: robot capability is assumed league-level in sim, + and real robots' gaps are compensated in the control layer, not in sim settings. + +## After the session + +1. **Keep the raw logs.** `replays/field/_real_.log.gz`. Never delete + an untrimmed log or archive; ask before deleting anything under `replays/`. +2. **Trim dead time** to new files: `pixi run python tools/trim_idle_log.py + replays/field/.log.gz --dry-run`, then without `--dry-run` (`--in-place` only on copies). +3. **Register the session** in `tools/field_sessions.json`: its setup, and which measurements + (`loop_delay`, `ball_roll`, `ball_noise`, `robot_noise`) it may be used for. Only registered + sessions are read. +4. **Measure the world**: `pixi run python tools/field_physics.py [--json OUT]` prints each + measurement per (day, radio) with its spread and whether the days agree. Stop rule: a number + enters the sim (`tools/evaluation/reference/world.json`) only if it repeats across days, or + its spread is deliberately used as the range. Changing `world.json` changes every match's + environment: every stored result plays again, so batch it and ask first. +5. **One robot's numbers from a log**: `pixi run python tools/robot_calibration.py + replays/field/.log [--json OUT]`. +6. **Share**: `pixi run python tools/package_logs.py field [DIR] [--dry-run]` compresses the + logs and bundles calibration and hardware config. +7. **Write down** what broke and what was measured (a dated note; open follow-ups listed). + Bugs seen on the pitch go through the `debug-incident` skill with the field log as the + replay (`docs/field_log_replay.md`). diff --git a/.gitignore b/.gitignore index 77556986..7c77de50 100644 --- a/.gitignore +++ b/.gitignore @@ -209,7 +209,8 @@ benchmark_results/ # local agent-tool config dirs .codex/ .agents/ -.claude/ +.claude/* +!.claude/skills/ .vscode diff --git a/AGENTS.md b/AGENTS.md index 4c09c0f1..68935356 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -161,6 +161,11 @@ declarations) — check there before reintroducing one of them. `docs/README.md` indexes every doc by kind and `docs/tools.md` every script; the ones agents need most: +- `.claude/skills/` — three step-by-step playbooks over those scripts (plain Markdown, readable by + any agent): `explain-result` (how a strategy plays, why it won or lost), `debug-incident` (one bad + moment, from symptom to a fixed cause with a test), `field-session` (a test day on real robots and + its logs). + - `docs/STRATEGY_DEVELOPMENT.md` — tactic-kernel model, referee handling, writing a `Tactic`, observability tooling. Read before any strategy-layer change. - `docs/tactic_model_design_decisions.md` — kernel/Tactic/Partitioner design rationale. diff --git a/docs/tools.md b/docs/tools.md index 84aa3a25..0f7b6241 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -9,6 +9,9 @@ Pick the tool by the question you have. Only tools that exist are named in this *planned* are designed but not built: see [strategy_tools_plan.md](strategy_tools_plan.md), which also says why the tools are split this way. +For the three jobs that chain several of them, follow a skill in `.claude/skills/`: `explain-result`, +`debug-incident`, `field-session`. + | Question | Tool | |---|---| | Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` reports them with how many matches checked them | From c128d9820e10cd20506e10129eea32e30ba16dab Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:19:00 +0000 Subject: [PATCH 26/59] cleanup: drop the restart fuzzer and the fixed settings from the environment Nothing turned the fuzzer on after evaluate.py lost --fuzz-restarts, and the planner is always fpp, so neither belongs in a match's environment id. The store is still empty, so changing the id replays nothing. ROUND_ROBIN_ENTRY becomes MATCH_ENTRY (same value, so no fingerprint moves); the dashboard's comments and three historical docs point at the strategy renames. Co-Authored-By: Claude Opus 5.5 --- docs/STRATEGY_DEVELOPMENT.md | 7 +- docs/custom_referee.md | 16 - docs/signal_report.md | 3 + docs/signals.md | 3 + docs/sim_realism.md | 3 + docs/strategy_tools_plan.md | 3 +- docs/tools.md | 2 +- tools/evaluation/evaluate.py | 3 - tools/evaluation/match.py | 23 +- tools/sim_setup.py | 19 +- utama_core/custom_referee/restart_fuzzer.py | 432 ------------------ utama_core/dashboard/static/tournament.js | 8 +- utama_core/replay/fingerprint.py | 4 +- utama_core/replay/match_results.py | 13 +- .../custom_referee/test_restart_fuzzer.py | 277 ----------- utama_core/tests/replay/test_fingerprint.py | 37 +- utama_core/tests/replay/test_match_results.py | 7 - utama_core/tests/tools/test_sim_setup.py | 7 - 18 files changed, 42 insertions(+), 825 deletions(-) delete mode 100644 utama_core/custom_referee/restart_fuzzer.py delete mode 100644 utama_core/tests/custom_referee/test_restart_fuzzer.py diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 081d3ba4..9a3e9ce1 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -239,8 +239,8 @@ changes and run one evaluation over the batch. **Reuse is automatic.** A match the match results store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played; there is no flag. A match's fixture is its -environment (the shared code and machine, the match length, the planner, the sim noise without its -seed, the restart fuzzing), both players' fingerprints, their sides and the noise seed. So after a +environment (the shared code and machine, the match length, the sim noise without its +seed), both players' fingerprints, their sides and the noise seed. So after a change to one strategy only its matches play. What counts as "runs" is `utama_core/replay/fingerprint.py`'s: the strategy's own module, every module that imports (`strategy/pickers.py`, the tactics, the planner and its compiled library among them, whole files), @@ -406,9 +406,6 @@ whoever runs it. `diagnosis` (ball in goal / past a line, taker not closing on the ball, taker at the ball but not kicking). The tournament prints a STALLS section, and writes it to `summary.json`; a possession-pinned backstop flags what the watchdog misses. -- **Restart fuzzing** (`custom_referee/restart_fuzzer.py`) — injects legal restarts at - seeded-random times to exercise auto-advance paths; same seed and interval reproduce the - schedule. No tool turns it on today (`sim_setup.sim_referee(fuzz_seed=...)`). Details: `docs/custom_referee.md`. - **Sim noise** (`rsoccer_simulator/src/Utils/sim_noise.py`, `--sim-noise JSON`) — seeded command latency per robot, kick speed and direction noise (a per-robot offset plus kick-to-kick spread), two-phase ball friction (slide after a kick, then roll), per-robot diff --git a/docs/custom_referee.md b/docs/custom_referee.md index f32cf0bf..263af426 100644 --- a/docs/custom_referee.md +++ b/docs/custom_referee.md @@ -130,22 +130,6 @@ unchanged. `CustomReferee.reset()` restores score/stage/command/timers for a new (`BaseRule.reset_for_new_episode()` also clears `GoalRule`'s cooldown); call `seed_clock()` again afterwards. -## Restart fuzzing (`RestartFuzzingReferee`) - -`custom_referee/restart_fuzzer.py`: an opt-in subclass that injects legal restarts at -seeded-random sim times during live play (never on top of a queued restart), via the same -public `set_command` path an operator uses, so a stall it exposes is a real one. rsim is -deterministic, so this is how an evaluation explores new restart geometries. Kinds: ball -placement → `DIRECT_FREE_*` (position ≥0.25m infield, ≥0.2m from both defense areas), -`PREPARE_KICKOFF_*`, and `STOP` → `FORCE_START`. `referee.injections` records each one; with a -`MatchLog` attached, they are traced as `restart_fuzzer_injection`. No tool turns it on today (`evaluate.py --fuzz-restarts` was removed on -2026-11-12): pass `fuzz_seed` to `tools/sim_setup.sim_referee` to use it. - -```python -referee = RestartFuzzingReferee.from_profile_name("simulation", seed=1, interval_s=(8.0, 20.0), - n_robots_yellow=6, n_robots_blue=6) -``` - ## Known gaps - **Last-touch attribution needs contact data for both teams.** Enemy `has_ball` is filled diff --git a/docs/signal_report.md b/docs/signal_report.md index 6e78b37e..38d48abb 100644 --- a/docs/signal_report.md +++ b/docs/signal_report.md @@ -3,6 +3,9 @@ What each strategy does well and badly, from the signals in [`signals.md`](signals.md), drawn from one round-robin. Standings are in [`strategies.md`](strategies.md); this shows why. +*Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names +(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). + **Run:** `tournament_20261017_151052` (sim-realism-20261016 at `423f63a0`, the 12 non-retired configs, 66 matches, sim noise `v3_seed2`). Regenerate the figures after a new full round-robin, then rewrite the notes: diff --git a/docs/signals.md b/docs/signals.md index 8f1ad223..42999260 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -4,6 +4,9 @@ Every signal we record about how a strategy plays, grouped by the question it an when designing or debugging a strategy: find the question, read the signal, compare with the reference range, and follow "if it's off". Add a signal here when you add one anywhere else. +*Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names +(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). + Signals are diagnostics, not objectives: use them to explain a result, to find what a strategy does badly, and to notice a shared primitive (reception, carrying, the planner, the referee) failing every strategy at once. A strategy that never passes or shoots loses the ball least, so diff --git a/docs/sim_realism.md b/docs/sim_realism.md index 001b4f02..6514bbf7 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -3,6 +3,9 @@ Status: plan, 2026-10-14 (priorities added 2026-10-16; Phases 0-2 are built, 2026-10-16/17). Nothing below is built yet unless it says so. +*Strategy names:* results here were recorded before the 2026-11-12 renames and use the old names +(`split_shape` is now `pendulum`, ...); the full map is the "Was" column in [`strategies.md`](strategies.md). + ## Where this leads The end goal is **search over the structured strategy space**: tactics, their parameters, and diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 05b0dec1..9acf8094 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -71,8 +71,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: opponents, no `--vs-champion`, no standings. The strategies were renamed the same day (`catalog.RENAMED`). 5. **One shared match and runner construction** for every tool. `tools/sim_setup.py` has `load_side` (a - catalog name, a `.strategy` file or `PATH.py:FUNCTION`), `sim_referee` (the referee, its kickoff team and - seeded restart fuzzing) and `sim_runner` (the rsim `StrategyRunner`). `repro_from_replay.py`, `moments.py`, + catalog name, a `.strategy` file or `PATH.py:FUNCTION`), `sim_referee` (the referee and its kickoff team) and `sim_runner` (the rsim `StrategyRunner`). `repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py` and `tools/evaluation/match.py` all build through them, so every tool plays `.strategy` files and the referee and runner exist in one place. `main.py` keeps its dashboard: the referee is built before the dashboard attaches, the runner after. `match.py`'s fingerprint changed with diff --git a/docs/tools.md b/docs/tools.md index 0f7b6241..9a82b764 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -52,7 +52,7 @@ For the three jobs that chain several of them, follow a skill in `.claude/skills | Script | Purpose | |---|---| | `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | -| `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | +| `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | | `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for `evaluate.py`, with the set-up from `tools/sim_setup.py` (not run directly) | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 04fce876..3298c95b 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -262,9 +262,6 @@ def main(argv: Optional[list[str]] = None) -> None: env_args = { "duration_seconds": MAX_MATCH_SECONDS, "sim_noise": noise, - "control_scheme": "fpp", - "fuzz_seed": None, - "fuzz_interval_s": (25.0, 45.0), } graph = CodeGraph() env = match_results.environment(graph, **env_args) diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index d75a6fac..0bb84bf6 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -7,7 +7,7 @@ the right kickoff-team/initial-command, wire up match_log/stats/replay paths, build and step a `StrategyRunner`, read back the score) that had drifted into two independent copies differing only in a few real parameters (duration, -whether side/kickoff are fixed or swept, fuzzing). Correctness fixes found in +whether side/kickoff are fixed or swept). Correctness fixes found in one copy (the `PREPARE_KICKOFF_*` vs `FORCE_START` kickoff-ceremony fix; the `_stats_to_dict` StallEvent-serialization fix) had to be manually ported to the other and could easily have been missed. This module is the single place @@ -122,9 +122,6 @@ def run_match( a_kicks_off: bool = True, run_dir: Optional[Path] = None, match_tag_suffix: str = "", - control_scheme: str = "fpp", - fuzz_seed: Optional[int] = None, - fuzz_interval_s: tuple[float, float] = (25.0, 45.0), sim_noise: Optional[SimNoise] = None, ) -> MatchResult: """Play one match between two strategies, until the referee calls full @@ -156,15 +153,7 @@ def run_match( `match_tag_suffix` is appended to the per-match file tag (e.g. a side/ kickoff cell tag like `_Rk`) so cells for the same pair don't collide. - `control_scheme` is used for both sides (matching StrategyRunner's - default of falling back to `control_scheme` when `opp_control_scheme` is - unset) — these tournament drivers compare strategies against each other, - not motion planners against each other (see - `tools/motion_planning_benchmark.py` for that). - - `fuzz_seed`, if set, swaps in `RestartFuzzingReferee` (see - `utama_core/custom_referee/restart_fuzzer.py`), so this match's referee, built by - `sim_setup.sim_referee`, injects extra seeded-random legal restarts during live play. + Both sides use the fpp planner (`tools/motion_planning_benchmark.py` compares planners). `sim_noise`, if set, plays the match with seeded latency, kick speed noise and vision noise (`utama_core/rsoccer_simulator/src/Utils/sim_noise.py`, `docs/sim_realism.md`). The draws @@ -176,9 +165,7 @@ def run_match( strategy_a = load_side(config_a_name) strategy_b = load_side(config_b_name) # config_a kicks off unless told otherwise; the referee's kickoff team and the ceremony follow it. - referee = sim_referee( - kickoff_team="yellow" if a_kicks_off else "blue", fuzz_seed=fuzz_seed, fuzz_interval_s=fuzz_interval_s - ) + referee = sim_referee(kickoff_team="yellow" if a_kicks_off else "blue") initial_command = RefereeCommand.PREPARE_KICKOFF_YELLOW if a_kicks_off else RefereeCommand.PREPARE_KICKOFF_BLUE match_tag = f"{_short_name(config_a_name)}_vs_{_short_name(config_b_name)}{match_tag_suffix}" @@ -203,8 +190,6 @@ def run_match( replay_name=f"{run_dir.name}/{match_tag}", overwrite_existing=True ) - resolved_scheme = None if control_scheme in (None, "auto") else control_scheme - runner, _ = sim_runner( strategy_a, strategy_b, @@ -212,7 +197,7 @@ def run_match( initial_command=initial_command, referee=referee, my_team_is_right=a_is_right, - control_scheme=resolved_scheme, + control_scheme="fpp", **extra_kwargs, ) diff --git a/tools/sim_setup.py b/tools/sim_setup.py index 3f425b4a..00696001 100644 --- a/tools/sim_setup.py +++ b/tools/sim_setup.py @@ -4,8 +4,7 @@ - `load_side(name)`: a strategy by catalog name, a `.strategy` file by path, or `PATH.py:FUNCTION` (a `build(outfield_robot_ids, motion_controller)` in a scratch file, to try a tactic without a repo change). -- `sim_referee(...)`: the referee of an rsim match: the "simulation" profile, with the kickoff team and, - for a seeded run, the restart fuzzing (`custom_referee/restart_fuzzer.py`). +- `sim_referee(...)`: the referee of an rsim match: the "simulation" profile, with the kickoff team. - `sim_runner(strategy, opponent, ...)`: the `StrategyRunner` for a 6-a-side rsim match against a referee (`sim_referee()` by default), our side yellow on the right, vision stream off. @@ -24,7 +23,6 @@ from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy from utama_core.custom_referee import CustomReferee from utama_core.custom_referee.profiles.profile_loader import load_profile -from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise @@ -75,22 +73,11 @@ def load_side(name: str, outfield_robot_ids: Optional[tuple[int, ...]] = None) - return AbstractStrategy(build=factory_for(name)(outfield_robot_ids or OUTFIELD_ROBOT_IDS)) -def sim_referee( - *, - kickoff_team: str = "yellow", - fuzz_seed: Optional[int] = None, - fuzz_interval_s: tuple[float, float] = (25.0, 45.0), -) -> CustomReferee: - """The referee of an rsim match: the "simulation" profile, `kickoff_team` taking the first kickoff. - With `fuzz_seed`, a `RestartFuzzingReferee` injecting seeded extra legal restarts `fuzz_interval_s` - apart.""" +def sim_referee(*, kickoff_team: str = "yellow") -> CustomReferee: + """The referee of an rsim match: the "simulation" profile, `kickoff_team` taking the first kickoff.""" profile = load_profile("simulation") if kickoff_team != profile.game.kickoff_team: profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, kickoff_team=kickoff_team)) - if fuzz_seed is not None: - return RestartFuzzingReferee( - profile, seed=fuzz_seed, interval_s=fuzz_interval_s, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS - ) return CustomReferee(profile, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) diff --git a/utama_core/custom_referee/restart_fuzzer.py b/utama_core/custom_referee/restart_fuzzer.py deleted file mode 100644 index 6969b3f9..00000000 --- a/utama_core/custom_referee/restart_fuzzer.py +++ /dev/null @@ -1,432 +0,0 @@ -"""RestartFuzzingReferee: opt-in referee subclass that injects scripted restarts. - -Motivation (see `docs/STRATEGY_DEVELOPMENT.md` / `docs/custom_referee.md`): -rsim is deterministic, and the 231-pairing round-robin tournament always -starts from the same kickoff and only ever *reacts* to whatever restarts -naturally occur during a match — most of which never happen at all in a -given pairing/formation. Most stalls found in practice have been in referee -restart auto-advance paths (`GameStateMachine.step()`'s five `Auto-advance` -blocks in `state_machine.py`) that only get exercised when a real foul/goal -happens to occur. `RestartFuzzingReferee` exercises those code paths far -more often, in many more ball/robot geometries, by injecting additional -*legal* restarts at seeded-random sim times during otherwise-normal live -play. - -This is deliberately a thin subclass, not a new referee: `CustomReferee` -already owns rule-checking, state transitions, and auto-advance; this class -only decides *when* and *what* to inject, then calls the same public -`set_command` API a human operator or scenario script would use (see -`utama_core/tests/strategy_runner/test_scenario_hooks.py`'s -`test_custom_referee_set_command_accepts_scripted_metadata`). Because -`set_command` inserts a real `STOP` before any set-piece command (see -`GameStateMachine.set_command`), an injected restart goes through exactly -the same `STOP -> queued restart -> NORMAL_START` auto-advance sequence a -naturally-detected foul/goal would, so a stall it exposes is indistinguishable -from — and just as real as — a naturally occurring one. - -`StrategyRunner` never needs to know about this class: it only checks -`isinstance(self.referee, CustomReferee)` (see `strategy_runner.py`) before -calling `referee.step(...)`, `referee.attach_match_log(...)`, etc. — all of -which this subclass inherits or overrides compatibly. -""" - -from __future__ import annotations - -import random -from dataclasses import dataclass -from typing import Optional - -from utama_core.custom_referee.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile -from utama_core.entities.data.referee import RefereeData -from utama_core.entities.game.game_frame import GameFrame -from utama_core.entities.referee.referee_command import RefereeCommand - -# Commands that count as "live play" — the only state an injection may -# start from (mirrors OutOfBoundsRule/BallSpeedRule/DefenseAreaRule's own -# `_ACTIVE_PLAY_COMMANDS` gating, kept independently here since we do not own -# any of those rule files). -_LIVE_PLAY_COMMANDS = frozenset({RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START}) - -# Rulebook margin (SSL §8.4.1: "keep at least 0.2 meters distance to the -# opponent defense area") reused from defense_area_stoppage_rule.py's -# `_MIN_DISTANCE` — not imported directly since that name is a private -# module constant of a file we don't own; duplicated as a literal with the -# same provenance noted here rather than reimplementing the geometry. -_DEFENSE_AREA_MARGIN = 0.2 - -# Delay (sim seconds) between the injected STOP and its FORCE_START -# follow-up for KIND_FORCE_START — long enough for `_all_robots_clear()`'s -# 0.5 m keep-out check (state_machine.py's `_BALL_CLEAR_DIST`) to plausibly -# be satisfied by the time FORCE_START lands, short enough to stay well -# under `_STOP_CLEAR_TIMEOUT_SECONDS` (15 s) so this follow-up is never -# mistaken for — or masks — the auto-advance stall detector it's meant to -# exercise coverage of. -_FORCE_START_STOP_DELAY_S = 2.0 - -# Field-line margin for a playable placement spot — mirrors -# OutOfBoundsRule._INFIELD_OFFSET (0.25 m), which OutOfBoundsRule itself -# picked "for a playable free-kick placement" against the same field-line -# geometry a fuzzed ball-placement target needs to respect. -_FIELD_LINE_MARGIN = 0.25 - -# Kinds of restart this fuzzer knows how to inject. Each is a self-contained -# scripted sequence built entirely from the public `set_command` API. -KIND_BALL_PLACEMENT_DIRECT_FREE = "ball_placement_direct_free" -KIND_FORCE_START = "force_start" -KIND_PREPARE_KICKOFF = "prepare_kickoff" - -ALL_KINDS = ( - KIND_BALL_PLACEMENT_DIRECT_FREE, - KIND_FORCE_START, - KIND_PREPARE_KICKOFF, -) - - -@dataclass(frozen=True) -class Injection: - """One record of a fuzzer-injected restart, kept on `injections` so a - caller (validation script, test) can log/inspect what was injected.""" - - sim_time: float - kind: str - team_is_yellow: Optional[bool] # None for kinds with no team (none currently, kept for forward-compat) - position: Optional[tuple[float, float]] # designated_position, when the kind sets one - - -class RestartFuzzingReferee(CustomReferee): - """`CustomReferee` subclass that periodically injects a scripted, legal - restart during live play, on top of whatever the rule checkers detect - naturally. - - Usage:: - - referee = RestartFuzzingReferee.from_profile_name( - "simulation", seed=1, interval_s=(8, 20), n_robots_yellow=6, n_robots_blue=6 - ) - runner = StrategyRunner(..., referee=referee) - runner.run() - for inj in referee.injections: - print(inj) - - Args: - profile: Same `RefereeProfile` `CustomReferee.__init__` takes. - seed: RNG seed. Same seed (and same sequence of `step()` sim times) - always produces the same injection schedule, kinds, teams, and - positions — see `test_seed_determinism`. - interval_s: `(min, max)` sim-seconds range between injections; - each gap is drawn uniformly from this range using `seed`. - kinds: Which injection kinds are enabled (subset of `ALL_KINDS`). - Defaults to all three. - n_robots_yellow, n_robots_blue: Passed through to `CustomReferee`. - """ - - def __init__( - self, - profile, - seed: int, - interval_s: tuple[float, float] = (8.0, 20.0), - kinds: tuple[str, ...] = ALL_KINDS, - n_robots_yellow: int = 3, - n_robots_blue: int = 3, - ) -> None: - super().__init__(profile, n_robots_yellow=n_robots_yellow, n_robots_blue=n_robots_blue) - if interval_s[0] <= 0 or interval_s[1] < interval_s[0]: - raise ValueError(f"interval_s must be a positive, non-decreasing (min, max) pair, got {interval_s}") - if not kinds: - raise ValueError("kinds must be non-empty") - unknown = set(kinds) - set(ALL_KINDS) - if unknown: - raise ValueError(f"unknown injection kind(s): {sorted(unknown)}") - - self._seed = seed - self._interval_s = interval_s - self._kinds = tuple(kinds) - self._rng = random.Random(seed) - - # Scheduled sim-time of the next injection. Set lazily on the first - # `step()` call once we know the clock's starting sim time (mirrors - # how `CustomReferee.seed_clock()` defers timer alignment until the - # first real game frame — we do the same here for the same reason: - # rsim time and grsim/real wall-clock time start from very different - # bases). - self._next_injection_time: Optional[float] = None - - # Pending follow-up for the two-step STOP-then-FORCE_START sequence - # (KIND_FORCE_START): the sim time at which to issue the follow-up - # `set_command`, or None when no follow-up is pending. Deferred to a - # later tick (rather than issued in the same `step()` call as the - # STOP) so the STOP is a real, observable tick on its own — the same - # shape a human GC operator or `strategy_runner.py`'s own - # STOP-after-goal fast path uses — and so a stalled STOP->FORCE_START - # transition is genuinely detectable rather than being collapsed - # into a single atomic call. - self._pending_force_start_at: Optional[float] = None - - # Pending follow-up for the KIND_BALL_PLACEMENT_DIRECT_FREE sequence: - # `(placement_cmd, direct_free_cmd)` once the initial `set_command` - # (queuing STOP -> placement_cmd) has been issued, or `None`. Consumed - # the moment `step()` observes `referee_command == placement_cmd` - # (i.e. GameStateMachine's own STOP auto-advance has actually flipped - # into it), at which point `next_command` is overwritten to - # `direct_free_cmd` so ball placement resumes into a real free kick - # instead of straight to NORMAL_START. See `_inject`'s - # KIND_BALL_PLACEMENT_DIRECT_FREE branch for why this two-step dance - # is necessary rather than a single `set_command(..., next_command=)` - # call. - self._pending_direct_free: Optional[tuple[RefereeCommand, RefereeCommand]] = None - - self.injections: list[Injection] = [] - - @classmethod - def from_profile_name( - cls, - name: str, - seed: int, - interval_s: tuple[float, float] = (8.0, 20.0), - kinds: tuple[str, ...] = ALL_KINDS, - n_robots_yellow: int = 3, - n_robots_blue: int = 3, - ) -> "RestartFuzzingReferee": - """Convenience constructor mirroring `CustomReferee.from_profile_name`.""" - profile = load_profile(name) - return cls( - profile, - seed=seed, - interval_s=interval_s, - kinds=kinds, - n_robots_yellow=n_robots_yellow, - n_robots_blue=n_robots_blue, - ) - - # ------------------------------------------------------------------ - # Main loop interface - # ------------------------------------------------------------------ - - def step(self, game_frame: GameFrame, current_time: float) -> RefereeData: - """Delegate to `CustomReferee.step()`, then decide whether to inject.""" - result = super().step(game_frame, current_time) - - # Fire any pending BALL_PLACEMENT_* -> DIRECT_FREE_* follow-up (see - # `_pending_direct_free`) once the state machine has actually - # transitioned into the queued placement command. - if self._pending_direct_free is not None: - placement_cmd, direct_free_cmd = self._pending_direct_free - if result.referee_command == placement_cmd: - self._pending_direct_free = None - self._state.next_command = direct_free_cmd - result = self._state._generate_referee_data(current_time) - - # Fire any pending STOP -> FORCE_START follow-up (see - # `_pending_force_start_at`) before considering a brand new - # injection, so the two never race within the same tick. - if self._pending_force_start_at is not None and current_time >= self._pending_force_start_at: - self._pending_force_start_at = None - self.set_command( - RefereeCommand.FORCE_START, - timestamp=current_time, - status_message="restart_fuzzer: injected FORCE_START", - ) - # `set_command` mutates `self._state` directly but (unlike - # `step()`) doesn't return a fresh `RefereeData` snapshot — ask - # the state machine to regenerate one so this method's return - # value reflects the FORCE_START we just issued, same as every - # other caller of `CustomReferee.step()` expects a same-tick - # snapshot. `_generate_referee_data` is a private read-only - # accessor (no state mutation) on `GameStateMachine`, which we - # don't own — used here rather than duplicating its trivial - # dataclass-construction logic. - result = self._state._generate_referee_data(current_time) - - if self._next_injection_time is None: - self._schedule_next(current_time) - return result - - if current_time < self._next_injection_time: - return result - - if ( - not self._is_live_play(result) - or self._pending_force_start_at is not None - or self._pending_direct_free is not None - ): - # Not currently eligible (mid-restart, just after a goal / ball - # not yet back in play, or a FORCE_START follow-up is already - # pending) — don't burn the schedule; just wait for the next - # tick and re-check. This means an injection can fire slightly - # later than `_next_injection_time` if the game happens to be - # mid-restart exactly then, but it will never fire *during* one. - return result - - self._inject(game_frame, current_time) - self._schedule_next(current_time) - return result - - # ------------------------------------------------------------------ - # Scheduling - # ------------------------------------------------------------------ - - def _schedule_next(self, current_time: float) -> None: - gap = self._rng.uniform(*self._interval_s) - self._next_injection_time = current_time + gap - - def _is_live_play(self, ref_data: RefereeData) -> bool: - """True iff the game is in ordinary live play right now: command is - NORMAL_START/FORCE_START (not mid-restart), and there is no - just-scored-goal ball-placement queued (a goal always routes through - `designated_position=(0.0, 0.0)` + a queued `BALL_PLACEMENT_*`/ - `PREPARE_KICKOFF_*` `next_command` per `GameStateMachine._handle_goal` - — `next_command is None` during genuine live play, since it's only - ever populated while a restart is queued/in-flight). - """ - return ref_data.referee_command in _LIVE_PLAY_COMMANDS and ref_data.next_command is None - - # ------------------------------------------------------------------ - # Injection - # ------------------------------------------------------------------ - - def _inject(self, game_frame: GameFrame, current_time: float) -> None: - kind = self._rng.choice(self._kinds) - team_is_yellow = self._rng.choice([True, False]) - - if kind == KIND_BALL_PLACEMENT_DIRECT_FREE: - position = self._random_legal_position() - placement_cmd = ( - RefereeCommand.BALL_PLACEMENT_YELLOW if team_is_yellow else RefereeCommand.BALL_PLACEMENT_BLUE - ) - direct_free_cmd = RefereeCommand.DIRECT_FREE_YELLOW if team_is_yellow else RefereeCommand.DIRECT_FREE_BLUE - # Chain BALL_PLACEMENT_* -> DIRECT_FREE_* -> NORMAL_START the same - # way a real foul does (GameStateMachine._handle_foul routes a - # foul's designated_position through ball placement first, then - # `_post_ball_placement_command` resumes into the real restart - # command once placement completes — see auto-advance 1 and 4 in - # state_machine.py). `_post_ball_placement_command` has no public - # setter, so it can't be reached through `set_command()` alone: - # passing `next_command=direct_free_cmd` to `set_command()` would - # silently overwrite the STOP-insertion's own `next_command = - # placement_cmd` and skip ball placement entirely (verified via a - # scratch rsim run: BALL_PLACEMENT_BLUE never appeared in the - # observed command history when this was tried). Two separate - # `set_command()` calls avoid that clobber: the first queues - # BALL_PLACEMENT_* behind a STOP exactly like a real foul would; - # once GameStateMachine's own auto-advance 1 flips STOP -> - # BALL_PLACEMENT_* (next_command defaults to NORMAL_START at that - # point per auto-advance 1's `self.next_command = - # self._post_ball_placement_command or RefereeCommand.NORMAL_START`), - # the second call (scheduled via `_pending_direct_free`, fired - # from `step()` once BALL_PLACEMENT_* is actually observed) - # overwrites `next_command` to the real DIRECT_FREE_* so auto- - # advance 4 resumes into it instead of straight to NORMAL_START. - self.set_command( - placement_cmd, - timestamp=current_time, - designated_position=position, - status_message="restart_fuzzer: injected ball placement", - ) - self._pending_direct_free = (placement_cmd, direct_free_cmd) - elif kind == KIND_FORCE_START: - position = None - # FORCE_START is not itself a member of `_NEEDS_STOP_FIRST`, so - # `set_command` has no built-in way to queue it as a `next_command` - # the way it does for BALL_PLACEMENT_*/PREPARE_KICKOFF_*/ - # DIRECT_FREE_*. Script the same two-step shape a human GC - # operator (or `strategy_runner.py`'s own STOP-after-goal fast - # path) uses instead: issue STOP now, then a genuine follow-up - # `set_command(FORCE_START)` a few seconds later once robots have - # had a chance to react to the STOP — scheduled via - # `_pending_force_start_at` and fired from a later `step()` call - # (see there) rather than in this same tick, so the STOP is a - # real, independently observable transition and a stall in - # either half of the sequence is genuinely detectable. - self.set_command( - RefereeCommand.STOP, - timestamp=current_time, - status_message="restart_fuzzer: injected STOP before FORCE_START", - ) - self._pending_force_start_at = current_time + _FORCE_START_STOP_DELAY_S - elif kind == KIND_PREPARE_KICKOFF: - position = None - kickoff_cmd = ( - RefereeCommand.PREPARE_KICKOFF_YELLOW if team_is_yellow else RefereeCommand.PREPARE_KICKOFF_BLUE - ) - # Same metadata shape a real kickoff restart uses (no - # designated_position — kickoff readiness is centre-circle - # presence, not a placement target; see - # GameStateMachine._kicker_in_centre_circle). set_command() - # inserts STOP first since PREPARE_KICKOFF_* is in - # `_NEEDS_STOP_FIRST`. - self.set_command( - kickoff_cmd, - timestamp=current_time, - status_message="restart_fuzzer: injected kickoff", - ) - else: # pragma: no cover - guarded by __init__'s kinds validation - raise AssertionError(f"unhandled kind: {kind}") - - injection = Injection( - sim_time=current_time, - kind=kind, - team_is_yellow=team_is_yellow, - position=position, - ) - self.injections.append(injection) - - if self._match_log is not None: - self._match_log.trace( - tick=self._match_log_tick, - sim_time=current_time, - key="restart_fuzzer_injection", - value={ - "kind": kind, - "team_is_yellow": team_is_yellow, - "position": list(position) if position is not None else None, - }, - ) - - def _random_legal_position(self) -> tuple[float, float]: - """Draw a designated-placement position that is legal per the SSL - rulebook: inside the field, outside both defense areas, and at - least the rulebook margin from the field boundary lines. - - Reuses `RefereeGeometry`'s own inside-field/defense-area helpers - (`is_in_field` is not used directly — sampling is done within a - margin-shrunk field rectangle from the start, so every draw is - legal by construction rather than rejection-sampled against - `is_in_field`) plus `is_in_left/right_defense_area` to reject draws - that land inside a defense area (rare, since defense areas sit at - the ends of the field, but not impossible for a draw near the - margin-shrunk rectangle's x-extremes). - """ - geometry = self.geometry - x_bound = geometry.half_length - _FIELD_LINE_MARGIN - y_bound = geometry.half_width - _FIELD_LINE_MARGIN - - for _ in range(1000): - x = self._rng.uniform(-x_bound, x_bound) - y = self._rng.uniform(-y_bound, y_bound) - if self._position_is_legal(x, y): - return (x, y) - # Practically unreachable (the margin-shrunk rectangle minus two - # defense-area rectangles at its ends still covers most of the - # field) — fall back to the centre spot, which is always legal on - # any standard or shrunk field geometry. - return (0.0, 0.0) - - def _position_is_legal(self, x: float, y: float) -> bool: - """True iff (x, y) is inside the field with the field-line margin - already baked into the caller's sampling rectangle, and at least - `_DEFENSE_AREA_MARGIN` from both defense areas (rulebook §8.4.1's - "0.2 meters distance to the opponent defense area", reused for - *either* defense area — an own-defense-area placement is illegal - for the same reason DefenseAreaRule keeps friendly robots out - during live play). Uses `RefereeGeometry.distance_to_left/right_ - defense_area`, which is already 0.0 for a point inside the - rectangle, so this rejects both "inside" and "too close" in one - check per side. - """ - geometry = self.geometry - if geometry.distance_to_left_defense_area(x, y) < _DEFENSE_AREA_MARGIN: - return False - if geometry.distance_to_right_defense_area(x, y) < _DEFENSE_AREA_MARGIN: - return False - return True diff --git a/utama_core/dashboard/static/tournament.js b/utama_core/dashboard/static/tournament.js index 05d22a6a..81a64b32 100644 --- a/utama_core/dashboard/static/tournament.js +++ b/utama_core/dashboard/static/tournament.js @@ -1,11 +1,11 @@ // Tournament view: standings + per-match results, sortable/expandable. // Successor concern to hand-reading round-robin log output — // reads replays//summary.json via the tournament view's Python side. -// A round_robin.py summary also carries a per-strategy table, stall +// A round summary (`evaluate.py`, or an older round_robin.py run) also carries a per-strategy table, stall // incidents, restart outcomes and fouls (docs/STRATEGY_DEVELOPMENT.md // "Reading a tournament run"); those are shown when present. Each result's // `replay` is the path of its replay file, or null (added server-side). -// `round_robin.py` writes `winner` as the literal string "draw" on +// `evaluate.py` (like the older round_robin.py) writes `winner` as the literal string "draw" on // a tie (never null), and `standings` only carries wins/draws per config — // losses/GF/GA/win% are derived here from `results`, not shipped precomputed. @@ -65,7 +65,7 @@ return rows; } - // round_robin.py's per-strategy table (summary.json `strategies`). + // a round's per-strategy table (summary.json `strategies`). function strategyRows(run) { return Object.entries(run.strategies).map(([name, s]) => ({ name, @@ -170,7 +170,7 @@ ]; function cellLabel(r, pairA) { - // round_robin.py plays each pair once, config_a as yellow + // a round plays each pair once, config_a as yellow if (r.a_is_right === undefined) return `${short(r.config_a)} (yellow) vs ${short(r.config_b)}`; // r.config_a may be either physical config depending on which side of // the 4-cell product ran; re-express relative to pairA (the group's diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index 8ad8837f..c6f53ce4 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -15,7 +15,7 @@ name, version and build), the installed robosim binary, the CPU model and the environment variables that change numerics. Not the code behind the process boundary (`PLAYER_SIDE`): a `.strategy` file brings its own, so editing a skill replays no match between two files. -- The run settings (duration, planner, sim noise, restart fuzzing, sides) and the two players' +- The run settings (duration, sim noise, sides) and the two players' fingerprints make up a match's fixture in `replay/match_results.py`. `audit()` lists every place the code reaches outside the import graph @@ -45,7 +45,7 @@ REPO_ROOT = Path(__file__).resolve().parents[2] STRATEGY_PACKAGE = "utama_core.strategy" -ROUND_ROBIN_ENTRY = "tools.evaluation.match" +MATCH_ENTRY = "tools.evaluation.match" # Behind the process boundary: a player's own code, which a `.strategy` file carries a copy of. PLAYER_SIDE = ( diff --git a/utama_core/replay/match_results.py b/utama_core/replay/match_results.py index 35079883..2583bc4d 100644 --- a/utama_core/replay/match_results.py +++ b/utama_core/replay/match_results.py @@ -1,8 +1,7 @@ """Every match result the evaluation tools have played, in one store: `replays/match_results/`. An rsim match is deterministic, so its result is a function of its fixture: the environment (the -shared code and machine, the match length, the planner, the sim noise without its seed and the -restart fuzzing), both players' code fingerprints (`fingerprint.py`), their sides and the noise +shared code and machine, the match length and the sim noise without its seed), both players' code fingerprints (`fingerprint.py`), their sides and the noise seed. `tools/evaluation/evaluate.py`'s `play_and_record` plays a fixture and returns its record; `evaluate.py` looks a fixture up first and plays it only when the store does not hold it, then stores the record. Reuse is automatic: there is no flag. A player whose code @@ -27,7 +26,7 @@ from pathlib import Path from typing import Iterable, Optional -from utama_core.replay.fingerprint import ROUND_ROBIN_ENTRY, CodeGraph, _digest +from utama_core.replay.fingerprint import MATCH_ENTRY, CodeGraph, _digest STORE_NAME = "match_results" @@ -42,24 +41,18 @@ def environment( *, duration_seconds: float, sim_noise: Optional[dict], - control_scheme: str = "fpp", - fuzz_seed: Optional[int] = None, - fuzz_interval_s: tuple[float, float] = (25.0, 45.0), ) -> str: """Id of what every match of one evaluation or round-robin shares. `sim_noise` is `SimNoise.to_dict()`, its seed left out (the seed is part of the fixture).""" noise = {k: v for k, v in (sim_noise or {}).items() if k != "seed"} settings = { "duration_seconds": duration_seconds, - "control_scheme": control_scheme, "sim_noise": noise, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": list(fuzz_interval_s) if fuzz_seed is not None else None, } return _digest( [ "evaluation environment", - graph.base_fingerprint([ROUND_ROBIN_ENTRY]), + graph.base_fingerprint([MATCH_ENTRY]), json.dumps(settings, sort_keys=True), ] )[:16] diff --git a/utama_core/tests/custom_referee/test_restart_fuzzer.py b/utama_core/tests/custom_referee/test_restart_fuzzer.py deleted file mode 100644 index 4a66a1c0..00000000 --- a/utama_core/tests/custom_referee/test_restart_fuzzer.py +++ /dev/null @@ -1,277 +0,0 @@ -"""Tests for `RestartFuzzingReferee` (utama_core/custom_referee/restart_fuzzer.py). - -Covers: - - Seed determinism: same seed → identical injection schedule/kinds/positions. - - Injections only fire during live play (never mid-restart, never right - after a goal before the queued kickoff resolves). - - Every drawn `designated_position` is legal (inside field with margin, - outside both defense areas with margin) — checked over several hundred - seeded draws. - - The `kinds` filter is respected. - -No rsim match: how many injections a match gets depends on how play unfolds, which differs by CPU, -so such a test failed on CI while passing locally. -""" - -from __future__ import annotations - -import math - -from utama_core.config.field_params import STANDARD_FIELD_DIMS -from utama_core.custom_referee.geometry import RefereeGeometry -from utama_core.custom_referee.restart_fuzzer import ( - ALL_KINDS, - KIND_BALL_PLACEMENT_DIRECT_FREE, - KIND_FORCE_START, - KIND_PREPARE_KICKOFF, - RestartFuzzingReferee, -) -from utama_core.engine.abstract_strategy import AbstractStrategy -from utama_core.entities.data.vector import Vector2D, Vector3D -from utama_core.entities.game.ball import Ball -from utama_core.entities.game.game_frame import GameFrame -from utama_core.entities.game.robot import Robot -from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.run.strategy_runner import StrategyRunner -from utama_core.strategy.catalog import builder - -GEO = RefereeGeometry.from_field_dims(STANDARD_FIELD_DIMS) - -# --------------------------------------------------------------------------- -# Helpers (mirrors utama_core/tests/custom_referee/test_custom_referee.py) -# --------------------------------------------------------------------------- - - -def _ball(x: float, y: float, vx: float = 0.0, vy: float = 0.0) -> Ball: - return Ball(p=Vector3D(x, y, 0.0), v=Vector3D(vx, vy, 0.0), a=Vector3D(0, 0, 0)) - - -def _robot(robot_id: int, x: float, y: float, is_friendly: bool) -> Robot: - return Robot( - id=robot_id, - is_friendly=is_friendly, - has_ball=False, - p=Vector2D(x, y), - v=Vector2D(0, 0), - a=Vector2D(0, 0), - orientation=0.0, - ) - - -def _frame( - ts: float, - ball_xy: tuple[float, float] = (0.0, 0.0), - friendly: dict | None = None, - enemy: dict | None = None, -) -> GameFrame: - return GameFrame( - ts=ts, - my_team_is_yellow=True, - my_team_is_right=False, - friendly_robots=friendly or {}, - enemy_robots=enemy or {}, - ball=_ball(*ball_xy), - referee=None, - ) - - -def _far_from_ball_robots() -> dict[int, Robot]: - """A handful of robots far from the ball/centre so `_all_robots_clear()` - is satisfied immediately and STOP auto-advances without needing to wait - out `_STOP_CLEAR_TIMEOUT_SECONDS`.""" - return { - 0: _robot(0, -3.0, 2.0, True), - 1: _robot(1, -3.0, -2.0, True), - 2: _robot(2, 3.0, 2.0, True), - } - - -def _run_ticks(referee: RestartFuzzingReferee, n_ticks: int, dt: float = 1 / 60) -> None: - """Drive `referee.step()` for `n_ticks` synthetic ticks, holding the ball - at the origin and robots far away throughout (so any STOP auto-advances - immediately) — enough to exercise scheduling/injection logic without a - real simulator. - """ - referee.seed_clock(0.0, RefereeCommand.NORMAL_START) - friendly = _far_from_ball_robots() - enemy = {10: _robot(10, 3.0, -2.0, False)} - t = 0.0 - for _ in range(n_ticks): - frame = _frame(t, ball_xy=(0.0, 0.0), friendly=friendly, enemy=enemy) - referee.step(frame, t) - t += dt - - -# --------------------------------------------------------------------------- -# Seed determinism -# --------------------------------------------------------------------------- - - -def test_seed_determinism_same_schedule_and_positions(): - ref_a = RestartFuzzingReferee.from_profile_name( - "simulation", seed=42, interval_s=(0.5, 1.0), n_robots_yellow=3, n_robots_blue=3 - ) - ref_b = RestartFuzzingReferee.from_profile_name( - "simulation", seed=42, interval_s=(0.5, 1.0), n_robots_yellow=3, n_robots_blue=3 - ) - - _run_ticks(ref_a, 600) # 10s @ 60Hz - _run_ticks(ref_b, 600) - - assert len(ref_a.injections) > 0, "test setup produced no injections to compare" - assert ref_a.injections == ref_b.injections - - -def test_different_seed_different_schedule(): - ref_a = RestartFuzzingReferee.from_profile_name( - "simulation", seed=1, interval_s=(0.5, 1.0), n_robots_yellow=3, n_robots_blue=3 - ) - ref_b = RestartFuzzingReferee.from_profile_name( - "simulation", seed=2, interval_s=(0.5, 1.0), n_robots_yellow=3, n_robots_blue=3 - ) - - _run_ticks(ref_a, 600) - _run_ticks(ref_b, 600) - - assert ref_a.injections != ref_b.injections - - -# --------------------------------------------------------------------------- -# Injections only during live play -# --------------------------------------------------------------------------- - - -def test_injection_never_starts_mid_restart(): - """Force the referee into a non-live-play command right when an - injection would be due, and confirm the fuzzer waits rather than - injecting on top of an in-flight restart.""" - referee = RestartFuzzingReferee.from_profile_name( - "simulation", seed=7, interval_s=(0.1, 0.1), n_robots_yellow=3, n_robots_blue=3 - ) - referee.seed_clock(0.0, RefereeCommand.NORMAL_START) - - friendly = _far_from_ball_robots() - enemy = {10: _robot(10, 3.0, -2.0, False)} - - # Put the referee into a real, in-flight restart (DIRECT_FREE_YELLOW) - # that will not auto-advance immediately (kicker/defenders not in - # position), then drive ticks through the scheduled injection time and - # confirm no injection fires while command != live play. - referee.force_command(RefereeCommand.DIRECT_FREE_YELLOW, 0.0) - - t = 0.0 - for _ in range(30): # 0.5s @ 60Hz — well past the 0.1s interval - frame = _frame(t, ball_xy=(0.0, 0.0), friendly=friendly, enemy=enemy) - result = referee.step(frame, t) - if result.referee_command in (RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START): - # Auto-advanced back to live play — from here on injections are - # legitimately allowed again, so stop asserting. - break - assert len(referee.injections) == 0, "fuzzer injected while a restart was already in flight" - t += 1 / 60 - - -def test_all_injections_recorded_during_live_play_command_at_time_of_injection(): - """Every recorded injection's `sim_time` must correspond to a tick where - the referee's command-before-injection was live play (NORMAL_START or - FORCE_START) with no restart already queued — i.e. `_is_live_play` held - at the moment `set_command` was first called for that injection.""" - referee = RestartFuzzingReferee.from_profile_name( - "simulation", seed=3, interval_s=(0.2, 0.4), n_robots_yellow=3, n_robots_blue=3 - ) - referee.seed_clock(0.0, RefereeCommand.NORMAL_START) - - friendly = _far_from_ball_robots() - enemy = {10: _robot(10, 3.0, -2.0, False)} - t = 0.0 - live_play_ticks: set[float] = set() - for _ in range(1200): # 20s @ 60Hz - frame = _frame(t, ball_xy=(0.0, 0.0), friendly=friendly, enemy=enemy) - result_before = (referee._state.command, referee._state.next_command) - referee.step(frame, t) - if result_before[0] in (RefereeCommand.NORMAL_START, RefereeCommand.FORCE_START) and result_before[1] is None: - live_play_ticks.add(round(t, 6)) - t += 1 / 60 - - assert len(referee.injections) > 0 - for inj in referee.injections: - assert round(inj.sim_time, 6) in live_play_ticks, ( - f"injection at sim_time={inj.sim_time} did not occur while the referee was in live play " - "with no restart queued" - ) - - -# --------------------------------------------------------------------------- -# Legal positions -# --------------------------------------------------------------------------- - - -def _assert_legal(x: float, y: float) -> None: - assert GEO.is_in_field(x, y), f"({x}, {y}) is not inside the field" - # Field-line margin: strictly inside the shrunk rectangle used for sampling. - assert abs(x) <= GEO.half_length - 0.25 + 1e-9 - assert abs(y) <= GEO.half_width - 0.25 + 1e-9 - assert GEO.distance_to_left_defense_area(x, y) >= 0.2 - 1e-9, f"({x}, {y}) too close to left defense area" - assert GEO.distance_to_right_defense_area(x, y) >= 0.2 - 1e-9, f"({x}, {y}) too close to right defense area" - - -def test_random_legal_position_always_legal_many_seeded_draws(): - for seed in range(300): - referee = RestartFuzzingReferee.from_profile_name( - "simulation", seed=seed, interval_s=(1.0, 1.0), n_robots_yellow=3, n_robots_blue=3 - ) - x, y = referee._random_legal_position() - _assert_legal(x, y) - - -def test_ball_placement_injections_use_legal_positions_end_to_end(): - referee = RestartFuzzingReferee.from_profile_name( - "simulation", - seed=11, - interval_s=(0.2, 0.3), - kinds=(KIND_BALL_PLACEMENT_DIRECT_FREE,), - n_robots_yellow=3, - n_robots_blue=3, - ) - _run_ticks(referee, 1200) # 20s @ 60Hz - - ball_placement_injections = [inj for inj in referee.injections if inj.kind == KIND_BALL_PLACEMENT_DIRECT_FREE] - assert len(ball_placement_injections) > 0 - for inj in ball_placement_injections: - assert inj.position is not None - _assert_legal(*inj.position) - - -# --------------------------------------------------------------------------- -# kinds filter -# --------------------------------------------------------------------------- - - -def test_kinds_filter_restricts_injected_kinds(): - for only_kind in ALL_KINDS: - referee = RestartFuzzingReferee.from_profile_name( - "simulation", - seed=5, - interval_s=(0.1, 0.2), - kinds=(only_kind,), - n_robots_yellow=3, - n_robots_blue=3, - ) - _run_ticks(referee, 1200) # 20s @ 60Hz - - assert len(referee.injections) > 0, f"no injections at all for kinds=({only_kind},)" - assert all(inj.kind == only_kind for inj in referee.injections) - - -def test_kinds_filter_rejects_unknown_kind(): - import pytest - - with pytest.raises(ValueError): - RestartFuzzingReferee.from_profile_name("simulation", seed=1, kinds=("not_a_real_kind",)) - - -def test_invalid_interval_raises(): - import pytest - - with pytest.raises(ValueError): - RestartFuzzingReferee.from_profile_name("simulation", seed=1, interval_s=(5.0, 1.0)) diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 95556f99..dadd9d7d 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -13,7 +13,7 @@ from utama_core.replay import fingerprint as fp from utama_core.replay import match_results -from utama_core.replay.fingerprint import REPO_ROOT, ROUND_ROBIN_ENTRY, CodeGraph +from utama_core.replay.fingerprint import MATCH_ENTRY, REPO_ROOT, CodeGraph from utama_core.strategy import catalog PICKERS = """\ @@ -112,7 +112,7 @@ def repo(tmp_path: Path) -> Path: def _fingerprints(root: Path) -> dict[str, str]: g = CodeGraph(root) out = {c: g.strategy_fingerprint(c) for c in CONFIGS} - out["base"] = g.base_fingerprint([ROUND_ROBIN_ENTRY]) + out["base"] = g.base_fingerprint([MATCH_ENTRY]) return out @@ -169,9 +169,6 @@ def _fixture( b, *, duration=65.0, - control_scheme="fpp", - fuzz_seed=None, - fuzz_interval_s=(25.0, 45.0), sim_noise=None, a_is_right=True, a_kicks_off=True, @@ -181,9 +178,6 @@ def _fixture( g, duration_seconds=duration, sim_noise=sim_noise, - control_scheme=control_scheme, - fuzz_seed=fuzz_seed, - fuzz_interval_s=fuzz_interval_s, ) seed = sim_noise.get("seed") if sim_noise else None return match_results.fixture_id( @@ -282,27 +276,22 @@ def test_the_fixture_covers_every_setting(repo): _fixture(g, a, b, duration=20.0), _fixture(g, a, b, a_is_right=False), _fixture(g, a, b, a_kicks_off=False), - _fixture(g, a, b, control_scheme="dwa"), - _fixture(g, a, b, fuzz_seed=1), _fixture(g, a, b, sim_noise={"seed": 1}), _fixture(g, a, b, sim_noise={"seed": 2}), ] assert len({ref, *variants}) == 1 + len(variants) - # the fuzz interval only matters when fuzzing is on - assert _fixture(g, a, b, fuzz_interval_s=(1.0, 2.0)) == ref - assert _fixture(g, a, b, fuzz_seed=1, fuzz_interval_s=(1.0, 2.0)) != variants[5] # the noise seed is per match, the rest of the noise per environment - assert _fixture(g, a, b, sim_noise={"seed": 1, "kick_speed_sd": 0.2}) != variants[6] + assert _fixture(g, a, b, sim_noise={"seed": 1, "kick_speed_sd": 0.2}) != variants[4] def test_numerics_env_vars_change_the_base(repo, monkeypatch): monkeypatch.delenv("UTAMA_EXACT_MATH", raising=False) - before = CodeGraph(repo).base_fingerprint([ROUND_ROBIN_ENTRY]) + before = CodeGraph(repo).base_fingerprint([MATCH_ENTRY]) monkeypatch.setenv("UTAMA_EXACT_MATH", "1") - assert CodeGraph(repo).base_fingerprint([ROUND_ROBIN_ENTRY]) != before - with_exact = CodeGraph(repo).base_fingerprint([ROUND_ROBIN_ENTRY]) + assert CodeGraph(repo).base_fingerprint([MATCH_ENTRY]) != before + with_exact = CodeGraph(repo).base_fingerprint([MATCH_ENTRY]) monkeypatch.setenv("UNRELATED_VAR", "1") - assert CodeGraph(repo).base_fingerprint([ROUND_ROBIN_ENTRY]) == with_exact + assert CodeGraph(repo).base_fingerprint([MATCH_ENTRY]) == with_exact # --- this repo ---------------------------------------------------------------------------- @@ -346,9 +335,9 @@ def test_every_tactic_a_strategy_builds_is_in_its_closure(graph): def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): """Otherwise an edit there would change a match and no fingerprint at all.""" - roots = [ROUND_ROBIN_ENTRY, *fp.SUBPROCESS_SCRIPTS] + roots = [MATCH_ENTRY, *fp.SUBPROCESS_SCRIPTS] resets = graph.closure(_RUNNER_ONLY_RESETS) - taken_out = graph.closure(roots) - graph.base_modules([ROUND_ROBIN_ENTRY]) - resets + taken_out = graph.closure(roots) - graph.base_modules([MATCH_ENTRY]) - resets for config in _players(): assert taken_out <= graph.strategy_modules(config), (config, taken_out - graph.strategy_modules(config)) @@ -374,7 +363,7 @@ def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): def test_the_match_process_reaches_into_player_side_code_only_where_listed(graph): found: dict[str, set[str]] = {} - for module in graph.base_modules([ROUND_ROBIN_ENTRY]): + for module in graph.base_modules([MATCH_ENTRY]): if module in fp.RUNNER_SIDE: continue for target in graph.imports(module): @@ -386,13 +375,13 @@ def test_the_match_process_reaches_into_player_side_code_only_where_listed(graph def test_the_tactics_are_outside_the_base(graph): """Otherwise a tactic edit would rerun every match: the per-player split is the point.""" - base = graph.base_modules([ROUND_ROBIN_ENTRY]) + base = graph.base_modules([MATCH_ENTRY]) for name in ("give_and_go", "press_and_contain", "shadow_and_mark", "switch_of_play", "defense"): assert f"utama_core.tactics.{name}" not in base def test_the_base_holds_the_sim_script_and_referee_profiles(graph): - base = graph.base_modules([ROUND_ROBIN_ENTRY]) + base = graph.base_modules([MATCH_ENTRY]) assert set(fp.SUBPROCESS_SCRIPTS) <= base assert any("custom_referee/profiles/simulation.yaml" in row for row in graph.data_files(base)) @@ -455,7 +444,7 @@ def test_the_base_holds_the_sim_script_and_referee_profiles(graph): def test_every_reach_outside_the_import_graph_is_accounted_for(graph): - everything = graph.base_modules([ROUND_ROBIN_ENTRY]) | {m for c in _players() for m in graph.strategy_modules(c)} + everything = graph.base_modules([MATCH_ENTRY]) | {m for c in _players() for m in graph.strategy_modules(c)} assert graph.audit(everything) == AUDIT diff --git a/utama_core/tests/replay/test_match_results.py b/utama_core/tests/replay/test_match_results.py index 7b8c73ea..f5671b21 100644 --- a/utama_core/tests/replay/test_match_results.py +++ b/utama_core/tests/replay/test_match_results.py @@ -77,13 +77,6 @@ def test_the_environment_covers_every_setting_but_the_noise_seed(): assert mr.environment(g, duration_seconds=1200.0, sim_noise={**noise, "seed": 2}) == base assert mr.environment(g, duration_seconds=300.0, sim_noise=noise) != base assert mr.environment(g, duration_seconds=1200.0, sim_noise=None) != base - assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, control_scheme="dwa") != base - assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1) != base - assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1, fuzz_interval_s=(1.0, 2.0)) != ( - mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1) - ) - # the fuzz interval only matters when fuzzing is on - assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_interval_s=(1.0, 2.0)) == base # shared code edits move the environment assert mr.environment(_Graph("edited"), duration_seconds=1200.0, sim_noise=noise) != base diff --git a/utama_core/tests/tools/test_sim_setup.py b/utama_core/tests/tools/test_sim_setup.py index 97b731bf..1750b6df 100644 --- a/utama_core/tests/tools/test_sim_setup.py +++ b/utama_core/tests/tools/test_sim_setup.py @@ -71,10 +71,3 @@ def test_sim_referee_gives_the_first_kickoff_to_the_team_asked(monkeypatch): sim_setup.sim_referee() assert [p.game.kickoff_team for p in profiles] == ["blue", "yellow"] - - -def test_sim_referee_injects_restarts_only_for_a_seeded_run(): - from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee - - assert isinstance(sim_setup.sim_referee(fuzz_seed=3), RestartFuzzingReferee) - assert not isinstance(sim_setup.sim_referee(), RestartFuzzingReferee) From 5e760dd6cc54397f4fa16c23593e21be3820cefb Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:19:53 +0000 Subject: [PATCH 27/59] skills: change-strategy, and pointers from the docs The fourth skill: branch, change one thing, test, evaluate (ask first), record and promote. STRATEGY_DEVELOPMENT.md keeps the reasons and points at the skills for the steps; "Reading a tournament run" becomes "Reading a round"; explain-result writes its outputs into the round folder, not /tmp. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 72 +++++++++++++++++++++++++ .claude/skills/explain-result/SKILL.md | 4 +- AGENTS.md | 9 ++-- docs/STRATEGY_DEVELOPMENT.md | 13 +++-- docs/tools.md | 2 +- 5 files changed, 88 insertions(+), 12 deletions(-) create mode 100644 .claude/skills/change-strategy/SKILL.md diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md new file mode 100644 index 00000000..da2d3645 --- /dev/null +++ b/.claude/skills/change-strategy/SKILL.md @@ -0,0 +1,72 @@ +--- +name: change-strategy +description: Write a new strategy or change an existing one, then test it, evaluate it against the champion and promote it if it wins - from branch to pull request. Use when asked to try a strategy idea, improve how a strategy plays, add a tactic for a strategy, or promote a strategy to the core. Not for explaining an existing result (explain-result) or fixing one incident (debug-incident). +--- + +# Change a strategy + +The model behind every step (tactics, partitioners, referee restarts, past tactic bugs) is +`docs/STRATEGY_DEVELOPMENT.md`; read its "Writing and evaluating a strategy" and "Strategy +branches" sections first. This skill is the order of the steps and the rules that are easy +to forget. + +## 1. Branch + +`strategy/` from `main`. In a git worktree run `tools/setup_worktree.sh`, and symlink +`replays` from the main checkout so the match results store is shared. + +## 2. Change one thing + +- **New strategy:** a new file `utama_core/strategy/.py` with + `build(outfield_robot_ids, motion_controller)` returning a `Strategy`. The catalog finds it; it + plays as a reserve until it is added to the core. Reuse `strategy/pickers.py`. +- **Changed strategy:** edit exactly one existing strategy module. Never new modules and an + edited one in the same branch. +- **New tactic:** a new module in `tactics/`. Never edit an existing tactic, `pickers.py` or + `catalog.py` on a strategy branch: the opponents run them. To improve a tactic, copy it and + change the copy. +- No module-level state (keep it inside `build`), no import-time effects, no imports of another + strategy. CI checks a `strategy/*` branch touches only `strategy/`, new `tactics/` modules, + `tests/strategy/` and `docs/strategies.md` (`tools/check_strategy_branch.py`). +- Every change needs a reason in game terms (what the robots will do differently, and why + that wins goals), not a threshold nudged until results move. + +## 3. Test + +1. Pure partitioner tests in `utama_core/tests/strategy/test_.py` (a hand-built `Game`, no rsim). +2. `pixi run pytest utama_core/tests/engine/test_all_strategy_configs.py --headless`. +3. `git add` new files, then `pixi run test` and `pixi run lint`. + +## 4. Evaluate (ask first) + +Never start matches without the user's yes. Then: + +``` +pixi run python tools/evaluation/evaluate.py NAME [NAME ...] +``` + +- Read the first line of each round: "N matches, X from the match results store, M to play". + After a change to one strategy, M is about its own 5 matches per round. Much more means + shared code changed since the store was filled; say so before waiting on it. +- Round 1 is a round robin: a stall reported there is a bug. Fix it (the `debug-incident` + skill) before reading the verdict. +- The verdict is goals only: better (P ≥ 0.99), worse (P ≤ 0.2) or undecided after 6 rounds. + Every other signal explains it (the `explain-result` skill), never overrules it. + +## 5. Record and promote + +- Add or update the strategy's row in `docs/strategies.md` with the verdict and margin. +- Better than the champion: promoting is one line in `tools/evaluation/reference/players.json` + (`champion`, and the core if it should play every round), in the pull request. It becomes the + reference at the next release. +- Open a draft pull request into `main` with the result. An agent never merges. + +## Rules + +- **Shared code is not a strategy change.** A change to `tactics/` (existing modules), `skills/`, + `pickers.py`, the planner or the referee reruns most matches: put it on an ordinary branch, + batch such changes, and evaluate once at the end. +- **Strategy and evaluation in separate commits**, so results stay comparable. +- **`world.json` / `robots.json` changes** replay every stored match: batch them and ask first. +- Keep evaluation at the sim settings in `tools/evaluation/reference/`; don't tune a strategy + to real-robot limits in sim (those are compensated in the control layer). diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md index f2f6e4dd..a9086d3c 100644 --- a/.claude/skills/explain-result/SKILL.md +++ b/.claude/skills/explain-result/SKILL.md @@ -30,7 +30,7 @@ they suggest changing, never a new ranking. the `debug-incident` skill. 3. **Where do goals come from?** - `pixi run python -m utama_core.analysis.goal_sources ROUND_DIR --out /tmp/gs.json`. + `pixi run python -m utama_core.analysis.goal_sources ROUND_DIR --out ROUND_DIR/goal_sources.json`. Goals per match = Σ over situation types (restart or ball won, by third) of situations per match × P(goal). Tells whether a change should create more situations, convert better, or allow fewer. Situation names: AGENTS.md glossary and `docs/signals.md`, "Where do goals come @@ -46,7 +46,7 @@ they suggest changing, never a new ranking. `report.json` gives it (a frozen file is named by its stem, e.g. `split_shape@cffe3a28`). - The whole field, for a doc figure: `pixi run python tools/signal_report.py ROUND_DIR`. - The signals marked *offline* in `docs/signals.md` (replays the run at 10 Hz, slow): - `pixi run python tools/metric_correlation.py ROUND_DIR --out /tmp/offline.md`. + `pixi run python tools/metric_correlation.py ROUND_DIR --out ROUND_DIR/offline.md`. Zones: use the names in `docs/pitch_zones.md` (defensive / middle / attacking third, wings, box). 5. **Write it up** in a few lines: the verdict and margin; which opponents decided it; the diff --git a/AGENTS.md b/AGENTS.md index 68935356..6f8c0a24 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -161,10 +161,11 @@ declarations) — check there before reintroducing one of them. `docs/README.md` indexes every doc by kind and `docs/tools.md` every script; the ones agents need most: -- `.claude/skills/` — three step-by-step playbooks over those scripts (plain Markdown, readable by - any agent): `explain-result` (how a strategy plays, why it won or lost), `debug-incident` (one bad - moment, from symptom to a fixed cause with a test), `field-session` (a test day on real robots and - its logs). +- `.claude/skills/` — four step-by-step playbooks over those scripts (plain Markdown, readable by + any agent): `change-strategy` (write, test, evaluate and promote a strategy), `explain-result` (how + a strategy plays, why it won or lost), `debug-incident` (one bad moment, from symptom to a fixed + cause with a test), `field-session` (a test day on real robots and its logs). The docs keep the + reasons; the skills keep the steps. - `docs/STRATEGY_DEVELOPMENT.md` — tactic-kernel model, referee handling, writing a `Tactic`, observability tooling. Read before any strategy-layer change. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 9a3e9ce1..d2676ab7 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -170,6 +170,8 @@ Lessons from bugs that recurred (mostly `SwitchOfPlayTactic`, `tactics/switch_of ## Writing and evaluating a strategy +The steps from branch to pull request, as a checklist: the `change-strategy` skill (`.claude/skills/`). + A strategy is a combination of existing tactics plus a partitioner that decides how many robots each gets. Most new strategies need no new tactic. When one does, add it as a new module in `tactics/` (on a strategy branch, never by changing an existing tactic: see below). @@ -252,7 +254,7 @@ the store, or one environment's folder inside it, to play everything again. Each **What counts as better.** The verdict is `evaluate.py`'s: goal difference per match, paired against the champion at the last release. W-D-L and every other signal are diagnostics. -Everything in [Reading a tournament run](#reading-a-tournament-run) explains a result; none of +Everything in [Reading a round](#reading-a-round) explains a result; none of it is a target. Don't tune a threshold until results move: a change needs a reason in game terms. ### Evaluating a strategy @@ -398,7 +400,7 @@ whoever runs it. [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: `tools/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and - writes `ball_losses.md`; see [Reading a tournament run](#reading-a-tournament-run). + writes `ball_losses.md`; see [Reading a round](#reading-a-round). `python -m utama_core.analysis.turnover_breakdown ` re-runs it on an older run. - **Stall watchdog** (`engine/match_stats.py`) — records `StallEvent`s, never affects play: `RESTART_STALL` (a restart/stoppage command held >15s) and `COMMITTED_FROZEN` (ball moved @@ -426,7 +428,8 @@ whoever runs it. A foul or failure seen in a match is a symptom: the cause may be the robot, the shared referee override, the planner, the referee itself, or the check that flagged it. Of the first six found -this way (table below), two were the referee or the check, not the robot. +this way (table below), two were the referee or the check, not the robot. The steps alone, as a +checklist, are the `debug-incident` skill (`.claude/skills/`); this section keeps the reasons and the bugs found. Start with `tools/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind and the pictured findings. Filter `findings.jsonl` on the kind you care about, open that finding's picture to see what it @@ -456,7 +459,7 @@ The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, ` 1. **Find it.** `tools/find_bugs.py` is the one starting point for "what went wrong in a run" (see the start of this section). It flags thrashing and stalls, and restart geometry with `--restarts`. - For our side's fouls by rule, `pixi run python tools/find_bugs.py replays/tournament_ --fouls --by + For our side's fouls by rule, `pixi run python tools/find_bugs.py ROUND_DIR --fouls --by strategy,rule` counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball leaving the field, is a stoppage and left out unless `--include-stoppages`); without `--by` it lists each with its time, robot, tactic and the referee command then active @@ -543,7 +546,7 @@ original numpy paths, byte-identical to before (`8c191eea`); the evaluation's wo all inherit it. The two modes agree to 1e-9 per call but matches diverge after the first differing tick, so a baseline recorded in one mode is only comparable with a candidate run in the same mode. -## Reading a tournament run +## Reading a round Every `evaluate.py` run prints round 1's sections and writes each round's data to `replays/eval_/round_/summary.json` (older round-robins: `replays/tournament_/`). [`docs/signals.md`](signals.md) lists every signal it records diff --git a/docs/tools.md b/docs/tools.md index 9a82b764..a55a2323 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -9,7 +9,7 @@ Pick the tool by the question you have. Only tools that exist are named in this *planned* are designed but not built: see [strategy_tools_plan.md](strategy_tools_plan.md), which also says why the tools are split this way. -For the three jobs that chain several of them, follow a skill in `.claude/skills/`: `explain-result`, +For the four jobs that chain several of them, follow a skill in `.claude/skills/`: `change-strategy`, `explain-result`, `debug-incident`, `field-session`. | Question | Tool | From 3cec922a6bf53aadb5b92bf4dcd598097579aa39 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:28:47 +0000 Subject: [PATCH 28/59] pixi: upgrade the lock file to format v7 Same packages; pixi re-solved from the locked content only to rewrite the format, which silences its v6 warning on every run. Co-Authored-By: Claude Opus 5.5 --- pixi.lock | 9248 +++++++++++++++++++++++++++-------------------------- 1 file changed, 4629 insertions(+), 4619 deletions(-) diff --git a/pixi.lock b/pixi.lock index a27a2962..1dfa8803 100644 --- a/pixi.lock +++ b/pixi.lock @@ -1,4 +1,16 @@ -version: 6 +version: 7 +platforms: +- name: linux-64 + virtual-packages: + - __unix=0=0 + - __linux=4.18 + - __glibc=2.28 + - __archspec=0=x86_64 +- name: osx-arm64 + virtual-packages: + - __unix=0=0 + - __osx=13.0 + - __archspec=0=m1 environments: default: channels: @@ -8,48 +20,26 @@ environments: packages: linux-64: - conda: https://prefix.dev/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - - conda: https://prefix.dev/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda - conda: https://prefix.dev/conda-forge/linux-64/alsa-lib-1.2.15.3-hb03c661_0.conda - - conda: https://prefix.dev/conda-forge/noarch/anyio-4.13.0-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda - conda: https://prefix.dev/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 - conda: https://prefix.dev/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2 - conda: https://prefix.dev/conda-forge/linux-64/atk-1.0-2.38.0-h04ea711_2.conda - - conda: https://prefix.dev/conda-forge/noarch/backports-1.0-pyhd8ed1ab_5.conda - - conda: https://prefix.dev/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda - conda: https://prefix.dev/conda-forge/linux-64/backports.zstd-1.4.0-py311h6b1f9c4_0.conda - conda: https://prefix.dev/conda-forge/linux-64/brotli-1.2.0-h505cf86_3.conda - conda: https://prefix.dev/conda-forge/linux-64/brotli-bin-1.2.0-h9908984_3.conda - conda: https://prefix.dev/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda - conda: https://prefix.dev/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda - - conda: https://prefix.dev/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/cffi-2.0.0-py311h03d9500_1.conda - - conda: https://prefix.dev/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda - - conda: https://prefix.dev/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda - - conda: https://prefix.dev/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/linux-64/contourpy-1.3.3-py311h724c32c_4.conda - conda: https://prefix.dev/conda-forge/linux-64/cryptography-48.0.0-py311h2005dd1_0.conda - - conda: https://prefix.dev/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda - conda: https://prefix.dev/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda - conda: https://prefix.dev/conda-forge/linux-64/dav1d-1.2.1-hd590300_0.conda - conda: https://prefix.dev/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda - - conda: https://prefix.dev/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda - - conda: https://prefix.dev/conda-forge/noarch/editables-0.6-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda - - conda: https://prefix.dev/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/farama-notifications-0.0.4-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/fluidsynth-2.5.4-h07a5eef_0.conda - - conda: https://prefix.dev/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - - conda: https://prefix.dev/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - - conda: https://prefix.dev/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - - conda: https://prefix.dev/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda - conda: https://prefix.dev/conda-forge/linux-64/fontconfig-2.17.1-h27c8c51_0.conda - - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda - conda: https://prefix.dev/conda-forge/linux-64/fonttools-4.63.0-py311h3778330_0.conda - conda: https://prefix.dev/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda - conda: https://prefix.dev/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda @@ -60,30 +50,10 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/gtk3-3.24.43-h993cebd_6.conda - conda: https://prefix.dev/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda - conda: https://prefix.dev/conda-forge/linux-64/gymnasium-1.3.0-np2py311hec5889a_0.conda - - conda: https://prefix.dev/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda - - conda: https://prefix.dev/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/harfbuzz-14.3.1-ha770c72_0.conda - - conda: https://prefix.dev/conda-forge/noarch/hatch-1.16.5-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/hatchling-1.29.0-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda - - conda: https://prefix.dev/conda-forge/noarch/hpack-4.1.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/hyperlink-21.0.0-pyh29332c3_1.conda - conda: https://prefix.dev/conda-forge/linux-64/icu-78.3-py310h44b86e0_2.conda - - conda: https://prefix.dev/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/jack-1.9.22-hf4617a5_3.conda - - conda: https://prefix.dev/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda - - conda: https://prefix.dev/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda - - conda: https://prefix.dev/conda-forge/noarch/jax-jumpy-1.0.0-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/jeepney-0.9.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda - conda: https://prefix.dev/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://prefix.dev/conda-forge/linux-64/kiwisolver-1.5.0-py311h724c32c_0.conda - conda: https://prefix.dev/conda-forge/linux-64/krb5-1.22.2-ha1258a1_0.conda @@ -165,56 +135,34 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda - conda: https://prefix.dev/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - conda: https://prefix.dev/conda-forge/linux-64/llvmlite-0.49.0-py311h1369f55_2.conda - - conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/matplotlib-3.11.1-py311h968eb38_2.conda - conda: https://prefix.dev/conda-forge/linux-64/matplotlib-base-3.11.1-py311he401cf6_2.conda - - conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda - - conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/numba-0.67.0-py311hdfc3925_1.conda - conda: https://prefix.dev/conda-forge/linux-64/numpy-2.0.2-py311h71ddf71_1.conda - conda: https://prefix.dev/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda - conda: https://prefix.dev/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda - conda: https://prefix.dev/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda - conda: https://prefix.dev/conda-forge/linux-64/opusfile-0.12-h3358134_2.conda - - conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://prefix.dev/conda-forge/linux-64/pandas-3.0.1-py311h8032f78_0.conda - conda: https://prefix.dev/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/linux-64/pillow-12.3.0-py311hf88fc01_0.conda - conda: https://prefix.dev/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda - - conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://prefix.dev/conda-forge/linux-64/portaudio-19.7.0-hf4617a5_0.conda - conda: https://prefix.dev/conda-forge/linux-64/portmidi-2.0.8-h3cb78e3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda - conda: https://prefix.dev/conda-forge/linux-64/protobuf-3.20.2-py311ha362b79_1.conda - conda: https://prefix.dev/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda - - conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/linux-64/pulseaudio-client-17.0-h9a6aba3_3.conda - - conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://prefix.dev/conda-forge/linux-64/pygame-2.6.1-py311h3209946_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda - conda: https://prefix.dev/conda-forge/linux-64/pyside6-6.11.1-py311hf27b23e_1.conda - - conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/linux-64/python-3.11.15-hd63d673_0_cpython.conda - - conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - - conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://prefix.dev/conda-forge/linux-64/pyyaml-6.0.3-py311h3778330_1.conda - conda: https://prefix.dev/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda - conda: https://prefix.dev/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_0.conda - conda: https://prefix.dev/conda-forge/linux-64/rav1e-0.8.1-h1fbca29_0.conda - conda: https://prefix.dev/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - - conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/ruff-0.15.12-h994f30f_0.conda - conda: https://prefix.dev/conda-forge/linux-64/scipy-1.17.1-py311hbe70eeb_0.conda - conda: https://prefix.dev/conda-forge/linux-64/sdl2-2.32.56-h54a6638_0.conda @@ -223,25 +171,12 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/sdl2_ttf-2.24.0-h287479f_0.conda - conda: https://prefix.dev/conda-forge/linux-64/sdl3-3.4.8-hdeec2a5_0.conda - conda: https://prefix.dev/conda-forge/linux-64/secretstorage-3.4.1-py311h38be061_0.conda - - conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda - - conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda - - conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda - - conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda - conda: https://prefix.dev/conda-forge/linux-64/svt-av1-4.0.1-hecca717_0.conda - conda: https://prefix.dev/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda - - conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda - conda: https://prefix.dev/conda-forge/linux-64/tornado-6.5.5-py311h49ec1c0_0.conda - - conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://prefix.dev/conda-forge/linux-64/ukkonen-1.1.0-py311hdf67eae_0.conda - conda: https://prefix.dev/conda-forge/linux-64/unicodedata2-17.0.1-py311h49ec1c0_0.conda - - conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/linux-64/uv-0.11.12-h29f5ae7_0.conda - - conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda - conda: https://prefix.dev/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda - conda: https://prefix.dev/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda @@ -269,70 +204,119 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda - conda: https://prefix.dev/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda - conda: https://prefix.dev/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda - - conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda - conda: https://prefix.dev/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://prefix.dev/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda + - conda: https://prefix.dev/conda-forge/noarch/anyio-4.13.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/backports-1.0-pyhd8ed1ab_5.conda + - conda: https://prefix.dev/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda + - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda + - conda: https://prefix.dev/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda + - conda: https://prefix.dev/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://prefix.dev/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/editables-0.6-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/farama-notifications-0.0.4-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://prefix.dev/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://prefix.dev/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://prefix.dev/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://prefix.dev/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/hatch-1.16.5-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/hatchling-1.29.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/hpack-4.1.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/hyperlink-21.0.0-pyh29332c3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda + - conda: https://prefix.dev/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/jax-jumpy-1.0.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/jeepney-0.9.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda + - conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda + - conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda + - conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda + - conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda + - conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda + - conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda + - conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda + - conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda - pypi: https://files.pythonhosted.org/packages/fb/06/6a7c30c3519181263e1bbf0cbea67ef4a43a64443ee16717c7d760214943/lenses-1.2.0-py3-none-any.whl osx-arm64: - - conda: https://prefix.dev/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda - conda: https://prefix.dev/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda - conda: https://prefix.dev/conda-forge/noarch/anyio-4.13.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda - conda: https://prefix.dev/conda-forge/noarch/backports-1.0-pyhd8ed1ab_5.conda - conda: https://prefix.dev/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/backports.zstd-1.4.0-py311h36d4fbb_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/brotli-1.2.0-hf00d406_3.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/brotli-bin-1.2.0-he4a93e4_3.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda - conda: https://prefix.dev/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/cffi-2.0.0-py311hd10dc20_1.conda - conda: https://prefix.dev/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda - conda: https://prefix.dev/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda - conda: https://prefix.dev/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/contourpy-1.3.3-py311h7d85929_4.conda - conda: https://prefix.dev/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/dbus-1.16.2-h3ff7a7c_1.conda - conda: https://prefix.dev/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/editables-0.6-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda - conda: https://prefix.dev/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/farama-notifications-0.0.4-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/fluidsynth-2.5.4-h985f16e_0.conda - conda: https://prefix.dev/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - conda: https://prefix.dev/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - conda: https://prefix.dev/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - conda: https://prefix.dev/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/fontconfig-2.17.1-h2b252f5_0.conda - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - conda: https://prefix.dev/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/fonttools-4.63.0-py311hc290fe0_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/freetype-2.14.3-hce30654_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/gdk-pixbuf-2.44.6-h4e57454_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/glib-tools-2.88.3-h5f197ff_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/graphviz-13.1.2-hcd33d8b_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/gtk3-3.24.43-h5febe37_6.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/gymnasium-1.3.0-np2py311h56d0776_0.conda - conda: https://prefix.dev/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda - conda: https://prefix.dev/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/harfbuzz-14.3.1-hce30654_0.conda - conda: https://prefix.dev/conda-forge/noarch/hatch-1.16.5-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/noarch/hatchling-1.29.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda - conda: https://prefix.dev/conda-forge/noarch/hpack-4.1.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda - conda: https://prefix.dev/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/hyperlink-21.0.0-pyh29332c3_1.conda - - conda: https://prefix.dev/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda - conda: https://prefix.dev/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda @@ -343,6 +327,70 @@ environments: - conda: https://prefix.dev/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda - conda: https://prefix.dev/conda-forge/noarch/jax-jumpy-1.0.0-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda + - conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda + - conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda + - conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda + - conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda + - conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda + - conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda + - conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda + - conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda + - conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda + - conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/backports.zstd-1.4.0-py311h36d4fbb_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/brotli-1.2.0-hf00d406_3.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/brotli-bin-1.2.0-he4a93e4_3.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/cffi-2.0.0-py311hd10dc20_1.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/contourpy-1.3.3-py311h7d85929_4.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/dbus-1.16.2-h3ff7a7c_1.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/fluidsynth-2.5.4-h985f16e_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/fontconfig-2.17.1-h2b252f5_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/fonttools-4.63.0-py311hc290fe0_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/freetype-2.14.3-hce30654_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/gdk-pixbuf-2.44.6-h4e57454_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/glib-tools-2.88.3-h5f197ff_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/graphviz-13.1.2-hcd33d8b_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/gtk3-3.24.43-h5febe37_6.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/gymnasium-1.3.0-np2py311h56d0776_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/harfbuzz-14.3.1-hce30654_0.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda + - conda: https://prefix.dev/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/kiwisolver-1.5.0-py311h7d85929_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 - conda: https://prefix.dev/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda @@ -392,52 +440,30 @@ environments: - conda: https://prefix.dev/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/llvm-openmp-22.1.4-hc7d1edf_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/llvmlite-0.49.0-py311h4a78e08_2.conda - - conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-3.11.1-py311ha01d089_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-base-3.11.1-py311h3c3ad35_2.conda - - conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/mpg123-1.32.9-hf642e45_0.conda - - conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - - conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/numba-0.67.0-py311hf682900_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/numpy-2.0.2-py311h649a571_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/opusfile-0.12-h5643135_2.conda - - conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pandas-3.0.1-py311h4a068b9_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pango-1.56.4-h875632e_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pillow-12.3.0-py311hd37aea2_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda - - conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/portaudio-19.7.0-h5833ebf_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/portmidi-2.0.8-haf25636_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/protobuf-3.20.2-py311ha397e9f_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-h84a0fba_1003.conda - - conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pygame-2.6.1-py311hc3e7c57_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda - - conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/python-3.11.15-h8561d8f_0_cpython.conda - - conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - - conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pyyaml-6.0.3-py311hc290fe0_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda - conda: https://prefix.dev/conda-forge/osx-arm64/rav1e-0.8.1-h8246384_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda - - conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/ruff-0.15.12-hbd3f8a3_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/scipy-1.17.1-py311he9931d0_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/sdl2-2.32.56-h248ca61_0.conda @@ -445,29 +471,15 @@ environments: - conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_mixer-2.6.3-h45fadf6_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_ttf-2.24.0-h443c5de_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/sdl3-3.4.8-h6fa9c73_0.conda - - conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda - - conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda - - conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda - - conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda - - conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/svt-av1-4.0.1-h0cb729a_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda - - conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/tornado-6.5.5-py311hc949640_0.conda - - conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda - - conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/ukkonen-1.1.0-py311h572238d_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/unicodedata2-17.0.1-py311hc949640_0.conda - - conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/uv-0.11.12-h2c65d96_0.conda - - conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxau-1.0.12-h84a0fba_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-h84a0fba_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda - - conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/zlib-ng-2.3.3-h31dac16_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda - pypi: https://files.pythonhosted.org/packages/fb/06/6a7c30c3519181263e1bbf0cbea67ef4a43a64443ee16717c7d760214943/lenses-1.2.0-py3-none-any.whl @@ -481,7 +493,6 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda - conda: https://prefix.dev/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda - conda: https://prefix.dev/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda - - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda - conda: https://prefix.dev/conda-forge/linux-64/cmake-3.26.4-hcfe8598_0.conda - conda: https://prefix.dev/conda-forge/linux-64/expat-2.8.0-hecca717_0.conda - conda: https://prefix.dev/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda @@ -513,22 +524,25 @@ environments: - conda: https://prefix.dev/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda - conda: https://prefix.dev/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda - conda: https://prefix.dev/conda-forge/linux-64/python-3.10.20-h3c07f61_0_cpython.conda - - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda - conda: https://prefix.dev/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://prefix.dev/conda-forge/linux-64/rhash-1.4.3-hd590300_2.conda - conda: https://prefix.dev/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda - - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://prefix.dev/conda-forge/linux-64/xz-5.8.3-ha02ee65_0.conda - conda: https://prefix.dev/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_0.conda - conda: https://prefix.dev/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_0.conda - conda: https://prefix.dev/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda - conda: https://prefix.dev/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - - pypi: https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda + - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - pypi: ./vendor/rSim + - pypi: https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl osx-arm64: + - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda + - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda - conda: https://prefix.dev/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda - - conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/cmake-3.26.4-hc0af03a_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/expat-2.8.0-hf6b4638_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/krb5-1.22.2-h385eeb1_0.conda @@ -551,18 +565,16 @@ environments: - conda: https://prefix.dev/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda - conda: https://prefix.dev/conda-forge/osx-arm64/python-3.10.20-h1b19095_0_cpython.conda - - conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda - conda: https://prefix.dev/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/rhash-1.4.3-hb547adb_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda - - conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - conda: https://prefix.dev/conda-forge/osx-arm64/xz-5.8.3-hd0f0c4f_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/xz-gpl-tools-5.8.3-hd0f0c4f_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/xz-tools-5.8.3-h8088a28_0.conda - conda: https://prefix.dev/conda-forge/osx-arm64/zlib-1.3.2-h8088a28_2.conda - conda: https://prefix.dev/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda - - pypi: https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl - pypi: ./vendor/rSim + - pypi: https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl packages: - conda: https://prefix.dev/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda build_number: 20 @@ -578,29 +590,6 @@ packages: purls: [] size: 28948 timestamp: 1770939786096 -- conda: https://prefix.dev/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda - build_number: 7 - sha256: 7acaa2e0782cad032bdaf756b536874346ac1375745fb250e9bdd6a48a7ab3cd - md5: a44032f282e7d2acdeb1c240308052dd - depends: - - llvm-openmp >=9.0.1 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 8325 - timestamp: 1764092507920 -- conda: https://prefix.dev/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda - sha256: a362b4f5c96a0bf4def96be1a77317e2730af38915eb9bec85e2a92836501ed7 - md5: b3f0179590f3c0637b7eb5309898f79e - depends: - - __unix - - hicolor-icon-theme - - librsvg - license: LGPL-3.0-or-later OR CC-BY-SA-3.0 - license_family: LGPL - purls: [] - size: 631452 - timestamp: 1758743294412 - conda: https://prefix.dev/conda-forge/linux-64/alsa-lib-1.2.15.3-hb03c661_0.conda sha256: d88aa7ae766cf584e180996e92fef2aa7d8e0a0a5ab1d4d49c32390c1b5fff31 md5: dcdc58c15961dbf17a0621312b01f5cb @@ -612,25 +601,6 @@ packages: purls: [] size: 584660 timestamp: 1768327524772 -- conda: https://prefix.dev/conda-forge/noarch/anyio-4.13.0-pyhcf101f3_0.conda - sha256: f09aed24661cd45ba54a43772504f05c0698248734f9ae8cd289d314ac89707e - md5: af2df4b9108808da3dc76710fe50eae2 - depends: - - exceptiongroup >=1.0.2 - - idna >=2.8 - - python >=3.10 - - typing_extensions >=4.5 - - python - constrains: - - trio >=0.32.0 - - uvloop >=0.22.1 - - winloop >=0.2.3 - license: MIT - license_family: MIT - purls: - - pkg:pypi/anyio?source=hash-mapping - size: 146764 - timestamp: 1774359453364 - conda: https://prefix.dev/conda-forge/linux-64/aom-3.9.1-hac33072_0.conda sha256: b08ef033817b5f9f76ce62dfcac7694e7b6b4006420372de22494503decac855 md5: 346722a0be40f6edc53f12640d301338 @@ -642,17 +612,6 @@ packages: purls: [] size: 2706396 timestamp: 1718551242397 -- conda: https://prefix.dev/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda - sha256: ec238f18ce8140485645252351a0eca9ef4f7a1c568a420f240a585229bc12ef - md5: 7adba36492a1bb22d98ffffe4f6fc6de - depends: - - __osx >=11.0 - - libcxx >=16 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 2235747 - timestamp: 1718551382432 - conda: https://prefix.dev/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 sha256: 26ab9386e80bf196e51ebe005da77d57decf6d989b4f34d96130560bc133479c md5: 6b889f174df1e0f816276ae69281af4d @@ -696,44 +655,6 @@ packages: purls: [] size: 355900 timestamp: 1713896169874 -- conda: https://prefix.dev/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda - sha256: b0747f9b1bc03d1932b4d8c586f39a35ac97e7e72fe6e63f2b2a2472d466f3c1 - md5: 57301986d02d30d6805fdce6c99074ee - depends: - - __osx >=11.0 - - libcxx >=16 - - libglib >=2.80.0,<3.0a0 - - libintl >=0.22.5,<1.0a0 - constrains: - - atk-1.0 2.38.0 - license: LGPL-2.0-or-later - license_family: LGPL - purls: [] - size: 347530 - timestamp: 1713896411580 -- conda: https://prefix.dev/conda-forge/noarch/backports-1.0-pyhd8ed1ab_5.conda - sha256: e1c3dc8b5aa6e12145423fed262b4754d70fec601339896b9ccf483178f690a6 - md5: 767d508c1a67e02ae8f50e44cacfadb2 - depends: - - python >=3.9 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 7069 - timestamp: 1733218168786 -- conda: https://prefix.dev/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda - sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 - md5: bea46844deb274b2cc2a3a941745fa73 - depends: - - python >=3.10 - - backports - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/backports-tarfile?source=hash-mapping - size: 35739 - timestamp: 1767290467820 - conda: https://prefix.dev/conda-forge/linux-64/backports.zstd-1.4.0-py311h6b1f9c4_0.conda sha256: a23717f9dc06924b988b92ba8dca0f4cb9154cac954457a40adb2f19d57896de md5: aa8c3009fd8903bebdcb22fbcb4c0dea @@ -748,19 +669,6 @@ packages: - pkg:pypi/backports-zstd?source=hash-mapping size: 245341 timestamp: 1777848716685 -- conda: https://prefix.dev/conda-forge/osx-arm64/backports.zstd-1.4.0-py311h36d4fbb_0.conda - sha256: 2e6399a3663e7e20134a208cd09befc44ce1e9efe94d1d36d8911db04f186270 - md5: 3ee7e8ae532366221658b80baee36dc0 - depends: - - python - - __osx >=11.0 - - python_abi 3.11.* *_cp311 - - zstd >=1.5.7,<1.6.0a0 - license: BSD-3-Clause AND MIT AND EPL-2.0 - purls: - - pkg:pypi/backports-zstd?source=hash-mapping - size: 244743 - timestamp: 1777848723707 - conda: https://prefix.dev/conda-forge/linux-64/brotli-1.2.0-h505cf86_3.conda sha256: 1f2ccfebe6e0113bfc473b21906372c1ee4eb69bf6faef0ad7f3d4d79af63a98 md5: 6ff307b78fbfb7dcafb7e25ff8bc9c10 @@ -775,19 +683,6 @@ packages: purls: [] size: 20676 timestamp: 1786622810792 -- conda: https://prefix.dev/conda-forge/osx-arm64/brotli-1.2.0-hf00d406_3.conda - sha256: 7050e1b11876219bd0df375ef3d83fd00f94fb4e13c1ffb21dede0c506893079 - md5: aa7df8174ee3b34a5ad8a3160429db68 - depends: - - __osx >=11.0 - - brotli-bin 1.2.0 he4a93e4_3 - - libbrotlidec 1.2.0 h5295a6a_3 - - libbrotlienc 1.2.0 h2ddc9cb_3 - license: MIT - license_family: MIT - purls: [] - size: 20767 - timestamp: 1786622887445 - conda: https://prefix.dev/conda-forge/linux-64/brotli-bin-1.2.0-h9908984_3.conda sha256: 56b2e5e8a49f9887af74cc63e0d55a3654e60b667ad5558da089549a36ae6a0c md5: 8929291d9efc59715df1cfa7daf5e3ed @@ -801,18 +696,6 @@ packages: purls: [] size: 21598 timestamp: 1786622801722 -- conda: https://prefix.dev/conda-forge/osx-arm64/brotli-bin-1.2.0-he4a93e4_3.conda - sha256: 1e92cea587c2eaab169e45dae01c149b9889a8249eda296b8b6db39aee708531 - md5: d9de6c0ad7e008afdf62fb2ffd450b4a - depends: - - __osx >=11.0 - - libbrotlidec 1.2.0 h5295a6a_3 - - libbrotlienc 1.2.0 h2ddc9cb_3 - license: MIT - license_family: MIT - purls: [] - size: 18962 - timestamp: 1786622878369 - conda: https://prefix.dev/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6 md5: d2ffd7602c02f2b316fd921d39876885 @@ -824,16 +707,6 @@ packages: purls: [] size: 260182 timestamp: 1771350215188 -- conda: https://prefix.dev/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda - sha256: 540fe54be35fac0c17feefbdc3e29725cce05d7367ffedfaaa1bdda234b019df - md5: 620b85a3f45526a8bc4d23fd78fc22f0 - depends: - - __osx >=11.0 - license: bzip2-1.0.6 - license_family: BSD - purls: [] - size: 124834 - timestamp: 1771350416561 - conda: https://prefix.dev/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda sha256: cc9accf72fa028d31c2a038460787751127317dcfa991f8d1f1babf216bb454e md5: 920bb03579f15389b9e512095ad995b7 @@ -845,25 +718,6 @@ packages: purls: [] size: 207882 timestamp: 1765214722852 -- conda: https://prefix.dev/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda - sha256: 2995f2aed4e53725e5efbc28199b46bf311c3cab2648fc4f10c2227d6d5fa196 - md5: bcb3cba70cf1eec964a03b4ba7775f01 - depends: - - __osx >=11.0 - license: MIT - license_family: MIT - purls: [] - size: 180327 - timestamp: 1765215064054 -- conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda - sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d - md5: e18ad67cf881dcadee8b8d9e2f8e5f73 - depends: - - __unix - license: ISC - purls: [] - size: 131039 - timestamp: 1776865545798 - conda: https://prefix.dev/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda sha256: 06525fa0c4e4f56e771a3b986d0fdf0f0fc5a3270830ee47e127a5105bde1b9a md5: bb6c4808bfa69d6f7f6b07e5846ced37 @@ -891,36 +745,6 @@ packages: purls: [] size: 989514 timestamp: 1766415934926 -- conda: https://prefix.dev/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda - sha256: cde9b79ee206fe3ba6ca2dc5906593fb7a1350515f85b2a1135a4ce8ec1539e3 - md5: 36200ecfbbfbcb82063c87725434161f - depends: - - __osx >=11.0 - - fontconfig >=2.15.0,<3.0a0 - - fonts-conda-ecosystem - - icu >=78.1,<79.0a0 - - libcxx >=19 - - libexpat >=2.7.3,<3.0a0 - - libfreetype >=2.14.1 - - libfreetype6 >=2.14.1 - - libglib >=2.86.3,<3.0a0 - - libpng >=1.6.53,<1.7.0a0 - - libzlib >=1.3.1,<2.0a0 - - pixman >=0.46.4,<1.0a0 - license: LGPL-2.1-only or MPL-1.1 - purls: [] - size: 900035 - timestamp: 1766416416791 -- conda: https://prefix.dev/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda - sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 - md5: 929471569c93acefb30282a22060dcd5 - depends: - - python >=3.10 - license: ISC - purls: - - pkg:pypi/certifi?source=hash-mapping - size: 135656 - timestamp: 1776866680878 - conda: https://prefix.dev/conda-forge/linux-64/cffi-2.0.0-py311h03d9500_1.conda sha256: 3ad13377356c86d3a945ae30e9b8c8734300925ef81a3cb0a9db0d755afbe7bb md5: 3912e4373de46adafd8f1e97e4bd166b @@ -937,61 +761,9 @@ packages: - pkg:pypi/cffi?source=hash-mapping size: 303338 timestamp: 1761202960110 -- conda: https://prefix.dev/conda-forge/osx-arm64/cffi-2.0.0-py311hd10dc20_1.conda - sha256: 1ffde698463d6e7ed571bdb85cb17bfc1d3a107c026d20047995512dcc2749ec - md5: 4d7f6780e36f18e7601811dddf3bbec5 - depends: - - __osx >=11.0 - - libffi >=3.5.2,<3.6.0a0 - - pycparser - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - license: MIT - license_family: MIT - purls: - - pkg:pypi/cffi?source=hash-mapping - size: 294848 - timestamp: 1761203196617 -- conda: https://prefix.dev/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda - sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 - md5: 381bd45fb7aa032691f3063aff47e3a1 - depends: - - python >=3.10 - license: MIT - license_family: MIT - purls: - - pkg:pypi/cfgv?source=hash-mapping - size: 13589 - timestamp: 1763607964133 -- conda: https://prefix.dev/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda - sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 - md5: 2266262ce8a425ecb6523d765f79b303 - depends: - - __unix - - python - - python >=3.10 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/click?source=hash-mapping - size: 100048 - timestamp: 1777219902525 -- conda: https://prefix.dev/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda - sha256: 4c287c2721d8a34c94928be8fe0e9a85754e90189dd4384a31b1806856b50a67 - md5: 61b8078a0905b12529abc622406cb62c - depends: - - python >=3.10 - - python - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/cloudpickle?source=hash-mapping - size: 27353 - timestamp: 1765303462831 -- conda: https://prefix.dev/conda-forge/linux-64/cmake-3.26.4-hcfe8598_0.conda - sha256: 37533b572a676017704c989c392998c344e889010786d6555dccdfc524a8e238 - md5: 1714cf0f0facaeb609a0846e4270aff2 +- conda: https://prefix.dev/conda-forge/linux-64/cmake-3.26.4-hcfe8598_0.conda + sha256: 37533b572a676017704c989c392998c344e889010786d6555dccdfc524a8e238 + md5: 1714cf0f0facaeb609a0846e4270aff2 depends: - bzip2 >=1.0.8,<2.0a0 - expat @@ -1011,38 +783,6 @@ packages: purls: [] size: 16343060 timestamp: 1684460894541 -- conda: https://prefix.dev/conda-forge/osx-arm64/cmake-3.26.4-hc0af03a_0.conda - sha256: cba596b6bba58e347bd8be51fce82583f16c5707f6c98b22a7e7ba1ecdb09783 - md5: 84c170713e88c74f45fd87ce2a065cd3 - depends: - - bzip2 >=1.0.8,<2.0a0 - - expat - - libcurl >=8.1.0,<9.0a0 - - libcxx >=15.0.7 - - libexpat >=2.5.0,<3.0a0 - - libuv - - libzlib >=1.2.13,<2.0.0a0 - - ncurses >=6.3,<7.0a0 - - rhash <=1.4.3 - - xz >=5.2.6,<6.0a0 - - zlib - - zstd >=1.5.2,<1.6.0a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 13748747 - timestamp: 1684461655168 -- conda: https://prefix.dev/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 - md5: 962b9857ee8e7018c22f2776ffa0b2d7 - depends: - - python >=3.9 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/colorama?source=hash-mapping - size: 27011 - timestamp: 1733218222191 - conda: https://prefix.dev/conda-forge/linux-64/contourpy-1.3.3-py311h724c32c_4.conda sha256: fd7aca059253cff3d8b0aec71f0c1bf2904823b13f1997bf222aea00a76f3cce md5: d04e508f5a03162c8bab4586a65d00bf @@ -1059,22 +799,6 @@ packages: - pkg:pypi/contourpy?source=hash-mapping size: 320553 timestamp: 1769155975008 -- conda: https://prefix.dev/conda-forge/osx-arm64/contourpy-1.3.3-py311h7d85929_4.conda - sha256: 57b2c28cbb45e7dacb565541483d802a15c6beff5ccdabba19784a526191f4d3 - md5: bd91dd35d73638e5c0f520a18850f6ba - depends: - - numpy >=1.25 - - python - - python 3.11.* *_cpython - - __osx >=11.0 - - libcxx >=19 - - python_abi 3.11.* *_cp311 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/contourpy?source=hash-mapping - size: 286095 - timestamp: 1769156091585 - conda: https://prefix.dev/conda-forge/linux-64/cryptography-48.0.0-py311h2005dd1_0.conda sha256: 838cde68e70f4e0dc6458613316fa0e50eee5cf86cafb1cee4b7ca1a701a8436 md5: 96f6e551c7ff30c95c1c8b4d2d1c5c9f @@ -1093,18 +817,6 @@ packages: - pkg:pypi/cryptography?source=hash-mapping size: 1913519 timestamp: 1777966158377 -- conda: https://prefix.dev/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda - sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1 - md5: 4c2a8fef270f6c69591889b93f9f55c1 - depends: - - python >=3.10 - - python - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/cycler?source=hash-mapping - size: 14778 - timestamp: 1764466758386 - conda: https://prefix.dev/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda sha256: 7684da83306bb69686c0506fb09aa7074e1a55ade50c3a879e4e5df6eebb1009 md5: af491aae930edc096b58466c51c4126c @@ -1131,14 +843,6 @@ packages: purls: [] size: 760229 timestamp: 1685695754230 -- conda: https://prefix.dev/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda - sha256: 93e077b880a85baec8227e8c72199220c7f87849ad32d02c14fb3807368260b8 - md5: 5a74cdee497e6b65173e10d94582fae6 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 316394 - timestamp: 1685695959391 - conda: https://prefix.dev/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda sha256: 8bb557af1b2b7983cf56292336a1a1853f26555d9c6cecf1e5b2b96838c9da87 md5: ce96f2f470d39bd96ce03945af92e280 @@ -1153,30 +857,6 @@ packages: purls: [] size: 447649 timestamp: 1764536047944 -- conda: https://prefix.dev/conda-forge/osx-arm64/dbus-1.16.2-h3ff7a7c_1.conda - sha256: a8207751ed261764061866880da38e4d3063e167178bfe85b6db9501432462ba - md5: 5a3506971d2d53023c1c4450e908a8da - depends: - - libcxx >=19 - - __osx >=11.0 - - libglib >=2.86.2,<3.0a0 - - libzlib >=1.3.1,<2.0a0 - - libexpat >=2.7.3,<3.0a0 - license: AFL-2.1 OR GPL-2.0-or-later - purls: [] - size: 393811 - timestamp: 1764536084131 -- conda: https://prefix.dev/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - sha256: 6d977f0b2fc24fee21a9554389ab83070db341af6d6f09285360b2e09ef8b26e - md5: 003b8ba0a94e2f1e117d0bd46aebc901 - depends: - - python >=3.9 - license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/distlib?source=hash-mapping - size: 275642 - timestamp: 1752823081585 - conda: https://prefix.dev/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda sha256: 40cdd1b048444d3235069d75f9c8e1f286db567f6278a93b4f024e5642cfaecc md5: dbe3ec0f120af456b3477743ffd99b74 @@ -1189,18 +869,6 @@ packages: purls: [] size: 71809 timestamp: 1765193127016 -- conda: https://prefix.dev/conda-forge/noarch/editables-0.6-pyhcf101f3_0.conda - sha256: bb826ff403b8195467e7cd5f504bc14767b424dac27bb225508ca2c1852554b2 - md5: 86b177231eecb011fe00e2117dbc3348 - depends: - - python >=3.10 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/editables?source=hash-mapping - size: 13160 - timestamp: 1776172429816 - conda: https://prefix.dev/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda sha256: a5b51e491fec22bcc1765f5b2c8fff8a97428e9a5a7ee6730095fb9d091b0747 md5: 057083b06ccf1c2778344b6dabace38b @@ -1224,27 +892,6 @@ packages: purls: [] size: 411735 timestamp: 1758743520805 -- conda: https://prefix.dev/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda - sha256: ba685b87529c95a4bf9de140a33d703d57dc46b036e9586ed26890de65c1c0d5 - md5: 3b87dabebe54c6d66a07b97b53ac5874 - depends: - - __osx >=11.0 - license: MIT - license_family: MIT - purls: [] - size: 296347 - timestamp: 1758743805063 -- conda: https://prefix.dev/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 - md5: 8e662bd460bda79b1ea39194e3c4c9ab - depends: - - python >=3.10 - - typing_extensions >=4.6.0 - license: MIT and PSF-2.0 - purls: - - pkg:pypi/exceptiongroup?source=hash-mapping - size: 21333 - timestamp: 1763918099466 - conda: https://prefix.dev/conda-forge/linux-64/expat-2.8.0-hecca717_0.conda sha256: ca4dc1da00a8aaa56c1088e7f45f1859ecea6f75874e67584f1af6e5cf8179f8 md5: 992e529e407c9d67d50be1d7543fde4c @@ -1257,38 +904,6 @@ packages: purls: [] size: 148114 timestamp: 1777846120303 -- conda: https://prefix.dev/conda-forge/osx-arm64/expat-2.8.0-hf6b4638_0.conda - sha256: 9f8657c32bcff353b218b1bd7369de34c0534dc5a461630b296265e65e94e2d8 - md5: 90f3b6fa818b07e9402d5ee89f3892d5 - depends: - - __osx >=11.0 - - libexpat 2.8.0 hf6b4638_0 - license: MIT - license_family: MIT - purls: [] - size: 135334 - timestamp: 1777846191235 -- conda: https://prefix.dev/conda-forge/noarch/farama-notifications-0.0.4-pyhd8ed1ab_0.conda - sha256: 8df190d75bac104c6c2317b13397eed9adfa6889b12405b0288ca2ca86855c06 - md5: 61f63fcf1c2deddeae7a85a516d46c94 - depends: - - python >=3.6 - license: MIT - license_family: MIT - purls: - - pkg:pypi/farama-notifications?source=hash-mapping - size: 8406 - timestamp: 1684258265351 -- conda: https://prefix.dev/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda - sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 - md5: 8fa8358d022a3a9bd101384a808044c6 - depends: - - python >=3.10 - license: Unlicense - purls: - - pkg:pypi/filelock?source=hash-mapping - size: 34211 - timestamp: 1776621506566 - conda: https://prefix.dev/conda-forge/linux-64/fluidsynth-2.5.4-h07a5eef_0.conda sha256: bb759e354a9f383635e1982d5a7ea547ac2a3a9d73ec62b07e489f26b8967ebc md5: e48d6e1f837a307d824f2b3f9a7065d7 @@ -1311,55 +926,6 @@ packages: purls: [] size: 341443 timestamp: 1776634510786 -- conda: https://prefix.dev/conda-forge/osx-arm64/fluidsynth-2.5.4-h985f16e_0.conda - sha256: 6fab2acb6b1c7ba0fc06c3d4cefa552c3da4c3d6a79dcdd2158eea96931c3929 - md5: 1f716f3ba6477330807ed061637048c7 - depends: - - __osx >=11.0 - - libcxx >=19 - - libglib >=2.86.4,<3.0a0 - - libsndfile >=1.2.2,<1.3.0a0 - - llvm-openmp >=19.1.7 - - portaudio >=19.7.0,<19.8.0a0 - - readline >=8.3,<9.0a0 - - sdl2 >=2.32.56,<3.0a0 - license: GPL-2.0-or-later - license_family: LGPL - purls: [] - size: 291966 - timestamp: 1776634889426 -- conda: https://prefix.dev/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 - sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b - md5: 0c96522c6bdaed4b1566d11387caaf45 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 397370 - timestamp: 1566932522327 -- conda: https://prefix.dev/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 - sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c - md5: 34893075a5c9e55cdafac56607368fc6 - license: OFL-1.1 - license_family: Other - purls: [] - size: 96530 - timestamp: 1620479909603 -- conda: https://prefix.dev/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 - sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139 - md5: 4d59c254e01d9cde7957100457e2d5fb - license: OFL-1.1 - license_family: Other - purls: [] - size: 700814 - timestamp: 1620479612257 -- conda: https://prefix.dev/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda - sha256: 2821ec1dc454bd8b9a31d0ed22a7ce22422c0aef163c59f49dfdf915d0f0ca14 - md5: 49023d73832ef61042f6a237cb2687e7 - license: LicenseRef-Ubuntu-Font-Licence-Version-1.0 - license_family: Other - purls: [] - size: 1620504 - timestamp: 1727511233259 - conda: https://prefix.dev/conda-forge/linux-64/fontconfig-2.17.1-h27c8c51_0.conda sha256: aa4a44dba97151221100a637c7f4bde619567afade9c0265f8e1c8eed8d7bd8c md5: 867127763fbe935bab59815b6e0b7b5c @@ -1376,46 +942,9 @@ packages: purls: [] size: 270705 timestamp: 1771382710863 -- conda: https://prefix.dev/conda-forge/osx-arm64/fontconfig-2.17.1-h2b252f5_0.conda - sha256: 851e9c778bfc54645dcab7038c0383445cbebf16f6bb2d3f62ce422b1605385a - md5: d06ae1a11b46cc4c74177ecd28de7c7a - depends: - - __osx >=11.0 - - libexpat >=2.7.4,<3.0a0 - - libfreetype >=2.14.1 - - libfreetype6 >=2.14.1 - - libzlib >=1.3.1,<2.0a0 - license: MIT - license_family: MIT - purls: [] - size: 237308 - timestamp: 1771382999247 -- conda: https://prefix.dev/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 - sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 - md5: fee5683a3f04bd15cbd8318b096a27ab - depends: - - fonts-conda-forge - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 3667 - timestamp: 1566974674465 -- conda: https://prefix.dev/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda - sha256: 54eea8469786bc2291cc40bca5f46438d3e062a399e8f53f013b6a9f50e98333 - md5: a7970cd949a077b7cb9696379d338681 - depends: - - font-ttf-ubuntu - - font-ttf-inconsolata - - font-ttf-dejavu-sans-mono - - font-ttf-source-code-pro - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 4059 - timestamp: 1762351264405 -- conda: https://prefix.dev/conda-forge/linux-64/fonttools-4.63.0-py311h3778330_0.conda - sha256: ce5004df66a6bf4e3d634850ab43471b98700291065281eb1982eb54b7bf7d85 - md5: 498ede447c05b203be980ae1dceb06f3 +- conda: https://prefix.dev/conda-forge/linux-64/fonttools-4.63.0-py311h3778330_0.conda + sha256: ce5004df66a6bf4e3d634850ab43471b98700291065281eb1982eb54b7bf7d85 + md5: 498ede447c05b203be980ae1dceb06f3 depends: - __glibc >=2.17,<3.0.a0 - brotli @@ -1430,23 +959,6 @@ packages: - pkg:pypi/fonttools?source=hash-mapping size: 3045399 timestamp: 1778770357867 -- conda: https://prefix.dev/conda-forge/osx-arm64/fonttools-4.63.0-py311hc290fe0_0.conda - sha256: e339446253b5aec4342526334cb2575a20beaf15478469d9baa3c5a11c7aa498 - md5: 23ee082b5c5dc73c19dc0b6451d35079 - depends: - - __osx >=11.0 - - brotli - - munkres - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - - unicodedata2 >=15.1.0 - license: MIT - license_family: MIT - purls: - - pkg:pypi/fonttools?source=hash-mapping - size: 2948507 - timestamp: 1778771011007 - conda: https://prefix.dev/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda sha256: c934c385889c7836f034039b43b05ccfa98f53c900db03d8411189892ced090b md5: 8462b5322567212beeb025f3519fb3e2 @@ -1457,16 +969,6 @@ packages: purls: [] size: 173839 timestamp: 1774298173462 -- conda: https://prefix.dev/conda-forge/osx-arm64/freetype-2.14.3-hce30654_0.conda - sha256: 5952bd9db12207a18a112e8924aa2ce8c2f9d57b62584d58a97d2f6afe1ea324 - md5: 6dcc75ba2e04c555e881b72793d3282f - depends: - - libfreetype 2.14.3 hce30654_0 - - libfreetype6 2.14.3 hdfa99f5_0 - license: GPL-2.0-only OR FTL - purls: [] - size: 173313 - timestamp: 1774298702053 - conda: https://prefix.dev/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda sha256: 858283ff33d4c033f4971bf440cebff217d5552a5222ba994c49be990dacd40d md5: f9f81ea472684d75b9dd8d0b328cf655 @@ -1477,15 +979,6 @@ packages: purls: [] size: 61244 timestamp: 1757438574066 -- conda: https://prefix.dev/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda - sha256: d856dc6744ecfba78c5f7df3378f03a75c911aadac803fa2b41a583667b4b600 - md5: 04bdce8d93a4ed181d1d726163c2d447 - depends: - - __osx >=11.0 - license: LGPL-2.1-or-later - purls: [] - size: 59391 - timestamp: 1757438897523 - conda: https://prefix.dev/conda-forge/linux-64/gdk-pixbuf-2.44.6-h2b0a6b4_0.conda sha256: c5594497f0646e9079705b3199dbb2d5b13c48173cf110000fa1c8818e2b3e0c md5: 7892f39a39ed39591a89a28eba03e987 @@ -1502,22 +995,6 @@ packages: purls: [] size: 577414 timestamp: 1774985848058 -- conda: https://prefix.dev/conda-forge/osx-arm64/gdk-pixbuf-2.44.6-h4e57454_0.conda - sha256: 07cbba4e12430de35ea608eb3006cf1f7f63832c4f89a081cd6f3872944c1aa6 - md5: e67ebd2f639f46e52af8531622fa6051 - depends: - - __osx >=11.0 - - libglib >=2.86.4,<3.0a0 - - libintl >=0.25.1,<1.0a0 - - libjpeg-turbo >=3.1.2,<4.0a0 - - liblzma >=5.8.2,<6.0a0 - - libpng >=1.6.56,<1.7.0a0 - - libtiff >=4.7.1,<4.8.0a0 - license: LGPL-2.1-or-later - license_family: LGPL - purls: [] - size: 548309 - timestamp: 1774986047281 - conda: https://prefix.dev/conda-forge/linux-64/glib-tools-2.88.3-h95f0039_0.conda sha256: ccdad3d9149ca12353583818bdfde9f66753da7e8ea6dd35a6312062e2fe60d2 md5: 841fd9387fd3f24ea69a4f679242e32c @@ -1530,18 +1007,6 @@ packages: purls: [] size: 238245 timestamp: 1785442107463 -- conda: https://prefix.dev/conda-forge/osx-arm64/glib-tools-2.88.3-h5f197ff_0.conda - sha256: 672b06a290ae9bd4443f9315334f2dbb6d0ba239b3a1f2ea40fd66321e7a3ac6 - md5: 607824e2f42f49049c999432385832e3 - depends: - - libglib ==2.88.3 ha08bb59_0 - - libffi - - __osx >=11.0 - - libintl >=0.25.1,<1.0a0 - license: LGPL-2.1-or-later - purls: [] - size: 205078 - timestamp: 1785442168180 - conda: https://prefix.dev/conda-forge/linux-64/graphite2-1.3.15-h54a6638_1.conda sha256: 7fa3b6a9c081fa3e545573152a788d061a0a0ba57df7251cc0f4f75225fc93e7 md5: f9fe2984587fa8235a6af6004760cd18 @@ -1554,17 +1019,6 @@ packages: purls: [] size: 102835 timestamp: 1786118485753 -- conda: https://prefix.dev/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda - sha256: 471f34a187fdb4f2df33e26f2e471b16c239a5b277903f643d9c3a8c9a9f44ec - md5: 0c7b78d9ffff4f5a6ca28d346f734d8f - depends: - - libcxx >=19 - - __osx >=11.0 - license: LGPL-2.0-or-later - license_family: LGPL - purls: [] - size: 86493 - timestamp: 1786118637573 - conda: https://prefix.dev/conda-forge/linux-64/graphviz-13.1.2-h87b6fe6_0.conda sha256: efbd7d483f3d79b7882515ccf229eceb7f4ff636ea2019044e98243722f428be md5: 0adddc9b820f596638d8b0ff9e3b4823 @@ -1590,30 +1044,6 @@ packages: purls: [] size: 2427887 timestamp: 1754732581595 -- conda: https://prefix.dev/conda-forge/osx-arm64/graphviz-13.1.2-hcd33d8b_0.conda - sha256: f25e1828d02ebd78214966f483cfca5ac6a7b18824369c748d8cda99c66ff588 - md5: 81ab85a5a8481667660c7ce6e84bd681 - depends: - - __osx >=11.0 - - adwaita-icon-theme - - cairo >=1.18.4,<2.0a0 - - fonts-conda-ecosystem - - gdk-pixbuf >=2.42.12,<3.0a0 - - gtk3 >=3.24.43,<4.0a0 - - gts >=0.7.6,<0.8.0a0 - - libcxx >=19 - - libexpat >=2.7.1,<3.0a0 - - libgd >=2.3.3,<2.4.0a0 - - libglib >=2.84.3,<3.0a0 - - librsvg >=2.58.4,<3.0a0 - - libwebp-base >=1.6.0,<2.0a0 - - libzlib >=1.3.1,<2.0a0 - - pango >=1.56.4,<2.0a0 - license: EPL-1.0 - license_family: Other - purls: [] - size: 2201370 - timestamp: 1754732518951 - conda: https://prefix.dev/conda-forge/linux-64/gtk3-3.24.43-h993cebd_6.conda sha256: 004688fbb2c479b200a6d85ef38c3129fcd4ce13537b7ee2371d962b372761c1 md5: f9f33c65b20e6a61f21714785e3613ec @@ -1655,30 +1085,6 @@ packages: purls: [] size: 5587108 timestamp: 1761327349586 -- conda: https://prefix.dev/conda-forge/osx-arm64/gtk3-3.24.43-h5febe37_6.conda - sha256: bd66a3325bf3ce63ada3bf12eaafcfe036698741ee4bb595e83e5fdd3dba9f3d - md5: a99f96906158ebae5e3c0904bcd45145 - depends: - - __osx >=11.0 - - atk-1.0 >=2.38.0 - - cairo >=1.18.4,<2.0a0 - - epoxy >=1.5.10,<1.6.0a0 - - fribidi >=1.0.16,<2.0a0 - - gdk-pixbuf >=2.44.4,<3.0a0 - - glib-tools - - harfbuzz >=11.5.1 - - hicolor-icon-theme - - libexpat >=2.7.1,<3.0a0 - - libglib >=2.86.0,<3.0a0 - - libintl >=0.25.1,<1.0a0 - - liblzma >=5.8.1,<6.0a0 - - libzlib >=1.3.1,<2.0a0 - - pango >=1.56.4,<2.0a0 - license: LGPL-2.0-or-later - license_family: LGPL - purls: [] - size: 4768791 - timestamp: 1761328318680 - conda: https://prefix.dev/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda sha256: b5cd16262fefb836f69dc26d879b6508d29f8a5c5948a966c47fe99e2e19c99b md5: 4d8df0b0db060d33c9a702ada998a8fe @@ -1691,17 +1097,6 @@ packages: purls: [] size: 318312 timestamp: 1686545244763 -- conda: https://prefix.dev/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda - sha256: e0f8c7bc1b9ea62ded78ffa848e37771eeaaaf55b3146580513c7266862043ba - md5: 21b4dd3098f63a74cf2aa9159cbef57d - depends: - - libcxx >=15.0.7 - - libglib >=2.76.3,<3.0a0 - license: LGPL-2.0-or-later - license_family: LGPL - purls: [] - size: 304331 - timestamp: 1686545503242 - conda: https://prefix.dev/conda-forge/linux-64/gymnasium-1.3.0-np2py311hec5889a_0.conda sha256: d1e8bc964d6a2a70b52ebd36f0815b9867a3db8a973e3f6da2e0c1a57b0144a2 md5: f7e72a66dea8ee8eeab367bd824a7d95 @@ -1719,50 +1114,6 @@ packages: - pkg:pypi/gymnasium?source=hash-mapping size: 1139365 timestamp: 1777204693923 -- conda: https://prefix.dev/conda-forge/osx-arm64/gymnasium-1.3.0-np2py311h56d0776_0.conda - sha256: ab03d30592506e1dfe9e6fc30cddea577dd42a7eb4b6da8a80de543928e2e6fd - md5: d64237fee1a064db6f7c53090a6844da - depends: - - python - - cloudpickle >=1.2.0 - - farama-notifications - - jax-jumpy >=1.0.0 - - typing_extensions >=4.3.0 - - python_abi 3.11.* *_cp311 - - numpy >=1.23,<3 - license: MIT - license_family: MIT - purls: - - pkg:pypi/gymnasium?source=hash-mapping - size: 1138451 - timestamp: 1777204698446 -- conda: https://prefix.dev/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda - sha256: 96cac6573fd35ae151f4d6979bab6fbc90cb6b1fb99054ba19eb075da9822fcb - md5: b8993c19b0c32a2f7b66cbb58ca27069 - depends: - - python >=3.10 - - typing_extensions - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/h11?source=hash-mapping - size: 39069 - timestamp: 1767729720872 -- conda: https://prefix.dev/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda - sha256: 84c64443368f84b600bfecc529a1194a3b14c3656ee2e832d15a20e0329b6da3 - md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 - depends: - - python >=3.10 - - hyperframe >=6.1,<7 - - hpack >=4.1,<5 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/h2?source=hash-mapping - size: 95967 - timestamp: 1756364871835 - conda: https://prefix.dev/conda-forge/linux-64/harfbuzz-14.3.1-ha770c72_0.conda sha256: d2b22411323270acf8199070fe3377d72f36830f467f09fb2f5bcd4dc3ef77dd md5: 15971d7910faa28aa5b0b2560b9a3bab @@ -1773,4569 +1124,5281 @@ packages: purls: [] size: 11076 timestamp: 1786970900409 -- conda: https://prefix.dev/conda-forge/osx-arm64/harfbuzz-14.3.1-hce30654_0.conda - sha256: 1120c57b917fb0bb8fef770d56f308564c94daea0eb29a643c9f5cf73195de78 - md5: 4fb57d98ef4b5f335d96d3ab0f25d6ea +- conda: https://prefix.dev/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda + sha256: 6d7e6e1286cb521059fe69696705100a03b006efb914ffe82a2ae97ecbae66b7 + md5: 129e404c5b001f3ef5581316971e3ea0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + size: 17625 + timestamp: 1771539597968 +- conda: https://prefix.dev/conda-forge/linux-64/icu-78.3-py310h44b86e0_2.conda + sha256: 9f07834f0c546ab14d885ce0366285f61f44e326c0edd1fc63b8294e113ae432 + md5: 72a381cbad04f24b1c2a43ef707f45b4 depends: - - libharfbuzz-devel 14.3.1 hcda0f7c_0 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 license: MIT license_family: MIT purls: [] - size: 11045 - timestamp: 1786970975481 -- conda: https://prefix.dev/conda-forge/noarch/hatch-1.16.5-pyhcf101f3_0.conda - sha256: e298f93e25d98f5b90f231cf9cd6467773fc3fd242a9a0dce2b82fcfa1b38971 - md5: 3191c464a2222e8af63e57926da9315c + size: 14459115 + timestamp: 1786545741408 +- conda: https://prefix.dev/conda-forge/linux-64/jack-1.9.22-hf4617a5_3.conda + sha256: 69f6b7228aa43177c82e21b90497adb1d7c61e70f1b8dd38d8ca8baa74a0cbf7 + md5: a071738556dc29fa1c844fb440506dc8 depends: - - click >=8.0.6 - - hatchling >=1.27.0 - - httpx >=0.22.0 - - hyperlink >=21.0.0 - - keyring >=23.5.0 - - packaging >=24.2 - - pexpect >=4.8,<5.dev0 - - platformdirs >=2.5.0 - - pyproject_hooks - - python >=3.10 - - rich >=11.2.0 - - shellingham >=1.4.0 - - tomli-w >=1.0 - - tomlkit >=0.11.1 - - userpath >=1.7,<2.dev0 - - uv >=0.5.23 - - virtualenv >=21 - - backports.zstd >=1.0.0 - - python-discovery >=1.1 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/hatch?source=hash-mapping - size: 208420 - timestamp: 1772806610433 -- conda: https://prefix.dev/conda-forge/noarch/hatchling-1.29.0-pyhcf101f3_0.conda - sha256: bb86ff4ca54a2a0f63714766c7653a772c13d34c9e7cfb7be653db2fb806f961 - md5: 9d67ecd4cd5e6a9be36522be95951785 - depends: - - packaging >=24.2 - - pathspec >=0.10.1 - - pluggy >=1.0.0 - - python >=3.10 - - tomli >=1.2.2 - - trove-classifiers - - editables >=0.3 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/hatchling?source=hash-mapping - size: 61052 - timestamp: 1773194193187 -- conda: https://prefix.dev/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda - sha256: 6d7e6e1286cb521059fe69696705100a03b006efb914ffe82a2ae97ecbae66b7 - md5: 129e404c5b001f3ef5581316971e3ea0 - license: GPL-2.0-or-later - license_family: GPL - purls: [] - size: 17625 - timestamp: 1771539597968 -- conda: https://prefix.dev/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda - sha256: 46a4958f2f916c5938f2a6dc0709f78b175ece42f601d79a04e0276d55d25d07 - md5: cfb39109ac5fa8601eb595d66d5bf156 - license: GPL-2.0-or-later - license_family: GPL + - __glibc >=2.17,<3.0.a0 + - alsa-lib >=1.2.14,<1.3.0a0 + - libgcc >=13 + - libopus >=1.5.2,<2.0a0 + - libstdcxx >=13 + license: LGPL-2.0-only + license_family: LGPL purls: [] - size: 17616 - timestamp: 1771539622983 -- conda: https://prefix.dev/conda-forge/noarch/hpack-4.1.0-pyhd8ed1ab_0.conda - sha256: 6ad78a180576c706aabeb5b4c8ceb97c0cb25f1e112d76495bff23e3779948ba - md5: 0a802cb9888dd14eeefc611f05c40b6e + size: 461260 + timestamp: 1747574434594 +- conda: https://prefix.dev/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4 + md5: b38117a3c920364aff79f870c984b4a3 depends: - - python >=3.9 - license: MIT - license_family: MIT - purls: - - pkg:pypi/hpack?source=hash-mapping - size: 30731 - timestamp: 1737618390337 -- conda: https://prefix.dev/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda - sha256: 04d49cb3c42714ce533a8553986e1642d0549a05dc5cc48e0d43ff5be6679a5b - md5: 4f14640d58e2cc0aa0819d9d8ba125bb + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: LGPL-2.1-or-later + purls: [] + size: 134088 + timestamp: 1754905959823 +- conda: https://prefix.dev/conda-forge/linux-64/kiwisolver-1.5.0-py311h724c32c_0.conda + sha256: 3ff7e51c88f53f05e22ca5549e935d1ccb398665f6ec080a9c6a5c9e9b186b79 + md5: 3d82751e8d682068b58f049edc924ce4 depends: - - python >=3.9 - - h11 >=0.16 - - h2 >=3,<5 - - sniffio 1.* - - anyio >=4.0,<5.0 - - certifi - python + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.11.* *_cp311 license: BSD-3-Clause license_family: BSD purls: - - pkg:pypi/httpcore?source=hash-mapping - size: 49483 - timestamp: 1745602916758 -- conda: https://prefix.dev/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda - sha256: cd0f1de3697b252df95f98383e9edb1d00386bfdd03fdf607fa42fe5fcb09950 - md5: d6989ead454181f4f9bc987d3dc4e285 - depends: - - anyio - - certifi - - httpcore 1.* - - idna - - python >=3.9 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/httpx?source=hash-mapping - size: 63082 - timestamp: 1733663449209 -- conda: https://prefix.dev/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda - sha256: 77af6f5fe8b62ca07d09ac60127a30d9069fdc3c68d6b256754d0ffb1f7779f8 - md5: 8e6923fc12f1fe8f8c4e5c9f343256ac + - pkg:pypi/kiwisolver?source=hash-mapping + size: 77967 + timestamp: 1773067041763 +- conda: https://prefix.dev/conda-forge/linux-64/krb5-1.22.2-ha1258a1_0.conda + sha256: 3e307628ca3527448dd1cb14ad7bb9d04d1d28c7d4c5f97ba196ae984571dd25 + md5: fb53fb07ce46a575c5d004bbc96032c2 depends: - - python >=3.9 + - __glibc >=2.17,<3.0.a0 + - keyutils >=1.6.3,<2.0a0 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - libgcc >=14 + - libstdcxx >=14 + - openssl >=3.5.5,<4.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/hyperframe?source=hash-mapping - size: 17397 - timestamp: 1737618427549 -- conda: https://prefix.dev/conda-forge/noarch/hyperlink-21.0.0-pyh29332c3_1.conda - sha256: 6fc0a91c590b3055bfb7983e6521c7b780ab8b11025058eaf898049ea827d829 - md5: c27acdecaf3c311e5781b81fe02d9641 + purls: [] + size: 1386730 + timestamp: 1769769569681 +- conda: https://prefix.dev/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 + sha256: aad2a703b9d7b038c0f745b853c6bb5f122988fe1a7a096e0e606d9cbec4eaab + md5: a8832b479f93521a9e7b5b743803be51 depends: - - python >=3.9 - - idna >=2.6 - - python + - libgcc-ng >=12 + license: LGPL-2.0-only + license_family: LGPL + purls: [] + size: 508258 + timestamp: 1664996250081 +- conda: https://prefix.dev/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda + sha256: 112b5b9462572d970f4abd2912f76a25ee7db158b1e7260163d91dd8a630db84 + md5: 8b3ce45e929cd8e8e5f4d18586b56d8b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/hyperlink?source=hash-mapping - size: 74751 - timestamp: 1733319972207 -- conda: https://prefix.dev/conda-forge/linux-64/icu-78.3-py310h44b86e0_2.conda - sha256: 9f07834f0c546ab14d885ce0366285f61f44e326c0edd1fc63b8294e113ae432 - md5: 72a381cbad04f24b1c2a43ef707f45b4 + purls: [] + size: 251971 + timestamp: 1780211695895 +- conda: https://prefix.dev/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c + md5: 18335a698559cdbcd86150a48bf54ba6 + depends: + - __glibc >=2.17,<3.0.a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - binutils_impl_linux-64 2.45.1 + license: GPL-3.0-only + license_family: GPL + purls: [] + size: 728002 + timestamp: 1774197446916 +- conda: https://prefix.dev/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda + sha256: f84cb54782f7e9cea95e810ea8fef186e0652d0fa73d3009914fa2c1262594e1 + md5: a752488c68f2e7c456bcbd8f16eec275 depends: - __glibc >=2.17,<3.0.a0 + - libgcc >=14 - libstdcxx >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 261513 + timestamp: 1773113328888 +- conda: https://prefix.dev/conda-forge/linux-64/libavif16-1.4.1-hcfa2d63_0.conda + sha256: e29d8ed0334305c6bafecb32f9a1967cfc0a081eac916e947a1f2f7c4bb41947 + md5: f79415aee8862b3af85ea55dea37e46b + depends: + - __glibc >=2.17,<3.0.a0 + - aom >=3.9.1,<3.10.0a0 + - dav1d >=1.2.1,<1.2.2.0a0 - libgcc >=14 + - rav1e >=0.8.1,<0.9.0a0 + - svt-av1 >=4.0.1,<4.0.2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 148710 + timestamp: 1774042709303 +- conda: https://prefix.dev/conda-forge/linux-64/libblas-3.11.0-6_h4a7cf45_openblas.conda + build_number: 6 + sha256: 7bfe936dbb5db04820cf300a9cc1f5ee8d5302fc896c2d66e30f1ee2f20fbfd6 + md5: 6d6d225559bfa6e2f3c90ee9c03d4e2e + depends: + - libopenblas >=0.3.32,<0.3.33.0a0 + - libopenblas >=0.3.32,<1.0a0 + constrains: + - blas 2.306 openblas + - liblapack 3.11.0 6*_openblas + - liblapacke 3.11.0 6*_openblas + - libcblas 3.11.0 6*_openblas + - mkl <2026 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 18621 + timestamp: 1774503034895 +- conda: https://prefix.dev/conda-forge/linux-64/libbrotlicommon-1.2.0-h39a168f_3.conda + sha256: e5864f257f839ffc27d681659bac95901f524f602b9121e5dcc5e2df18437f2d + md5: 7a2499a177753582fb7ae7e9dc4a908a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 license: MIT license_family: MIT purls: [] - size: 14459115 - timestamp: 1786545741408 -- conda: https://prefix.dev/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda - sha256: 6cdb5dee54c72e56ab189fb3ad33cb28533553d42590e7e831160248f4416a43 - md5: a5efc0b42bb8b42e97d0a29ae3e3c187 + size: 80265 + timestamp: 1786622773969 +- conda: https://prefix.dev/conda-forge/linux-64/libbrotlidec-1.2.0-ha411449_3.conda + sha256: dad31b6d104973deb89710929a35651033aad692d4e7793cdb5b786a9bd54678 + md5: 6ab3315dc56618d652c1da42a648a129 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 h39a168f_3 + - libgcc >=15 license: MIT license_family: MIT purls: [] - size: 14070242 - timestamp: 1786545847761 -- conda: https://prefix.dev/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda - sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 - md5: 84a3233b709a289a4ddd7a2fd27dd988 + size: 34828 + timestamp: 1786622783405 +- conda: https://prefix.dev/conda-forge/linux-64/libbrotlienc-1.2.0-h018ffa1_3.conda + sha256: d37124d0f51816e7d5e3a94bfc9ed3d6174d077f9b4f832d20c5a08b52bebf1f + md5: 2ac965638d4c6b2b38383bb1aebaf543 depends: - - python >=3.10 - - ukkonen + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 h39a168f_3 + - libgcc >=15 license: MIT license_family: MIT - purls: - - pkg:pypi/identify?source=hash-mapping - size: 79757 - timestamp: 1776455344188 -- conda: https://prefix.dev/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda - sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 - md5: fb7130c190f9b4ec91219840a05ba3ac - depends: - - python >=3.10 - - python - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/idna?source=hash-mapping - size: 59038 - timestamp: 1776947141407 -- conda: https://prefix.dev/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda - sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 - md5: 080594bf4493e6bae2607e65390c520a + purls: [] + size: 298639 + timestamp: 1786622792145 +- conda: https://prefix.dev/conda-forge/linux-64/libcap-2.77-hd0affe5_1.conda + sha256: 37c41b1024d0c75da76822e3c079aabaf121618a32fe05e53a897b35a88008fc + md5: 499cd8e2d4358986dbe3b30e8fe1bf6a depends: - - python >=3.10 - - zipp >=3.20 - - python - license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/importlib-metadata?source=hash-mapping - size: 34387 - timestamp: 1773931568510 -- conda: https://prefix.dev/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda - sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a - md5: 0ba6225c279baf7ea9473a62ea0ec9ae + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 124432 + timestamp: 1774333989027 +- conda: https://prefix.dev/conda-forge/linux-64/libcblas-3.11.0-6_h0358290_openblas.conda + build_number: 6 + sha256: 57edafa7796f6fa3ebbd5367692dd4c7f552be42109c2dd1a7c89b55089bf374 + md5: 36ae340a916635b97ac8a0655ace2a35 depends: - - python >=3.10 - - zipp >=3.1.0 + - libblas 3.11.0 6_h4a7cf45_openblas constrains: - - importlib-resources >=7.1.0,<7.1.1.0a0 - license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/importlib-resources?source=hash-mapping - size: 34809 - timestamp: 1776068839274 -- conda: https://prefix.dev/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda - sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 - md5: 9614359868482abba1bd15ce465e3c42 + - blas 2.306 openblas + - liblapack 3.11.0 6*_openblas + - liblapacke 3.11.0 6*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 18622 + timestamp: 1774503050205 +- conda: https://prefix.dev/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda + sha256: 4695ce68eda595b4f53146bea1096a9f2e0d33290618ba83a246b5ed8871ebc9 + md5: 6a3d962d34385e0a511b859d679f6ea2 depends: - - python >=3.10 - license: MIT - license_family: MIT - purls: - - pkg:pypi/iniconfig?source=hash-mapping - size: 13387 - timestamp: 1760831448842 -- conda: https://prefix.dev/conda-forge/linux-64/jack-1.9.22-hf4617a5_3.conda - sha256: 69f6b7228aa43177c82e21b90497adb1d7c61e70f1b8dd38d8ca8baa74a0cbf7 - md5: a071738556dc29fa1c844fb440506dc8 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + constrains: + - libccd <1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 36171 + timestamp: 1687341825064 +- conda: https://prefix.dev/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h08c5240_6.conda + sha256: fc2981a8e45dd232ae88cf2580f7e75c258f4dccdc96f879b68ef0a9b45c9a2b + md5: 4fd9026a57bb45cd15bd08ff8bd0578e depends: + - libstdcxx >=14 + - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - alsa-lib >=1.2.14,<1.3.0a0 - - libgcc >=13 - - libopus >=1.5.2,<2.0a0 - - libstdcxx >=13 - license: LGPL-2.0-only - license_family: LGPL + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE purls: [] - size: 461260 - timestamp: 1747574434594 -- conda: https://prefix.dev/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda - sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 - md5: d59568bad316413c89831456e691de29 - depends: - - python >=3.10 - - more-itertools - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/jaraco-classes?source=hash-mapping - size: 14831 - timestamp: 1767294269456 -- conda: https://prefix.dev/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda - sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc - md5: b9d2b1ffa307961f6bb7d83c8ba8a8be - depends: - - python >=3.10 - - backports.tarfile - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/jaraco-context?source=hash-mapping - size: 16222 - timestamp: 1776862415793 -- conda: https://prefix.dev/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda - sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda - md5: aa83cc08626bf6b613a3103942be8951 + size: 24171067 + timestamp: 1786527767794 +- conda: https://prefix.dev/conda-forge/linux-64/libclang13-22.1.8-default_hd70ba2e_6.conda + sha256: 8475136d3be6c2d16bdb801dcaf8769cb2ba372cad239c89ebd6a58912e14465 + md5: a8e147873eca89dc1c5d319b027a6cd3 depends: - - python >=3.10 - - more-itertools - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/jaraco-functools?source=hash-mapping - size: 18744 - timestamp: 1767294193246 -- conda: https://prefix.dev/conda-forge/noarch/jax-jumpy-1.0.0-pyhd8ed1ab_1.conda - sha256: c414b2be28e7d963e55c962caad1a25833d2e415a3d7a16e4f9da9e187dd37b3 - md5: d15bad1eca61880b5e465c4038d7c3f4 + - libclang-cpp22.1 ==22.1.8 default_h08c5240_6 + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + purls: [] + size: 14275196 + timestamp: 1786527767794 +- conda: https://prefix.dev/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda + sha256: 205c4f19550f3647832ec44e35e6d93c8c206782bdd620c1d7cf66237580ff9c + md5: 49c553b47ff679a6a1e9fc80b9c5a2d4 depends: - - numpy >=1.18.0 - - python >=3.9 + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/jax-jumpy?source=hash-mapping - size: 20757 - timestamp: 1734210042598 -- conda: https://prefix.dev/conda-forge/noarch/jeepney-0.9.0-pyhd8ed1ab_0.conda - sha256: 00d37d85ca856431c67c8f6e890251e7cc9e5ef3724a0302b8d4a101f22aa27f - md5: b4b91eb14fbe2f850dd2c5fc20676c0d + license_family: Apache + purls: [] + size: 4518030 + timestamp: 1770902209173 +- conda: https://prefix.dev/conda-forge/linux-64/libcurl-8.20.0-hcf29cc6_0.conda + sha256: 75963a5dd913311f59a35dbd307592f4fa754c4808aff9c33edb430c415e38eb + md5: c3cc2864f82a944bc90a7beb4d3b0e88 depends: - - python >=3.9 - license: MIT + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libnghttp2 >=1.68.1,<2.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.6,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl license_family: MIT - purls: - - pkg:pypi/jeepney?source=hash-mapping - size: 40015 - timestamp: 1740828380668 -- conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda - sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 - md5: c88f9579d08eb4031159f03640714ce3 + purls: [] + size: 468706 + timestamp: 1777461492876 +- conda: https://prefix.dev/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda + sha256: aa8e8c4be9a2e81610ddf574e05b64ee131fab5e0e3693210c9d6d2fba32c680 + md5: 6c77a605a7a689d17d4819c0f8ac9a00 depends: - - __osx - - importlib-metadata >=4.11.4 - - importlib_resources - - jaraco.classes - - jaraco.context - - jaraco.functools - - python >=3.10 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 license: MIT license_family: MIT - purls: - - pkg:pypi/keyring?source=hash-mapping - size: 37924 - timestamp: 1763320995459 -- conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda - sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 - md5: 9eeb0eaf04fa934808d3e070eebbe630 + purls: [] + size: 73490 + timestamp: 1761979956660 +- conda: https://prefix.dev/conda-forge/linux-64/libdrm-2.4.125-hb03c661_1.conda + sha256: c076a213bd3676cc1ef22eeff91588826273513ccc6040d9bea68bccdc849501 + md5: 9314bc5a1fe7d1044dc9dfd3ef400535 depends: - - __linux - - importlib-metadata >=4.11.4 - - importlib_resources - - jaraco.classes - - jaraco.context - - jaraco.functools - - jeepney >=0.4.2 - - python >=3.10 - - secretstorage >=3.2 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libpciaccess >=0.18,<0.19.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/keyring?source=hash-mapping - size: 37717 - timestamp: 1763320674488 -- conda: https://prefix.dev/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4 - md5: b38117a3c920364aff79f870c984b4a3 + purls: [] + size: 310785 + timestamp: 1757212153962 +- conda: https://prefix.dev/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 + md5: c277e0a4d549b03ac1e9d6cbbe3d017b depends: + - ncurses - __glibc >=2.17,<3.0.a0 - libgcc >=13 - license: LGPL-2.1-or-later + - ncurses >=6.5,<7.0a0 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 134088 - timestamp: 1754905959823 -- conda: https://prefix.dev/conda-forge/linux-64/kiwisolver-1.5.0-py311h724c32c_0.conda - sha256: 3ff7e51c88f53f05e22ca5549e935d1ccb398665f6ec080a9c6a5c9e9b186b79 - md5: 3d82751e8d682068b58f049edc924ce4 + size: 134676 + timestamp: 1738479519902 +- conda: https://prefix.dev/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda + sha256: 7fd5408d359d05a969133e47af580183fbf38e2235b562193d427bb9dad79723 + md5: c151d5eb730e9b7480e6d48c0fc44048 depends: - - python - - libstdcxx >=14 - - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - python_abi 3.11.* *_cp311 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/kiwisolver?source=hash-mapping - size: 77967 - timestamp: 1773067041763 -- conda: https://prefix.dev/conda-forge/osx-arm64/kiwisolver-1.5.0-py311h7d85929_0.conda - sha256: bad01811dae8d727a7ff5a271c8304be495e7e594dfddb9f1d576e41ba7c1a76 - md5: 9b4b32f37ebf95463c38636ae2f2ec56 + - libglvnd 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd + purls: [] + size: 44840 + timestamp: 1731330973553 +- conda: https://prefix.dev/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_2.conda + sha256: f6e7095260305dc05238062142fb8db4b940346329b5b54894a90610afa6749f + md5: b513eb83b3137eca1192c34bf4f013a7 depends: - - python - - __osx >=11.0 - - python 3.11.* *_cpython - - libcxx >=19 - - python_abi 3.11.* *_cp311 - license: BSD-3-Clause + - __glibc >=2.17,<3.0.a0 + - libegl 1.7.0 ha4b6fd6_2 + - libgl-devel 1.7.0 ha4b6fd6_2 + - xorg-libx11 + license: LicenseRef-libglvnd + purls: [] + size: 30380 + timestamp: 1731331017249 +- conda: https://prefix.dev/conda-forge/linux-64/libev-4.33-hd590300_2.conda + sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 + md5: 172bf1cd1ff8629f2b1179945ed45055 + depends: + - libgcc-ng >=12 + license: BSD-2-Clause license_family: BSD - purls: - - pkg:pypi/kiwisolver?source=hash-mapping - size: 66903 - timestamp: 1773067313219 -- conda: https://prefix.dev/conda-forge/linux-64/krb5-1.22.2-ha1258a1_0.conda - sha256: 3e307628ca3527448dd1cb14ad7bb9d04d1d28c7d4c5f97ba196ae984571dd25 - md5: fb53fb07ce46a575c5d004bbc96032c2 + purls: [] + size: 112766 + timestamp: 1702146165126 +- conda: https://prefix.dev/conda-forge/linux-64/libexpat-2.8.0-hecca717_0.conda + sha256: ea33c40977ea7a2c3658c522230058395bc2ee0d89d99f0711390b6a1ee80d12 + md5: a3b390520c563d78cc58974de95a03e5 depends: - __glibc >=2.17,<3.0.a0 - - keyutils >=1.6.3,<2.0a0 - - libedit >=3.1.20250104,<3.2.0a0 - - libedit >=3.1.20250104,<4.0a0 - libgcc >=14 - - libstdcxx >=14 - - openssl >=3.5.5,<4.0a0 + constrains: + - expat 2.8.0.* license: MIT license_family: MIT purls: [] - size: 1386730 - timestamp: 1769769569681 -- conda: https://prefix.dev/conda-forge/osx-arm64/krb5-1.22.2-h385eeb1_0.conda - sha256: c0a0bf028fe7f3defcdcaa464e536cf1b202d07451e18ad83fdd169d15bef6ed - md5: e446e1822f4da8e5080a9de93474184d + size: 77241 + timestamp: 1777846112704 +- conda: https://prefix.dev/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 + md5: a360c33a5abe61c07959e449fa1453eb depends: - - __osx >=11.0 - - libcxx >=19 - - libedit >=3.1.20250104,<3.2.0a0 - - libedit >=3.1.20250104,<4.0a0 - - openssl >=3.5.5,<4.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 license: MIT license_family: MIT purls: [] - size: 1160828 - timestamp: 1769770119811 -- conda: https://prefix.dev/conda-forge/linux-64/lame-3.100-h166bdaf_1003.tar.bz2 - sha256: aad2a703b9d7b038c0f745b853c6bb5f122988fe1a7a096e0e606d9cbec4eaab - md5: a8832b479f93521a9e7b5b743803be51 - depends: - - libgcc-ng >=12 - license: LGPL-2.0-only - license_family: LGPL - purls: [] - size: 508258 - timestamp: 1664996250081 -- conda: https://prefix.dev/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 - sha256: f40ce7324b2cf5338b766d4cdb8e0453e4156a4f83c2f31bbfff750785de304c - md5: bff0e851d66725f78dc2fd8b032ddb7e - license: LGPL-2.0-only - license_family: LGPL - purls: [] - size: 528805 - timestamp: 1664996399305 -- conda: https://prefix.dev/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda - sha256: 112b5b9462572d970f4abd2912f76a25ee7db158b1e7260163d91dd8a630db84 - md5: 8b3ce45e929cd8e8e5f4d18586b56d8b + size: 58592 + timestamp: 1769456073053 +- conda: https://prefix.dev/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda + sha256: e755e234236bdda3d265ae82e5b0581d259a9279e3e5b31d745dc43251ad64fb + md5: 47595b9d53054907a00d95e4d47af1d6 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - - libjpeg-turbo >=3.1.4.1,<4.0a0 - - libtiff >=4.7.1,<4.8.0a0 - license: MIT - license_family: MIT + - libiconv >=1.18,<2.0a0 + - libogg >=1.3.5,<1.4.0a0 + - libstdcxx >=14 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 251971 - timestamp: 1780211695895 -- conda: https://prefix.dev/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda - sha256: ccb5598fad3694e79bf54f0eb812e3b3c3dd63d1497e631f5978800eadb9bcc4 - md5: d2f2c7c10e2957647d45589b7701a453 + size: 424563 + timestamp: 1764526740626 +- conda: https://prefix.dev/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda + sha256: 38f014a7129e644636e46064ecd6b1945e729c2140e21d75bb476af39e692db2 + md5: e289f3d17880e44b633ba911d57a321b depends: - - __osx >=11.0 - - libjpeg-turbo >=3.1.4.1,<4.0a0 - - libtiff >=4.7.1,<4.8.0a0 - license: MIT - license_family: MIT + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL purls: [] - size: 213747 - timestamp: 1780212240694 -- conda: https://prefix.dev/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda - sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c - md5: 18335a698559cdbcd86150a48bf54ba6 + size: 8049 + timestamp: 1774298163029 +- conda: https://prefix.dev/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda + sha256: 16f020f96da79db1863fcdd8f2b8f4f7d52f177dd4c58601e38e9182e91adf1d + md5: fb16b4b69e3f1dcfe79d80db8fd0c55d depends: - __glibc >=2.17,<3.0.a0 - - zstd >=1.5.7,<1.6.0a0 + - libgcc >=14 + - libpng >=1.6.55,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 constrains: - - binutils_impl_linux-64 2.45.1 - license: GPL-3.0-only - license_family: GPL + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL purls: [] - size: 728002 - timestamp: 1774197446916 -- pypi: https://files.pythonhosted.org/packages/fb/06/6a7c30c3519181263e1bbf0cbea67ef4a43a64443ee16717c7d760214943/lenses-1.2.0-py3-none-any.whl - name: lenses - version: 1.2.0 - sha256: e03c81e35500e12e1d35504f76c26489c0a4e08b0881e96fc4e8a1b707c53f16 - requires_dist: - - sphinx ; extra == 'docs' - - pyrsistent ; extra == 'lints' - - ufmt ; extra == 'lints' - - flake8 ; extra == 'lints' - - mypy ; implementation_name == 'cpython' and extra == 'lints' - - pyrsistent ; extra == 'optional' - - pyrsistent ; extra == 'tests' - - pytest ; extra == 'tests' - - pytest-sugar ; extra == 'tests' - - coverage ; extra == 'tests' - - pytest-coverage ; extra == 'tests' - - hypothesis ; extra == 'tests' - requires_python: '>=3.7,<4' -- conda: https://prefix.dev/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda - sha256: f84cb54782f7e9cea95e810ea8fef186e0652d0fa73d3009914fa2c1262594e1 - md5: a752488c68f2e7c456bcbd8f16eec275 + size: 384575 + timestamp: 1774298162622 +- conda: https://prefix.dev/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + sha256: 8e0a3b5e41272e5678499b5dfc4cddb673f9e935de01eb0767ce857001229f46 + md5: 57736f29cc2b0ec0b6c2952d3f101b6a depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - license: Apache-2.0 - license_family: Apache + - _openmp_mutex >=4.5 + constrains: + - libgcc-ng ==15.2.0=*_19 + - libgomp 15.2.0 he0feb66_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 261513 - timestamp: 1773113328888 -- conda: https://prefix.dev/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda - sha256: 66e5ffd301a44da696f3efc2f25d6d94f42a9adc0db06c44ad753ab844148c51 - md5: 095e5749868adab9cae42d4b460e5443 + size: 1041084 + timestamp: 1778269013026 +- conda: https://prefix.dev/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda + sha256: 9dcf54adfaa5e861123c2da4f2f0451a685464ea7e5a41ad91cf67b31d658d98 + md5: 331ee9b72b9dff570d56b1302c5ab37d depends: - - __osx >=11.0 - - libcxx >=19 - license: Apache-2.0 - license_family: Apache + - libgcc 15.2.0 he0feb66_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 164222 - timestamp: 1773114244984 -- conda: https://prefix.dev/conda-forge/linux-64/libavif16-1.4.1-hcfa2d63_0.conda - sha256: e29d8ed0334305c6bafecb32f9a1967cfc0a081eac916e947a1f2f7c4bb41947 - md5: f79415aee8862b3af85ea55dea37e46b + size: 27694 + timestamp: 1778269016987 +- conda: https://prefix.dev/conda-forge/linux-64/libgd-2.3.3-h5fbf134_12.conda + sha256: 245be793e831170504f36213134f4c24eedaf39e634679809fd5391ad214480b + md5: 88c1c66987cd52a712eea89c27104be6 depends: - __glibc >=2.17,<3.0.a0 - - aom >=3.9.1,<3.10.0a0 - - dav1d >=1.2.1,<1.2.2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.1,<79.0a0 + - libexpat >=2.7.3,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 - libgcc >=14 - - rav1e >=0.8.1,<0.9.0a0 - - svt-av1 >=4.0.1,<4.0.2.0a0 - license: BSD-2-Clause + - libjpeg-turbo >=3.1.2,<4.0a0 + - libpng >=1.6.53,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + license: GD license_family: BSD purls: [] - size: 148710 - timestamp: 1774042709303 -- conda: https://prefix.dev/conda-forge/osx-arm64/libavif16-1.4.1-hfce71f6_0.conda - sha256: 09e31e51026a3b74d947ba4b30a68dd99013aeef2860bcb03565bf43cad18da6 - md5: 2df04ee54a2ce2d34cf375eb02a63725 - depends: - - __osx >=11.0 - - aom >=3.9.1,<3.10.0a0 - - dav1d >=1.2.1,<1.2.2.0a0 - - rav1e >=0.8.1,<0.9.0a0 - - svt-av1 >=4.0.1,<4.0.2.0a0 - license: BSD-2-Clause - license_family: BSD + size: 177306 + timestamp: 1766331805898 +- conda: https://prefix.dev/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda + sha256: 561a42758ef25b9ce308c4e2cf56daee4f06138385a17e29a492cd928e00be6f + md5: 42bf7eca1a951735fa06c0e3c0d5c8e6 + depends: + - libgfortran5 15.2.0 h68bc16d_19 + constrains: + - libgfortran-ng ==15.2.0=*_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 118959 - timestamp: 1774043016600 -- conda: https://prefix.dev/conda-forge/linux-64/libblas-3.11.0-6_h4a7cf45_openblas.conda - build_number: 6 - sha256: 7bfe936dbb5db04820cf300a9cc1f5ee8d5302fc896c2d66e30f1ee2f20fbfd6 - md5: 6d6d225559bfa6e2f3c90ee9c03d4e2e + size: 27655 + timestamp: 1778269042954 +- conda: https://prefix.dev/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda + sha256: 057978bb69fea29ed715a9b98adf71015c31baecc4aeb2bfc20d4fd5d83579d4 + md5: 85072b0ad177c966294f129b7c04a2d5 depends: - - libopenblas >=0.3.32,<0.3.33.0a0 - - libopenblas >=0.3.32,<1.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=15.2.0 constrains: - - blas 2.306 openblas - - liblapack 3.11.0 6*_openblas - - liblapacke 3.11.0 6*_openblas - - libcblas 3.11.0 6*_openblas - - mkl <2026 - license: BSD-3-Clause - license_family: BSD + - libgfortran 15.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 18621 - timestamp: 1774503034895 -- conda: https://prefix.dev/conda-forge/osx-arm64/libblas-3.11.0-6_h51639a9_openblas.conda - build_number: 6 - sha256: 979227fc03628925037ab2dfda008eb7b5592644d9c2c21dd285cefe8c42553d - md5: e551103471911260488a02155cef9c94 + size: 2483673 + timestamp: 1778269025089 +- conda: https://prefix.dev/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + sha256: dc2752241fa3d9e40ce552c1942d0a4b5eeb93740c9723873f6fcf8d39ef8d2d + md5: 928b8be80851f5d8ffb016f9c81dae7a depends: - - libopenblas >=0.3.32,<0.3.33.0a0 - - libopenblas >=0.3.32,<1.0a0 + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - libglx 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd + purls: [] + size: 134712 + timestamp: 1731330998354 +- conda: https://prefix.dev/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_2.conda + sha256: e281356c0975751f478c53e14f3efea6cd1e23c3069406d10708d6c409525260 + md5: 53e7cbb2beb03d69a478631e23e340e9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgl 1.7.0 ha4b6fd6_2 + - libglx-devel 1.7.0 ha4b6fd6_2 + license: LicenseRef-libglvnd + purls: [] + size: 113911 + timestamp: 1731331012126 +- conda: https://prefix.dev/conda-forge/linux-64/libglib-2.88.3-h0d30a3d_0.conda + sha256: 69ea4df61403531e5b3e5f3d52ba2837423df361b4eb8727f5b63aaf6de6768a + md5: 17c3b7b6bcbd35b688c933eb4834c0bc + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libffi >=3.5.2,<3.6.0a0 constrains: - - liblapacke 3.11.0 6*_openblas - - liblapack 3.11.0 6*_openblas - - blas 2.306 openblas - - libcblas 3.11.0 6*_openblas - - mkl <2026 - license: BSD-3-Clause - license_family: BSD + - glib >2.66 + license: LGPL-2.1-or-later purls: [] - size: 18859 - timestamp: 1774504387211 -- conda: https://prefix.dev/conda-forge/linux-64/libbrotlicommon-1.2.0-h39a168f_3.conda - sha256: e5864f257f839ffc27d681659bac95901f524f602b9121e5dcc5e2df18437f2d - md5: 7a2499a177753582fb7ae7e9dc4a908a + size: 4755324 + timestamp: 1785442107463 +- conda: https://prefix.dev/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + sha256: 1175f8a7a0c68b7f81962699751bb6574e6f07db4c9f72825f978e3016f46850 + md5: 434ca7e50e40f4918ab701e3facd59a0 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=15 - license: MIT - license_family: MIT + license: LicenseRef-libglvnd purls: [] - size: 80265 - timestamp: 1786622773969 -- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlicommon-1.2.0-h1dcdb26_3.conda - sha256: 5e62b856b2e77ce98db44133bacab1281b42c1040dcbd69dbacfb80890cff5b0 - md5: b457450ba3f27c4749783c0204bd17b0 + size: 132463 + timestamp: 1731330968309 +- conda: https://prefix.dev/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + sha256: 2d35a679624a93ce5b3e9dd301fff92343db609b79f0363e6d0ceb3a6478bfa7 + md5: c8013e438185f33b13814c5c488acd5c depends: - - __osx >=11.0 - license: MIT - license_family: MIT + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - xorg-libx11 >=1.8.10,<2.0a0 + license: LicenseRef-libglvnd purls: [] - size: 80027 - timestamp: 1786622846050 -- conda: https://prefix.dev/conda-forge/linux-64/libbrotlidec-1.2.0-ha411449_3.conda - sha256: dad31b6d104973deb89710929a35651033aad692d4e7793cdb5b786a9bd54678 - md5: 6ab3315dc56618d652c1da42a648a129 + size: 75504 + timestamp: 1731330988898 +- conda: https://prefix.dev/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_2.conda + sha256: 0a930e0148ab6e61089bbcdba25a2e17ee383e7de82e7af10cc5c12c82c580f3 + md5: 27ac5ae872a21375d980bd4a6f99edf3 depends: - __glibc >=2.17,<3.0.a0 - - libbrotlicommon 1.2.0 h39a168f_3 - - libgcc >=15 - license: MIT - license_family: MIT + - libglx 1.7.0 ha4b6fd6_2 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-xorgproto + license: LicenseRef-libglvnd purls: [] - size: 34828 - timestamp: 1786622783405 -- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlidec-1.2.0-h5295a6a_3.conda - sha256: 510c9fce0d9ffcf41741dd96fc05db381672109d5665ef002c2e58f0d4ca0118 - md5: e07a99c6fdd984f4d588060f2f936bf4 + size: 26388 + timestamp: 1731331003255 +- conda: https://prefix.dev/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b + md5: faac990cb7aedc7f3a2224f2c9b0c26c depends: - - __osx >=11.0 - - libbrotlicommon 1.2.0 h1dcdb26_3 - license: MIT - license_family: MIT + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 29935 - timestamp: 1786622857695 -- conda: https://prefix.dev/conda-forge/linux-64/libbrotlienc-1.2.0-h018ffa1_3.conda - sha256: d37124d0f51816e7d5e3a94bfc9ed3d6174d077f9b4f832d20c5a08b52bebf1f - md5: 2ac965638d4c6b2b38383bb1aebaf543 + size: 603817 + timestamp: 1778268942614 +- conda: https://prefix.dev/conda-forge/linux-64/libharfbuzz-14.3.1-h23af247_0.conda + sha256: a4eac5a21b84e0fc753b72de01781f634fc9ab70fd32a28d6a40a19700c9188a + md5: 29709e61096dd490fff9e833e4c869f6 depends: - __glibc >=2.17,<3.0.a0 - - libbrotlicommon 1.2.0 h39a168f_3 + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 - libgcc >=15 + - libglib >=2.88.3,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libstdcxx >=15 + - libzlib >=1.3.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 298639 - timestamp: 1786622792145 -- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlienc-1.2.0-h2ddc9cb_3.conda - sha256: eac412417eee2e93c62e9d53559f1f9c14f40b6c41e2c432af8b517596898dd1 - md5: 954c78a9f591bfb12c79beaff7338ec8 + size: 1353639 + timestamp: 1786970872936 +- conda: https://prefix.dev/conda-forge/linux-64/libharfbuzz-devel-14.3.1-h23af247_0.conda + sha256: 9d9d620141102dcb580d8f42d1a6c9e7e691a8dfa0284783e712679723067d15 + md5: e0f17ce01589ffa7d773be573e97b36c depends: - - __osx >=11.0 - - libbrotlicommon 1.2.0 h1dcdb26_3 + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - freetype + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=15 + - libglib >=2.88.3,<3.0a0 + - libharfbuzz 14.3.1 h23af247_0 + - libpng >=1.6.58,<1.7.0a0 + - libstdcxx >=15 + - libzlib >=1.3.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 295650 - timestamp: 1786622868044 -- conda: https://prefix.dev/conda-forge/linux-64/libcap-2.77-hd0affe5_1.conda - sha256: 37c41b1024d0c75da76822e3c079aabaf121618a32fe05e53a897b35a88008fc - md5: 499cd8e2d4358986dbe3b30e8fe1bf6a + size: 2114382 + timestamp: 1786970892473 +- conda: https://prefix.dev/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f + md5: 915f5995e94f60e9a4826e0b0920ee88 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - license: BSD-3-Clause - license_family: BSD + license: LGPL-2.1-only purls: [] - size: 124432 - timestamp: 1774333989027 -- conda: https://prefix.dev/conda-forge/linux-64/libcblas-3.11.0-6_h0358290_openblas.conda - build_number: 6 - sha256: 57edafa7796f6fa3ebbd5367692dd4c7f552be42109c2dd1a7c89b55089bf374 - md5: 36ae340a916635b97ac8a0655ace2a35 + size: 790176 + timestamp: 1754908768807 +- conda: https://prefix.dev/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda + sha256: 10056646c28115b174de81a44e23e3a0a3b95b5347d2e6c45cc6d49d35294256 + md5: 6178c6f2fb254558238ef4e6c56fb782 depends: - - libblas 3.11.0 6_h4a7cf45_openblas + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 constrains: - - blas 2.306 openblas - - liblapack 3.11.0 6*_openblas - - liblapacke 3.11.0 6*_openblas - license: BSD-3-Clause - license_family: BSD + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib purls: [] - size: 18622 - timestamp: 1774503050205 -- conda: https://prefix.dev/conda-forge/osx-arm64/libcblas-3.11.0-6_hb0561ab_openblas.conda + size: 633831 + timestamp: 1775962768273 +- conda: https://prefix.dev/conda-forge/linux-64/liblapack-3.11.0-6_h47877c9_openblas.conda build_number: 6 - sha256: 2e6b3e9b1ab672133b70fc6730e42290e952793f132cb5e72eee22835463eba0 - md5: 805c6d31c5621fd75e53dfcf21fb243a + sha256: 371f517eb7010b21c6cc882c7606daccebb943307cb9a3bf2c70456a5c024f7d + md5: 881d801569b201c2e753f03c84b85e15 depends: - - libblas 3.11.0 6_h51639a9_openblas + - libblas 3.11.0 6_h4a7cf45_openblas constrains: - - liblapacke 3.11.0 6*_openblas - blas 2.306 openblas - - liblapack 3.11.0 6*_openblas + - liblapacke 3.11.0 6*_openblas + - libcblas 3.11.0 6*_openblas license: BSD-3-Clause license_family: BSD purls: [] - size: 18863 - timestamp: 1774504433388 -- conda: https://prefix.dev/conda-forge/linux-64/libccd-double-2.1-h59595ed_3.conda - sha256: 4695ce68eda595b4f53146bea1096a9f2e0d33290618ba83a246b5ed8871ebc9 - md5: 6a3d962d34385e0a511b859d679f6ea2 - depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 - constrains: - - libccd <1 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 36171 - timestamp: 1687341825064 -- conda: https://prefix.dev/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 - sha256: eaba0b8153f4346229a0c52916a13fbedd689a3d3b31f4196bac65ece9050b8e - md5: 4d27a7d50c8d4bcafe33c9215e66251c - depends: - - libcxx >=13.0.1 - constrains: - - libccd <1 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 29852 - timestamp: 1654586481871 -- conda: https://prefix.dev/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h08c5240_6.conda - sha256: fc2981a8e45dd232ae88cf2580f7e75c258f4dccdc96f879b68ef0a9b45c9a2b - md5: 4fd9026a57bb45cd15bd08ff8bd0578e + size: 18624 + timestamp: 1774503065378 +- conda: https://prefix.dev/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda + sha256: e9b5f301d6b001a9b8ce782157f56b75c92c4fbc9eba95dc6345c1139251d13b + md5: 298bb2483fc7d15396147cf1c1465359 depends: - - libstdcxx >=14 - - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libzlib >=1.3.2,<2.0a0 - - zstd >=1.5.7,<1.6.0a0 + - libgcc >=14 + - libstdcxx >=14 - libxml2 - libxml2-16 >=2.14.6 - - libllvm22 >=22.1.8,<22.2.0a0 - license: Apache-2.0 WITH LLVM-exception - license_family: APACHE - purls: [] - size: 24171067 - timestamp: 1786527767794 -- conda: https://prefix.dev/conda-forge/linux-64/libclang13-22.1.8-default_hd70ba2e_6.conda - sha256: 8475136d3be6c2d16bdb801dcaf8769cb2ba372cad239c89ebd6a58912e14465 - md5: a8e147873eca89dc1c5d319b027a6cd3 - depends: - - libclang-cpp22.1 ==22.1.8 default_h08c5240_6 - - libstdcxx >=14 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - libzlib >=1.3.2,<2.0a0 - zstd >=1.5.7,<1.6.0a0 - - libxml2 - - libxml2-16 >=2.14.6 - - libllvm22 >=22.1.8,<22.2.0a0 license: Apache-2.0 WITH LLVM-exception - license_family: APACHE + license_family: Apache purls: [] - size: 14275196 - timestamp: 1786527767794 -- conda: https://prefix.dev/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda - sha256: 205c4f19550f3647832ec44e35e6d93c8c206782bdd620c1d7cf66237580ff9c - md5: 49c553b47ff679a6a1e9fc80b9c5a2d4 + size: 44320272 + timestamp: 1781788728739 +- conda: https://prefix.dev/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d + md5: b88d90cad08e6bc8ad540cb310a761fb depends: - __glibc >=2.17,<3.0.a0 - - krb5 >=1.22.2,<1.23.0a0 - libgcc >=14 - - libstdcxx >=14 - - libzlib >=1.3.1,<2.0a0 - license: Apache-2.0 - license_family: Apache + constrains: + - xz 5.8.3.* + license: 0BSD purls: [] - size: 4518030 - timestamp: 1770902209173 -- conda: https://prefix.dev/conda-forge/linux-64/libcurl-8.20.0-hcf29cc6_0.conda - sha256: 75963a5dd913311f59a35dbd307592f4fa754c4808aff9c33edb430c415e38eb - md5: c3cc2864f82a944bc90a7beb4d3b0e88 + size: 113478 + timestamp: 1775825492909 +- conda: https://prefix.dev/conda-forge/linux-64/liblzma-devel-5.8.3-hb03c661_0.conda + sha256: 7858f6a173206bc8a5bdc8e75690483bb66c0dcc3809ac1cb43c561a4723623a + md5: 55c20edec8e90c4703787acaade60808 depends: - __glibc >=2.17,<3.0.a0 - - krb5 >=1.22.2,<1.23.0a0 - libgcc >=14 - - libnghttp2 >=1.68.1,<2.0a0 - - libssh2 >=1.11.1,<2.0a0 - - libzlib >=1.3.2,<2.0a0 - - openssl >=3.5.6,<4.0a0 - - zstd >=1.5.7,<1.6.0a0 - license: curl - license_family: MIT - purls: [] - size: 468706 - timestamp: 1777461492876 -- conda: https://prefix.dev/conda-forge/osx-arm64/libcurl-8.20.0-hd5a2499_0.conda - sha256: 38c0bc634b61e542776e97cfd15d5d41edd304d4e47c333004d2d622439b2381 - md5: 2f57b7d0c6adda88957586b7afd78438 - depends: - - __osx >=11.0 - - krb5 >=1.22.2,<1.23.0a0 - - libnghttp2 >=1.68.1,<2.0a0 - - libssh2 >=1.11.1,<2.0a0 - - libzlib >=1.3.2,<2.0a0 - - openssl >=3.5.6,<4.0a0 - - zstd >=1.5.7,<1.6.0a0 - license: curl - license_family: MIT + - liblzma 5.8.3 hb03c661_0 + license: 0BSD purls: [] - size: 400568 - timestamp: 1777462251987 -- conda: https://prefix.dev/conda-forge/osx-arm64/libcxx-22.1.5-h55c6f16_1.conda - sha256: dddd01bd6b338221342a89530a1caffe6051a70cc8f8b1d8bb591d5447a3c603 - md5: ff484b683fecf1e875dfc7aa01d19796 + size: 491429 + timestamp: 1775825511214 +- conda: https://prefix.dev/conda-forge/linux-64/libmad-0.15.1b-h0b41bf4_1001.conda + sha256: 9e94cec54c4baadaa652c761179b8d32771fe7fa55faf6c78c2e35f942367f74 + md5: dc5cc4700f02ffeecc48253c9f29025b depends: - - __osx >=11.0 - license: Apache-2.0 WITH LLVM-exception - license_family: Apache + - libgcc-ng >=12 + license: GPL-2.0-only + license_family: GPL purls: [] - size: 569359 - timestamp: 1778191546305 -- conda: https://prefix.dev/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda - sha256: aa8e8c4be9a2e81610ddf574e05b64ee131fab5e0e3693210c9d6d2fba32c680 - md5: 6c77a605a7a689d17d4819c0f8ac9a00 + size: 78561 + timestamp: 1670815547616 +- conda: https://prefix.dev/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda + sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f + md5: 2a45e7f8af083626f009645a6481f12d depends: - __glibc >=2.17,<3.0.a0 + - c-ares >=1.34.6,<2.0a0 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.5,<4.0a0 license: MIT license_family: MIT purls: [] - size: 73490 - timestamp: 1761979956660 -- conda: https://prefix.dev/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda - sha256: 5e0b6961be3304a5f027a8c00bd0967fc46ae162cffb7553ff45c70f51b8314c - md5: a6130c709305cd9828b4e1bd9ba0000c + size: 663344 + timestamp: 1773854035739 +- conda: https://prefix.dev/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda + sha256: 927fe72b054277cde6cb82597d0fcf6baf127dcbce2e0a9d8925a68f1265eef5 + md5: d864d34357c3b65a4b731f78c0801dc4 depends: - - __osx >=11.0 - license: MIT - license_family: MIT + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: LGPL-2.1-only + license_family: GPL purls: [] - size: 55420 - timestamp: 1761980066242 -- conda: https://prefix.dev/conda-forge/linux-64/libdrm-2.4.125-hb03c661_1.conda - sha256: c076a213bd3676cc1ef22eeff91588826273513ccc6040d9bea68bccdc849501 - md5: 9314bc5a1fe7d1044dc9dfd3ef400535 + size: 33731 + timestamp: 1750274110928 +- conda: https://prefix.dev/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda + sha256: 3b3f19ced060013c2dd99d9d46403be6d319d4601814c772a3472fe2955612b0 + md5: 7c7927b404672409d9917d49bff5f2d6 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libpciaccess >=0.18,<0.19.0a0 - license: MIT - license_family: MIT + - libgcc >=13 + license: LGPL-2.1-or-later purls: [] - size: 310785 - timestamp: 1757212153962 -- conda: https://prefix.dev/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 - md5: c277e0a4d549b03ac1e9d6cbbe3d017b + size: 33418 + timestamp: 1734670021371 +- conda: https://prefix.dev/conda-forge/linux-64/libode-0.16.6-h18afd86_0.conda + sha256: 6ff25c1e497e384cc04e53ec45f0a024c8b2a85bd5afb3737cd1043869ef83a0 + md5: 49d678980383b08f99146ea8a7400806 depends: - - ncurses - __glibc >=2.17,<3.0.a0 + - libccd-double >=2.1,<2.2.0a0 + - libgcc >=14 + - libstdcxx >=14 + - pthread-stubs + - python_abi 3.10.* *_cp310 + license: LGPL-2.1-or-later OR BSD-4-Clause + purls: [] + size: 509471 + timestamp: 1760969190850 +- conda: https://prefix.dev/conda-forge/linux-64/libogg-1.3.5-hd0c01bc_1.conda + sha256: ffb066ddf2e76953f92e06677021c73c85536098f1c21fcd15360dbc859e22e4 + md5: 68e52064ed3897463c0e958ab5c8f91b + depends: - libgcc >=13 - - ncurses >=6.5,<7.0a0 - license: BSD-2-Clause + - __glibc >=2.17,<3.0.a0 + license: BSD-3-Clause license_family: BSD purls: [] - size: 134676 - timestamp: 1738479519902 -- conda: https://prefix.dev/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - sha256: 66aa216a403de0bb0c1340a88d1a06adaff66bae2cfd196731aa24db9859d631 - md5: 44083d2d2c2025afca315c7a172eab2b + size: 218500 + timestamp: 1745825989535 +- conda: https://prefix.dev/conda-forge/linux-64/libopenblas-0.3.32-pthreads_h94d23a6_0.conda + sha256: 6dc30b28f32737a1c52dada10c8f3a41bc9e021854215efca04a7f00487d09d9 + md5: 89d61bc91d3f39fda0ca10fcd3c68594 depends: - - ncurses - - __osx >=11.0 - - ncurses >=6.5,<7.0a0 - license: BSD-2-Clause + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libgfortran + - libgfortran5 >=14.3.0 + constrains: + - openblas >=0.3.32,<0.3.33.0a0 + license: BSD-3-Clause license_family: BSD purls: [] - size: 107691 - timestamp: 1738479560845 -- conda: https://prefix.dev/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda - sha256: 7fd5408d359d05a969133e47af580183fbf38e2235b562193d427bb9dad79723 - md5: c151d5eb730e9b7480e6d48c0fc44048 + size: 5928890 + timestamp: 1774471724897 +- conda: https://prefix.dev/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda + sha256: 215086c108d80349e96051ad14131b751d17af3ed2cb5a34edd62fa89bfe8ead + md5: 7df50d44d4a14d6c31a2c54f2cd92157 depends: - __glibc >=2.17,<3.0.a0 - libglvnd 1.7.0 ha4b6fd6_2 license: LicenseRef-libglvnd purls: [] - size: 44840 - timestamp: 1731330973553 -- conda: https://prefix.dev/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_2.conda - sha256: f6e7095260305dc05238062142fb8db4b940346329b5b54894a90610afa6749f - md5: b513eb83b3137eca1192c34bf4f013a7 + size: 50757 + timestamp: 1731330993524 +- conda: https://prefix.dev/conda-forge/linux-64/libopus-1.6.1-h280c20c_0.conda + sha256: f1061a26213b9653bbb8372bfa3f291787ca091a9a3060a10df4d5297aad74fd + md5: 2446ac1fe030c2aa6141386c1f5a6aed depends: - __glibc >=2.17,<3.0.a0 - - libegl 1.7.0 ha4b6fd6_2 - - libgl-devel 1.7.0 ha4b6fd6_2 - - xorg-libx11 - license: LicenseRef-libglvnd + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 30380 - timestamp: 1731331017249 -- conda: https://prefix.dev/conda-forge/linux-64/libev-4.33-hd590300_2.conda - sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 - md5: 172bf1cd1ff8629f2b1179945ed45055 - depends: - - libgcc-ng >=12 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 112766 - timestamp: 1702146165126 -- conda: https://prefix.dev/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f - md5: 36d33e440c31857372a72137f78bacf5 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 107458 - timestamp: 1702146414478 -- conda: https://prefix.dev/conda-forge/linux-64/libexpat-2.8.0-hecca717_0.conda - sha256: ea33c40977ea7a2c3658c522230058395bc2ee0d89d99f0711390b6a1ee80d12 - md5: a3b390520c563d78cc58974de95a03e5 + size: 324993 + timestamp: 1768497114401 +- conda: https://prefix.dev/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda + sha256: 0bd91de9b447a2991e666f284ae8c722ffb1d84acb594dbd0c031bd656fa32b2 + md5: 70e3400cbbfa03e96dcde7fc13e38c7b depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - constrains: - - expat 2.8.0.* - license: MIT - license_family: MIT - purls: [] - size: 77241 - timestamp: 1777846112704 -- conda: https://prefix.dev/conda-forge/osx-arm64/libexpat-2.8.0-hf6b4638_0.conda - sha256: f4b1cafc59afaede8fa0a2d9cf376840f1c553001acd72f6ead18bbc8ac8c49c - md5: 65466e82c09e888ca7560c11a97d5450 - depends: - - __osx >=11.0 - constrains: - - expat 2.8.0.* + - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 68789 - timestamp: 1777846180142 -- conda: https://prefix.dev/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 - md5: a360c33a5abe61c07959e449fa1453eb + size: 28424 + timestamp: 1749901812541 +- conda: https://prefix.dev/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda + sha256: 377cfe037f3eeb3b1bf3ad333f724a64d32f315ee1958581fc671891d63d3f89 + md5: eba48a68a1a2b9d3c0d9511548db85db depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - license: MIT - license_family: MIT - purls: [] - size: 58592 - timestamp: 1769456073053 -- conda: https://prefix.dev/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda - sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7 - md5: 43c04d9cb46ef176bb2a4c77e324d599 - depends: - - __osx >=11.0 - license: MIT - license_family: MIT + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement purls: [] - size: 40979 - timestamp: 1769456747661 -- conda: https://prefix.dev/conda-forge/linux-64/libflac-1.5.0-he200343_1.conda - sha256: e755e234236bdda3d265ae82e5b0581d259a9279e3e5b31d745dc43251ad64fb - md5: 47595b9d53054907a00d95e4d47af1d6 + size: 317729 + timestamp: 1776315175087 +- conda: https://prefix.dev/conda-forge/linux-64/libpq-18.6-h9d76c99_0.conda + sha256: b1eb210c180fda9c445b11cba1286ec250ce2c2a85ccb0551a4ed5423df51e68 + md5: 72e019c04ed02a179da38c56965802d1 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libiconv >=1.18,<2.0a0 - - libogg >=1.3.5,<1.4.0a0 - - libstdcxx >=14 - license: BSD-3-Clause - license_family: BSD + - icu >=78.3,<79.0a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=15 + - openldap >=2.6.13,<2.7.0a0 + - openssl >=3.5.7,<4.0a0 + license: PostgreSQL purls: [] - size: 424563 - timestamp: 1764526740626 -- conda: https://prefix.dev/conda-forge/osx-arm64/libflac-1.5.0-h6824b09_1.conda - sha256: 565e5c38e80eb5752bfa52f6b771fa2fd75c0551a1f61ea84a12a2fb4454900c - md5: b14b19359aed60c200b1ca58b53f5ca3 + size: 2719680 + timestamp: 1786641133110 +- conda: https://prefix.dev/conda-forge/linux-64/libprotobuf-3.20.2-h6239696_0.tar.bz2 + sha256: 158899bc39d00dc79e9b3fe8e39ed413a7ae266ddf69a7ff149be16859c24149 + md5: dd9c398d02aa82219a4ea5fa69739ae7 depends: - - __osx >=11.0 - - libcxx >=19 - - libiconv >=1.18,<2.0a0 - - libogg >=1.3.5,<1.4.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.2.13,<2.0.0a0 license: BSD-3-Clause license_family: BSD purls: [] - size: 321872 - timestamp: 1764527007890 -- conda: https://prefix.dev/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda - sha256: 38f014a7129e644636e46064ecd6b1945e729c2140e21d75bb476af39e692db2 - md5: e289f3d17880e44b633ba911d57a321b + size: 2715070 + timestamp: 1668469845918 +- conda: https://prefix.dev/conda-forge/linux-64/libraqm-0.11.0-h6406941_0.conda + sha256: ab3ccb9fd5816f76b18ee8974d359cd2605ca87d8ddef55369dc461b9986f95c + md5: 3ac89a48d224409739dbf6200e524373 depends: + - libgcc >=14 + - __glibc >=2.28,<3.0.a0 + - fribidi >=1.0.16,<2.0a0 + - libfreetype >=2.14.3 - libfreetype6 >=2.14.3 - license: GPL-2.0-only OR FTL + - libharfbuzz >=14.2.1 + license: MIT + license_family: MIT purls: [] - size: 8049 - timestamp: 1774298163029 -- conda: https://prefix.dev/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_0.conda - sha256: a047a2f238362a37d484f9620e8cba29f513a933cd9eb68571ad4b270d6f8f3e - md5: f73b109d49568d5d1dda43bb147ae37f + size: 33983 + timestamp: 1784850267262 +- conda: https://prefix.dev/conda-forge/linux-64/librsvg-2.60.2-h61e6d4b_0.conda + sha256: 38b3189cf246f7265e06917f32d046ac375117c88834d045efe73ec48ceacc59 + md5: d62da3d560992bfa2feb611d7be813b8 depends: - - libfreetype6 >=2.14.3 - license: GPL-2.0-only OR FTL + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - gdk-pixbuf >=2.44.5,<3.0a0 + - libgcc >=14 + - libglib >=2.86.4,<3.0a0 + - libxml2-16 >=2.14.6 + - pango >=1.56.4,<2.0a0 + constrains: + - __glibc >=2.17 + license: LGPL-2.1-or-later purls: [] - size: 8091 - timestamp: 1774298691258 -- conda: https://prefix.dev/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda - sha256: 16f020f96da79db1863fcdd8f2b8f4f7d52f177dd4c58601e38e9182e91adf1d - md5: fb16b4b69e3f1dcfe79d80db8fd0c55d + size: 4011590 + timestamp: 1771399906142 +- conda: https://prefix.dev/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda + sha256: 57cb5f92110324c04498b96563211a1bca6a74b2918b1e8df578bfed03cc32e4 + md5: 067590f061c9f6ea7e61e3b2112ed6b3 depends: - __glibc >=2.17,<3.0.a0 + - lame >=3.100,<3.101.0a0 + - libflac >=1.5.0,<1.6.0a0 - libgcc >=14 - - libpng >=1.6.55,<1.7.0a0 - - libzlib >=1.3.2,<2.0a0 - constrains: - - freetype >=2.14.3 - license: GPL-2.0-only OR FTL + - libogg >=1.3.5,<1.4.0a0 + - libopus >=1.5.2,<2.0a0 + - libstdcxx >=14 + - libvorbis >=1.3.7,<1.4.0a0 + - mpg123 >=1.32.9,<1.33.0a0 + license: LGPL-2.1-or-later + license_family: LGPL purls: [] - size: 384575 - timestamp: 1774298162622 -- conda: https://prefix.dev/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_0.conda - sha256: ff764608e1f2839e95e2cf9b243681475f8778c36af7a42b3f78f476fdbb1dd3 - md5: e98ba7b5f09a5f450eca083d5a1c4649 + size: 355619 + timestamp: 1765181778282 +- conda: https://prefix.dev/conda-forge/linux-64/libsqlite-3.53.1-h0c1763c_0.conda + sha256: 54cdcd3214313b62c2a8ee277e6f42150d9b748264c1b70d958bf735e420ef8d + md5: 7dc38adcbf71e6b38748e919e16e0dce depends: - - __osx >=11.0 - - libpng >=1.6.55,<1.7.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 - libzlib >=1.3.2,<2.0a0 - constrains: - - freetype >=2.14.3 - license: GPL-2.0-only OR FTL + license: blessing purls: [] - size: 338085 - timestamp: 1774298689297 -- conda: https://prefix.dev/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - sha256: 8e0a3b5e41272e5678499b5dfc4cddb673f9e935de01eb0767ce857001229f46 - md5: 57736f29cc2b0ec0b6c2952d3f101b6a + size: 954962 + timestamp: 1777986471789 +- conda: https://prefix.dev/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda + sha256: fa39bfd69228a13e553bd24601332b7cfeb30ca11a3ca50bb028108fe90a7661 + md5: eecce068c7e4eddeb169591baac20ac4 depends: - __glibc >=2.17,<3.0.a0 - - _openmp_mutex >=4.5 - constrains: - - libgcc-ng ==15.2.0=*_19 - - libgomp 15.2.0 he0feb66_19 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.0,<4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 1041084 - timestamp: 1778269013026 -- conda: https://prefix.dev/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda - sha256: 06644fa4d34d57c9e48f4d84b1256f9e5f654fdb37f43acc8a58a396952d42b7 - md5: 644058123986582db33aebd4ae2ca184 + size: 304790 + timestamp: 1745608545575 +- conda: https://prefix.dev/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + sha256: dff1058c76ec6b8759e41cefa2508162d00e4a5e6721aa68ec3fd10094e702dc + md5: 5794b3bdc38177caf969dabd3af08549 depends: - - _openmp_mutex + - __glibc >=2.17,<3.0.a0 + - libgcc 15.2.0 he0feb66_19 constrains: - - libgcc-ng ==15.2.0=*_19 - - libgomp 15.2.0 19 + - libstdcxx-ng ==15.2.0=*_19 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 404080 - timestamp: 1778273064154 -- conda: https://prefix.dev/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda - sha256: 9dcf54adfaa5e861123c2da4f2f0451a685464ea7e5a41ad91cf67b31d658d98 - md5: 331ee9b72b9dff570d56b1302c5ab37d + size: 5852044 + timestamp: 1778269036376 +- conda: https://prefix.dev/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda + sha256: 0672b6b6e1791c92e8eccad58081a99d614fcf82bca5841f9dfa3c3e658f83b9 + md5: e5ce228e579726c07255dbf90dc62101 depends: - - libgcc 15.2.0 he0feb66_19 + - libstdcxx 15.2.0 h934c35e_19 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL purls: [] - size: 27694 - timestamp: 1778269016987 -- conda: https://prefix.dev/conda-forge/linux-64/libgd-2.3.3-h5fbf134_12.conda - sha256: 245be793e831170504f36213134f4c24eedaf39e634679809fd5391ad214480b - md5: 88c1c66987cd52a712eea89c27104be6 + size: 27776 + timestamp: 1778269074600 +- conda: https://prefix.dev/conda-forge/linux-64/libsystemd0-257.13-hd0affe5_0.conda + sha256: c5008b602cb5c819f7b52d418b3ed17e1818cbbf6705b189e7ab36bb70cce3d8 + md5: 8ee3cb7f64be0e8c4787f3a4dbe024e6 depends: - __glibc >=2.17,<3.0.a0 - - fontconfig >=2.15.0,<3.0a0 - - fonts-conda-ecosystem - - icu >=78.1,<79.0a0 - - libexpat >=2.7.3,<3.0a0 - - libfreetype >=2.14.1 - - libfreetype6 >=2.14.1 + - libcap >=2.77,<2.78.0a0 - libgcc >=14 - - libjpeg-turbo >=3.1.2,<4.0a0 - - libpng >=1.6.53,<1.7.0a0 - - libtiff >=4.7.1,<4.8.0a0 - - libwebp-base >=1.6.0,<2.0a0 - - libzlib >=1.3.1,<2.0a0 - license: GD - license_family: BSD + license: LGPL-2.1-or-later purls: [] - size: 177306 - timestamp: 1766331805898 -- conda: https://prefix.dev/conda-forge/osx-arm64/libgd-2.3.3-h05bcc79_12.conda - sha256: 269edce527e204a80d3d05673301e0207efcd0dbeebc036a118ceb52690d6341 - md5: fa4a92cfaae9570d89700a292a9ca714 + size: 492799 + timestamp: 1773797095649 +- conda: https://prefix.dev/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda + sha256: e5f8c38625aa6d567809733ae04bb71c161a42e44a9fa8227abe61fa5c60ebe0 + md5: cd5a90476766d53e901500df9215e927 depends: - - __osx >=11.0 - - fontconfig >=2.15.0,<3.0a0 - - fonts-conda-ecosystem - - icu >=78.1,<79.0a0 - - libexpat >=2.7.3,<3.0a0 - - libfreetype >=2.14.1 - - libfreetype6 >=2.14.1 - - libiconv >=1.18,<2.0a0 - - libjpeg-turbo >=3.1.2,<4.0a0 - - libpng >=1.6.53,<1.7.0a0 - - libtiff >=4.7.1,<4.8.0a0 + - __glibc >=2.17,<3.0.a0 + - lerc >=4.0.0,<5.0a0 + - libdeflate >=1.25,<1.26.0a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.0,<4.0a0 + - liblzma >=5.8.1,<6.0a0 + - libstdcxx >=14 - libwebp-base >=1.6.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - license: GD - license_family: BSD + - zstd >=1.5.7,<1.6.0a0 + license: HPND purls: [] - size: 159247 - timestamp: 1766331953491 -- conda: https://prefix.dev/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda - sha256: 561a42758ef25b9ce308c4e2cf56daee4f06138385a17e29a492cd928e00be6f - md5: 42bf7eca1a951735fa06c0e3c0d5c8e6 + size: 435273 + timestamp: 1762022005702 +- conda: https://prefix.dev/conda-forge/linux-64/libudev1-257.13-hd0affe5_0.conda + sha256: 1a1e367c04d66030aa93b4d33905f7f6fbb59cfc292e816fe3e9c1e8b3f4d1e2 + md5: 2c2270f93d6f9073cbf72d821dfc7d72 depends: - - libgfortran5 15.2.0 h68bc16d_19 - constrains: - - libgfortran-ng ==15.2.0=*_19 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - __glibc >=2.17,<3.0.a0 + - libcap >=2.77,<2.78.0a0 + - libgcc >=14 + license: LGPL-2.1-or-later purls: [] - size: 27655 - timestamp: 1778269042954 -- conda: https://prefix.dev/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda - sha256: d4837b3b9b30af3132d260225e91ab9dde83be04c59513f500cc81050fb37486 - md5: 1ea03f87cdb1078fbc0e2b2deb63752c + size: 145087 + timestamp: 1773797108513 +- conda: https://prefix.dev/conda-forge/linux-64/libunwind-1.8.3-h65a8314_0.conda + sha256: 71c8b9d5c72473752a0bb6e91b01dd209a03916cb71f36cc6a564e3a2a132d7a + md5: e179a69edd30d75c0144d7a380b88f28 depends: - - libgfortran5 15.2.0 hdae7583_19 - constrains: - - libgfortran-ng ==15.2.0=*_19 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT purls: [] - size: 139675 - timestamp: 1778273280875 -- conda: https://prefix.dev/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda - sha256: 057978bb69fea29ed715a9b98adf71015c31baecc4aeb2bfc20d4fd5d83579d4 - md5: 85072b0ad177c966294f129b7c04a2d5 + size: 75995 + timestamp: 1757032240102 +- conda: https://prefix.dev/conda-forge/linux-64/liburing-2.14-hb700be7_0.conda + sha256: 3d17b7aa90610afc65356e9e6149aeac0b2df19deda73a51f0a09cf04fd89286 + md5: 56f65185b520e016d29d01657ac02c0d depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=15.2.0 - constrains: - - libgfortran 15.2.0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT purls: [] - size: 2483673 - timestamp: 1778269025089 -- conda: https://prefix.dev/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda - sha256: d0a68b7a121d115b80c169e24d1265dcc25a3fe58d107df1bbc430797e226d88 - md5: ba36d8c606a6a53fe0b8c12d47267b3d + size: 154203 + timestamp: 1770566529700 +- conda: https://prefix.dev/conda-forge/linux-64/libusb-1.0.29-h73b1eb8_0.conda + sha256: 89c84f5b26028a9d0f5c4014330703e7dff73ba0c98f90103e9cef6b43a5323c + md5: d17e3fb595a9f24fa9e149239a33475d depends: - - libgcc >=15.2.0 - constrains: - - libgfortran 15.2.0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libudev1 >=257.4 + license: LGPL-2.1-or-later purls: [] - size: 599691 - timestamp: 1778273075448 -- conda: https://prefix.dev/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda - sha256: dc2752241fa3d9e40ce552c1942d0a4b5eeb93740c9723873f6fcf8d39ef8d2d - md5: 928b8be80851f5d8ffb016f9c81dae7a + size: 89551 + timestamp: 1748856210075 +- conda: https://prefix.dev/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda + sha256: bc1b08c92626c91500fd9f26f2c797f3eb153b627d53e9c13cd167f1e12b2829 + md5: 38ffe67b78c9d4de527be8315e5ada2c depends: - __glibc >=2.17,<3.0.a0 - - libglvnd 1.7.0 ha4b6fd6_2 - - libglx 1.7.0 ha4b6fd6_2 - license: LicenseRef-libglvnd + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 134712 - timestamp: 1731330998354 -- conda: https://prefix.dev/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_2.conda - sha256: e281356c0975751f478c53e14f3efea6cd1e23c3069406d10708d6c409525260 - md5: 53e7cbb2beb03d69a478631e23e340e9 + size: 40297 + timestamp: 1775052476770 +- conda: https://prefix.dev/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda + sha256: c180f4124a889ac343fc59d15558e93667d894a966ec6fdb61da1604481be26b + md5: 0f03292cc56bf91a077a134ea8747118 depends: - __glibc >=2.17,<3.0.a0 - - libgl 1.7.0 ha4b6fd6_2 - - libglx-devel 1.7.0 ha4b6fd6_2 - license: LicenseRef-libglvnd + - libgcc >=14 + license: MIT + license_family: MIT purls: [] - size: 113911 - timestamp: 1731331012126 -- conda: https://prefix.dev/conda-forge/linux-64/libglib-2.88.3-h0d30a3d_0.conda - sha256: 69ea4df61403531e5b3e5f3d52ba2837423df361b4eb8727f5b63aaf6de6768a - md5: 17c3b7b6bcbd35b688c933eb4834c0bc + size: 895108 + timestamp: 1753948278280 +- conda: https://prefix.dev/conda-forge/linux-64/libvorbis-1.3.7-h54a6638_2.conda + sha256: ca494c99c7e5ecc1b4cd2f72b5584cef3d4ce631d23511184411abcbb90a21a5 + md5: b4ecbefe517ed0157c37f8182768271c depends: + - libogg - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libiconv >=1.18,<2.0a0 - - libzlib >=1.3.2,<2.0a0 - - pcre2 >=10.47,<10.48.0a0 - - libffi >=3.5.2,<3.6.0a0 - constrains: - - glib >2.66 - license: LGPL-2.1-or-later + - libstdcxx >=14 + - libgcc >=14 + - libogg >=1.3.5,<1.4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 4755324 - timestamp: 1785442107463 -- conda: https://prefix.dev/conda-forge/osx-arm64/libglib-2.88.3-ha08bb59_0.conda - sha256: a14417ae1f3f4a92c5766354eb280342fa6aae72a09af86bf7fcfc12a8c9225c - md5: 4a9309d9502a08a2d29b1743dcfb0e7f + size: 285894 + timestamp: 1753879378005 +- conda: https://prefix.dev/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda + sha256: a68280d57dfd29e3d53400409a39d67c4b9515097eba733aa6fe00c880620e2b + md5: 31ad065eda3c2d88f8215b1289df9c89 depends: - - __osx >=11.0 - - pcre2 >=10.47,<10.48.0a0 - - libzlib >=1.3.2,<2.0a0 - - libffi >=3.5.2,<3.6.0a0 - - libintl >=0.25.1,<1.0a0 - - libiconv >=1.18,<2.0a0 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 constrains: - - glib >2.66 - license: LGPL-2.1-or-later + - libvulkan-headers 1.4.341.0.* + license: Apache-2.0 + license_family: APACHE purls: [] - size: 4448109 - timestamp: 1785442168180 -- conda: https://prefix.dev/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda - sha256: 1175f8a7a0c68b7f81962699751bb6574e6f07db4c9f72825f978e3016f46850 - md5: 434ca7e50e40f4918ab701e3facd59a0 + size: 199795 + timestamp: 1770077125520 +- conda: https://prefix.dev/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda + sha256: 3aed21ab28eddffdaf7f804f49be7a7d701e8f0e46c856d801270b470820a37b + md5: aea31d2e5b1091feca96fcfe945c3cf9 depends: - __glibc >=2.17,<3.0.a0 - license: LicenseRef-libglvnd + - libgcc >=14 + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 132463 - timestamp: 1731330968309 -- conda: https://prefix.dev/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda - sha256: 2d35a679624a93ce5b3e9dd301fff92343db609b79f0363e6d0ceb3a6478bfa7 - md5: c8013e438185f33b13814c5c488acd5c + size: 429011 + timestamp: 1752159441324 +- conda: https://prefix.dev/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa + md5: 92ed62436b625154323d40d5f2f11dd7 depends: - __glibc >=2.17,<3.0.a0 - - libglvnd 1.7.0 ha4b6fd6_2 - - xorg-libx11 >=1.8.10,<2.0a0 - license: LicenseRef-libglvnd + - libgcc >=13 + - pthread-stubs + - xorg-libxau >=1.0.11,<2.0a0 + - xorg-libxdmcp + license: MIT + license_family: MIT purls: [] - size: 75504 - timestamp: 1731330988898 -- conda: https://prefix.dev/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_2.conda - sha256: 0a930e0148ab6e61089bbcdba25a2e17ee383e7de82e7af10cc5c12c82c580f3 - md5: 27ac5ae872a21375d980bd4a6f99edf3 + size: 395888 + timestamp: 1727278577118 +- conda: https://prefix.dev/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c + md5: 5aa797f8787fe7a17d1b0821485b5adc depends: - - __glibc >=2.17,<3.0.a0 - - libglx 1.7.0 ha4b6fd6_2 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-xorgproto - license: LicenseRef-libglvnd + - libgcc-ng >=12 + license: LGPL-2.1-or-later purls: [] - size: 26388 - timestamp: 1731331003255 -- conda: https://prefix.dev/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda - sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b - md5: faac990cb7aedc7f3a2224f2c9b0c26c + size: 100393 + timestamp: 1702724383534 +- conda: https://prefix.dev/conda-forge/linux-64/libxkbcommon-1.13.1-hca5e8e5_0.conda + sha256: d2195b5fbcb0af1ff7b345efdf89290c279b8d1d74f325ae0ac98148c375863c + md5: 2bca1fbb221d9c3c8e3a155784bbc2e9 depends: - __glibc >=2.17,<3.0.a0 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL - purls: [] - size: 603817 - timestamp: 1778268942614 -- conda: https://prefix.dev/conda-forge/linux-64/libharfbuzz-14.3.1-h23af247_0.conda - sha256: a4eac5a21b84e0fc753b72de01781f634fc9ab70fd32a28d6a40a19700c9188a - md5: 29709e61096dd490fff9e833e4c869f6 - depends: - - __glibc >=2.17,<3.0.a0 - - cairo >=1.18.4,<2.0a0 - - graphite2 >=1.3.15,<2.0a0 - - icu >=78.3,<79.0a0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libgcc >=15 - - libglib >=2.88.3,<3.0a0 - - libpng >=1.6.58,<1.7.0a0 - - libstdcxx >=15 - - libzlib >=1.3.2,<2.0a0 - license: MIT + - libgcc >=14 + - libstdcxx >=14 + - libxcb >=1.17.0,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - xkeyboard-config + - xorg-libxau >=1.0.12,<2.0a0 + license: MIT/X11 Derivative license_family: MIT purls: [] - size: 1353639 - timestamp: 1786970872936 -- conda: https://prefix.dev/conda-forge/osx-arm64/libharfbuzz-14.3.1-hcda0f7c_0.conda - sha256: 67af14f8fbf9b9725890f728179d933ac35a95a6b50f37b7b568a11bfa8a4c1d - md5: 1631ca9ffe7d368850904baa1df1abf4 + size: 837922 + timestamp: 1764794163823 +- conda: https://prefix.dev/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda + sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a + md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 depends: - - __osx >=11.0 - - cairo >=1.18.4,<2.0a0 - - graphite2 >=1.3.15,<2.0a0 + - __glibc >=2.17,<3.0.a0 - icu >=78.3,<79.0a0 - - libcxx >=21 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libglib >=2.88.3,<3.0a0 - - libpng >=1.6.58,<1.7.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.3 license: MIT license_family: MIT purls: [] - size: 953252 - timestamp: 1786970947180 -- conda: https://prefix.dev/conda-forge/linux-64/libharfbuzz-devel-14.3.1-h23af247_0.conda - sha256: 9d9d620141102dcb580d8f42d1a6c9e7e691a8dfa0284783e712679723067d15 - md5: e0f17ce01589ffa7d773be573e97b36c + size: 559775 + timestamp: 1776376739004 +- conda: https://prefix.dev/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda + sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba + md5: 995d8c8bad2a3cc8db14675a153dec2b depends: - __glibc >=2.17,<3.0.a0 - - cairo >=1.18.4,<2.0a0 - - freetype - - graphite2 >=1.3.15,<2.0a0 - icu >=78.3,<79.0a0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libgcc >=15 - - libglib >=2.88.3,<3.0a0 - - libharfbuzz 14.3.1 h23af247_0 - - libpng >=1.6.58,<1.7.0a0 - - libstdcxx >=15 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.3 hca6bf5a_0 - libzlib >=1.3.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 2114382 - timestamp: 1786970892473 -- conda: https://prefix.dev/conda-forge/osx-arm64/libharfbuzz-devel-14.3.1-hcda0f7c_0.conda - sha256: 076db9dac1b7ab31383ffd35da5f5b9ab9e56987b7751a5ec767c330f0e3c359 - md5: 911b746bffebd782ea8d53e663b0269c + size: 46810 + timestamp: 1776376751152 +- conda: https://prefix.dev/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda + sha256: 0694760a3e62bdc659d90a14ae9c6e132b525a7900e59785b18a08bb52a5d7e5 + md5: 87e6096ec6d542d1c1f8b33245fe8300 depends: - - __osx >=11.0 - - cairo >=1.18.4,<2.0a0 - - freetype - - graphite2 >=1.3.15,<2.0a0 - - icu >=78.3,<79.0a0 - - libcxx >=21 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libglib >=2.88.3,<3.0a0 - - libharfbuzz 14.3.1 hcda0f7c_0 - - libpng >=1.6.58,<1.7.0a0 - - libzlib >=1.3.2,<2.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libxml2 + - libxml2-16 >=2.14.6 license: MIT license_family: MIT purls: [] - size: 1500884 - timestamp: 1786970969119 -- conda: https://prefix.dev/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f - md5: 915f5995e94f60e9a4826e0b0920ee88 + size: 245434 + timestamp: 1757963724977 +- conda: https://prefix.dev/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 + md5: d87ff7921124eccd67248aa483c23fec depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - license: LGPL-2.1-only + constrains: + - zlib 1.3.2 *_2 + license: Zlib + license_family: Other purls: [] - size: 790176 - timestamp: 1754908768807 -- conda: https://prefix.dev/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda - sha256: de0336e800b2af9a40bdd694b03870ac4a848161b35c8a2325704f123f185f03 - md5: 4d5a7445f0b25b6a3ddbb56e790f5251 + size: 63629 + timestamp: 1774072609062 +- conda: https://prefix.dev/conda-forge/linux-64/llvmlite-0.49.0-py311h1369f55_2.conda + sha256: bd4ddf72a6ee81991759d407d0cf8fadf9804500562839448a22c11f8e829f8e + md5: 7d4c6843f49e890b8f6fb813d7e94c1f depends: - - __osx >=11.0 - license: LGPL-2.1-only - purls: [] - size: 750379 - timestamp: 1754909073836 -- conda: https://prefix.dev/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda - sha256: 99d2cebcd8f84961b86784451b010f5f0a795ed1c08f1e7c76fbb3c22abf021a - md5: 5103f6a6b210a3912faf8d7db516918c + - python + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - libgcc >=15 + - zstd >=1.5.7,<1.6.0a0 + - python_abi 3.11.* *_cp311 + - libzlib >=1.3.2,<2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 40845513 + timestamp: 1788013791127 +- conda: https://prefix.dev/conda-forge/linux-64/matplotlib-3.11.1-py311h968eb38_2.conda + sha256: b677501911fa682ea74a86472a003a2f8cbb046f8fb6bbc501521af6aea0744f + md5: 2cb7827f42621fe32c5161ad927ecaa7 depends: - - __osx >=11.0 - - libiconv >=1.18,<2.0a0 - license: LGPL-2.1-or-later + - matplotlib-base >=3.11.1,<3.11.2.0a0 + - pyside6 >=6.7.2 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - tornado >=5 + license: PSF-2.0 + license_family: PSF purls: [] - size: 90957 - timestamp: 1751558394144 -- conda: https://prefix.dev/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda - sha256: 10056646c28115b174de81a44e23e3a0a3b95b5347d2e6c45cc6d49d35294256 - md5: 6178c6f2fb254558238ef4e6c56fb782 + size: 14988 + timestamp: 1785211075423 +- conda: https://prefix.dev/conda-forge/linux-64/matplotlib-base-3.11.1-py311he401cf6_2.conda + sha256: f9f48162f2553080d041b061b9f6cfec64d79d7c40df0e6379496f9ad2df738c + md5: f602c096988d0f744f4f017aa0269e30 depends: - __glibc >=2.17,<3.0.a0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.28.2 + - freetype + - kiwisolver >=1.3.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 - libgcc >=14 - constrains: - - jpeg <0.0.0a - license: IJG AND BSD-3-Clause AND Zlib + - libraqm >=0.11.0,<0.12.0a0 + - libstdcxx >=14 + - numpy >=1.23,<3 + - numpy >=1.25 + - packaging >=20.0 + - pillow >=9 + - pyparsing >=3 + - python >=3.11,<3.12.0a0 + - python-dateutil >=2.7 + - python_abi 3.11.* *_cp311 + - qhull >=2020.2,<2020.3.0a0 + - tk >=8.6.13,<8.7.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=hash-mapping + size: 8925010 + timestamp: 1785211062689 +- conda: https://prefix.dev/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda + sha256: 39c4700fb3fbe403a77d8cc27352fa72ba744db487559d5d44bf8411bb4ea200 + md5: c7f302fd11eeb0987a6a5e1f3aed6a21 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: LGPL-2.1-only + license_family: LGPL purls: [] - size: 633831 - timestamp: 1775962768273 -- conda: https://prefix.dev/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda - sha256: 17e035ae6a520ff6a6bb5dd93a4a7c3895891f4f9743bcb8c6ef607445a31cd0 - md5: b8a7544c83a67258b0e8592ec6a5d322 + size: 491140 + timestamp: 1730581373280 +- conda: https://prefix.dev/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3 + md5: fc21868a1a5aacc937e7a18747acb8a5 depends: - - __osx >=11.0 - constrains: - - jpeg <0.0.0a - license: IJG AND BSD-3-Clause AND Zlib + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: X11 AND BSD-3-Clause purls: [] - size: 555681 - timestamp: 1775962975624 -- conda: https://prefix.dev/conda-forge/linux-64/liblapack-3.11.0-6_h47877c9_openblas.conda - build_number: 6 - sha256: 371f517eb7010b21c6cc882c7606daccebb943307cb9a3bf2c70456a5c024f7d - md5: 881d801569b201c2e753f03c84b85e15 + size: 918956 + timestamp: 1777422145199 +- conda: https://prefix.dev/conda-forge/linux-64/numba-0.67.0-py311hdfc3925_1.conda + sha256: 3129c290e7d02cd7fd8a44da0f1985539e7c659b18624b7298baaa267718d942 + md5: e32e21325dea34226840b71a57982ef3 depends: - - libblas 3.11.0 6_h4a7cf45_openblas + - python + - llvmlite >=0.49.0,<0.50.0a0 + - numpy >=1.22.3,<2.6 + - _openmp_mutex >=4.5 + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + - numpy >=1.23,<3 + - python_abi 3.11.* *_cp311 constrains: - - blas 2.306 openblas - - liblapacke 3.11.0 6*_openblas - - libcblas 3.11.0 6*_openblas - license: BSD-3-Clause + - tbb >=2021.6.0 + - libopenblas !=0.3.6 + - cuda-version >=11.2 + - cudatoolkit >=11.2 + - scipy >=1.0 + - cuda-python >=11.6 + license: BSD-2-Clause license_family: BSD - purls: [] - size: 18624 - timestamp: 1774503065378 -- conda: https://prefix.dev/conda-forge/osx-arm64/liblapack-3.11.0-6_hd9741b5_openblas.conda - build_number: 6 - sha256: 21606b7346810559e259807497b86f438950cf19e71838e44ebaf4bd2b35b549 - md5: ee33d2d05a7c5ea1f67653b37eb74db1 + purls: + - pkg:pypi/numba?source=hash-mapping + size: 6286682 + timestamp: 1787145506914 +- conda: https://prefix.dev/conda-forge/linux-64/numpy-2.0.2-py311h71ddf71_1.conda + sha256: a922ec6947ad6953cb011b8f1a44779f6b55d62a14c5bcd25d19a8fb1629da30 + md5: 04ce874aa54fc1d9c735a04e0c6d99c4 depends: - - libblas 3.11.0 6_h51639a9_openblas + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=13 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=13 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 constrains: - - liblapacke 3.11.0 6*_openblas - - libcblas 3.11.0 6*_openblas - - blas 2.306 openblas + - numpy-base <0a0 license: BSD-3-Clause license_family: BSD - purls: [] - size: 18863 - timestamp: 1774504467905 -- conda: https://prefix.dev/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda - sha256: e9b5f301d6b001a9b8ce782157f56b75c92c4fbc9eba95dc6345c1139251d13b - md5: 298bb2483fc7d15396147cf1c1465359 + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 9148240 + timestamp: 1732314901472 +- conda: https://prefix.dev/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda + sha256: 3900f9f2dbbf4129cf3ad6acf4e4b6f7101390b53843591c53b00f034343bc4d + md5: 11b3379b191f63139e29c0d19dee24cd depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 + - libpng >=1.6.50,<1.7.0a0 - libstdcxx >=14 - - libxml2 - - libxml2-16 >=2.14.6 - - libzlib >=1.3.2,<2.0a0 - - zstd >=1.5.7,<1.6.0a0 - license: Apache-2.0 WITH LLVM-exception - license_family: Apache + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 44320272 - timestamp: 1781788728739 -- conda: https://prefix.dev/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda - sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d - md5: b88d90cad08e6bc8ad540cb310a761fb + size: 355400 + timestamp: 1758489294972 +- conda: https://prefix.dev/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda + sha256: 21c4f6c7f41dc9bec2ea2f9c80440d9a4d45a6f2ac13243e658f10dcf1044146 + md5: 680608784722880fbfe1745067570b00 depends: - __glibc >=2.17,<3.0.a0 + - cyrus-sasl >=2.1.28,<3.0a0 + - krb5 >=1.22.2,<1.23.0a0 - libgcc >=14 - constrains: - - xz 5.8.3.* - license: 0BSD - purls: [] - size: 113478 - timestamp: 1775825492909 -- conda: https://prefix.dev/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda - sha256: 34878d87275c298f1a732c6806349125cebbf340d24c6c23727268184bba051e - md5: b1fd823b5ae54fbec272cea0811bd8a9 - depends: - - __osx >=11.0 - constrains: - - xz 5.8.3.* - license: 0BSD + - libstdcxx >=14 + - openssl >=3.5.6,<4.0a0 + license: OLDAP-2.8 + license_family: BSD purls: [] - size: 92472 - timestamp: 1775825802659 -- conda: https://prefix.dev/conda-forge/linux-64/liblzma-devel-5.8.3-hb03c661_0.conda - sha256: 7858f6a173206bc8a5bdc8e75690483bb66c0dcc3809ac1cb43c561a4723623a - md5: 55c20edec8e90c4703787acaade60808 + size: 786149 + timestamp: 1775741359582 +- conda: https://prefix.dev/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda + sha256: c0ef482280e38c71a08ad6d71448194b719630345b0c9c60744a2010e8a8e0cb + md5: da1b85b6a87e141f5140bb9924cecab0 depends: - __glibc >=2.17,<3.0.a0 + - ca-certificates - libgcc >=14 - - liblzma 5.8.3 hb03c661_0 - license: 0BSD - purls: [] - size: 491429 - timestamp: 1775825511214 -- conda: https://prefix.dev/conda-forge/osx-arm64/liblzma-devel-5.8.3-h8088a28_0.conda - sha256: 3002be39c0e98ec6cd103b0dc2963dc9e0d7cab127fb2fe9a8de9707a76ed1f0 - md5: ebe1f5418d6e2d4bbc26b2c906a0a470 - depends: - - __osx >=11.0 - - liblzma 5.8.3 h8088a28_0 - license: 0BSD + license: Apache-2.0 + license_family: Apache purls: [] - size: 118482 - timestamp: 1775825828010 -- conda: https://prefix.dev/conda-forge/linux-64/libmad-0.15.1b-h0b41bf4_1001.conda - sha256: 9e94cec54c4baadaa652c761179b8d32771fe7fa55faf6c78c2e35f942367f74 - md5: dc5cc4700f02ffeecc48253c9f29025b + size: 3167099 + timestamp: 1775587756857 +- conda: https://prefix.dev/conda-forge/linux-64/opusfile-0.12-h3358134_2.conda + sha256: f4df9df880e405e5c856383f869d5b9d434f78fb7c234c9e7b099ab604fb7fc3 + md5: 5931bcae00b98f952696b6bcdd0be34b depends: - libgcc-ng >=12 - license: GPL-2.0-only - license_family: GPL - purls: [] - size: 78561 - timestamp: 1670815547616 -- conda: https://prefix.dev/conda-forge/osx-arm64/libmad-0.15.1b-h1a8c8d9_1001.conda - sha256: 8e9209acf4bf6865760e61dc0d86116ffc9efc3e13c7f559eb1ea78532a3a625 - md5: 1eb30852ed396fbe6e301fe6d715aef9 - license: GPL-2.0-only - license_family: GPL + - libogg >=1.3.4,<1.4.0a0 + - libopus >=1.3.1,<2.0a0 + - openssl >=3.0.7,<4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 77255 - timestamp: 1670815732700 -- conda: https://prefix.dev/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda - sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f - md5: 2a45e7f8af083626f009645a6481f12d + size: 65901 + timestamp: 1670387479735 +- conda: https://prefix.dev/conda-forge/linux-64/pandas-3.0.1-py311h8032f78_0.conda + sha256: 3e58067de2e0b8220cf1323c1fc736028b2a117b7a7173bfe67f7da11094271f + md5: 3ac73c673df24589b5b84d43a4afd235 depends: - - __glibc >=2.17,<3.0.a0 - - c-ares >=1.34.6,<2.0a0 - - libev >=4.33,<4.34.0a0 - - libev >=4.33,<5.0a0 + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 - libgcc >=14 + - __glibc >=2.17,<3.0.a0 - libstdcxx >=14 - - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.5,<4.0a0 - license: MIT - license_family: MIT - purls: [] - size: 663344 - timestamp: 1773854035739 -- conda: https://prefix.dev/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda - sha256: 2bc7bc3978066f2c274ebcbf711850cc9ab92e023e433b9631958a098d11e10a - md5: 6ea18834adbc3b33df9bd9fb45eaf95b - depends: - - __osx >=11.0 - - c-ares >=1.34.6,<2.0a0 - - libcxx >=19 - - libev >=4.33,<4.34.0a0 - - libev >=4.33,<5.0a0 - - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.5,<4.0a0 - license: MIT - license_family: MIT - purls: [] - size: 576526 - timestamp: 1773854624224 -- conda: https://prefix.dev/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - sha256: 927fe72b054277cde6cb82597d0fcf6baf127dcbce2e0a9d8925a68f1265eef5 - md5: d864d34357c3b65a4b731f78c0801dc4 + - python_abi 3.11.* *_cp311 + - numpy >=1.23,<3 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 + - pyxlsb >=1.0.10 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=hash-mapping + size: 15143263 + timestamp: 1771408984246 +- conda: https://prefix.dev/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda + sha256: 3613774ad27e48503a3a6a9d72017087ea70f1426f6e5541dbdb59a3b626eaaf + md5: 79f71230c069a287efe3a8614069ddf1 depends: - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - fribidi >=1.0.10,<2.0a0 + - harfbuzz >=11.0.1 + - libexpat >=2.7.0,<3.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 - libgcc >=13 - license: LGPL-2.1-only - license_family: GPL + - libglib >=2.84.2,<3.0a0 + - libpng >=1.6.49,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + license: LGPL-2.1-or-later purls: [] - size: 33731 - timestamp: 1750274110928 -- conda: https://prefix.dev/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda - sha256: 3b3f19ced060013c2dd99d9d46403be6d319d4601814c772a3472fe2955612b0 - md5: 7c7927b404672409d9917d49bff5f2d6 + size: 455420 + timestamp: 1751292466873 +- conda: https://prefix.dev/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda + sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff + md5: 7a3bff861a6583f1889021facefc08b1 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - license: LGPL-2.1-or-later + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=14 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 33418 - timestamp: 1734670021371 -- conda: https://prefix.dev/conda-forge/linux-64/libode-0.16.6-h18afd86_0.conda - sha256: 6ff25c1e497e384cc04e53ec45f0a024c8b2a85bd5afb3737cd1043869ef83a0 - md5: 49d678980383b08f99146ea8a7400806 + size: 1222481 + timestamp: 1763655398280 +- conda: https://prefix.dev/conda-forge/linux-64/pillow-12.3.0-py311hf88fc01_0.conda + sha256: fc8a6dbcf1f367cc33ae6d505370b8d9d51ca5eae9b53bf1517307f863300d27 + md5: 9782d37ef50862d2c8a9ba58c1725754 depends: - - __glibc >=2.17,<3.0.a0 - - libccd-double >=2.1,<2.2.0a0 + - python - libgcc >=14 - - libstdcxx >=14 - - pthread-stubs - - python_abi 3.10.* *_cp310 - license: LGPL-2.1-or-later OR BSD-4-Clause - purls: [] - size: 509471 - timestamp: 1760969190850 -- conda: https://prefix.dev/conda-forge/osx-arm64/libode-0.16.6-py310h46abf29_0.conda - sha256: 2f3d4fb77c4cdca3d156c196271fc4a637af8cac93573ba682c1a12c9def54d8 - md5: f23a539191cb27d18453bad21c648c2f - depends: - - __osx >=11.0 - - libccd-double >=2.1,<2.2.0a0 - - libcxx >=19 - - pthread-stubs - - python >=3.10,<3.11.0a0 *_cpython - - python_abi 3.10.* *_cp310 - license: LGPL-2.1-or-later OR BSD-4-Clause - purls: [] - size: 378594 - timestamp: 1760969550819 -- conda: https://prefix.dev/conda-forge/linux-64/libogg-1.3.5-hd0c01bc_1.conda - sha256: ffb066ddf2e76953f92e06677021c73c85536098f1c21fcd15360dbc859e22e4 - md5: 68e52064ed3897463c0e958ab5c8f91b - depends: - - libgcc >=13 - __glibc >=2.17,<3.0.a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 218500 - timestamp: 1745825989535 -- conda: https://prefix.dev/conda-forge/osx-arm64/libogg-1.3.5-h48c0fde_1.conda - sha256: 28bd1fe20fe43da105da41b95ac201e95a1616126f287985df8e86ddebd1c3d8 - md5: 29b8b11f6d7e6bd0e76c029dcf9dd024 - depends: - - __osx >=11.0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 216719 - timestamp: 1745826006052 -- conda: https://prefix.dev/conda-forge/linux-64/libopenblas-0.3.32-pthreads_h94d23a6_0.conda - sha256: 6dc30b28f32737a1c52dada10c8f3a41bc9e021854215efca04a7f00487d09d9 - md5: 89d61bc91d3f39fda0ca10fcd3c68594 + - openjpeg >=2.5.4,<3.0a0 + - lcms2 >=2.19.1,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - tk >=8.6.13,<8.7.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - python_abi 3.11.* *_cp311 + - libtiff >=4.7.1,<4.8.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=hash-mapping + size: 1081155 + timestamp: 1782912080163 +- conda: https://prefix.dev/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda + sha256: 43d37bc9ca3b257c5dd7bf76a8426addbdec381f6786ff441dc90b1a49143b6a + md5: c01af13bdc553d1a8fbfff6e8db075f0 depends: - - __glibc >=2.17,<3.0.a0 - libgcc >=14 - - libgfortran - - libgfortran5 >=14.3.0 - constrains: - - openblas >=0.3.32,<0.3.33.0a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 5928890 - timestamp: 1774471724897 -- conda: https://prefix.dev/conda-forge/osx-arm64/libopenblas-0.3.32-openmp_he657e61_0.conda - sha256: 713e453bde3531c22a660577e59bf91ef578dcdfd5edb1253a399fa23514949a - md5: 3a1111a4b6626abebe8b978bb5a323bf - depends: - - __osx >=11.0 - - libgfortran - - libgfortran5 >=14.3.0 - - llvm-openmp >=19.1.7 - constrains: - - openblas >=0.3.32,<0.3.33.0a0 - license: BSD-3-Clause - license_family: BSD + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT purls: [] - size: 4308797 - timestamp: 1774472508546 -- conda: https://prefix.dev/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda - sha256: 215086c108d80349e96051ad14131b751d17af3ed2cb5a34edd62fa89bfe8ead - md5: 7df50d44d4a14d6c31a2c54f2cd92157 + size: 450960 + timestamp: 1754665235234 +- conda: https://prefix.dev/conda-forge/linux-64/portaudio-19.7.0-hf4617a5_0.conda + sha256: 3259d2bf63d0c889c516511c8fa73214791ca30baeeee0962eee8b97d17cd1c6 + md5: 053455c094c711e9aa77cf5023cf2bc3 depends: - __glibc >=2.17,<3.0.a0 - - libglvnd 1.7.0 ha4b6fd6_2 - license: LicenseRef-libglvnd + - alsa-lib >=1.2.12,<1.3.0a0 + - libgcc >=13 + - libstdcxx >=13 + license: MIT + license_family: MIT purls: [] - size: 50757 - timestamp: 1731330993524 -- conda: https://prefix.dev/conda-forge/linux-64/libopus-1.6.1-h280c20c_0.conda - sha256: f1061a26213b9653bbb8372bfa3f291787ca091a9a3060a10df4d5297aad74fd - md5: 2446ac1fe030c2aa6141386c1f5a6aed + size: 77342 + timestamp: 1730364040048 +- conda: https://prefix.dev/conda-forge/linux-64/portmidi-2.0.8-h3cb78e3_0.conda + sha256: 13b1f300f609d386d7aec2e31c4ab2fd35c0ed6a2b28ec89605db5b4b044514b + md5: 2333d6737b6fd5c6a70977f8ec1bf110 depends: - __glibc >=2.17,<3.0.a0 + - alsa-lib >=1.2.14,<1.3.0a0 - libgcc >=14 - license: BSD-3-Clause - license_family: BSD + - libstdcxx >=14 + license: MIT + license_family: MIT purls: [] - size: 324993 - timestamp: 1768497114401 -- conda: https://prefix.dev/conda-forge/osx-arm64/libopus-1.6.1-h1a92334_0.conda - sha256: 5c95a5f7712f543c59083e62fc3a95efec8b7f3773fbf4542ad1fb87fbf51ff4 - md5: 7f414dd3fd1cb7a76e51fec074a9c49e + size: 44178 + timestamp: 1764706159843 +- conda: https://prefix.dev/conda-forge/linux-64/protobuf-3.20.2-py311ha362b79_1.conda + sha256: b5927c5e5d3d2bee29e87cfee3e45781e6f6fd663e890389726cd513ef746177 + md5: 9d64275197aab7121cd9318b593a21bd depends: - - __osx >=11.0 + - libgcc-ng >=12 + - libprotobuf 3.20.2.* + - libprotobuf >=3.20.2,<3.21.0a0 + - libstdcxx-ng >=12 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - setuptools + - six license: BSD-3-Clause license_family: BSD - purls: [] - size: 308000 - timestamp: 1768497248058 -- conda: https://prefix.dev/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda - sha256: 0bd91de9b447a2991e666f284ae8c722ffb1d84acb594dbd0c031bd656fa32b2 - md5: 70e3400cbbfa03e96dcde7fc13e38c7b + purls: + - pkg:pypi/protobuf?source=hash-mapping + size: 368989 + timestamp: 1669119100095 +- conda: https://prefix.dev/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 + md5: b3c17d95b5a10c6e64a21fa17573e70e depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 license: MIT license_family: MIT purls: [] - size: 28424 - timestamp: 1749901812541 -- conda: https://prefix.dev/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda - sha256: 377cfe037f3eeb3b1bf3ad333f724a64d32f315ee1958581fc671891d63d3f89 - md5: eba48a68a1a2b9d3c0d9511548db85db + size: 8252 + timestamp: 1726802366959 +- conda: https://prefix.dev/conda-forge/linux-64/pulseaudio-client-17.0-h9a6aba3_3.conda + sha256: 0a0858c59805d627d02bdceee965dd84fde0aceab03a2f984325eec08d822096 + md5: b8ea447fdf62e3597cb8d2fae4eb1a90 depends: - __glibc >=2.17,<3.0.a0 + - dbus >=1.16.2,<2.0a0 - libgcc >=14 - - libzlib >=1.3.2,<2.0a0 - license: zlib-acknowledgement - purls: [] - size: 317729 - timestamp: 1776315175087 -- conda: https://prefix.dev/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda - sha256: 66eae34546df1f098a67064970c92aa14ae7a7505091889e00468294d2882c36 - md5: 2259ae0949dbe20c0665850365109b27 - depends: - - __osx >=11.0 - - libzlib >=1.3.2,<2.0a0 - license: zlib-acknowledgement + - libglib >=2.86.1,<3.0a0 + - libiconv >=1.18,<2.0a0 + - libsndfile >=1.2.2,<1.3.0a0 + - libsystemd0 >=257.10 + - libxcb >=1.17.0,<2.0a0 + constrains: + - pulseaudio 17.0 *_3 + license: LGPL-2.1-or-later + license_family: LGPL purls: [] - size: 289546 - timestamp: 1776315246750 -- conda: https://prefix.dev/conda-forge/linux-64/libpq-18.6-h9d76c99_0.conda - sha256: b1eb210c180fda9c445b11cba1286ec250ce2c2a85ccb0551a4ed5423df51e68 - md5: 72e019c04ed02a179da38c56965802d1 + size: 750785 + timestamp: 1763148198088 +- conda: https://prefix.dev/conda-forge/linux-64/pygame-2.6.1-py311h3209946_0.conda + sha256: f008b83bf960c59e2f6336b9f246e7c6c8ac5327e5a8b7574e7e152e681f1887 + md5: d79d066a1ee9b690f90c02aac432e9c7 depends: - __glibc >=2.17,<3.0.a0 - - icu >=78.3,<79.0a0 - - krb5 >=1.22.2,<1.23.0a0 - - libgcc >=15 - - openldap >=2.6.13,<2.7.0a0 - - openssl >=3.5.7,<4.0a0 - license: PostgreSQL - purls: [] - size: 2719680 - timestamp: 1786641133110 -- conda: https://prefix.dev/conda-forge/linux-64/libprotobuf-3.20.2-h6239696_0.tar.bz2 - sha256: 158899bc39d00dc79e9b3fe8e39ed413a7ae266ddf69a7ff149be16859c24149 - md5: dd9c398d02aa82219a4ea5fa69739ae7 + - fontconfig >=2.14.2,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - libgcc >=13 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - portmidi >=2.0.4,<3.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - sdl2 >=2.30.7,<3.0a0 + - sdl2_image >=2.8.2,<3.0a0 + - sdl2_mixer >=2.6.3,<3.0a0 + - sdl2_ttf >=2.22.0,<3.0a0 + license: LGPL-2.1-only + purls: + - pkg:pypi/pygame?source=hash-mapping + size: 3068168 + timestamp: 1727636682074 +- conda: https://prefix.dev/conda-forge/linux-64/pyside6-6.11.1-py311hf27b23e_1.conda + sha256: 3cd4963051cffa6d96972cd8e42e6b224bbf385353e9a743940b4434fba176e6 + md5: dfd3d0af46ab4c53740abe6d6dbdd403 depends: - - libgcc-ng >=12 - - libstdcxx-ng >=12 - - libzlib >=1.2.13,<2.0.0a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 2715070 - timestamp: 1668469845918 -- conda: https://prefix.dev/conda-forge/osx-arm64/libprotobuf-3.20.2-hb5ab8b9_0.tar.bz2 - sha256: a47188a95c95cb131f9903014e18b7868ab9b445da629f7d3a9d53d9aa8caa2c - md5: a6f25546f30d4cd56bc37b0b56ab954c + - python + - qt6-main 6.11.1.* + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libegl >=1.7.0,<2.0a0 + - libopengl >=1.7.0,<2.0a0 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - libgl >=1.7.0,<2.0a0 + - python_abi 3.11.* *_cp311 + - libxslt >=1.1.43,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - libclang13 >=22.1.5 + - qt6-main >=6.11.1,<6.12.0a0 + license: LGPL-3.0-only + license_family: LGPL + purls: + - pkg:pypi/pyside6?source=hash-mapping + - pkg:pypi/shiboken6?source=hash-mapping + size: 13815486 + timestamp: 1778933870587 +- conda: https://prefix.dev/conda-forge/linux-64/python-3.10.20-h3c07f61_0_cpython.conda + sha256: 8ff2ce308faf2588b69c65b120293f59a8f2577b772b34df4e817d220b09e081 + md5: 5d4e2b00d99feacd026859b7fa239dc0 depends: - - libcxx >=14.0.6 - - libzlib >=1.2.13,<2.0.0a0 - license: BSD-3-Clause - license_family: BSD + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.4,<4.0a0 + - libgcc >=14 + - liblzma >=5.8.2,<6.0a0 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.51.2,<4.0a0 + - libuuid >=2.41.3,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - openssl >=3.5.5,<4.0a0 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 purls: [] - size: 2281852 - timestamp: 1668470370774 -- conda: https://prefix.dev/conda-forge/linux-64/libraqm-0.11.0-h6406941_0.conda - sha256: ab3ccb9fd5816f76b18ee8974d359cd2605ca87d8ddef55369dc461b9986f95c - md5: 3ac89a48d224409739dbf6200e524373 + size: 25455342 + timestamp: 1772729810280 +- conda: https://prefix.dev/conda-forge/linux-64/python-3.11.15-hd63d673_0_cpython.conda + sha256: bf6a32c69889d38482436a786bea32276756cedf0e9805cc856ffd088e8d00f0 + md5: a5ebcefec0c12a333bcd6d7bf3bddc1f depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 - libgcc >=14 - - __glibc >=2.28,<3.0.a0 - - fribidi >=1.0.16,<2.0a0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libharfbuzz >=14.2.1 - license: MIT - license_family: MIT + - liblzma >=5.8.2,<6.0a0 + - libnsl >=2.0.1,<2.1.0a0 + - libsqlite >=3.51.2,<4.0a0 + - libuuid >=2.41.3,<3.0a0 + - libxcrypt >=4.4.36 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - openssl >=3.5.5,<4.0a0 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 purls: [] - size: 33983 - timestamp: 1784850267262 -- conda: https://prefix.dev/conda-forge/osx-arm64/libraqm-0.11.0-h45af499_0.conda - sha256: b110f7f9b2cec61ea793c521950414e00cd64826e18aeb4ab40369acf05c0039 - md5: 46ea0eb4e71bffa35ab7070678bcb053 + size: 30949404 + timestamp: 1772730362552 +- conda: https://prefix.dev/conda-forge/linux-64/pyyaml-6.0.3-py311h3778330_1.conda + sha256: c9a6cd2c290d7c3d2b30ea34a0ccda30f770e8ddb2937871f2c404faf60d0050 + md5: a24add9a3bababee946f3bc1c829acfe depends: - - __osx >=11.0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libharfbuzz >=14.2.1 - - fribidi >=1.0.16,<2.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT + purls: + - pkg:pypi/pyyaml?source=hash-mapping + size: 206190 + timestamp: 1770223702917 +- conda: https://prefix.dev/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc + md5: 353823361b1d27eb3960efb076dfcaf6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: LicenseRef-Qhull purls: [] - size: 31333 - timestamp: 1784850348342 -- conda: https://prefix.dev/conda-forge/linux-64/librsvg-2.60.2-h61e6d4b_0.conda - sha256: 38b3189cf246f7265e06917f32d046ac375117c88834d045efe73ec48ceacc59 - md5: d62da3d560992bfa2feb611d7be813b8 + size: 552937 + timestamp: 1720813982144 +- conda: https://prefix.dev/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_0.conda + sha256: 787d9a8eb7bb993e4a543901b8edade35c1c8e75d67cadb65c56a8f9c38119a5 + md5: cdae26862f9e4c674b8443fd267f2401 depends: + - libxcb + - xcb-util + - xcb-util-wm + - xcb-util-keysyms + - xcb-util-image + - xcb-util-renderutil + - xcb-util-cursor + - libgl-devel + - libegl-devel - __glibc >=2.17,<3.0.a0 - - cairo >=1.18.4,<2.0a0 - - gdk-pixbuf >=2.44.5,<3.0a0 + - libstdcxx >=14 - libgcc >=14 - - libglib >=2.86.4,<3.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - alsa-lib >=1.2.15.3,<1.3.0a0 + - xcb-util-renderutil >=0.3.10,<0.4.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - double-conversion >=3.4.0,<3.5.0a0 + - dbus >=1.16.2,<2.0a0 + - libglib >=2.88.1,<3.0a0 + - libsqlite >=3.53.1,<4.0a0 + - xorg-libx11 >=1.8.13,<2.0a0 + - krb5 >=1.22.2,<1.23.0a0 + - libdrm >=2.4.125,<2.5.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - harfbuzz >=14.2.0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - libbrotlicommon >=1.2.0,<1.3.0a0 + - libbrotlienc >=1.2.0,<1.3.0a0 + - libbrotlidec >=1.2.0,<1.3.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - xorg-libxcomposite >=0.4.7,<1.0a0 + - openssl >=3.5.6,<4.0a0 + - xcb-util-cursor >=0.1.6,<0.2.0a0 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + - xorg-libxxf86vm >=1.1.7,<2.0a0 + - icu >=78.3,<79.0a0 + - libxcb >=1.17.0,<2.0a0 + - wayland >=1.25.0,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libpq >=18.3,<19.0a0 + - libegl >=1.7.0,<2.0a0 + - xcb-util-wm >=0.4.2,<0.5.0a0 + - xcb-util-keysyms >=0.4.1,<0.5.0a0 + - libxkbcommon >=1.13.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - fontconfig >=2.17.1,<3.0a0 + - fonts-conda-ecosystem + - xorg-libxtst >=1.2.5,<2.0a0 + - libxml2 - libxml2-16 >=2.14.6 - - pango >=1.56.4,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libcups >=2.3.3,<2.4.0a0 + - libgl >=1.7.0,<2.0a0 + - xcb-util >=0.4.1,<0.5.0a0 constrains: - - __glibc >=2.17 - license: LGPL-2.1-or-later + - qt ==6.11.1 + license: LGPL-3.0-only + license_family: LGPL purls: [] - size: 4011590 - timestamp: 1771399906142 -- conda: https://prefix.dev/conda-forge/osx-arm64/librsvg-2.60.0-h9001022_1.conda - sha256: 9ba1531b46c75313736e2ef8ba1a4d3ef7d3ffd22efe8d593bfa99da7143a1cb - md5: b6c81d5b3324b9ff9fe8f39d25d8be66 + size: 60185269 + timestamp: 1778597122245 +- conda: https://prefix.dev/conda-forge/linux-64/rav1e-0.8.1-h1fbca29_0.conda + sha256: cf550bbc8e5ebedb6dba9ccaead3e07bd1cb86b183644a4c853e06e4b3ad5ac7 + md5: d83958768626b3c8471ce032e28afcd3 depends: - - __osx >=11.0 - - cairo >=1.18.4,<2.0a0 - - gdk-pixbuf >=2.44.5,<3.0a0 - - libglib >=2.86.4,<3.0a0 - - libxml2-16 >=2.14.6 - - pango >=1.56.4,<2.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 constrains: - - __osx >=11.0 - license: LGPL-2.1-or-later + - __glibc >=2.17 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 2357137 - timestamp: 1771302195666 -- conda: https://prefix.dev/conda-forge/linux-64/libsndfile-1.2.2-hc7d488a_2.conda - sha256: 57cb5f92110324c04498b96563211a1bca6a74b2918b1e8df578bfed03cc32e4 - md5: 067590f061c9f6ea7e61e3b2112ed6b3 + size: 5595970 + timestamp: 1772540833621 +- conda: https://prefix.dev/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002 + md5: d7d95fc8287ea7bf33e0e7116d2b95ec depends: - __glibc >=2.17,<3.0.a0 - - lame >=3.100,<3.101.0a0 - - libflac >=1.5.0,<1.6.0a0 - libgcc >=14 - - libogg >=1.3.5,<1.4.0a0 - - libopus >=1.5.2,<2.0a0 - - libstdcxx >=14 - - libvorbis >=1.3.7,<1.4.0a0 - - mpg123 >=1.32.9,<1.33.0a0 - license: LGPL-2.1-or-later - license_family: LGPL + - ncurses >=6.5,<7.0a0 + license: GPL-3.0-only + license_family: GPL purls: [] - size: 355619 - timestamp: 1765181778282 -- conda: https://prefix.dev/conda-forge/osx-arm64/libsndfile-1.2.2-hf95f74e_2.conda - sha256: f549aafe57439ca7c362884968f24fcc35a26e4e1eb66bb6985aa9e553c25521 - md5: 27e1a5a9249833f98a739249c7d1518b + size: 345073 + timestamp: 1765813471974 +- conda: https://prefix.dev/conda-forge/linux-64/rhash-1.4.3-hd590300_2.conda + sha256: 475f68cac8981ff2b10c56e53c2f376fc3c805fbc7ec30d22f870cd88f1479ba + md5: 4cabe3858a856bff08d9a0992e413084 depends: - - __osx >=11.0 - - lame >=3.100,<3.101.0a0 - - libcxx >=19 - - libflac >=1.5.0,<1.6.0a0 - - libogg >=1.3.5,<1.4.0a0 - - libopus >=1.5.2,<2.0a0 - - libvorbis >=1.3.7,<1.4.0a0 - - mpg123 >=1.32.9,<1.33.0a0 - license: LGPL-2.1-or-later - license_family: LGPL + - libgcc-ng >=12 + license: MIT + license_family: MIT purls: [] - size: 321233 - timestamp: 1765182495193 -- conda: https://prefix.dev/conda-forge/linux-64/libsqlite-3.53.1-h0c1763c_0.conda - sha256: 54cdcd3214313b62c2a8ee277e6f42150d9b748264c1b70d958bf735e420ef8d - md5: 7dc38adcbf71e6b38748e919e16e0dce + size: 184509 + timestamp: 1693427593121 +- conda: https://prefix.dev/conda-forge/linux-64/ruff-0.15.12-h994f30f_0.conda + noarch: python + sha256: 98c771464ed93a2733bae460c39cfa9640feb20972d2e651b44e85db296942eb + md5: 3c8f229055ad244fa3a97c6c45b77099 depends: - - __glibc >=2.17,<3.0.a0 + - python - libgcc >=14 - - libzlib >=1.3.2,<2.0a0 - license: blessing - purls: [] - size: 954962 - timestamp: 1777986471789 -- conda: https://prefix.dev/conda-forge/osx-arm64/libsqlite-3.53.1-h1b79a29_0.conda - sha256: 49daec7c83e70d4efc17b813547824bc2bcf2f7256d84061d24fbfe537da9f74 - md5: 6681822ea9d362953206352371b6a904 - depends: - - __osx >=11.0 - - libzlib >=1.3.2,<2.0a0 - license: blessing - purls: [] - size: 920047 - timestamp: 1777987051643 -- conda: https://prefix.dev/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - sha256: fa39bfd69228a13e553bd24601332b7cfeb30ca11a3ca50bb028108fe90a7661 - md5: eecce068c7e4eddeb169591baac20ac4 - depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.0,<4.0a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 304790 - timestamp: 1745608545575 -- conda: https://prefix.dev/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - sha256: 8bfe837221390ffc6f111ecca24fa12d4a6325da0c8d131333d63d6c37f27e0a - md5: b68e8f66b94b44aaa8de4583d3d4cc40 + constrains: + - __glibc >=2.17 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ruff?source=hash-mapping + size: 9266480 + timestamp: 1778119386343 +- conda: https://prefix.dev/conda-forge/linux-64/scipy-1.17.1-py311hbe70eeb_0.conda + sha256: 0063a75e9406357ef8ecc2fb38808a2442b269bfc5a854cf2bcd368060d9a2d7 + md5: 5ae6d73ab0bebbc892c2d46dc51e90a5 depends: - - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.0,<4.0a0 + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=14 + - libgfortran + - libgfortran5 >=14.3.0 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=14 + - numpy <2.7 + - numpy >=1.23,<3 + - numpy >=1.25.2 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 license: BSD-3-Clause license_family: BSD - purls: [] - size: 279193 - timestamp: 1745608793272 -- conda: https://prefix.dev/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda - sha256: dff1058c76ec6b8759e41cefa2508162d00e4a5e6721aa68ec3fd10094e702dc - md5: 5794b3bdc38177caf969dabd3af08549 + purls: + - pkg:pypi/scipy?source=hash-mapping + size: 17099824 + timestamp: 1771880736635 +- conda: https://prefix.dev/conda-forge/linux-64/sdl2-2.32.56-h54a6638_0.conda + sha256: 987ad072939fdd51c92ea8d3544b286bb240aefda329f9b03a51d9b7e777f9de + md5: cdd138897d94dc07d99afe7113a07bec depends: + - libstdcxx >=14 + - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libgcc 15.2.0 he0feb66_19 - constrains: - - libstdcxx-ng ==15.2.0=*_19 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - libgl >=1.7.0,<2.0a0 + - sdl3 >=3.2.22,<4.0a0 + - libegl >=1.7.0,<2.0a0 + license: Zlib purls: [] - size: 5852044 - timestamp: 1778269036376 -- conda: https://prefix.dev/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda - sha256: 0672b6b6e1791c92e8eccad58081a99d614fcf82bca5841f9dfa3c3e658f83b9 - md5: e5ce228e579726c07255dbf90dc62101 + size: 589145 + timestamp: 1757842881000 +- conda: https://prefix.dev/conda-forge/linux-64/sdl2_image-2.8.2-h06ee604_1.conda + sha256: f18184e016e2e57306d1540dea584d38f4617d7ddb6aad4af6b5f21c52fa39ea + md5: 65e113270b460dcdfc4dc0a80bb3d11c depends: - - libstdcxx 15.2.0 h934c35e_19 - license: GPL-3.0-only WITH GCC-exception-3.1 - license_family: GPL + - libavif16 >=1.0.4,<2.0a0 + - libgcc-ng >=12 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libstdcxx-ng >=12 + - libtiff >=4.6.0,<4.8.0a0 + - libwebp-base >=1.4.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - sdl2 >=2.30.2,<3.0a0 + license: Zlib purls: [] - size: 27776 - timestamp: 1778269074600 -- conda: https://prefix.dev/conda-forge/linux-64/libsystemd0-257.13-hd0affe5_0.conda - sha256: c5008b602cb5c819f7b52d418b3ed17e1818cbbf6705b189e7ab36bb70cce3d8 - md5: 8ee3cb7f64be0e8c4787f3a4dbe024e6 + size: 152110 + timestamp: 1716857107234 +- conda: https://prefix.dev/conda-forge/linux-64/sdl2_mixer-2.6.3-hb8bcbd3_2.conda + sha256: 3a36f7d6349d132c571516514dc8cd771a705e93adef942c8eee38a09875d97a + md5: 97fbc8b1372f0000321d568c0e459e3c depends: - __glibc >=2.17,<3.0.a0 - - libcap >=2.77,<2.78.0a0 + - fluidsynth >=2.5.2,<2.6.0a0 + - libflac >=1.5.0,<1.6.0a0 - libgcc >=14 - license: LGPL-2.1-or-later + - libmad >=0.15.1b,<0.16.0a0 + - libogg >=1.3.5,<1.4.0a0 + - libstdcxx >=14 + - libvorbis >=1.3.7,<1.4.0a0 + - mpg123 >=1.32.9,<1.33.0a0 + - opusfile >=0.12,<0.13.0a0 + - sdl2 >=2.32.56,<3.0a0 + license: Zlib purls: [] - size: 492799 - timestamp: 1773797095649 -- conda: https://prefix.dev/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda - sha256: e5f8c38625aa6d567809733ae04bb71c161a42e44a9fa8227abe61fa5c60ebe0 - md5: cd5a90476766d53e901500df9215e927 + size: 205164 + timestamp: 1766614707552 +- conda: https://prefix.dev/conda-forge/linux-64/sdl2_ttf-2.24.0-h287479f_0.conda + sha256: 431d19b666db6e7a4f09c37c43c83f115176a006b2ac321853ca26bee888c519 + md5: bccd5b74eb55a523dfcc66b857555714 depends: - __glibc >=2.17,<3.0.a0 - - lerc >=4.0.0,<5.0a0 - - libdeflate >=1.25,<1.26.0a0 - - libgcc >=14 - - libjpeg-turbo >=3.1.0,<4.0a0 - - liblzma >=5.8.1,<6.0a0 - - libstdcxx >=14 - - libwebp-base >=1.6.0,<2.0a0 + - freetype >=2.12.1,<3.0a0 + - harfbuzz >=10.1.0 + - libgcc >=13 - libzlib >=1.3.1,<2.0a0 - - zstd >=1.5.7,<1.6.0a0 - license: HPND + - sdl2 >=2.30.10,<3.0a0 + license: Zlib purls: [] - size: 435273 - timestamp: 1762022005702 -- conda: https://prefix.dev/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda - sha256: e9248077b3fa63db94caca42c8dbc6949c6f32f94d1cafad127f9005d9b1507f - md5: e2a72ab2fa54ecb6abab2b26cde93500 + size: 61954 + timestamp: 1736117956977 +- conda: https://prefix.dev/conda-forge/linux-64/sdl3-3.4.8-hdeec2a5_0.conda + sha256: bec327fffc08369afe4c1384a5b50cac9b38e7af42ebdf5f89628633bd980dbd + md5: 508bad511e617479f0ad60cc49fba903 depends: - - __osx >=11.0 - - lerc >=4.0.0,<5.0a0 - - libcxx >=19 - - libdeflate >=1.25,<1.26.0a0 - - libjpeg-turbo >=3.1.0,<4.0a0 - - liblzma >=5.8.1,<6.0a0 - - libwebp-base >=1.6.0,<2.0a0 - - libzlib >=1.3.1,<2.0a0 - - zstd >=1.5.7,<1.6.0a0 - license: HPND + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - pulseaudio-client >=17.0,<17.1.0a0 + - libgl >=1.7.0,<2.0a0 + - libunwind >=1.8.3,<1.9.0a0 + - xorg-libxtst >=1.2.5,<2.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - libegl >=1.7.0,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + - libudev1 >=257.13 + - xorg-libxext >=1.3.7,<2.0a0 + - libusb >=1.0.29,<2.0a0 + - wayland >=1.25.0,<2.0a0 + - xorg-libxi >=1.8.2,<2.0a0 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - liburing >=2.14,<2.15.0a0 + - xorg-libxscrnsaver >=1.2.4,<2.0a0 + - dbus >=1.16.2,<2.0a0 + - libxkbcommon >=1.13.1,<2.0a0 + - libdrm >=2.4.125,<2.5.0a0 + - xorg-libx11 >=1.8.13,<2.0a0 + license: Zlib purls: [] - size: 373892 - timestamp: 1762022345545 -- conda: https://prefix.dev/conda-forge/linux-64/libudev1-257.13-hd0affe5_0.conda - sha256: 1a1e367c04d66030aa93b4d33905f7f6fbb59cfc292e816fe3e9c1e8b3f4d1e2 - md5: 2c2270f93d6f9073cbf72d821dfc7d72 + size: 2146080 + timestamp: 1777693555942 +- conda: https://prefix.dev/conda-forge/linux-64/secretstorage-3.4.1-py311h38be061_0.conda + sha256: 47f28b12e760ae3ce8a1e616c5b56f5e874e0e4a036bdd09516ebf263c19521f + md5: ec955e67147942a68469a46d0bdf0a7b + depends: + - cryptography >=2.0 + - dbus + - jeepney >=0.6 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/secretstorage?source=hash-mapping + size: 32968 + timestamp: 1763045430433 +- conda: https://prefix.dev/conda-forge/linux-64/svt-av1-4.0.1-hecca717_0.conda + sha256: 4a1d2005153b9454fc21c9bad1b539df189905be49e851ec62a6212c2e045381 + md5: 2a2170a3e5c9a354d09e4be718c43235 depends: - __glibc >=2.17,<3.0.a0 - - libcap >=2.77,<2.78.0a0 - libgcc >=14 - license: LGPL-2.1-or-later + - libstdcxx >=14 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 145087 - timestamp: 1773797108513 -- conda: https://prefix.dev/conda-forge/linux-64/libunwind-1.8.3-h65a8314_0.conda - sha256: 71c8b9d5c72473752a0bb6e91b01dd209a03916cb71f36cc6a564e3a2a132d7a - md5: e179a69edd30d75c0144d7a380b88f28 + size: 2619743 + timestamp: 1769664536467 +- conda: https://prefix.dev/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda + sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac + md5: cffd3bdd58090148f4cfcd831f4b26ab depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - - libstdcxx >=14 - license: MIT - license_family: MIT - purls: [] - size: 75995 - timestamp: 1757032240102 -- conda: https://prefix.dev/conda-forge/linux-64/liburing-2.14-hb700be7_0.conda - sha256: 3d17b7aa90610afc65356e9e6149aeac0b2df19deda73a51f0a09cf04fd89286 - md5: 56f65185b520e016d29d01657ac02c0d + - libzlib >=1.3.1,<2.0a0 + constrains: + - xorg-libx11 >=1.8.12,<2.0a0 + license: TCL + license_family: BSD + purls: [] + size: 3301196 + timestamp: 1769460227866 +- conda: https://prefix.dev/conda-forge/linux-64/tornado-6.5.5-py311h49ec1c0_0.conda + sha256: cd8bc08ca661291cfbb05581b79f7e6a6971a072a54a335abcea5460c1230880 + md5: 73b44a114241e564deb5846e7394bf19 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=hash-mapping + size: 876817 + timestamp: 1774358035290 +- conda: https://prefix.dev/conda-forge/linux-64/ukkonen-1.1.0-py311hdf67eae_0.conda + sha256: 31ad759e2d7668f1615021bca0ae2358a284939e3ca3fcb971b3f7aa83c2a6d6 + md5: 5a715cf5e3dc6cd68717c50e47dd7b6b depends: - __glibc >=2.17,<3.0.a0 + - cffi - libgcc >=14 - libstdcxx >=14 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 license: MIT license_family: MIT - purls: [] - size: 154203 - timestamp: 1770566529700 -- conda: https://prefix.dev/conda-forge/linux-64/libusb-1.0.29-h73b1eb8_0.conda - sha256: 89c84f5b26028a9d0f5c4014330703e7dff73ba0c98f90103e9cef6b43a5323c - md5: d17e3fb595a9f24fa9e149239a33475d + purls: + - pkg:pypi/ukkonen?source=hash-mapping + size: 14898 + timestamp: 1769438724694 +- conda: https://prefix.dev/conda-forge/linux-64/unicodedata2-17.0.1-py311h49ec1c0_0.conda + sha256: 2bd8ee058dc98e614003591eb221a8b08449768b13aebe76dad8528bf0f5f88b + md5: 2889f0c0b6a6d7a37bd64ec60f4cc210 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libudev1 >=257.4 - license: LGPL-2.1-or-later - purls: [] - size: 89551 - timestamp: 1748856210075 -- conda: https://prefix.dev/conda-forge/osx-arm64/libusb-1.0.29-hbc156a2_0.conda - sha256: 5eee9a2bf359e474d4548874bcfc8d29ebad0d9ba015314439c256904e40aaad - md5: f6654e9e96e9d973981b3b2f898a5bfa - depends: - - __osx >=11.0 - license: LGPL-2.1-or-later - purls: [] - size: 83849 - timestamp: 1748856224950 -- conda: https://prefix.dev/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda - sha256: bc1b08c92626c91500fd9f26f2c797f3eb153b627d53e9c13cd167f1e12b2829 - md5: 38ffe67b78c9d4de527be8315e5ada2c + - libgcc >=14 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 409682 + timestamp: 1770909108616 +- conda: https://prefix.dev/conda-forge/linux-64/uv-0.11.12-h29f5ae7_0.conda + sha256: 4fc1481bb6ecf5a1a755661483eb99a0ec2054cd02e5893b55f9c80bac9437a8 + md5: e86a95851fd53465f0657c068cb6c403 depends: - - __glibc >=2.17,<3.0.a0 - libgcc >=14 - license: BSD-3-Clause - license_family: BSD + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + constrains: + - __glibc >=2.17 + license: Apache-2.0 OR MIT purls: [] - size: 40297 - timestamp: 1775052476770 -- conda: https://prefix.dev/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - sha256: c180f4124a889ac343fc59d15558e93667d894a966ec6fdb61da1604481be26b - md5: 0f03292cc56bf91a077a134ea8747118 + size: 19190543 + timestamp: 1778287747008 +- conda: https://prefix.dev/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda + sha256: ea374d57a8fcda281a0a89af0ee49a2c2e99cc4ac97cf2e2db7064e74e764bdb + md5: 996583ea9c796e5b915f7d7580b51ea6 depends: - __glibc >=2.17,<3.0.a0 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 - libgcc >=14 + - libstdcxx >=14 license: MIT license_family: MIT purls: [] - size: 895108 - timestamp: 1753948278280 -- conda: https://prefix.dev/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda - sha256: 042c7488ad97a5629ec0a991a8b2a3345599401ecc75ad6a5af73b60e6db9689 - md5: c0d87c3c8e075daf1daf6c31b53e8083 + size: 334139 + timestamp: 1773959575393 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda + sha256: ad8cab7e07e2af268449c2ce855cbb51f43f4664936eff679b1f3862e6e4b01d + md5: fdc27cb255a7a2cc73b7919a968b48f0 depends: - - __osx >=11.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.17.0,<2.0a0 license: MIT license_family: MIT purls: [] - size: 421195 - timestamp: 1753948426421 -- conda: https://prefix.dev/conda-forge/linux-64/libvorbis-1.3.7-h54a6638_2.conda - sha256: ca494c99c7e5ecc1b4cd2f72b5584cef3d4ce631d23511184411abcbb90a21a5 - md5: b4ecbefe517ed0157c37f8182768271c + size: 20772 + timestamp: 1750436796633 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda + sha256: c2be9cae786fdb2df7c2387d2db31b285cf90ab3bfabda8fa75a596c3d20fc67 + md5: 4d1fc190b99912ed557a8236e958c559 depends: - - libogg - - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libstdcxx >=14 - libgcc >=14 - - libogg >=1.3.5,<1.4.0a0 - license: BSD-3-Clause - license_family: BSD + - libxcb >=1.13 + - libxcb >=1.17.0,<2.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-renderutil >=0.3.10,<0.4.0a0 + license: MIT + license_family: MIT purls: [] - size: 285894 - timestamp: 1753879378005 -- conda: https://prefix.dev/conda-forge/osx-arm64/libvorbis-1.3.7-h81086ad_2.conda - sha256: 95768e4eceaffb973081fd986d03da15d93aa10609ed202e6fd5ca1e490a3dce - md5: 719e7653178a09f5ca0aa05f349b41f7 + size: 20829 + timestamp: 1763366954390 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda + sha256: 94b12ff8b30260d9de4fd7a28cca12e028e572cbc504fd42aa2646ec4a5bded7 + md5: a0901183f08b6c7107aab109733a3c91 depends: - - libogg - - libcxx >=19 - - __osx >=11.0 - - libogg >=1.3.5,<1.4.0a0 - license: BSD-3-Clause - license_family: BSD + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + - xcb-util >=0.4.1,<0.5.0a0 + license: MIT + license_family: MIT purls: [] - size: 259122 - timestamp: 1753879389702 -- conda: https://prefix.dev/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda - sha256: a68280d57dfd29e3d53400409a39d67c4b9515097eba733aa6fe00c880620e2b - md5: 31ad065eda3c2d88f8215b1289df9c89 + size: 24551 + timestamp: 1718880534789 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda + sha256: 546e3ee01e95a4c884b6401284bb22da449a2f4daf508d038fdfa0712fe4cc69 + md5: ad748ccca349aec3e91743e08b5e2b50 depends: - - __glibc >=2.17,<3.0.a0 - - libstdcxx >=14 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxrandr >=1.5.5,<2.0a0 - constrains: - - libvulkan-headers 1.4.341.0.* - license: Apache-2.0 - license_family: APACHE + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + license: MIT + license_family: MIT purls: [] - size: 199795 - timestamp: 1770077125520 -- conda: https://prefix.dev/conda-forge/osx-arm64/libvulkan-loader-1.4.341.0-h3feff0a_0.conda - sha256: d2790dafc9149b1acd45b9033d02cfa3f3e9ee5af97bd61e0a5718c414a0a135 - md5: 6b4c9a5b130759136a0dde0c373cb0ea + size: 14314 + timestamp: 1718846569232 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda + sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df + md5: 0e0cbe0564d03a99afd5fd7b362feecd depends: - - __osx >=11.0 - - libcxx >=19 - constrains: - - libvulkan-headers 1.4.341.0.* - license: Apache-2.0 - license_family: APACHE + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + license: MIT + license_family: MIT purls: [] - size: 180304 - timestamp: 1770077143460 -- conda: https://prefix.dev/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda - sha256: 3aed21ab28eddffdaf7f804f49be7a7d701e8f0e46c856d801270b470820a37b - md5: aea31d2e5b1091feca96fcfe945c3cf9 + size: 16978 + timestamp: 1718848865819 +- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + sha256: 31d44f297ad87a1e6510895740325a635dd204556aa7e079194a0034cdd7e66a + md5: 608e0ef8256b81d04456e8d211eee3e8 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - constrains: - - libwebp 1.6.0 - license: BSD-3-Clause - license_family: BSD + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + license: MIT + license_family: MIT purls: [] - size: 429011 - timestamp: 1752159441324 -- conda: https://prefix.dev/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda - sha256: a4de3f371bb7ada325e1f27a4ef7bcc81b2b6a330e46fac9c2f78ac0755ea3dd - md5: e5e7d467f80da752be17796b87fe6385 + size: 51689 + timestamp: 1718844051451 +- conda: https://prefix.dev/conda-forge/linux-64/xkeyboard-config-2.47-hb03c661_0.conda + sha256: 19c2bb14bec84b0e995b56b752369775c75f1589314b43733948bb5f471a6915 + md5: b56e0c8432b56decafae7e78c5f29ba5 depends: - - __osx >=11.0 - constrains: - - libwebp 1.6.0 - license: BSD-3-Clause - license_family: BSD + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.13,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 294974 - timestamp: 1752159906788 -- conda: https://prefix.dev/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda - sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa - md5: 92ed62436b625154323d40d5f2f11dd7 + size: 399291 + timestamp: 1772021302485 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b + md5: fb901ff28063514abb6046c9ec2c4a45 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 - - pthread-stubs - - xorg-libxau >=1.0.11,<2.0a0 - - xorg-libxdmcp license: MIT license_family: MIT purls: [] - size: 395888 - timestamp: 1727278577118 -- conda: https://prefix.dev/conda-forge/osx-arm64/libxcb-1.17.0-hbffa61f_1.conda - sha256: 81f9b4fb64d977c19474d1b5616974757aaac21d55401ea105f21022b386bd28 - md5: 923bf656578743d064f352f0b56ee658 - depends: - - __osx >=11.0 - - pthread-stubs - - xorg-libxau >=1.0.12,<2.0a0 - - xorg-libxdmcp >=1.1.5,<2.0a0 + size: 58628 + timestamp: 1734227592886 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda + sha256: 277841c43a39f738927145930ff963c5ce4c4dacf66637a3d95d802a64173250 + md5: 1c74ff8c35dcadf952a16f752ca5aa49 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libuuid >=2.38.1,<3.0a0 + - xorg-libice >=1.1.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 324264 - timestamp: 1787077544793 -- conda: https://prefix.dev/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c - md5: 5aa797f8787fe7a17d1b0821485b5adc - depends: - - libgcc-ng >=12 - license: LGPL-2.1-or-later - purls: [] - size: 100393 - timestamp: 1702724383534 -- conda: https://prefix.dev/conda-forge/linux-64/libxkbcommon-1.13.1-hca5e8e5_0.conda - sha256: d2195b5fbcb0af1ff7b345efdf89290c279b8d1d74f325ae0ac98148c375863c - md5: 2bca1fbb221d9c3c8e3a155784bbc2e9 + size: 27590 + timestamp: 1741896361728 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda + sha256: 516d4060139dbb4de49a4dcdc6317a9353fb39ebd47789c14e6fe52de0deee42 + md5: 861fb6ccbc677bb9a9fb2468430b9c6a depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - - libstdcxx >=14 - libxcb >=1.17.0,<2.0a0 - - libxml2 - - libxml2-16 >=2.14.6 - - xkeyboard-config - - xorg-libxau >=1.0.12,<2.0a0 - license: MIT/X11 Derivative + license: MIT license_family: MIT purls: [] - size: 837922 - timestamp: 1764794163823 -- conda: https://prefix.dev/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda - sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba - md5: 995d8c8bad2a3cc8db14675a153dec2b + size: 839652 + timestamp: 1770819209719 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda + sha256: 6bc6ab7a90a5d8ac94c7e300cc10beb0500eeba4b99822768ca2f2ef356f731b + md5: b2895afaf55bf96a8c8282a2e47a5de0 depends: - __glibc >=2.17,<3.0.a0 - - icu >=78.3,<79.0a0 - libgcc >=14 - - libiconv >=1.18,<2.0a0 - - liblzma >=5.8.3,<6.0a0 - - libxml2-16 2.15.3 hca6bf5a_0 - - libzlib >=1.3.2,<2.0a0 license: MIT license_family: MIT purls: [] - size: 46810 - timestamp: 1776376751152 -- conda: https://prefix.dev/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda - sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a - md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 + size: 15321 + timestamp: 1762976464266 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda + sha256: 048c103000af9541c919deef03ae7c5e9c570ffb4024b42ecb58dbde402e373a + md5: f2ba4192d38b6cef2bb2c25029071d90 depends: - __glibc >=2.17,<3.0.a0 - - icu >=78.3,<79.0a0 - libgcc >=14 - - libiconv >=1.18,<2.0a0 - - liblzma >=5.8.3,<6.0a0 - - libzlib >=1.3.2,<2.0a0 - constrains: - - libxml2 2.15.3 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 license: MIT license_family: MIT purls: [] - size: 559775 - timestamp: 1776376739004 -- conda: https://prefix.dev/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda - sha256: ff75b84cdb9e8d123db2fa694a8ac2c2059516b6cbc98ac21fb68e235d0fd354 - md5: 19edaa53885fc8205614b03da2482282 + size: 14415 + timestamp: 1770044404696 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a + md5: 2ccd714aa2242315acaf0a67faea780b depends: - - __osx >=11.0 - - icu >=78.3,<79.0a0 - - libiconv >=1.18,<2.0a0 - - liblzma >=5.8.3,<6.0a0 - - libzlib >=1.3.2,<2.0a0 - constrains: - - libxml2 2.15.3 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 license: MIT license_family: MIT purls: [] - size: 466360 - timestamp: 1776377102261 -- conda: https://prefix.dev/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda - sha256: 0694760a3e62bdc659d90a14ae9c6e132b525a7900e59785b18a08bb52a5d7e5 - md5: 87e6096ec6d542d1c1f8b33245fe8300 + size: 32533 + timestamp: 1730908305254 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0 + md5: b5fcc7172d22516e1f965490e65e33a4 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libxml2 - - libxml2-16 >=2.14.6 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 license: MIT license_family: MIT purls: [] - size: 245434 - timestamp: 1757963724977 -- conda: https://prefix.dev/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 - md5: d87ff7921124eccd67248aa483c23fec + size: 13217 + timestamp: 1727891438799 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda + sha256: 25d255fb2eef929d21ff660a0c687d38a6d2ccfbcbf0cc6aa738b12af6e9d142 + md5: 1dafce8548e38671bea82e3f5c6ce22f depends: - __glibc >=2.17,<3.0.a0 - constrains: - - zlib 1.3.2 *_2 - license: Zlib - license_family: Other - purls: [] - size: 63629 - timestamp: 1774072609062 -- conda: https://prefix.dev/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - sha256: 361415a698514b19a852f5d1123c5da746d4642139904156ddfca7c922d23a05 - md5: bc5a5721b6439f2f62a84f2548136082 - depends: - - __osx >=11.0 - constrains: - - zlib 1.3.2 *_2 - license: Zlib - license_family: Other + - libgcc >=14 + license: MIT + license_family: MIT purls: [] - size: 47759 - timestamp: 1774072956767 -- conda: https://prefix.dev/conda-forge/osx-arm64/llvm-openmp-22.1.4-hc7d1edf_0.conda - sha256: a269273ccf48be6ac582bb958713ba8373262b9157a0fc76b7e5475e8a1d2a78 - md5: 46d04a647df7a4525e487d88068d19ef + size: 20591 + timestamp: 1762976546182 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda + sha256: 79c60fc6acfd3d713d6340d3b4e296836a0f8c51602327b32794625826bd052f + md5: 34e54f03dfea3e7a2dcf1453a85f1085 depends: - - __osx >=11.0 - constrains: - - openmp 22.1.4|22.1.4.* - - intel-openmp <0.0a0 - license: Apache-2.0 WITH LLVM-exception - license_family: APACHE + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 286406 - timestamp: 1776846235007 -- conda: https://prefix.dev/conda-forge/linux-64/llvmlite-0.49.0-py311h1369f55_2.conda - sha256: bd4ddf72a6ee81991759d407d0cf8fadf9804500562839448a22c11f8e829f8e - md5: 7d4c6843f49e890b8f6fb813d7e94c1f + size: 50326 + timestamp: 1769445253162 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda + sha256: 83c4c99d60b8784a611351220452a0a85b080668188dce5dfa394b723d7b64f4 + md5: ba231da7fccf9ea1e768caf5c7099b84 depends: - - python - __glibc >=2.17,<3.0.a0 - - libstdcxx >=15 - - libgcc >=15 - - zstd >=1.5.7,<1.6.0a0 - - python_abi 3.11.* *_cp311 - - libzlib >=1.3.2,<2.0a0 - license: BSD-2-Clause - license_family: BSD - purls: - - pkg:pypi/llvmlite?source=hash-mapping - size: 40845513 - timestamp: 1788013791127 -- conda: https://prefix.dev/conda-forge/osx-arm64/llvmlite-0.49.0-py311h4a78e08_2.conda - sha256: 42f645cb34752835a9e9a39da5f383c5d5341727f37f3d96741ac035cc94d164 - md5: 16e87603b33bbbff99352220dee440a6 - depends: - - python - - __osx >=11.0 - - libcxx >=21 - - zstd >=1.5.7,<1.6.0a0 - - python_abi 3.11.* *_cp311 - - libzlib >=1.3.2,<2.0a0 - license: BSD-2-Clause - license_family: BSD - purls: - - pkg:pypi/llvmlite?source=hash-mapping - size: 30512158 - timestamp: 1788013780870 -- conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda - sha256: 0c4c35376fe920714390d46e4b8d31c876d65f18e1655899e0763ec25f2a902f - md5: 6d03368f2b2b0a5fb6839df53b2eb5e0 - depends: - - mdurl >=0.1,<1 - - python >=3.10 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/markdown-it-py?source=hash-mapping - size: 69017 - timestamp: 1778169663339 -- conda: https://prefix.dev/conda-forge/linux-64/matplotlib-3.11.1-py311h968eb38_2.conda - sha256: b677501911fa682ea74a86472a003a2f8cbb046f8fb6bbc501521af6aea0744f - md5: 2cb7827f42621fe32c5161ad927ecaa7 - depends: - - matplotlib-base >=3.11.1,<3.11.2.0a0 - - pyside6 >=6.7.2 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - - tornado >=5 - license: PSF-2.0 - license_family: PSF purls: [] - size: 14988 - timestamp: 1785211075423 -- conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-3.11.1-py311ha01d089_2.conda - sha256: 3e9381c800201853483185f7403d8ceb8f013d8a0dcda37c864a34e708158180 - md5: 7ce16f8bcf8a38405f1f09801e1bf832 + size: 20071 + timestamp: 1759282564045 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda + sha256: 1a724b47d98d7880f26da40e45f01728e7638e6ec69f35a3e11f92acd05f9e7a + md5: 17dcc85db3c7886650b8908b183d6876 depends: - - matplotlib-base >=3.11.1,<3.11.2.0a0 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - - tornado >=5 - license: PSF-2.0 - license_family: PSF + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + license: MIT + license_family: MIT purls: [] - size: 14921 - timestamp: 1785211095125 -- conda: https://prefix.dev/conda-forge/linux-64/matplotlib-base-3.11.1-py311he401cf6_2.conda - sha256: f9f48162f2553080d041b061b9f6cfec64d79d7c40df0e6379496f9ad2df738c - md5: f602c096988d0f744f4f017aa0269e30 + size: 47179 + timestamp: 1727799254088 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxinerama-1.1.6-hecca717_0.conda + sha256: 3a9da41aac6dca9d3ff1b53ee18b9d314de88add76bafad9ca2287a494abcd86 + md5: 93f5d4b5c17c8540479ad65f206fea51 depends: - __glibc >=2.17,<3.0.a0 - - contourpy >=1.0.1 - - cycler >=0.10 - - fonttools >=4.28.2 - - freetype - - kiwisolver >=1.3.1 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - libgcc >=14 - - libraqm >=0.11.0,<0.12.0a0 - libstdcxx >=14 - - numpy >=1.23,<3 - - numpy >=1.25 - - packaging >=20.0 - - pillow >=9 - - pyparsing >=3 - - python >=3.11,<3.12.0a0 - - python-dateutil >=2.7 - - python_abi 3.11.* *_cp311 - - qhull >=2020.2,<2020.3.0a0 - - tk >=8.6.13,<8.7.0a0 - license: PSF-2.0 - license_family: PSF - purls: - - pkg:pypi/matplotlib?source=hash-mapping - size: 8925010 - timestamp: 1785211062689 -- conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-base-3.11.1-py311h3c3ad35_2.conda - sha256: 09330e68ce42c7ed076a296b04ce3ea0cb10d72fb5c31b68bf1aa93ecf553a07 - md5: e0a2569461d3cc107301cce6835cf0ba + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 14818 + timestamp: 1769432261050 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda + sha256: 80ed047a5cb30632c3dc5804c7716131d767089f65877813d4ae855ee5c9d343 + md5: e192019153591938acf7322b6459d36e depends: - - __osx >=11.0 - - contourpy >=1.0.1 - - cycler >=0.10 - - fonttools >=4.28.2 - - freetype - - kiwisolver >=1.3.1 - - libcxx >=19 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libraqm >=0.11.0,<0.12.0a0 - - numpy >=1.23,<3 - - numpy >=1.25 - - packaging >=20.0 - - pillow >=9 - - pyparsing >=3 - - python >=3.11,<3.12.0a0 - - python-dateutil >=2.7 - - python_abi 3.11.* *_cp311 - - qhull >=2020.2,<2020.3.0a0 - license: PSF-2.0 - license_family: PSF - purls: - - pkg:pypi/matplotlib?source=hash-mapping - size: 8811362 - timestamp: 1785211075697 -- conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda - sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 - md5: 592132998493b3ff25fd7479396e8351 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: MIT + license_family: MIT + purls: [] + size: 30456 + timestamp: 1769445263457 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1 + md5: 96d57aba173e878a2089d5638016dc5e depends: - - python >=3.9 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/mdurl?source=hash-mapping - size: 14465 - timestamp: 1733255681319 -- conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda - sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 - md5: b874955758a30a37c78b82ea5cf78fdb + purls: [] + size: 33005 + timestamp: 1734229037766 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxscrnsaver-1.2.4-hb9d3cd8_0.conda + sha256: 58e8fc1687534124832d22e102f098b5401173212ac69eb9fd96b16a3e2c8cb2 + md5: 303f7a0e9e0cd7d250bb6b952cecda90 depends: - - python >=3.10 - - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/more-itertools?source=hash-mapping - size: 71254 - timestamp: 1775762492525 -- conda: https://prefix.dev/conda-forge/linux-64/mpg123-1.32.9-hc50e24c_0.conda - sha256: 39c4700fb3fbe403a77d8cc27352fa72ba744db487559d5d44bf8411bb4ea200 - md5: c7f302fd11eeb0987a6a5e1f3aed6a21 + purls: [] + size: 14412 + timestamp: 1727899730073 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + sha256: 752fdaac5d58ed863bbf685bb6f98092fe1a488ea8ebb7ed7b606ccfce08637a + md5: 7bbe9a0cc0df0ac5f5a8ad6d6a11af2f depends: - __glibc >=2.17,<3.0.a0 - libgcc >=13 - - libstdcxx >=13 - license: LGPL-2.1-only - license_family: LGPL + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxi >=1.7.10,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 491140 - timestamp: 1730581373280 -- conda: https://prefix.dev/conda-forge/osx-arm64/mpg123-1.32.9-hf642e45_0.conda - sha256: 070bbbbb96856c325c0b6637638ce535afdc49adbaff306e2238c6032d28dddf - md5: d2b4857bdc3b76c36e23236172d09840 + size: 32808 + timestamp: 1727964811275 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda + sha256: 64db17baaf36fa03ed8fae105e2e671a7383e22df4077486646f7dbf12842c9f + md5: 665d152b9c6e78da404086088077c844 depends: - - __osx >=11.0 - - libcxx >=18 - license: LGPL-2.1-only - license_family: LGPL + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 360712 - timestamp: 1730581491116 -- conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda - sha256: d09c47c2cf456de5c09fa66d2c3c5035aa1fa228a1983a433c47b876aa16ce90 - md5: 37293a85a0f4f77bbd9cf7aaefc62609 + size: 18701 + timestamp: 1769434732453 +- conda: https://prefix.dev/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda + sha256: 7a8c64938428c2bfd016359f9cb3c44f94acc256c6167dbdade9f2a1f5ca7a36 + md5: aa8d21be4b461ce612d8f5fb791decae depends: - - python >=3.9 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/munkres?source=hash-mapping - size: 15851 - timestamp: 1749895533014 -- conda: https://prefix.dev/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3 - md5: fc21868a1a5aacc937e7a18747acb8a5 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + size: 570010 + timestamp: 1766154256151 +- conda: https://prefix.dev/conda-forge/linux-64/xz-5.8.3-ha02ee65_0.conda + sha256: 2553fd3ec0a1020b2ca05ca10b0036a596cb0d4bf3645922fcf69dacce0e6679 + md5: 6a1b6af49a334e4e06b9f103367762bf depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - license: X11 AND BSD-3-Clause + - liblzma 5.8.3 hb03c661_0 + - liblzma-devel 5.8.3 hb03c661_0 + - xz-gpl-tools 5.8.3 ha02ee65_0 + - xz-tools 5.8.3 hb03c661_0 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later purls: [] - size: 918956 - timestamp: 1777422145199 -- conda: https://prefix.dev/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - sha256: 4ea6c620b87bd1d42bb2ccc2c87cd2483fa2d7f9e905b14c223f11ff3f4c455d - md5: 343d10ed5b44030a2f67193905aea159 + size: 24360 + timestamp: 1775825568523 +- conda: https://prefix.dev/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_0.conda + sha256: 8f139666ea18dc8340a44a54056627dd4e89e242e8cd136ab2467d6dc2c192ba + md5: 8f5e2c6726c1339287a3c76a2c138ac7 depends: - - __osx >=11.0 - license: X11 AND BSD-3-Clause + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_0 + constrains: + - xz 5.8.3.* + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later purls: [] - size: 805509 - timestamp: 1777423252320 -- conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda - sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee - md5: eb52d14a901e23c39e9e7b4a1a5c015f + size: 34213 + timestamp: 1775825548743 +- conda: https://prefix.dev/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_0.conda + sha256: 162ebd76803464b8c8ebc7d45df32edf0ec717b3bf369a437ae3b0254f22dc2e + md5: b62b615caa60812640f24db3a8d0fc87 depends: - - python >=3.10 - - setuptools - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/nodeenv?source=hash-mapping - size: 40866 - timestamp: 1766261270149 -- conda: https://prefix.dev/conda-forge/linux-64/numba-0.67.0-py311hdfc3925_1.conda - sha256: 3129c290e7d02cd7fd8a44da0f1985539e7c659b18624b7298baaa267718d942 - md5: e32e21325dea34226840b71a57982ef3 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_0 + constrains: + - xz 5.8.3.* + license: 0BSD AND LGPL-2.1-or-later + purls: [] + size: 95955 + timestamp: 1775825530484 +- conda: https://prefix.dev/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda + sha256: 6d9ea2f731e284e9316d95fa61869fe7bbba33df7929f82693c121022810f4ad + md5: a77f85f77be52ff59391544bfe73390a + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + purls: [] + size: 85189 + timestamp: 1753484064210 +- conda: https://prefix.dev/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda + sha256: 245c9ee8d688e23661b95e3c6dd7272ca936fabc03d423cdb3cdee1bbcf9f2f2 + md5: c2a01a08fc991620a74b32420e97868a + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib 1.3.2 h25fd6f3_2 + license: Zlib + license_family: Other + purls: [] + size: 95931 + timestamp: 1774072620848 +- conda: https://prefix.dev/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda + sha256: 8b786bb4380fa69a718b08a400040b865bc9207eda337e0a1955717c3c3a9403 + md5: 1726acec19beeed1c764385cd8622405 depends: - - python - - llvmlite >=0.49.0,<0.50.0a0 - - numpy >=1.22.3,<2.6 - - _openmp_mutex >=4.5 - __glibc >=2.17,<3.0.a0 - libgcc >=15 - libstdcxx >=15 - - numpy >=1.23,<3 - - python_abi 3.11.* *_cp311 - constrains: - - tbb >=2021.6.0 - - libopenblas !=0.3.6 - - cuda-version >=11.2 - - cudatoolkit >=11.2 - - scipy >=1.0 - - cuda-python >=11.6 - license: BSD-2-Clause - license_family: BSD - purls: - - pkg:pypi/numba?source=hash-mapping - size: 6286682 - timestamp: 1787145506914 -- conda: https://prefix.dev/conda-forge/osx-arm64/numba-0.67.0-py311hf682900_1.conda - sha256: fd613c23e421aa4b8700308951c90b7c4f5f3b78f85025e0c3af9366fdf5c4b0 - md5: 643ca1646acb686990d5febe0c0e5d63 - depends: - - python - - llvmlite >=0.49.0,<0.50.0a0 - - numpy >=1.22.3,<2.6 - - libcxx >=21 - - __osx >=11.0 - - llvm-openmp >=21.1.8 - - python_abi 3.11.* *_cp311 - - numpy >=1.23,<3 - constrains: - - tbb >=2021.6.0 - - libopenblas >=0.3.18,!=0.3.20 - - cuda-version >=11.2 - - cudatoolkit >=11.2 - - scipy >=1.0 - - cuda-python >=11.6 - license: BSD-2-Clause - license_family: BSD - purls: - - pkg:pypi/numba?source=hash-mapping - size: 6273051 - timestamp: 1787145526945 -- pypi: https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl - name: numpy - version: 2.0.2 - sha256: f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04 - requires_python: '>=3.9' -- pypi: https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl - name: numpy - version: 2.0.2 - sha256: 496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318 - requires_python: '>=3.9' -- conda: https://prefix.dev/conda-forge/linux-64/numpy-2.0.2-py311h71ddf71_1.conda - sha256: a922ec6947ad6953cb011b8f1a44779f6b55d62a14c5bcd25d19a8fb1629da30 - md5: 04ce874aa54fc1d9c735a04e0c6d99c4 + license: Zlib + license_family: Other + purls: [] + size: 123959 + timestamp: 1786736890973 +- conda: https://prefix.dev/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 + md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 depends: - __glibc >=2.17,<3.0.a0 - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - libgcc >=13 - - liblapack >=3.9.0,<4.0a0 - - libstdcxx >=13 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - constrains: - - numpy-base <0a0 + - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/numpy?source=hash-mapping - size: 9148240 - timestamp: 1732314901472 -- conda: https://prefix.dev/conda-forge/osx-arm64/numpy-2.0.2-py311h649a571_1.conda - sha256: 3d4c508041d17007a56f79b593a6d6a69d4f4e2453f1f7ee29ecb48992cc3acc - md5: 417c4c5c4a4693156f5b878cf94bf7a0 + purls: [] + size: 601375 + timestamp: 1764777111296 +- conda: https://prefix.dev/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda + sha256: a362b4f5c96a0bf4def96be1a77317e2730af38915eb9bec85e2a92836501ed7 + md5: b3f0179590f3c0637b7eb5309898f79e depends: - - __osx >=11.0 - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - libcxx >=18 - - liblapack >=3.9.0,<4.0a0 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 + - __unix + - hicolor-icon-theme + - librsvg + license: LGPL-3.0-or-later OR CC-BY-SA-3.0 + license_family: LGPL + purls: [] + size: 631452 + timestamp: 1758743294412 +- conda: https://prefix.dev/conda-forge/noarch/anyio-4.13.0-pyhcf101f3_0.conda + sha256: f09aed24661cd45ba54a43772504f05c0698248734f9ae8cd289d314ac89707e + md5: af2df4b9108808da3dc76710fe50eae2 + depends: + - exceptiongroup >=1.0.2 + - idna >=2.8 + - python >=3.10 + - typing_extensions >=4.5 + - python constrains: - - numpy-base <0a0 - license: BSD-3-Clause - license_family: BSD + - trio >=0.32.0 + - uvloop >=0.22.1 + - winloop >=0.2.3 + license: MIT + license_family: MIT purls: - - pkg:pypi/numpy?source=hash-mapping - size: 6893464 - timestamp: 1732314808608 -- conda: https://prefix.dev/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda - sha256: 3900f9f2dbbf4129cf3ad6acf4e4b6f7101390b53843591c53b00f034343bc4d - md5: 11b3379b191f63139e29c0d19dee24cd + - pkg:pypi/anyio?source=hash-mapping + size: 146764 + timestamp: 1774359453364 +- conda: https://prefix.dev/conda-forge/noarch/backports-1.0-pyhd8ed1ab_5.conda + sha256: e1c3dc8b5aa6e12145423fed262b4754d70fec601339896b9ccf483178f690a6 + md5: 767d508c1a67e02ae8f50e44cacfadb2 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libpng >=1.6.50,<1.7.0a0 - - libstdcxx >=14 - - libtiff >=4.7.1,<4.8.0a0 - - libzlib >=1.3.1,<2.0a0 - license: BSD-2-Clause + - python >=3.9 + license: BSD-3-Clause license_family: BSD purls: [] - size: 355400 - timestamp: 1758489294972 -- conda: https://prefix.dev/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda - sha256: 60aca8b9f94d06b852b296c276b3cf0efba5a6eb9f25feb8708570d3a74f00e4 - md5: 4b5d3a91320976eec71678fad1e3569b + size: 7069 + timestamp: 1733218168786 +- conda: https://prefix.dev/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 + md5: bea46844deb274b2cc2a3a941745fa73 depends: - - __osx >=11.0 - - libcxx >=19 - - libpng >=1.6.55,<1.7.0a0 - - libtiff >=4.7.1,<4.8.0a0 - - libzlib >=1.3.1,<2.0a0 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 319697 - timestamp: 1772625397692 -- conda: https://prefix.dev/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda - sha256: 21c4f6c7f41dc9bec2ea2f9c80440d9a4d45a6f2ac13243e658f10dcf1044146 - md5: 680608784722880fbfe1745067570b00 + - python >=3.10 + - backports + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/backports-tarfile?source=hash-mapping + size: 35739 + timestamp: 1767290467820 +- conda: https://prefix.dev/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 depends: - - __glibc >=2.17,<3.0.a0 - - cyrus-sasl >=2.1.28,<3.0a0 - - krb5 >=1.22.2,<1.23.0a0 - - libgcc >=14 - - libstdcxx >=14 - - openssl >=3.5.6,<4.0a0 - license: OLDAP-2.8 - license_family: BSD + - __unix + license: ISC purls: [] - size: 786149 - timestamp: 1775741359582 -- conda: https://prefix.dev/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda - sha256: c0ef482280e38c71a08ad6d71448194b719630345b0c9c60744a2010e8a8e0cb - md5: da1b85b6a87e141f5140bb9924cecab0 + size: 131039 + timestamp: 1776865545798 +- conda: https://prefix.dev/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 + md5: 929471569c93acefb30282a22060dcd5 depends: - - __glibc >=2.17,<3.0.a0 - - ca-certificates - - libgcc >=14 - license: Apache-2.0 - license_family: Apache - purls: [] - size: 3167099 - timestamp: 1775587756857 -- conda: https://prefix.dev/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda - sha256: c91bf510c130a1ea1b6ff023e28bac0ccaef869446acd805e2016f69ebdc49ea - md5: 25dcccd4f80f1638428613e0d7c9b4e1 + - python >=3.10 + license: ISC + purls: + - pkg:pypi/certifi?source=hash-mapping + size: 135656 + timestamp: 1776866680878 +- conda: https://prefix.dev/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 + md5: 381bd45fb7aa032691f3063aff47e3a1 depends: - - __osx >=11.0 - - ca-certificates - license: Apache-2.0 - license_family: Apache - purls: [] - size: 3106008 - timestamp: 1775587972483 -- conda: https://prefix.dev/conda-forge/linux-64/opusfile-0.12-h3358134_2.conda - sha256: f4df9df880e405e5c856383f869d5b9d434f78fb7c234c9e7b099ab604fb7fc3 - md5: 5931bcae00b98f952696b6bcdd0be34b + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/cfgv?source=hash-mapping + size: 13589 + timestamp: 1763607964133 +- conda: https://prefix.dev/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda + sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 + md5: 2266262ce8a425ecb6523d765f79b303 depends: - - libgcc-ng >=12 - - libogg >=1.3.4,<1.4.0a0 - - libopus >=1.3.1,<2.0a0 - - openssl >=3.0.7,<4.0a0 + - __unix + - python + - python >=3.10 license: BSD-3-Clause license_family: BSD - purls: [] - size: 65901 - timestamp: 1670387479735 -- conda: https://prefix.dev/conda-forge/osx-arm64/opusfile-0.12-h5643135_2.conda - sha256: 108dbee936a8e3c21d2aa5618326343844df8f1fe14067c4dc5a731d7945ecc0 - md5: e34e472ae04beeb642c5e937a2aeeebf + purls: + - pkg:pypi/click?source=hash-mapping + size: 100048 + timestamp: 1777219902525 +- conda: https://prefix.dev/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + sha256: 4c287c2721d8a34c94928be8fe0e9a85754e90189dd4384a31b1806856b50a67 + md5: 61b8078a0905b12529abc622406cb62c depends: - - libogg >=1.3.4,<1.4.0a0 - - libopus >=1.3.1,<2.0a0 - - openssl >=3.0.7,<4.0a0 + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cloudpickle?source=hash-mapping + size: 27353 + timestamp: 1765303462831 +- conda: https://prefix.dev/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + md5: 962b9857ee8e7018c22f2776ffa0b2d7 + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/colorama?source=hash-mapping + size: 27011 + timestamp: 1733218222191 +- conda: https://prefix.dev/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1 + md5: 4c2a8fef270f6c69591889b93f9f55c1 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cycler?source=hash-mapping + size: 14778 + timestamp: 1764466758386 +- conda: https://prefix.dev/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda + sha256: 6d977f0b2fc24fee21a9554389ab83070db341af6d6f09285360b2e09ef8b26e + md5: 003b8ba0a94e2f1e117d0bd46aebc901 + depends: + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/distlib?source=hash-mapping + size: 275642 + timestamp: 1752823081585 +- conda: https://prefix.dev/conda-forge/noarch/editables-0.6-pyhcf101f3_0.conda + sha256: bb826ff403b8195467e7cd5f504bc14767b424dac27bb225508ca2c1852554b2 + md5: 86b177231eecb011fe00e2117dbc3348 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/editables?source=hash-mapping + size: 13160 + timestamp: 1776172429816 +- conda: https://prefix.dev/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 + md5: 8e662bd460bda79b1ea39194e3c4c9ab + depends: + - python >=3.10 + - typing_extensions >=4.6.0 + license: MIT and PSF-2.0 + purls: + - pkg:pypi/exceptiongroup?source=hash-mapping + size: 21333 + timestamp: 1763918099466 +- conda: https://prefix.dev/conda-forge/noarch/farama-notifications-0.0.4-pyhd8ed1ab_0.conda + sha256: 8df190d75bac104c6c2317b13397eed9adfa6889b12405b0288ca2ca86855c06 + md5: 61f63fcf1c2deddeae7a85a516d46c94 + depends: + - python >=3.6 + license: MIT + license_family: MIT + purls: + - pkg:pypi/farama-notifications?source=hash-mapping + size: 8406 + timestamp: 1684258265351 +- conda: https://prefix.dev/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 + md5: 8fa8358d022a3a9bd101384a808044c6 + depends: + - python >=3.10 + license: Unlicense + purls: + - pkg:pypi/filelock?source=hash-mapping + size: 34211 + timestamp: 1776621506566 +- conda: https://prefix.dev/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b + md5: 0c96522c6bdaed4b1566d11387caaf45 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 397370 + timestamp: 1566932522327 +- conda: https://prefix.dev/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c + md5: 34893075a5c9e55cdafac56607368fc6 + license: OFL-1.1 + license_family: Other + purls: [] + size: 96530 + timestamp: 1620479909603 +- conda: https://prefix.dev/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139 + md5: 4d59c254e01d9cde7957100457e2d5fb + license: OFL-1.1 + license_family: Other + purls: [] + size: 700814 + timestamp: 1620479612257 +- conda: https://prefix.dev/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + sha256: 2821ec1dc454bd8b9a31d0ed22a7ce22422c0aef163c59f49dfdf915d0f0ca14 + md5: 49023d73832ef61042f6a237cb2687e7 + license: LicenseRef-Ubuntu-Font-Licence-Version-1.0 + license_family: Other + purls: [] + size: 1620504 + timestamp: 1727511233259 +- conda: https://prefix.dev/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 + md5: fee5683a3f04bd15cbd8318b096a27ab + depends: + - fonts-conda-forge + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 3667 + timestamp: 1566974674465 +- conda: https://prefix.dev/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + sha256: 54eea8469786bc2291cc40bca5f46438d3e062a399e8f53f013b6a9f50e98333 + md5: a7970cd949a077b7cb9696379d338681 + depends: + - font-ttf-ubuntu + - font-ttf-inconsolata + - font-ttf-dejavu-sans-mono + - font-ttf-source-code-pro + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 4059 + timestamp: 1762351264405 +- conda: https://prefix.dev/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda + sha256: 96cac6573fd35ae151f4d6979bab6fbc90cb6b1fb99054ba19eb075da9822fcb + md5: b8993c19b0c32a2f7b66cbb58ca27069 + depends: + - python >=3.10 + - typing_extensions + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/h11?source=hash-mapping + size: 39069 + timestamp: 1767729720872 +- conda: https://prefix.dev/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda + sha256: 84c64443368f84b600bfecc529a1194a3b14c3656ee2e832d15a20e0329b6da3 + md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 + depends: + - python >=3.10 + - hyperframe >=6.1,<7 + - hpack >=4.1,<5 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/h2?source=hash-mapping + size: 95967 + timestamp: 1756364871835 +- conda: https://prefix.dev/conda-forge/noarch/hatch-1.16.5-pyhcf101f3_0.conda + sha256: e298f93e25d98f5b90f231cf9cd6467773fc3fd242a9a0dce2b82fcfa1b38971 + md5: 3191c464a2222e8af63e57926da9315c + depends: + - click >=8.0.6 + - hatchling >=1.27.0 + - httpx >=0.22.0 + - hyperlink >=21.0.0 + - keyring >=23.5.0 + - packaging >=24.2 + - pexpect >=4.8,<5.dev0 + - platformdirs >=2.5.0 + - pyproject_hooks + - python >=3.10 + - rich >=11.2.0 + - shellingham >=1.4.0 + - tomli-w >=1.0 + - tomlkit >=0.11.1 + - userpath >=1.7,<2.dev0 + - uv >=0.5.23 + - virtualenv >=21 + - backports.zstd >=1.0.0 + - python-discovery >=1.1 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/hatch?source=hash-mapping + size: 208420 + timestamp: 1772806610433 +- conda: https://prefix.dev/conda-forge/noarch/hatchling-1.29.0-pyhcf101f3_0.conda + sha256: bb86ff4ca54a2a0f63714766c7653a772c13d34c9e7cfb7be653db2fb806f961 + md5: 9d67ecd4cd5e6a9be36522be95951785 + depends: + - packaging >=24.2 + - pathspec >=0.10.1 + - pluggy >=1.0.0 + - python >=3.10 + - tomli >=1.2.2 + - trove-classifiers + - editables >=0.3 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/hatchling?source=hash-mapping + size: 61052 + timestamp: 1773194193187 +- conda: https://prefix.dev/conda-forge/noarch/hpack-4.1.0-pyhd8ed1ab_0.conda + sha256: 6ad78a180576c706aabeb5b4c8ceb97c0cb25f1e112d76495bff23e3779948ba + md5: 0a802cb9888dd14eeefc611f05c40b6e + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/hpack?source=hash-mapping + size: 30731 + timestamp: 1737618390337 +- conda: https://prefix.dev/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda + sha256: 04d49cb3c42714ce533a8553986e1642d0549a05dc5cc48e0d43ff5be6679a5b + md5: 4f14640d58e2cc0aa0819d9d8ba125bb + depends: + - python >=3.9 + - h11 >=0.16 + - h2 >=3,<5 + - sniffio 1.* + - anyio >=4.0,<5.0 + - certifi + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/httpcore?source=hash-mapping + size: 49483 + timestamp: 1745602916758 +- conda: https://prefix.dev/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + sha256: cd0f1de3697b252df95f98383e9edb1d00386bfdd03fdf607fa42fe5fcb09950 + md5: d6989ead454181f4f9bc987d3dc4e285 + depends: + - anyio + - certifi + - httpcore 1.* + - idna + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/httpx?source=hash-mapping + size: 63082 + timestamp: 1733663449209 +- conda: https://prefix.dev/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda + sha256: 77af6f5fe8b62ca07d09ac60127a30d9069fdc3c68d6b256754d0ffb1f7779f8 + md5: 8e6923fc12f1fe8f8c4e5c9f343256ac + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/hyperframe?source=hash-mapping + size: 17397 + timestamp: 1737618427549 +- conda: https://prefix.dev/conda-forge/noarch/hyperlink-21.0.0-pyh29332c3_1.conda + sha256: 6fc0a91c590b3055bfb7983e6521c7b780ab8b11025058eaf898049ea827d829 + md5: c27acdecaf3c311e5781b81fe02d9641 + depends: + - python >=3.9 + - idna >=2.6 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/hyperlink?source=hash-mapping + size: 74751 + timestamp: 1733319972207 +- conda: https://prefix.dev/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + depends: + - python >=3.10 + - ukkonen + license: MIT + license_family: MIT + purls: + - pkg:pypi/identify?source=hash-mapping + size: 79757 + timestamp: 1776455344188 +- conda: https://prefix.dev/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 + md5: fb7130c190f9b4ec91219840a05ba3ac + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/idna?source=hash-mapping + size: 59038 + timestamp: 1776947141407 +- conda: https://prefix.dev/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 + md5: 080594bf4493e6bae2607e65390c520a + depends: + - python >=3.10 + - zipp >=3.20 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=hash-mapping + size: 34387 + timestamp: 1773931568510 +- conda: https://prefix.dev/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + depends: + - python >=3.10 + - zipp >=3.1.0 + constrains: + - importlib-resources >=7.1.0,<7.1.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/importlib-resources?source=hash-mapping + size: 34809 + timestamp: 1776068839274 +- conda: https://prefix.dev/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 + md5: 9614359868482abba1bd15ce465e3c42 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/iniconfig?source=hash-mapping + size: 13387 + timestamp: 1760831448842 +- conda: https://prefix.dev/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 + md5: d59568bad316413c89831456e691de29 + depends: + - python >=3.10 + - more-itertools + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/jaraco-classes?source=hash-mapping + size: 14831 + timestamp: 1767294269456 +- conda: https://prefix.dev/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + depends: + - python >=3.10 + - backports.tarfile + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/jaraco-context?source=hash-mapping + size: 16222 + timestamp: 1776862415793 +- conda: https://prefix.dev/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda + md5: aa83cc08626bf6b613a3103942be8951 + depends: + - python >=3.10 + - more-itertools + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/jaraco-functools?source=hash-mapping + size: 18744 + timestamp: 1767294193246 +- conda: https://prefix.dev/conda-forge/noarch/jax-jumpy-1.0.0-pyhd8ed1ab_1.conda + sha256: c414b2be28e7d963e55c962caad1a25833d2e415a3d7a16e4f9da9e187dd37b3 + md5: d15bad1eca61880b5e465c4038d7c3f4 + depends: + - numpy >=1.18.0 + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/jax-jumpy?source=hash-mapping + size: 20757 + timestamp: 1734210042598 +- conda: https://prefix.dev/conda-forge/noarch/jeepney-0.9.0-pyhd8ed1ab_0.conda + sha256: 00d37d85ca856431c67c8f6e890251e7cc9e5ef3724a0302b8d4a101f22aa27f + md5: b4b91eb14fbe2f850dd2c5fc20676c0d + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/jeepney?source=hash-mapping + size: 40015 + timestamp: 1740828380668 +- conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda + sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 + md5: c88f9579d08eb4031159f03640714ce3 + depends: + - __osx + - importlib-metadata >=4.11.4 + - importlib_resources + - jaraco.classes + - jaraco.context + - jaraco.functools + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/keyring?source=hash-mapping + size: 37924 + timestamp: 1763320995459 +- conda: https://prefix.dev/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda + sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 + md5: 9eeb0eaf04fa934808d3e070eebbe630 + depends: + - __linux + - importlib-metadata >=4.11.4 + - importlib_resources + - jaraco.classes + - jaraco.context + - jaraco.functools + - jeepney >=0.4.2 + - python >=3.10 + - secretstorage >=3.2 + license: MIT + license_family: MIT + purls: + - pkg:pypi/keyring?source=hash-mapping + size: 37717 + timestamp: 1763320674488 +- conda: https://prefix.dev/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda + sha256: 0c4c35376fe920714390d46e4b8d31c876d65f18e1655899e0763ec25f2a902f + md5: 6d03368f2b2b0a5fb6839df53b2eb5e0 + depends: + - mdurl >=0.1,<1 + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/markdown-it-py?source=hash-mapping + size: 69017 + timestamp: 1778169663339 +- conda: https://prefix.dev/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + md5: 592132998493b3ff25fd7479396e8351 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/mdurl?source=hash-mapping + size: 14465 + timestamp: 1733255681319 +- conda: https://prefix.dev/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 + md5: b874955758a30a37c78b82ea5cf78fdb + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/more-itertools?source=hash-mapping + size: 71254 + timestamp: 1775762492525 +- conda: https://prefix.dev/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + sha256: d09c47c2cf456de5c09fa66d2c3c5035aa1fa228a1983a433c47b876aa16ce90 + md5: 37293a85a0f4f77bbd9cf7aaefc62609 + depends: + - python >=3.9 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/munkres?source=hash-mapping + size: 15851 + timestamp: 1749895533014 +- conda: https://prefix.dev/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee + md5: eb52d14a901e23c39e9e7b4a1a5c015f + depends: + - python >=3.10 + - setuptools + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/nodeenv?source=hash-mapping + size: 40866 + timestamp: 1766261270149 +- conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 + md5: 4c06a92e74452cfa53623a81592e8934 + depends: + - python >=3.8 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/packaging?source=hash-mapping + size: 91574 + timestamp: 1777103621679 +- conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 + md5: 11adc78451c998c0fd162584abfa3559 + depends: + - python >=3.10 + license: MPL-2.0 + license_family: MOZILLA + purls: + - pkg:pypi/pathspec?source=hash-mapping + size: 56559 + timestamp: 1777271601895 +- conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + sha256: 202af1de83b585d36445dc1fda94266697341994d1a3328fabde4989e1b3d07a + md5: d0d408b1f18883a944376da5cf8101ea + depends: + - ptyprocess >=0.5 + - python >=3.9 + license: ISC + purls: + - pkg:pypi/pexpect?source=hash-mapping + size: 53561 + timestamp: 1733302019362 +- conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/platformdirs?source=hash-mapping + size: 25862 + timestamp: 1775741140609 +- conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e + md5: d7585b6550ad04c8c5e21097ada2888e + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/pluggy?source=hash-mapping + size: 25877 + timestamp: 1764896838868 +- conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + depends: + - cfgv >=2.0.0 + - identify >=1.0.0 + - nodeenv >=0.11.1 + - python >=3.10 + - pyyaml >=5.1 + - virtualenv >=20.10.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pre-commit?source=hash-mapping + size: 201606 + timestamp: 1776858157327 +- conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + sha256: a7713dfe30faf17508ec359e0bc7e0983f5d94682492469bd462cdaae9c64d83 + md5: 7d9daffbb8d8e0af0f769dbbcd173a54 + depends: + - python >=3.9 + license: ISC + purls: + - pkg:pypi/ptyprocess?source=hash-mapping + size: 19457 + timestamp: 1733302371990 +- conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 + md5: 12c566707c80111f9799308d9e265aef + depends: + - python >=3.9 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pycparser?source=hash-mapping + size: 110100 + timestamp: 1733195786147 +- conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 + md5: 16c18772b340887160c79a6acc022db0 + depends: + - python >=3.10 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/pygments?source=hash-mapping + size: 893031 + timestamp: 1774796815820 +- conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + sha256: 417fba4783e528ee732afa82999300859b065dc59927344b4859c64aae7182de + md5: 3687cc0b82a8b4c17e1f0eb7e47163d5 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyparsing?source=hash-mapping + size: 110893 + timestamp: 1769003998136 +- conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + sha256: 065ac44591da9abf1ff740feb25929554b920b00d09287a551fcced2c9791092 + md5: d4582021af437c931d7d77ec39007845 + depends: + - python >=3.9 + - tomli >=1.1.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyproject-hooks?source=hash-mapping + size: 15528 + timestamp: 1733710122949 +- conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda + sha256: 8c618e8ca376d73133c9971abe45463a48c9cfb529788d609fd19568764941ba + md5: b27a6cd32160c34682ce6053b04c12c6 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyserial?source=hash-mapping + size: 73910 + timestamp: 1767289527295 +- conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + sha256: 75245ca9d0cbd6d38bb45ec02430189a9d4c21c055c5259739d738a2298d61b3 + md5: 799ed216dc6af62520f32aa39bc1c2bb + depends: + - colorama + - exceptiongroup >=1.0.0rc8 + - iniconfig + - packaging + - pluggy <2,>=1.5 + - python >=3.9 + - tomli >=1 + constrains: + - pytest-faulthandler >=2 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pytest?source=hash-mapping + size: 259195 + timestamp: 1733217599806 +- conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 + md5: 5b8d21249ff20967101ffa321cab24e8 + depends: + - python >=3.9 + - six >=1.5 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/python-dateutil?source=hash-mapping + size: 233310 + timestamp: 1751104122689 +- conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda + sha256: ae70eb1c16970f2317e71dd2dee7d3a41abd26a47298ca8d9163a94b6579517b + md5: 696db6f25e56c0fafdccb0a7426fffb6 + depends: + - python >=3.10 + - filelock >=3.15.4 + - platformdirs <5,>=4.3.6 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/python-discovery?source=hash-mapping + size: 35030 + timestamp: 1778013338579 +- conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda + build_number: 8 + sha256: 7ad76fa396e4bde336872350124c0819032a9e8a0a40590744ff9527b54351c1 + md5: 05e00f3b21e88bb3d658ac700b2ce58c + constrains: + - python 3.10.* *_cpython license: BSD-3-Clause license_family: BSD purls: [] - size: 80128 - timestamp: 1670387790769 -- conda: https://prefix.dev/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 - md5: 4c06a92e74452cfa53623a81592e8934 + size: 6999 + timestamp: 1752805924192 +- conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda + build_number: 8 + sha256: fddf123692aa4b1fc48f0471e346400d9852d96eeed77dbfdd746fa50a8ff894 + md5: 8fcb6b0e2161850556231336dae58358 + constrains: + - python 3.11.* *_cpython + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 7003 + timestamp: 1752805919375 +- conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda + sha256: a941b5e002504e1c9b02ea02180d40186b67d03e8e7d668bf746393c266b3951 + md5: 2e6a922d07244f514863b7e10bf5c923 + depends: + - markdown-it-py >=2.2.0 + - pygments >=2.13.0,<3.0.0 + - python >=3.10 + - typing_extensions >=4.0.0,<5.0.0 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/rich?source=hash-mapping + size: 208480 + timestamp: 1775880677603 +- conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 + md5: 8e194e7b992f99a5015edbd4ebd38efd + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/setuptools?source=hash-mapping + size: 639697 + timestamp: 1773074868565 +- conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/shellingham?source=hash-mapping + size: 15018 + timestamp: 1762858315311 +- conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d + md5: 3339e3b65d58accf4ca4fb8748ab16b3 + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/six?source=hash-mapping + size: 18455 + timestamp: 1753199211006 +- conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda + sha256: 833326122c18887b338262c13365cb146b6702c79d72da74a1c6b8af4c50e162 + md5: 421b7a950e384949ca1b0f04f0751ce0 + depends: + - python >=3.9 + - tornado >=2.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/snakeviz?source=hash-mapping + size: 171545 + timestamp: 1735289409501 +- conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda + sha256: dce518f45e24cd03f401cb0616917773159a210c19d601c5f2d4e0e5879d30ad + md5: 03fe290994c5e4ec17293cfb6bdce520 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/sniffio?source=hash-mapping + size: 15698 + timestamp: 1762941572482 +- conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd + md5: b5325cf06a000c5b14970462ff5e4d58 depends: - - python >=3.8 + - python >=3.10 - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping + size: 21561 + timestamp: 1774492402955 +- conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda + sha256: 304834f2438017921d69f05b3f5a6394b42dc89a90a6128a46acbf8160d377f6 + md5: 32e37e8fe9ef45c637ee38ad51377769 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomli-w?source=hash-mapping + size: 12680 + timestamp: 1736962345843 +- conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda + sha256: 1cd52f9ccb4854c4d731438afe0e833b6b71edaf5ede661152aa98efb3a7cc70 + md5: 42ef10a8f7f5d55a2e267c0d5daa6387 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomlkit?source=hash-mapping + size: 41169 + timestamp: 1778423744478 +- conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda + sha256: b06931edfab2f6bde64fae1e7323216b74389b5a27242bf2b54b401246efb04d + md5: 58ad6f35e45eca7db0fd5da95aafc693 + depends: + - python >=3.10 license: Apache-2.0 - license_family: APACHE + license_family: Apache purls: - - pkg:pypi/packaging?source=hash-mapping - size: 91574 - timestamp: 1777103621679 -- conda: https://prefix.dev/conda-forge/linux-64/pandas-3.0.1-py311h8032f78_0.conda - sha256: 3e58067de2e0b8220cf1323c1fc736028b2a117b7a7173bfe67f7da11094271f - md5: 3ac73c673df24589b5b84d43a4afd235 + - pkg:pypi/trove-classifiers?source=hash-mapping + size: 20076 + timestamp: 1778229720640 +- conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731 + md5: 0caa1af407ecff61170c9437a808404d depends: + - python >=3.10 - python - - numpy >=1.26.0 - - python-dateutil >=2.8.2 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - libstdcxx >=14 - - python_abi 3.11.* *_cp311 - - numpy >=1.23,<3 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/typing-extensions?source=hash-mapping + size: 51692 + timestamp: 1756220668932 +- conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c + md5: ad659d0a2b3e47e38d829aa8cad2d610 + license: LicenseRef-Public-Domain + purls: [] + size: 119135 + timestamp: 1767016325805 +- conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda + sha256: 26e53b42f7fa1127e6115a35b91c20e15f75984648b88f115136f27715d4a440 + md5: 946e3571aaa55e0870fec0dea13de3bf + depends: + - click + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/userpath?source=hash-mapping + size: 14292 + timestamp: 1735925027874 +- conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda + sha256: 8888b4725d4166ab54435ba4b6a24e9f089578301a88f8157d012dd38a88ac43 + md5: dd6a1f3ce9d1cfa8b5b1b32953a80a55 + depends: + - python >=3.10 + - distlib >=0.3.7,<1 + - filelock <4,>=3.24.2 + - importlib-metadata >=6.6 + - platformdirs >=3.9.1,<5 + - python-discovery >=1 + - typing_extensions >=4.13.2 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/virtualenv?source=hash-mapping + size: 5154970 + timestamp: 1777964652524 +- conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca + md5: e1c36c6121a7c9c76f2f148f1e83b983 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/zipp?source=hash-mapping + size: 24461 + timestamp: 1776131454755 +- conda: https://prefix.dev/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda + build_number: 7 + sha256: 7acaa2e0782cad032bdaf756b536874346ac1375745fb250e9bdd6a48a7ab3cd + md5: a44032f282e7d2acdeb1c240308052dd + depends: + - llvm-openmp >=9.0.1 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 8325 + timestamp: 1764092507920 +- conda: https://prefix.dev/conda-forge/osx-arm64/aom-3.9.1-h7bae524_0.conda + sha256: ec238f18ce8140485645252351a0eca9ef4f7a1c568a420f240a585229bc12ef + md5: 7adba36492a1bb22d98ffffe4f6fc6de + depends: + - __osx >=11.0 + - libcxx >=16 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 2235747 + timestamp: 1718551382432 +- conda: https://prefix.dev/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda + sha256: b0747f9b1bc03d1932b4d8c586f39a35ac97e7e72fe6e63f2b2a2472d466f3c1 + md5: 57301986d02d30d6805fdce6c99074ee + depends: + - __osx >=11.0 + - libcxx >=16 + - libglib >=2.80.0,<3.0a0 + - libintl >=0.22.5,<1.0a0 constrains: - - adbc-driver-postgresql >=1.2.0 - - adbc-driver-sqlite >=1.2.0 - - beautifulsoup4 >=4.12.3 - - blosc >=1.21.3 - - bottleneck >=1.4.2 - - fastparquet >=2024.11.0 - - fsspec >=2024.10.0 - - gcsfs >=2024.10.0 - - html5lib >=1.1 - - hypothesis >=6.116.0 - - jinja2 >=3.1.5 - - lxml >=5.3.0 - - matplotlib >=3.9.3 - - numba >=0.60.0 - - numexpr >=2.10.2 - - odfpy >=1.4.1 - - openpyxl >=3.1.5 - - psycopg2 >=2.9.10 - - pyarrow >=13.0.0 - - pyiceberg >=0.8.1 - - pymysql >=1.1.1 - - pyqt5 >=5.15.9 - - pyreadstat >=1.2.8 - - pytables >=3.10.1 - - pytest >=8.3.4 - - pytest-xdist >=3.6.1 - - python-calamine >=0.3.0 - - pytz >=2024.2 - - pyxlsb >=1.0.10 - - qtpy >=2.4.2 - - scipy >=1.14.1 - - s3fs >=2024.10.0 - - sqlalchemy >=2.0.36 - - tabulate >=0.9.0 - - xarray >=2024.10.0 - - xlrd >=2.0.1 - - xlsxwriter >=3.2.0 - - zstandard >=0.23.0 + - atk-1.0 2.38.0 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 347530 + timestamp: 1713896411580 +- conda: https://prefix.dev/conda-forge/osx-arm64/backports.zstd-1.4.0-py311h36d4fbb_0.conda + sha256: 2e6399a3663e7e20134a208cd09befc44ce1e9efe94d1d36d8911db04f186270 + md5: 3ee7e8ae532366221658b80baee36dc0 + depends: + - python + - __osx >=11.0 + - python_abi 3.11.* *_cp311 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-3-Clause AND MIT AND EPL-2.0 + purls: + - pkg:pypi/backports-zstd?source=hash-mapping + size: 244743 + timestamp: 1777848723707 +- conda: https://prefix.dev/conda-forge/osx-arm64/brotli-1.2.0-hf00d406_3.conda + sha256: 7050e1b11876219bd0df375ef3d83fd00f94fb4e13c1ffb21dede0c506893079 + md5: aa7df8174ee3b34a5ad8a3160429db68 + depends: + - __osx >=11.0 + - brotli-bin 1.2.0 he4a93e4_3 + - libbrotlidec 1.2.0 h5295a6a_3 + - libbrotlienc 1.2.0 h2ddc9cb_3 + license: MIT + license_family: MIT + purls: [] + size: 20767 + timestamp: 1786622887445 +- conda: https://prefix.dev/conda-forge/osx-arm64/brotli-bin-1.2.0-he4a93e4_3.conda + sha256: 1e92cea587c2eaab169e45dae01c149b9889a8249eda296b8b6db39aee708531 + md5: d9de6c0ad7e008afdf62fb2ffd450b4a + depends: + - __osx >=11.0 + - libbrotlidec 1.2.0 h5295a6a_3 + - libbrotlienc 1.2.0 h2ddc9cb_3 + license: MIT + license_family: MIT + purls: [] + size: 18962 + timestamp: 1786622878369 +- conda: https://prefix.dev/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda + sha256: 540fe54be35fac0c17feefbdc3e29725cce05d7367ffedfaaa1bdda234b019df + md5: 620b85a3f45526a8bc4d23fd78fc22f0 + depends: + - __osx >=11.0 + license: bzip2-1.0.6 + license_family: BSD + purls: [] + size: 124834 + timestamp: 1771350416561 +- conda: https://prefix.dev/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda + sha256: 2995f2aed4e53725e5efbc28199b46bf311c3cab2648fc4f10c2227d6d5fa196 + md5: bcb3cba70cf1eec964a03b4ba7775f01 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: [] + size: 180327 + timestamp: 1765215064054 +- conda: https://prefix.dev/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda + sha256: cde9b79ee206fe3ba6ca2dc5906593fb7a1350515f85b2a1135a4ce8ec1539e3 + md5: 36200ecfbbfbcb82063c87725434161f + depends: + - __osx >=11.0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.1,<79.0a0 + - libcxx >=19 + - libexpat >=2.7.3,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 + - libglib >=2.86.3,<3.0a0 + - libpng >=1.6.53,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + - pixman >=0.46.4,<1.0a0 + license: LGPL-2.1-only or MPL-1.1 + purls: [] + size: 900035 + timestamp: 1766416416791 +- conda: https://prefix.dev/conda-forge/osx-arm64/cffi-2.0.0-py311hd10dc20_1.conda + sha256: 1ffde698463d6e7ed571bdb85cb17bfc1d3a107c026d20047995512dcc2749ec + md5: 4d7f6780e36f18e7601811dddf3bbec5 + depends: + - __osx >=11.0 + - libffi >=3.5.2,<3.6.0a0 + - pycparser + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: MIT + license_family: MIT + purls: + - pkg:pypi/cffi?source=hash-mapping + size: 294848 + timestamp: 1761203196617 +- conda: https://prefix.dev/conda-forge/osx-arm64/cmake-3.26.4-hc0af03a_0.conda + sha256: cba596b6bba58e347bd8be51fce82583f16c5707f6c98b22a7e7ba1ecdb09783 + md5: 84c170713e88c74f45fd87ce2a065cd3 + depends: + - bzip2 >=1.0.8,<2.0a0 + - expat + - libcurl >=8.1.0,<9.0a0 + - libcxx >=15.0.7 + - libexpat >=2.5.0,<3.0a0 + - libuv + - libzlib >=1.2.13,<2.0.0a0 + - ncurses >=6.3,<7.0a0 + - rhash <=1.4.3 + - xz >=5.2.6,<6.0a0 + - zlib + - zstd >=1.5.2,<1.6.0a0 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/pandas?source=hash-mapping - size: 15143263 - timestamp: 1771408984246 -- conda: https://prefix.dev/conda-forge/osx-arm64/pandas-3.0.1-py311h4a068b9_0.conda - sha256: 1a0f57d3c5fb08e97c8a92f560e1ce011f4ab5a1185eacb60e83c00458684dc4 - md5: e853dd807ee17d7d4f6c3c57b29456ac + purls: [] + size: 13748747 + timestamp: 1684461655168 +- conda: https://prefix.dev/conda-forge/osx-arm64/contourpy-1.3.3-py311h7d85929_4.conda + sha256: 57b2c28cbb45e7dacb565541483d802a15c6beff5ccdabba19784a526191f4d3 + md5: bd91dd35d73638e5c0f520a18850f6ba depends: + - numpy >=1.25 - python - - numpy >=1.26.0 - - python-dateutil >=2.8.2 + - python 3.11.* *_cpython - __osx >=11.0 - libcxx >=19 - - python 3.11.* *_cpython - - numpy >=1.23,<3 - python_abi 3.11.* *_cp311 - constrains: - - adbc-driver-postgresql >=1.2.0 - - adbc-driver-sqlite >=1.2.0 - - beautifulsoup4 >=4.12.3 - - blosc >=1.21.3 - - bottleneck >=1.4.2 - - fastparquet >=2024.11.0 - - fsspec >=2024.10.0 - - gcsfs >=2024.10.0 - - html5lib >=1.1 - - hypothesis >=6.116.0 - - jinja2 >=3.1.5 - - lxml >=5.3.0 - - matplotlib >=3.9.3 - - numba >=0.60.0 - - numexpr >=2.10.2 - - odfpy >=1.4.1 - - openpyxl >=3.1.5 - - psycopg2 >=2.9.10 - - pyarrow >=13.0.0 - - pyiceberg >=0.8.1 - - pymysql >=1.1.1 - - pyqt5 >=5.15.9 - - pyreadstat >=1.2.8 - - pytables >=3.10.1 - - pytest >=8.3.4 - - pytest-xdist >=3.6.1 - - python-calamine >=0.3.0 - - pytz >=2024.2 - - pyxlsb >=1.0.10 - - qtpy >=2.4.2 - - scipy >=1.14.1 - - s3fs >=2024.10.0 - - sqlalchemy >=2.0.36 - - tabulate >=0.9.0 - - xarray >=2024.10.0 - - xlrd >=2.0.1 - - xlsxwriter >=3.2.0 - - zstandard >=0.23.0 license: BSD-3-Clause license_family: BSD purls: - - pkg:pypi/pandas?source=hash-mapping - size: 14295353 - timestamp: 1771409101672 -- conda: https://prefix.dev/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda - sha256: 3613774ad27e48503a3a6a9d72017087ea70f1426f6e5541dbdb59a3b626eaaf - md5: 79f71230c069a287efe3a8614069ddf1 + - pkg:pypi/contourpy?source=hash-mapping + size: 286095 + timestamp: 1769156091585 +- conda: https://prefix.dev/conda-forge/osx-arm64/dav1d-1.2.1-hb547adb_0.conda + sha256: 93e077b880a85baec8227e8c72199220c7f87849ad32d02c14fb3807368260b8 + md5: 5a74cdee497e6b65173e10d94582fae6 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 316394 + timestamp: 1685695959391 +- conda: https://prefix.dev/conda-forge/osx-arm64/dbus-1.16.2-h3ff7a7c_1.conda + sha256: a8207751ed261764061866880da38e4d3063e167178bfe85b6db9501432462ba + md5: 5a3506971d2d53023c1c4450e908a8da depends: - - __glibc >=2.17,<3.0.a0 - - cairo >=1.18.4,<2.0a0 - - fontconfig >=2.15.0,<3.0a0 - - fonts-conda-ecosystem - - fribidi >=1.0.10,<2.0a0 - - harfbuzz >=11.0.1 - - libexpat >=2.7.0,<3.0a0 - - libfreetype >=2.13.3 - - libfreetype6 >=2.13.3 - - libgcc >=13 - - libglib >=2.84.2,<3.0a0 - - libpng >=1.6.49,<1.7.0a0 + - libcxx >=19 + - __osx >=11.0 + - libglib >=2.86.2,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - libexpat >=2.7.3,<3.0a0 + license: AFL-2.1 OR GPL-2.0-or-later + purls: [] + size: 393811 + timestamp: 1764536084131 +- conda: https://prefix.dev/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda + sha256: ba685b87529c95a4bf9de140a33d703d57dc46b036e9586ed26890de65c1c0d5 + md5: 3b87dabebe54c6d66a07b97b53ac5874 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: [] + size: 296347 + timestamp: 1758743805063 +- conda: https://prefix.dev/conda-forge/osx-arm64/expat-2.8.0-hf6b4638_0.conda + sha256: 9f8657c32bcff353b218b1bd7369de34c0534dc5a461630b296265e65e94e2d8 + md5: 90f3b6fa818b07e9402d5ee89f3892d5 + depends: + - __osx >=11.0 + - libexpat 2.8.0 hf6b4638_0 + license: MIT + license_family: MIT + purls: [] + size: 135334 + timestamp: 1777846191235 +- conda: https://prefix.dev/conda-forge/osx-arm64/fluidsynth-2.5.4-h985f16e_0.conda + sha256: 6fab2acb6b1c7ba0fc06c3d4cefa552c3da4c3d6a79dcdd2158eea96931c3929 + md5: 1f716f3ba6477330807ed061637048c7 + depends: + - __osx >=11.0 + - libcxx >=19 + - libglib >=2.86.4,<3.0a0 + - libsndfile >=1.2.2,<1.3.0a0 + - llvm-openmp >=19.1.7 + - portaudio >=19.7.0,<19.8.0a0 + - readline >=8.3,<9.0a0 + - sdl2 >=2.32.56,<3.0a0 + license: GPL-2.0-or-later + license_family: LGPL + purls: [] + size: 291966 + timestamp: 1776634889426 +- conda: https://prefix.dev/conda-forge/osx-arm64/fontconfig-2.17.1-h2b252f5_0.conda + sha256: 851e9c778bfc54645dcab7038c0383445cbebf16f6bb2d3f62ce422b1605385a + md5: d06ae1a11b46cc4c74177ecd28de7c7a + depends: + - __osx >=11.0 + - libexpat >=2.7.4,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 - libzlib >=1.3.1,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 237308 + timestamp: 1771382999247 +- conda: https://prefix.dev/conda-forge/osx-arm64/fonttools-4.63.0-py311hc290fe0_0.conda + sha256: e339446253b5aec4342526334cb2575a20beaf15478469d9baa3c5a11c7aa498 + md5: 23ee082b5c5dc73c19dc0b6451d35079 + depends: + - __osx >=11.0 + - brotli + - munkres + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - unicodedata2 >=15.1.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/fonttools?source=hash-mapping + size: 2948507 + timestamp: 1778771011007 +- conda: https://prefix.dev/conda-forge/osx-arm64/freetype-2.14.3-hce30654_0.conda + sha256: 5952bd9db12207a18a112e8924aa2ce8c2f9d57b62584d58a97d2f6afe1ea324 + md5: 6dcc75ba2e04c555e881b72793d3282f + depends: + - libfreetype 2.14.3 hce30654_0 + - libfreetype6 2.14.3 hdfa99f5_0 + license: GPL-2.0-only OR FTL + purls: [] + size: 173313 + timestamp: 1774298702053 +- conda: https://prefix.dev/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda + sha256: d856dc6744ecfba78c5f7df3378f03a75c911aadac803fa2b41a583667b4b600 + md5: 04bdce8d93a4ed181d1d726163c2d447 + depends: + - __osx >=11.0 license: LGPL-2.1-or-later purls: [] - size: 455420 - timestamp: 1751292466873 -- conda: https://prefix.dev/conda-forge/osx-arm64/pango-1.56.4-h875632e_0.conda - sha256: 705484ad60adee86cab1aad3d2d8def03a699ece438c864e8ac995f6f66401a6 - md5: 7d57f8b4b7acfc75c777bc231f0d31be + size: 59391 + timestamp: 1757438897523 +- conda: https://prefix.dev/conda-forge/osx-arm64/gdk-pixbuf-2.44.6-h4e57454_0.conda + sha256: 07cbba4e12430de35ea608eb3006cf1f7f63832c4f89a081cd6f3872944c1aa6 + md5: e67ebd2f639f46e52af8531622fa6051 + depends: + - __osx >=11.0 + - libglib >=2.86.4,<3.0a0 + - libintl >=0.25.1,<1.0a0 + - libjpeg-turbo >=3.1.2,<4.0a0 + - liblzma >=5.8.2,<6.0a0 + - libpng >=1.6.56,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + purls: [] + size: 548309 + timestamp: 1774986047281 +- conda: https://prefix.dev/conda-forge/osx-arm64/glib-tools-2.88.3-h5f197ff_0.conda + sha256: 672b06a290ae9bd4443f9315334f2dbb6d0ba239b3a1f2ea40fd66321e7a3ac6 + md5: 607824e2f42f49049c999432385832e3 depends: + - libglib ==2.88.3 ha08bb59_0 + - libffi - __osx >=11.0 - - cairo >=1.18.4,<2.0a0 - - fontconfig >=2.15.0,<3.0a0 - - fonts-conda-ecosystem - - fribidi >=1.0.10,<2.0a0 - - harfbuzz >=11.0.1 - - libexpat >=2.7.0,<3.0a0 - - libfreetype >=2.13.3 - - libfreetype6 >=2.13.3 - - libglib >=2.84.2,<3.0a0 - - libpng >=1.6.49,<1.7.0a0 - - libzlib >=1.3.1,<2.0a0 + - libintl >=0.25.1,<1.0a0 license: LGPL-2.1-or-later purls: [] - size: 426931 - timestamp: 1751292636271 -- conda: https://prefix.dev/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda - sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 - md5: 11adc78451c998c0fd162584abfa3559 + size: 205078 + timestamp: 1785442168180 +- conda: https://prefix.dev/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda + sha256: 471f34a187fdb4f2df33e26f2e471b16c239a5b277903f643d9c3a8c9a9f44ec + md5: 0c7b78d9ffff4f5a6ca28d346f734d8f depends: - - python >=3.10 - license: MPL-2.0 - license_family: MOZILLA - purls: - - pkg:pypi/pathspec?source=hash-mapping - size: 56559 - timestamp: 1777271601895 -- conda: https://prefix.dev/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda - sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff - md5: 7a3bff861a6583f1889021facefc08b1 + - libcxx >=19 + - __osx >=11.0 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 86493 + timestamp: 1786118637573 +- conda: https://prefix.dev/conda-forge/osx-arm64/graphviz-13.1.2-hcd33d8b_0.conda + sha256: f25e1828d02ebd78214966f483cfca5ac6a7b18824369c748d8cda99c66ff588 + md5: 81ab85a5a8481667660c7ce6e84bd681 depends: - - __glibc >=2.17,<3.0.a0 - - bzip2 >=1.0.8,<2.0a0 - - libgcc >=14 + - __osx >=11.0 + - adwaita-icon-theme + - cairo >=1.18.4,<2.0a0 + - fonts-conda-ecosystem + - gdk-pixbuf >=2.42.12,<3.0a0 + - gtk3 >=3.24.43,<4.0a0 + - gts >=0.7.6,<0.8.0a0 + - libcxx >=19 + - libexpat >=2.7.1,<3.0a0 + - libgd >=2.3.3,<2.4.0a0 + - libglib >=2.84.3,<3.0a0 + - librsvg >=2.58.4,<3.0a0 + - libwebp-base >=1.6.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - license: BSD-3-Clause - license_family: BSD + - pango >=1.56.4,<2.0a0 + license: EPL-1.0 + license_family: Other purls: [] - size: 1222481 - timestamp: 1763655398280 -- conda: https://prefix.dev/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda - sha256: 5e2e443f796f2fd92adf7978286a525fb768c34e12b1ee9ded4000a41b2894ba - md5: 9b4190c4055435ca3502070186eba53a + size: 2201370 + timestamp: 1754732518951 +- conda: https://prefix.dev/conda-forge/osx-arm64/gtk3-3.24.43-h5febe37_6.conda + sha256: bd66a3325bf3ce63ada3bf12eaafcfe036698741ee4bb595e83e5fdd3dba9f3d + md5: a99f96906158ebae5e3c0904bcd45145 depends: - __osx >=11.0 - - bzip2 >=1.0.8,<2.0a0 + - atk-1.0 >=2.38.0 + - cairo >=1.18.4,<2.0a0 + - epoxy >=1.5.10,<1.6.0a0 + - fribidi >=1.0.16,<2.0a0 + - gdk-pixbuf >=2.44.4,<3.0a0 + - glib-tools + - harfbuzz >=11.5.1 + - hicolor-icon-theme + - libexpat >=2.7.1,<3.0a0 + - libglib >=2.86.0,<3.0a0 + - libintl >=0.25.1,<1.0a0 + - liblzma >=5.8.1,<6.0a0 - libzlib >=1.3.1,<2.0a0 - license: BSD-3-Clause - license_family: BSD + - pango >=1.56.4,<2.0a0 + license: LGPL-2.0-or-later + license_family: LGPL purls: [] - size: 850231 - timestamp: 1763655726735 -- conda: https://prefix.dev/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda - sha256: 202af1de83b585d36445dc1fda94266697341994d1a3328fabde4989e1b3d07a - md5: d0d408b1f18883a944376da5cf8101ea - depends: - - ptyprocess >=0.5 - - python >=3.9 - license: ISC - purls: - - pkg:pypi/pexpect?source=hash-mapping - size: 53561 - timestamp: 1733302019362 -- conda: https://prefix.dev/conda-forge/linux-64/pillow-12.3.0-py311hf88fc01_0.conda - sha256: fc8a6dbcf1f367cc33ae6d505370b8d9d51ca5eae9b53bf1517307f863300d27 - md5: 9782d37ef50862d2c8a9ba58c1725754 + size: 4768791 + timestamp: 1761328318680 +- conda: https://prefix.dev/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda + sha256: e0f8c7bc1b9ea62ded78ffa848e37771eeaaaf55b3146580513c7266862043ba + md5: 21b4dd3098f63a74cf2aa9159cbef57d depends: - - python - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - openjpeg >=2.5.4,<3.0a0 - - lcms2 >=2.19.1,<3.0a0 - - libxcb >=1.17.0,<2.0a0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - tk >=8.6.13,<8.7.0a0 - - libjpeg-turbo >=3.1.4.1,<4.0a0 - - libwebp-base >=1.6.0,<2.0a0 - - python_abi 3.11.* *_cp311 - - libtiff >=4.7.1,<4.8.0a0 - - zlib-ng >=2.3.3,<2.4.0a0 - license: HPND - purls: - - pkg:pypi/pillow?source=hash-mapping - size: 1081155 - timestamp: 1782912080163 -- conda: https://prefix.dev/conda-forge/osx-arm64/pillow-12.3.0-py311hd37aea2_0.conda - sha256: 3c680e002d0aadf9e21b6ee50929d8fec6ced9234b1340a027255b4518e6e49f - md5: 26ba3b773222fada6f89baf4846190e3 + - libcxx >=15.0.7 + - libglib >=2.76.3,<3.0a0 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 304331 + timestamp: 1686545503242 +- conda: https://prefix.dev/conda-forge/osx-arm64/gymnasium-1.3.0-np2py311h56d0776_0.conda + sha256: ab03d30592506e1dfe9e6fc30cddea577dd42a7eb4b6da8a80de543928e2e6fd + md5: d64237fee1a064db6f7c53090a6844da depends: - python - - python 3.11.* *_cpython - - __osx >=11.0 - - openjpeg >=2.5.4,<3.0a0 - - libfreetype >=2.14.3 - - libfreetype6 >=2.14.3 - - libjpeg-turbo >=3.1.4.1,<4.0a0 - - zlib-ng >=2.3.3,<2.4.0a0 + - cloudpickle >=1.2.0 + - farama-notifications + - jax-jumpy >=1.0.0 + - typing_extensions >=4.3.0 - python_abi 3.11.* *_cp311 - - libtiff >=4.7.1,<4.8.0a0 - - libxcb >=1.17.0,<2.0a0 - - tk >=8.6.13,<8.7.0a0 - - lcms2 >=2.19.1,<3.0a0 - - libwebp-base >=1.6.0,<2.0a0 - license: HPND + - numpy >=1.23,<3 + license: MIT + license_family: MIT purls: - - pkg:pypi/pillow?source=hash-mapping - size: 993213 - timestamp: 1782912213683 -- conda: https://prefix.dev/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda - sha256: 43d37bc9ca3b257c5dd7bf76a8426addbdec381f6786ff441dc90b1a49143b6a - md5: c01af13bdc553d1a8fbfff6e8db075f0 + - pkg:pypi/gymnasium?source=hash-mapping + size: 1138451 + timestamp: 1777204698446 +- conda: https://prefix.dev/conda-forge/osx-arm64/harfbuzz-14.3.1-hce30654_0.conda + sha256: 1120c57b917fb0bb8fef770d56f308564c94daea0eb29a643c9f5cf73195de78 + md5: 4fb57d98ef4b5f335d96d3ab0f25d6ea depends: - - libgcc >=14 - - libstdcxx >=14 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 + - libharfbuzz-devel 14.3.1 hcda0f7c_0 license: MIT license_family: MIT purls: [] - size: 450960 - timestamp: 1754665235234 -- conda: https://prefix.dev/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda - sha256: 29c9b08a9b8b7810f9d4f159aecfd205fce051633169040005c0b7efad4bc718 - md5: 17c3d745db6ea72ae2fce17e7338547f + size: 11045 + timestamp: 1786970975481 +- conda: https://prefix.dev/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda + sha256: 46a4958f2f916c5938f2a6dc0709f78b175ece42f601d79a04e0276d55d25d07 + md5: cfb39109ac5fa8601eb595d66d5bf156 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + size: 17616 + timestamp: 1771539622983 +- conda: https://prefix.dev/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda + sha256: 6cdb5dee54c72e56ab189fb3ad33cb28533553d42590e7e831160248f4416a43 + md5: a5efc0b42bb8b42e97d0a29ae3e3c187 depends: - __osx >=11.0 - - libcxx >=19 license: MIT license_family: MIT purls: [] - size: 248045 - timestamp: 1754665282033 -- conda: https://prefix.dev/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda - sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 - md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 - depends: - - python >=3.10 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/platformdirs?source=hash-mapping - size: 25862 - timestamp: 1775741140609 -- conda: https://prefix.dev/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e - md5: d7585b6550ad04c8c5e21097ada2888e + size: 14070242 + timestamp: 1786545847761 +- conda: https://prefix.dev/conda-forge/osx-arm64/kiwisolver-1.5.0-py311h7d85929_0.conda + sha256: bad01811dae8d727a7ff5a271c8304be495e7e594dfddb9f1d576e41ba7c1a76 + md5: 9b4b32f37ebf95463c38636ae2f2ec56 depends: - - python >=3.9 - python - license: MIT - license_family: MIT + - __osx >=11.0 + - python 3.11.* *_cpython + - libcxx >=19 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD purls: - - pkg:pypi/pluggy?source=hash-mapping - size: 25877 - timestamp: 1764896838868 -- conda: https://prefix.dev/conda-forge/linux-64/portaudio-19.7.0-hf4617a5_0.conda - sha256: 3259d2bf63d0c889c516511c8fa73214791ca30baeeee0962eee8b97d17cd1c6 - md5: 053455c094c711e9aa77cf5023cf2bc3 - depends: - - __glibc >=2.17,<3.0.a0 - - alsa-lib >=1.2.12,<1.3.0a0 - - libgcc >=13 - - libstdcxx >=13 - license: MIT - license_family: MIT - purls: [] - size: 77342 - timestamp: 1730364040048 -- conda: https://prefix.dev/conda-forge/osx-arm64/portaudio-19.7.0-h5833ebf_0.conda - sha256: 3d86803ade1ff3fd29ea1b61ce2e5ad65af0966d795ab8a7a2685fee75cf0f82 - md5: fb72bb70cfea298990d5e1a12317047c + - pkg:pypi/kiwisolver?source=hash-mapping + size: 66903 + timestamp: 1773067313219 +- conda: https://prefix.dev/conda-forge/osx-arm64/krb5-1.22.2-h385eeb1_0.conda + sha256: c0a0bf028fe7f3defcdcaa464e536cf1b202d07451e18ad83fdd169d15bef6ed + md5: e446e1822f4da8e5080a9de93474184d depends: - __osx >=11.0 - - libcxx >=17 + - libcxx >=19 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - openssl >=3.5.5,<4.0a0 license: MIT license_family: MIT purls: [] - size: 58138 - timestamp: 1730364270871 -- conda: https://prefix.dev/conda-forge/linux-64/portmidi-2.0.8-h3cb78e3_0.conda - sha256: 13b1f300f609d386d7aec2e31c4ab2fd35c0ed6a2b28ec89605db5b4b044514b - md5: 2333d6737b6fd5c6a70977f8ec1bf110 + size: 1160828 + timestamp: 1769770119811 +- conda: https://prefix.dev/conda-forge/osx-arm64/lame-3.100-h1a8c8d9_1003.tar.bz2 + sha256: f40ce7324b2cf5338b766d4cdb8e0453e4156a4f83c2f31bbfff750785de304c + md5: bff0e851d66725f78dc2fd8b032ddb7e + license: LGPL-2.0-only + license_family: LGPL + purls: [] + size: 528805 + timestamp: 1664996399305 +- conda: https://prefix.dev/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda + sha256: ccb5598fad3694e79bf54f0eb812e3b3c3dd63d1497e631f5978800eadb9bcc4 + md5: d2f2c7c10e2957647d45589b7701a453 depends: - - __glibc >=2.17,<3.0.a0 - - alsa-lib >=1.2.14,<1.3.0a0 - - libgcc >=14 - - libstdcxx >=14 + - __osx >=11.0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 license: MIT license_family: MIT purls: [] - size: 44178 - timestamp: 1764706159843 -- conda: https://prefix.dev/conda-forge/osx-arm64/portmidi-2.0.8-haf25636_0.conda - sha256: 2a1fb2c2507a3b88ac68c4dac435a836be365446e66e995749d2188456fb4262 - md5: 2544b03efb37c9476f3ab4e993c224d1 + size: 213747 + timestamp: 1780212240694 +- conda: https://prefix.dev/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda + sha256: 66e5ffd301a44da696f3efc2f25d6d94f42a9adc0db06c44ad753ab844148c51 + md5: 095e5749868adab9cae42d4b460e5443 depends: - __osx >=11.0 - libcxx >=19 - license: MIT - license_family: MIT + license: Apache-2.0 + license_family: Apache purls: [] - size: 41391 - timestamp: 1764706738148 -- conda: https://prefix.dev/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda - sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b - md5: 7859736b4f8ebe6c8481bf48d91c9a1e - depends: - - cfgv >=2.0.0 - - identify >=1.0.0 - - nodeenv >=0.11.1 - - python >=3.10 - - pyyaml >=5.1 - - virtualenv >=20.10.0 - license: MIT - license_family: MIT - purls: - - pkg:pypi/pre-commit?source=hash-mapping - size: 201606 - timestamp: 1776858157327 -- conda: https://prefix.dev/conda-forge/linux-64/protobuf-3.20.2-py311ha362b79_1.conda - sha256: b5927c5e5d3d2bee29e87cfee3e45781e6f6fd663e890389726cd513ef746177 - md5: 9d64275197aab7121cd9318b593a21bd + size: 164222 + timestamp: 1773114244984 +- conda: https://prefix.dev/conda-forge/osx-arm64/libavif16-1.4.1-hfce71f6_0.conda + sha256: 09e31e51026a3b74d947ba4b30a68dd99013aeef2860bcb03565bf43cad18da6 + md5: 2df04ee54a2ce2d34cf375eb02a63725 depends: - - libgcc-ng >=12 - - libprotobuf 3.20.2.* - - libprotobuf >=3.20.2,<3.21.0a0 - - libstdcxx-ng >=12 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - - setuptools - - six - license: BSD-3-Clause + - __osx >=11.0 + - aom >=3.9.1,<3.10.0a0 + - dav1d >=1.2.1,<1.2.2.0a0 + - rav1e >=0.8.1,<0.9.0a0 + - svt-av1 >=4.0.1,<4.0.2.0a0 + license: BSD-2-Clause license_family: BSD - purls: - - pkg:pypi/protobuf?source=hash-mapping - size: 368989 - timestamp: 1669119100095 -- conda: https://prefix.dev/conda-forge/osx-arm64/protobuf-3.20.2-py311ha397e9f_1.conda - sha256: 38ea7c727a352ae38199c9b87b5b5636cd6bb62de13491788d803e69611776da - md5: cfa15b242f40e62b78281a3b85b07eec + purls: [] + size: 118959 + timestamp: 1774043016600 +- conda: https://prefix.dev/conda-forge/osx-arm64/libblas-3.11.0-6_h51639a9_openblas.conda + build_number: 6 + sha256: 979227fc03628925037ab2dfda008eb7b5592644d9c2c21dd285cefe8c42553d + md5: e551103471911260488a02155cef9c94 depends: - - libcxx >=14.0.6 - - libprotobuf 3.20.2.* - - libprotobuf >=3.20.2,<3.21.0a0 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - - setuptools - - six + - libopenblas >=0.3.32,<0.3.33.0a0 + - libopenblas >=0.3.32,<1.0a0 + constrains: + - liblapacke 3.11.0 6*_openblas + - liblapack 3.11.0 6*_openblas + - blas 2.306 openblas + - libcblas 3.11.0 6*_openblas + - mkl <2026 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/protobuf?source=hash-mapping - size: 348201 - timestamp: 1669119662437 -- conda: https://prefix.dev/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda - sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 - md5: b3c17d95b5a10c6e64a21fa17573e70e + purls: [] + size: 18859 + timestamp: 1774504387211 +- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlicommon-1.2.0-h1dcdb26_3.conda + sha256: 5e62b856b2e77ce98db44133bacab1281b42c1040dcbd69dbacfb80890cff5b0 + md5: b457450ba3f27c4749783c0204bd17b0 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 8252 - timestamp: 1726802366959 -- conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-h84a0fba_1003.conda - sha256: 1c2338b9b0486af86883b9593d2f3e2845bbf216ea453dfe5d9a228e8dbe4057 - md5: d4852e6054b74645cf49ca10f6349191 + size: 80027 + timestamp: 1786622846050 +- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlidec-1.2.0-h5295a6a_3.conda + sha256: 510c9fce0d9ffcf41741dd96fc05db381672109d5665ef002c2e58f0d4ca0118 + md5: e07a99c6fdd984f4d588060f2f936bf4 depends: - __osx >=11.0 + - libbrotlicommon 1.2.0 h1dcdb26_3 license: MIT license_family: MIT purls: [] - size: 9238 - timestamp: 1786068031100 -- conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda - sha256: 8ed65e17fbb0ca944bfb8093b60086e3f9dd678c3448b5de212017394c247ee3 - md5: 415816daf82e0b23a736a069a75e9da7 + size: 29935 + timestamp: 1786622857695 +- conda: https://prefix.dev/conda-forge/osx-arm64/libbrotlienc-1.2.0-h2ddc9cb_3.conda + sha256: eac412417eee2e93c62e9d53559f1f9c14f40b6c41e2c432af8b517596898dd1 + md5: 954c78a9f591bfb12c79beaff7338ec8 depends: - __osx >=11.0 + - libbrotlicommon 1.2.0 h1dcdb26_3 license: MIT license_family: MIT purls: [] - size: 8381 - timestamp: 1726802424786 -- conda: https://prefix.dev/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda - sha256: a7713dfe30faf17508ec359e0bc7e0983f5d94682492469bd462cdaae9c64d83 - md5: 7d9daffbb8d8e0af0f769dbbcd173a54 - depends: - - python >=3.9 - license: ISC - purls: - - pkg:pypi/ptyprocess?source=hash-mapping - size: 19457 - timestamp: 1733302371990 -- conda: https://prefix.dev/conda-forge/linux-64/pulseaudio-client-17.0-h9a6aba3_3.conda - sha256: 0a0858c59805d627d02bdceee965dd84fde0aceab03a2f984325eec08d822096 - md5: b8ea447fdf62e3597cb8d2fae4eb1a90 + size: 295650 + timestamp: 1786622868044 +- conda: https://prefix.dev/conda-forge/osx-arm64/libcblas-3.11.0-6_hb0561ab_openblas.conda + build_number: 6 + sha256: 2e6b3e9b1ab672133b70fc6730e42290e952793f132cb5e72eee22835463eba0 + md5: 805c6d31c5621fd75e53dfcf21fb243a depends: - - __glibc >=2.17,<3.0.a0 - - dbus >=1.16.2,<2.0a0 - - libgcc >=14 - - libglib >=2.86.1,<3.0a0 - - libiconv >=1.18,<2.0a0 - - libsndfile >=1.2.2,<1.3.0a0 - - libsystemd0 >=257.10 - - libxcb >=1.17.0,<2.0a0 + - libblas 3.11.0 6_h51639a9_openblas constrains: - - pulseaudio 17.0 *_3 - license: LGPL-2.1-or-later - license_family: LGPL - purls: [] - size: 750785 - timestamp: 1763148198088 -- conda: https://prefix.dev/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 - md5: 12c566707c80111f9799308d9e265aef - depends: - - python >=3.9 - - python + - liblapacke 3.11.0 6*_openblas + - blas 2.306 openblas + - liblapack 3.11.0 6*_openblas license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/pycparser?source=hash-mapping - size: 110100 - timestamp: 1733195786147 -- conda: https://prefix.dev/conda-forge/linux-64/pygame-2.6.1-py311h3209946_0.conda - sha256: f008b83bf960c59e2f6336b9f246e7c6c8ac5327e5a8b7574e7e152e681f1887 - md5: d79d066a1ee9b690f90c02aac432e9c7 - depends: - - __glibc >=2.17,<3.0.a0 - - fontconfig >=2.14.2,<3.0a0 - - fonts-conda-ecosystem - - freetype >=2.12.1,<3.0a0 - - libgcc >=13 - - libjpeg-turbo >=3.0.0,<4.0a0 - - libpng >=1.6.44,<1.7.0a0 - - libstdcxx >=13 - - libzlib >=1.3.1,<2.0a0 - - portmidi >=2.0.4,<3.0a0 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - - sdl2 >=2.30.7,<3.0a0 - - sdl2_image >=2.8.2,<3.0a0 - - sdl2_mixer >=2.6.3,<3.0a0 - - sdl2_ttf >=2.22.0,<3.0a0 - license: LGPL-2.1-only - purls: - - pkg:pypi/pygame?source=hash-mapping - size: 3068168 - timestamp: 1727636682074 -- conda: https://prefix.dev/conda-forge/osx-arm64/pygame-2.6.1-py311hc3e7c57_0.conda - sha256: e95e452aed4e6511b16f2650526c3e74438d5198a14e646832020d854dfa9964 - md5: db72b6d24c6c7ce1d80b8c659b4aeb2b - depends: - - __osx >=11.0 - - fontconfig >=2.14.2,<3.0a0 - - fonts-conda-ecosystem - - freetype >=2.12.1,<3.0a0 - - libcxx >=17 - - libjpeg-turbo >=3.0.0,<4.0a0 - - libpng >=1.6.44,<1.7.0a0 - - libzlib >=1.3.1,<2.0a0 - - portmidi >=2.0.4,<3.0a0 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - - sdl2 >=2.30.7,<3.0a0 - - sdl2_image >=2.8.2,<3.0a0 - - sdl2_mixer >=2.6.3,<3.0a0 - - sdl2_ttf >=2.22.0,<3.0a0 - license: LGPL-2.1-only - purls: - - pkg:pypi/pygame?source=hash-mapping - size: 2917534 - timestamp: 1727636756068 -- conda: https://prefix.dev/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 - md5: 16c18772b340887160c79a6acc022db0 + license_family: BSD + purls: [] + size: 18863 + timestamp: 1774504433388 +- conda: https://prefix.dev/conda-forge/osx-arm64/libccd-double-2.1-h9a09cb3_2.tar.bz2 + sha256: eaba0b8153f4346229a0c52916a13fbedd689a3d3b31f4196bac65ece9050b8e + md5: 4d27a7d50c8d4bcafe33c9215e66251c depends: - - python >=3.10 - license: BSD-2-Clause + - libcxx >=13.0.1 + constrains: + - libccd <1 + license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/pygments?source=hash-mapping - size: 893031 - timestamp: 1774796815820 -- conda: https://prefix.dev/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda - sha256: 417fba4783e528ee732afa82999300859b065dc59927344b4859c64aae7182de - md5: 3687cc0b82a8b4c17e1f0eb7e47163d5 + purls: [] + size: 29852 + timestamp: 1654586481871 +- conda: https://prefix.dev/conda-forge/osx-arm64/libcurl-8.20.0-hd5a2499_0.conda + sha256: 38c0bc634b61e542776e97cfd15d5d41edd304d4e47c333004d2d622439b2381 + md5: 2f57b7d0c6adda88957586b7afd78438 depends: - - python >=3.10 - - python - license: MIT + - __osx >=11.0 + - krb5 >=1.22.2,<1.23.0a0 + - libnghttp2 >=1.68.1,<2.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.6,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl license_family: MIT - purls: - - pkg:pypi/pyparsing?source=hash-mapping - size: 110893 - timestamp: 1769003998136 -- conda: https://prefix.dev/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda - sha256: 065ac44591da9abf1ff740feb25929554b920b00d09287a551fcced2c9791092 - md5: d4582021af437c931d7d77ec39007845 + purls: [] + size: 400568 + timestamp: 1777462251987 +- conda: https://prefix.dev/conda-forge/osx-arm64/libcxx-22.1.5-h55c6f16_1.conda + sha256: dddd01bd6b338221342a89530a1caffe6051a70cc8f8b1d8bb591d5447a3c603 + md5: ff484b683fecf1e875dfc7aa01d19796 depends: - - python >=3.9 - - tomli >=1.1.0 + - __osx >=11.0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: [] + size: 569359 + timestamp: 1778191546305 +- conda: https://prefix.dev/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda + sha256: 5e0b6961be3304a5f027a8c00bd0967fc46ae162cffb7553ff45c70f51b8314c + md5: a6130c709305cd9828b4e1bd9ba0000c + depends: + - __osx >=11.0 license: MIT license_family: MIT - purls: - - pkg:pypi/pyproject-hooks?source=hash-mapping - size: 15528 - timestamp: 1733710122949 -- conda: https://prefix.dev/conda-forge/noarch/pyserial-3.5-pyhcf101f3_2.conda - sha256: 8c618e8ca376d73133c9971abe45463a48c9cfb529788d609fd19568764941ba - md5: b27a6cd32160c34682ce6053b04c12c6 + purls: [] + size: 55420 + timestamp: 1761980066242 +- conda: https://prefix.dev/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda + sha256: 66aa216a403de0bb0c1340a88d1a06adaff66bae2cfd196731aa24db9859d631 + md5: 44083d2d2c2025afca315c7a172eab2b depends: - - python >=3.10 - - python - license: BSD-3-Clause + - ncurses + - __osx >=11.0 + - ncurses >=6.5,<7.0a0 + license: BSD-2-Clause license_family: BSD - purls: - - pkg:pypi/pyserial?source=hash-mapping - size: 73910 - timestamp: 1767289527295 -- conda: https://prefix.dev/conda-forge/linux-64/pyside6-6.11.1-py311hf27b23e_1.conda - sha256: 3cd4963051cffa6d96972cd8e42e6b224bbf385353e9a743940b4434fba176e6 - md5: dfd3d0af46ab4c53740abe6d6dbdd403 - depends: - - python - - qt6-main 6.11.1.* - - libstdcxx >=14 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - libegl >=1.7.0,<2.0a0 - - libopengl >=1.7.0,<2.0a0 - - libvulkan-loader >=1.4.341.0,<2.0a0 - - libgl >=1.7.0,<2.0a0 - - python_abi 3.11.* *_cp311 - - libxslt >=1.1.43,<2.0a0 - - libxml2 - - libxml2-16 >=2.14.6 - - libclang13 >=22.1.5 - - qt6-main >=6.11.1,<6.12.0a0 - license: LGPL-3.0-only - license_family: LGPL - purls: - - pkg:pypi/pyside6?source=hash-mapping - - pkg:pypi/shiboken6?source=hash-mapping - size: 13815486 - timestamp: 1778933870587 -- conda: https://prefix.dev/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda - sha256: 75245ca9d0cbd6d38bb45ec02430189a9d4c21c055c5259739d738a2298d61b3 - md5: 799ed216dc6af62520f32aa39bc1c2bb + purls: [] + size: 107691 + timestamp: 1738479560845 +- conda: https://prefix.dev/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda + sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f + md5: 36d33e440c31857372a72137f78bacf5 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 107458 + timestamp: 1702146414478 +- conda: https://prefix.dev/conda-forge/osx-arm64/libexpat-2.8.0-hf6b4638_0.conda + sha256: f4b1cafc59afaede8fa0a2d9cf376840f1c553001acd72f6ead18bbc8ac8c49c + md5: 65466e82c09e888ca7560c11a97d5450 depends: - - colorama - - exceptiongroup >=1.0.0rc8 - - iniconfig - - packaging - - pluggy <2,>=1.5 - - python >=3.9 - - tomli >=1 + - __osx >=11.0 constrains: - - pytest-faulthandler >=2 + - expat 2.8.0.* license: MIT license_family: MIT - purls: - - pkg:pypi/pytest?source=hash-mapping - size: 259195 - timestamp: 1733217599806 -- conda: https://prefix.dev/conda-forge/linux-64/python-3.10.20-h3c07f61_0_cpython.conda - sha256: 8ff2ce308faf2588b69c65b120293f59a8f2577b772b34df4e817d220b09e081 - md5: 5d4e2b00d99feacd026859b7fa239dc0 + purls: [] + size: 68789 + timestamp: 1777846180142 +- conda: https://prefix.dev/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda + sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7 + md5: 43c04d9cb46ef176bb2a4c77e324d599 depends: - - __glibc >=2.17,<3.0.a0 - - bzip2 >=1.0.8,<2.0a0 - - ld_impl_linux-64 >=2.36.1 - - libexpat >=2.7.4,<3.0a0 - - libffi >=3.4,<4.0a0 - - libgcc >=14 - - liblzma >=5.8.2,<6.0a0 - - libnsl >=2.0.1,<2.1.0a0 - - libsqlite >=3.51.2,<4.0a0 - - libuuid >=2.41.3,<3.0a0 - - libxcrypt >=4.4.36 - - libzlib >=1.3.1,<2.0a0 - - ncurses >=6.5,<7.0a0 - - openssl >=3.5.5,<4.0a0 - - readline >=8.3,<9.0a0 - - tk >=8.6.13,<8.7.0a0 - - tzdata - constrains: - - python_abi 3.10.* *_cp310 - license: Python-2.0 + - __osx >=11.0 + license: MIT + license_family: MIT purls: [] - size: 25455342 - timestamp: 1772729810280 -- conda: https://prefix.dev/conda-forge/linux-64/python-3.11.15-hd63d673_0_cpython.conda - sha256: bf6a32c69889d38482436a786bea32276756cedf0e9805cc856ffd088e8d00f0 - md5: a5ebcefec0c12a333bcd6d7bf3bddc1f + size: 40979 + timestamp: 1769456747661 +- conda: https://prefix.dev/conda-forge/osx-arm64/libflac-1.5.0-h6824b09_1.conda + sha256: 565e5c38e80eb5752bfa52f6b771fa2fd75c0551a1f61ea84a12a2fb4454900c + md5: b14b19359aed60c200b1ca58b53f5ca3 depends: - - __glibc >=2.17,<3.0.a0 - - bzip2 >=1.0.8,<2.0a0 - - ld_impl_linux-64 >=2.36.1 - - libexpat >=2.7.4,<3.0a0 - - libffi >=3.5.2,<3.6.0a0 - - libgcc >=14 - - liblzma >=5.8.2,<6.0a0 - - libnsl >=2.0.1,<2.1.0a0 - - libsqlite >=3.51.2,<4.0a0 - - libuuid >=2.41.3,<3.0a0 - - libxcrypt >=4.4.36 - - libzlib >=1.3.1,<2.0a0 - - ncurses >=6.5,<7.0a0 - - openssl >=3.5.5,<4.0a0 - - readline >=8.3,<9.0a0 - - tk >=8.6.13,<8.7.0a0 - - tzdata - constrains: - - python_abi 3.11.* *_cp311 - license: Python-2.0 + - __osx >=11.0 + - libcxx >=19 + - libiconv >=1.18,<2.0a0 + - libogg >=1.3.5,<1.4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 30949404 - timestamp: 1772730362552 -- conda: https://prefix.dev/conda-forge/osx-arm64/python-3.10.20-h1b19095_0_cpython.conda - sha256: f0f6fcbb6cfdee5a6b9c03b5b94d2bbe737f3b17a618006c7685cc48992ae667 - md5: 55ec25b0d09379eb11c32dbe09ee28c4 + size: 321872 + timestamp: 1764527007890 +- conda: https://prefix.dev/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_0.conda + sha256: a047a2f238362a37d484f9620e8cba29f513a933cd9eb68571ad4b270d6f8f3e + md5: f73b109d49568d5d1dda43bb147ae37f + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 8091 + timestamp: 1774298691258 +- conda: https://prefix.dev/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_0.conda + sha256: ff764608e1f2839e95e2cf9b243681475f8778c36af7a42b3f78f476fdbb1dd3 + md5: e98ba7b5f09a5f450eca083d5a1c4649 depends: - __osx >=11.0 - - bzip2 >=1.0.8,<2.0a0 - - libexpat >=2.7.4,<3.0a0 - - libffi >=3.4,<4.0a0 - - liblzma >=5.8.2,<6.0a0 - - libsqlite >=3.51.2,<4.0a0 - - libzlib >=1.3.1,<2.0a0 - - ncurses >=6.5,<7.0a0 - - openssl >=3.5.5,<4.0a0 - - readline >=8.3,<9.0a0 - - tk >=8.6.13,<8.7.0a0 - - tzdata + - libpng >=1.6.55,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 constrains: - - python_abi 3.10.* *_cp310 - license: Python-2.0 + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 338085 + timestamp: 1774298689297 +- conda: https://prefix.dev/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda + sha256: 06644fa4d34d57c9e48f4d84b1256f9e5f654fdb37f43acc8a58a396952d42b7 + md5: 644058123986582db33aebd4ae2ca184 + depends: + - _openmp_mutex + constrains: + - libgcc-ng ==15.2.0=*_19 + - libgomp 15.2.0 19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 12468674 - timestamp: 1772730636766 -- conda: https://prefix.dev/conda-forge/osx-arm64/python-3.11.15-h8561d8f_0_cpython.conda - sha256: 9a846065863925b2562126a5c6fecd7a972e84aaa4de9e686ad3715ca506acfa - md5: 49c7d96c58b969585cf09fb01d74e08e + size: 404080 + timestamp: 1778273064154 +- conda: https://prefix.dev/conda-forge/osx-arm64/libgd-2.3.3-h05bcc79_12.conda + sha256: 269edce527e204a80d3d05673301e0207efcd0dbeebc036a118ceb52690d6341 + md5: fa4a92cfaae9570d89700a292a9ca714 depends: - __osx >=11.0 - - bzip2 >=1.0.8,<2.0a0 - - libexpat >=2.7.4,<3.0a0 - - libffi >=3.5.2,<3.6.0a0 - - liblzma >=5.8.2,<6.0a0 - - libsqlite >=3.51.2,<4.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.1,<79.0a0 + - libexpat >=2.7.3,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 + - libiconv >=1.18,<2.0a0 + - libjpeg-turbo >=3.1.2,<4.0a0 + - libpng >=1.6.53,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libwebp-base >=1.6.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - ncurses >=6.5,<7.0a0 - - openssl >=3.5.5,<4.0a0 - - readline >=8.3,<9.0a0 - - tk >=8.6.13,<8.7.0a0 - - tzdata - constrains: - - python_abi 3.11.* *_cp311 - license: Python-2.0 + license: GD + license_family: BSD purls: [] - size: 14753109 - timestamp: 1772730203101 -- conda: https://prefix.dev/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 - md5: 5b8d21249ff20967101ffa321cab24e8 - depends: - - python >=3.9 - - six >=1.5 - - python - license: Apache-2.0 - license_family: APACHE - purls: - - pkg:pypi/python-dateutil?source=hash-mapping - size: 233310 - timestamp: 1751104122689 -- conda: https://prefix.dev/conda-forge/noarch/python-discovery-1.3.0-pyhcf101f3_0.conda - sha256: ae70eb1c16970f2317e71dd2dee7d3a41abd26a47298ca8d9163a94b6579517b - md5: 696db6f25e56c0fafdccb0a7426fffb6 + size: 159247 + timestamp: 1766331953491 +- conda: https://prefix.dev/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda + sha256: d4837b3b9b30af3132d260225e91ab9dde83be04c59513f500cc81050fb37486 + md5: 1ea03f87cdb1078fbc0e2b2deb63752c depends: - - python >=3.10 - - filelock >=3.15.4 - - platformdirs <5,>=4.3.6 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/python-discovery?source=hash-mapping - size: 35030 - timestamp: 1778013338579 -- conda: https://prefix.dev/conda-forge/noarch/python_abi-3.10-8_cp310.conda - build_number: 8 - sha256: 7ad76fa396e4bde336872350124c0819032a9e8a0a40590744ff9527b54351c1 - md5: 05e00f3b21e88bb3d658ac700b2ce58c + - libgfortran5 15.2.0 hdae7583_19 constrains: - - python 3.10.* *_cpython - license: BSD-3-Clause - license_family: BSD + - libgfortran-ng ==15.2.0=*_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 6999 - timestamp: 1752805924192 -- conda: https://prefix.dev/conda-forge/noarch/python_abi-3.11-8_cp311.conda - build_number: 8 - sha256: fddf123692aa4b1fc48f0471e346400d9852d96eeed77dbfdd746fa50a8ff894 - md5: 8fcb6b0e2161850556231336dae58358 + size: 139675 + timestamp: 1778273280875 +- conda: https://prefix.dev/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda + sha256: d0a68b7a121d115b80c169e24d1265dcc25a3fe58d107df1bbc430797e226d88 + md5: ba36d8c606a6a53fe0b8c12d47267b3d + depends: + - libgcc >=15.2.0 constrains: - - python 3.11.* *_cpython - license: BSD-3-Clause - license_family: BSD + - libgfortran 15.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL purls: [] - size: 7003 - timestamp: 1752805919375 -- conda: https://prefix.dev/conda-forge/linux-64/pyyaml-6.0.3-py311h3778330_1.conda - sha256: c9a6cd2c290d7c3d2b30ea34a0ccda30f770e8ddb2937871f2c404faf60d0050 - md5: a24add9a3bababee946f3bc1c829acfe + size: 599691 + timestamp: 1778273075448 +- conda: https://prefix.dev/conda-forge/osx-arm64/libglib-2.88.3-ha08bb59_0.conda + sha256: a14417ae1f3f4a92c5766354eb280342fa6aae72a09af86bf7fcfc12a8c9225c + md5: 4a9309d9502a08a2d29b1743dcfb0e7f depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - - yaml >=0.2.5,<0.3.0a0 - license: MIT - license_family: MIT - purls: - - pkg:pypi/pyyaml?source=hash-mapping - size: 206190 - timestamp: 1770223702917 -- conda: https://prefix.dev/conda-forge/osx-arm64/pyyaml-6.0.3-py311hc290fe0_1.conda - sha256: 984e73d7957460689e10533059de8adb38a308853d298900a37acc58edd84cec - md5: e4b908da7cd496b3fa6798c0f60a2a19 + - __osx >=11.0 + - pcre2 >=10.47,<10.48.0a0 + - libzlib >=1.3.2,<2.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libintl >=0.25.1,<1.0a0 + - libiconv >=1.18,<2.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + purls: [] + size: 4448109 + timestamp: 1785442168180 +- conda: https://prefix.dev/conda-forge/osx-arm64/libharfbuzz-14.3.1-hcda0f7c_0.conda + sha256: 67af14f8fbf9b9725890f728179d933ac35a95a6b50f37b7b568a11bfa8a4c1d + md5: 1631ca9ffe7d368850904baa1df1abf4 depends: - __osx >=11.0 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - - yaml >=0.2.5,<0.3.0a0 + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=21 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.88.3,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/pyyaml?source=hash-mapping - size: 192948 - timestamp: 1770223655988 -- conda: https://prefix.dev/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda - sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc - md5: 353823361b1d27eb3960efb076dfcaf6 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 - - libstdcxx-ng >=12 - license: LicenseRef-Qhull purls: [] - size: 552937 - timestamp: 1720813982144 -- conda: https://prefix.dev/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda - sha256: 873ac689484262a51fd79bc6103c1a1bedbf524924d7f0088fb80703042805e4 - md5: 6483b1f59526e05d7d894e466b5b6924 + size: 953252 + timestamp: 1786970947180 +- conda: https://prefix.dev/conda-forge/osx-arm64/libharfbuzz-devel-14.3.1-hcda0f7c_0.conda + sha256: 076db9dac1b7ab31383ffd35da5f5b9ab9e56987b7751a5ec767c330f0e3c359 + md5: 911b746bffebd782ea8d53e663b0269c depends: - __osx >=11.0 - - libcxx >=16 - license: LicenseRef-Qhull - purls: [] - size: 516376 - timestamp: 1720814307311 -- conda: https://prefix.dev/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_0.conda - sha256: 787d9a8eb7bb993e4a543901b8edade35c1c8e75d67cadb65c56a8f9c38119a5 - md5: cdae26862f9e4c674b8443fd267f2401 - depends: - - libxcb - - xcb-util - - xcb-util-wm - - xcb-util-keysyms - - xcb-util-image - - xcb-util-renderutil - - xcb-util-cursor - - libgl-devel - - libegl-devel - - __glibc >=2.17,<3.0.a0 - - libstdcxx >=14 - - libgcc >=14 - - libjpeg-turbo >=3.1.4.1,<4.0a0 - - alsa-lib >=1.2.15.3,<1.3.0a0 - - xcb-util-renderutil >=0.3.10,<0.4.0a0 - - xorg-libxcursor >=1.2.3,<2.0a0 - - double-conversion >=3.4.0,<3.5.0a0 - - dbus >=1.16.2,<2.0a0 - - libglib >=2.88.1,<3.0a0 - - libsqlite >=3.53.1,<4.0a0 - - xorg-libx11 >=1.8.13,<2.0a0 - - krb5 >=1.22.2,<1.23.0a0 - - libdrm >=2.4.125,<2.5.0a0 - - xorg-libxext >=1.3.7,<2.0a0 - - libwebp-base >=1.6.0,<2.0a0 - - harfbuzz >=14.2.0 - - xorg-libice >=1.1.2,<2.0a0 - - xorg-libxdamage >=1.1.6,<2.0a0 - - libbrotlicommon >=1.2.0,<1.3.0a0 - - libbrotlienc >=1.2.0,<1.3.0a0 - - libbrotlidec >=1.2.0,<1.3.0a0 - - xorg-libxrandr >=1.5.5,<2.0a0 - - xcb-util-image >=0.4.0,<0.5.0a0 + - cairo >=1.18.4,<2.0a0 + - freetype + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=21 - libfreetype >=2.14.3 - libfreetype6 >=2.14.3 - - xorg-libxcomposite >=0.4.7,<1.0a0 - - openssl >=3.5.6,<4.0a0 - - xcb-util-cursor >=0.1.6,<0.2.0a0 - - libvulkan-loader >=1.4.341.0,<2.0a0 - - pcre2 >=10.47,<10.48.0a0 - - xorg-libxxf86vm >=1.1.7,<2.0a0 - - icu >=78.3,<79.0a0 - - libxcb >=1.17.0,<2.0a0 - - wayland >=1.25.0,<2.0a0 - - xorg-libsm >=1.2.6,<2.0a0 - - libtiff >=4.7.1,<4.8.0a0 - - libpq >=18.3,<19.0a0 - - libegl >=1.7.0,<2.0a0 - - xcb-util-wm >=0.4.2,<0.5.0a0 - - xcb-util-keysyms >=0.4.1,<0.5.0a0 - - libxkbcommon >=1.13.1,<2.0a0 - - zstd >=1.5.7,<1.6.0a0 - - fontconfig >=2.17.1,<3.0a0 - - fonts-conda-ecosystem - - xorg-libxtst >=1.2.5,<2.0a0 - - libxml2 - - libxml2-16 >=2.14.6 - - libzlib >=1.3.2,<2.0a0 - - libpng >=1.6.58,<1.7.0a0 - - libcups >=2.3.3,<2.4.0a0 - - libgl >=1.7.0,<2.0a0 - - xcb-util >=0.4.1,<0.5.0a0 - constrains: - - qt ==6.11.1 - license: LGPL-3.0-only - license_family: LGPL + - libglib >=2.88.3,<3.0a0 + - libharfbuzz 14.3.1 hcda0f7c_0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 60185269 - timestamp: 1778597122245 -- conda: https://prefix.dev/conda-forge/linux-64/rav1e-0.8.1-h1fbca29_0.conda - sha256: cf550bbc8e5ebedb6dba9ccaead3e07bd1cb86b183644a4c853e06e4b3ad5ac7 - md5: d83958768626b3c8471ce032e28afcd3 + size: 1500884 + timestamp: 1786970969119 +- conda: https://prefix.dev/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + sha256: de0336e800b2af9a40bdd694b03870ac4a848161b35c8a2325704f123f185f03 + md5: 4d5a7445f0b25b6a3ddbb56e790f5251 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - constrains: - - __glibc >=2.17 - license: BSD-2-Clause - license_family: BSD + - __osx >=11.0 + license: LGPL-2.1-only purls: [] - size: 5595970 - timestamp: 1772540833621 -- conda: https://prefix.dev/conda-forge/osx-arm64/rav1e-0.8.1-h8246384_0.conda - sha256: 925e35b71fe513e0380ecd2fe137e3f4f248bf7ce4bad96946c7c704b7a50d26 - md5: 4706a8a71474c692482c3f86c2175454 + size: 750379 + timestamp: 1754909073836 +- conda: https://prefix.dev/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + sha256: 99d2cebcd8f84961b86784451b010f5f0a795ed1c08f1e7c76fbb3c22abf021a + md5: 5103f6a6b210a3912faf8d7db516918c depends: - __osx >=11.0 - constrains: + - libiconv >=1.18,<2.0a0 + license: LGPL-2.1-or-later + purls: [] + size: 90957 + timestamp: 1751558394144 +- conda: https://prefix.dev/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda + sha256: 17e035ae6a520ff6a6bb5dd93a4a7c3895891f4f9743bcb8c6ef607445a31cd0 + md5: b8a7544c83a67258b0e8592ec6a5d322 + depends: - __osx >=11.0 - license: BSD-2-Clause - license_family: BSD + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib purls: [] - size: 886953 - timestamp: 1772541394570 -- pypi: ./vendor/rSim - name: rc-robosim - version: 1.2.0+utama - sha256: 3ee70be6ae49588d10349b223ee29716b1694b243a04c7523b8a78f667820579 -- conda: https://prefix.dev/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002 - md5: d7d95fc8287ea7bf33e0e7116d2b95ec + size: 555681 + timestamp: 1775962975624 +- conda: https://prefix.dev/conda-forge/osx-arm64/liblapack-3.11.0-6_hd9741b5_openblas.conda + build_number: 6 + sha256: 21606b7346810559e259807497b86f438950cf19e71838e44ebaf4bd2b35b549 + md5: ee33d2d05a7c5ea1f67653b37eb74db1 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - ncurses >=6.5,<7.0a0 - license: GPL-3.0-only - license_family: GPL + - libblas 3.11.0 6_h51639a9_openblas + constrains: + - liblapacke 3.11.0 6*_openblas + - libcblas 3.11.0 6*_openblas + - blas 2.306 openblas + license: BSD-3-Clause + license_family: BSD purls: [] - size: 345073 - timestamp: 1765813471974 -- conda: https://prefix.dev/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda - sha256: a77010528efb4b548ac2a4484eaf7e1c3907f2aec86123ed9c5212ae44502477 - md5: f8381319127120ce51e081dce4865cf4 + size: 18863 + timestamp: 1774504467905 +- conda: https://prefix.dev/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda + sha256: 34878d87275c298f1a732c6806349125cebbf340d24c6c23727268184bba051e + md5: b1fd823b5ae54fbec272cea0811bd8a9 depends: - __osx >=11.0 - - ncurses >=6.5,<7.0a0 - license: GPL-3.0-only - license_family: GPL + constrains: + - xz 5.8.3.* + license: 0BSD purls: [] - size: 313930 - timestamp: 1765813902568 -- conda: https://prefix.dev/conda-forge/linux-64/rhash-1.4.3-hd590300_2.conda - sha256: 475f68cac8981ff2b10c56e53c2f376fc3c805fbc7ec30d22f870cd88f1479ba - md5: 4cabe3858a856bff08d9a0992e413084 + size: 92472 + timestamp: 1775825802659 +- conda: https://prefix.dev/conda-forge/osx-arm64/liblzma-devel-5.8.3-h8088a28_0.conda + sha256: 3002be39c0e98ec6cd103b0dc2963dc9e0d7cab127fb2fe9a8de9707a76ed1f0 + md5: ebe1f5418d6e2d4bbc26b2c906a0a470 depends: - - libgcc-ng >=12 - license: MIT - license_family: MIT + - __osx >=11.0 + - liblzma 5.8.3 h8088a28_0 + license: 0BSD purls: [] - size: 184509 - timestamp: 1693427593121 -- conda: https://prefix.dev/conda-forge/osx-arm64/rhash-1.4.3-hb547adb_2.conda - sha256: f20c9765768d0c61bbbb462dc83b55372328498a746f60e1e93c985e3436ef73 - md5: 24308c7e0949c572688900b8b2f2a3ba - license: MIT - license_family: MIT + size: 118482 + timestamp: 1775825828010 +- conda: https://prefix.dev/conda-forge/osx-arm64/libmad-0.15.1b-h1a8c8d9_1001.conda + sha256: 8e9209acf4bf6865760e61dc0d86116ffc9efc3e13c7f559eb1ea78532a3a625 + md5: 1eb30852ed396fbe6e301fe6d715aef9 + license: GPL-2.0-only + license_family: GPL purls: [] - size: 176444 - timestamp: 1693427792263 -- conda: https://prefix.dev/conda-forge/noarch/rich-14.3.4-pyhcf101f3_0.conda - sha256: a941b5e002504e1c9b02ea02180d40186b67d03e8e7d668bf746393c266b3951 - md5: 2e6a922d07244f514863b7e10bf5c923 - depends: - - markdown-it-py >=2.2.0 - - pygments >=2.13.0,<3.0.0 - - python >=3.10 - - typing_extensions >=4.0.0,<5.0.0 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/rich?source=hash-mapping - size: 208480 - timestamp: 1775880677603 -- conda: https://prefix.dev/conda-forge/linux-64/ruff-0.15.12-h994f30f_0.conda - noarch: python - sha256: 98c771464ed93a2733bae460c39cfa9640feb20972d2e651b44e85db296942eb - md5: 3c8f229055ad244fa3a97c6c45b77099 + size: 77255 + timestamp: 1670815732700 +- conda: https://prefix.dev/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda + sha256: 2bc7bc3978066f2c274ebcbf711850cc9ab92e023e433b9631958a098d11e10a + md5: 6ea18834adbc3b33df9bd9fb45eaf95b depends: - - python - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - constrains: - - __glibc >=2.17 + - __osx >=11.0 + - c-ares >=1.34.6,<2.0a0 + - libcxx >=19 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.5,<4.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/ruff?source=hash-mapping - size: 9266480 - timestamp: 1778119386343 -- conda: https://prefix.dev/conda-forge/osx-arm64/ruff-0.15.12-hbd3f8a3_0.conda - noarch: python - sha256: 91992a557456cbe9980e8ffb0f0d1200f65f741adeefc7ecf568d1935690a7bc - md5: 7151a0851207b88c0031f388a7825e9b + purls: [] + size: 576526 + timestamp: 1773854624224 +- conda: https://prefix.dev/conda-forge/osx-arm64/libode-0.16.6-py310h46abf29_0.conda + sha256: 2f3d4fb77c4cdca3d156c196271fc4a637af8cac93573ba682c1a12c9def54d8 + md5: f23a539191cb27d18453bad21c648c2f depends: - - python - - __osx >=11.0 - constrains: - __osx >=11.0 - license: MIT - license_family: MIT - purls: - - pkg:pypi/ruff?source=hash-mapping - size: 8485007 - timestamp: 1778119519471 -- conda: https://prefix.dev/conda-forge/linux-64/scipy-1.17.1-py311hbe70eeb_0.conda - sha256: 0063a75e9406357ef8ecc2fb38808a2442b269bfc5a854cf2bcd368060d9a2d7 - md5: 5ae6d73ab0bebbc892c2d46dc51e90a5 + - libccd-double >=2.1,<2.2.0a0 + - libcxx >=19 + - pthread-stubs + - python >=3.10,<3.11.0a0 *_cpython + - python_abi 3.10.* *_cp310 + license: LGPL-2.1-or-later OR BSD-4-Clause + purls: [] + size: 378594 + timestamp: 1760969550819 +- conda: https://prefix.dev/conda-forge/osx-arm64/libogg-1.3.5-h48c0fde_1.conda + sha256: 28bd1fe20fe43da105da41b95ac201e95a1616126f287985df8e86ddebd1c3d8 + md5: 29b8b11f6d7e6bd0e76c029dcf9dd024 depends: - - __glibc >=2.17,<3.0.a0 - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - libgcc >=14 - - libgfortran - - libgfortran5 >=14.3.0 - - liblapack >=3.9.0,<4.0a0 - - libstdcxx >=14 - - numpy <2.7 - - numpy >=1.23,<3 - - numpy >=1.25.2 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 + - __osx >=11.0 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/scipy?source=hash-mapping - size: 17099824 - timestamp: 1771880736635 -- conda: https://prefix.dev/conda-forge/osx-arm64/scipy-1.17.1-py311he9931d0_0.conda - sha256: f212138a7eb86cf8bcdb46f003ae552967cd7e48d2c539f7f8dd6e800c74b70d - md5: 40606bef4834281d5f746626338829dc + purls: [] + size: 216719 + timestamp: 1745826006052 +- conda: https://prefix.dev/conda-forge/osx-arm64/libopenblas-0.3.32-openmp_he657e61_0.conda + sha256: 713e453bde3531c22a660577e59bf91ef578dcdfd5edb1253a399fa23514949a + md5: 3a1111a4b6626abebe8b978bb5a323bf depends: - __osx >=11.0 - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - libcxx >=19 - libgfortran - libgfortran5 >=14.3.0 - - liblapack >=3.9.0,<4.0a0 - - numpy <2.7 - - numpy >=1.23,<3 - - numpy >=1.25.2 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 + - llvm-openmp >=19.1.7 + constrains: + - openblas >=0.3.32,<0.3.33.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 4308797 + timestamp: 1774472508546 +- conda: https://prefix.dev/conda-forge/osx-arm64/libopus-1.6.1-h1a92334_0.conda + sha256: 5c95a5f7712f543c59083e62fc3a95efec8b7f3773fbf4542ad1fb87fbf51ff4 + md5: 7f414dd3fd1cb7a76e51fec074a9c49e + depends: + - __osx >=11.0 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/scipy?source=hash-mapping - size: 14107248 - timestamp: 1771880859933 -- conda: https://prefix.dev/conda-forge/linux-64/sdl2-2.32.56-h54a6638_0.conda - sha256: 987ad072939fdd51c92ea8d3544b286bb240aefda329f9b03a51d9b7e777f9de - md5: cdd138897d94dc07d99afe7113a07bec - depends: - - libstdcxx >=14 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - libgl >=1.7.0,<2.0a0 - - sdl3 >=3.2.22,<4.0a0 - - libegl >=1.7.0,<2.0a0 - license: Zlib purls: [] - size: 589145 - timestamp: 1757842881 -- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2-2.32.56-h248ca61_0.conda - sha256: 704c5cae4bc839a18c70cbf3387d7789f1902828c79c6ddabcd34daf594f4103 - md5: 092c5b693dc6adf5f409d12f33295a2a + size: 308000 + timestamp: 1768497248058 +- conda: https://prefix.dev/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda + sha256: 66eae34546df1f098a67064970c92aa14ae7a7505091889e00468294d2882c36 + md5: 2259ae0949dbe20c0665850365109b27 depends: - - libcxx >=19 - __osx >=11.0 - - sdl3 >=3.2.22,<4.0a0 - license: Zlib + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement purls: [] - size: 542508 - timestamp: 1757842919681 -- conda: https://prefix.dev/conda-forge/linux-64/sdl2_image-2.8.2-h06ee604_1.conda - sha256: f18184e016e2e57306d1540dea584d38f4617d7ddb6aad4af6b5f21c52fa39ea - md5: 65e113270b460dcdfc4dc0a80bb3d11c + size: 289546 + timestamp: 1776315246750 +- conda: https://prefix.dev/conda-forge/osx-arm64/libprotobuf-3.20.2-hb5ab8b9_0.tar.bz2 + sha256: a47188a95c95cb131f9903014e18b7868ab9b445da629f7d3a9d53d9aa8caa2c + md5: a6f25546f30d4cd56bc37b0b56ab954c depends: - - libavif16 >=1.0.4,<2.0a0 - - libgcc-ng >=12 - - libjpeg-turbo >=3.0.0,<4.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libstdcxx-ng >=12 - - libtiff >=4.6.0,<4.8.0a0 - - libwebp-base >=1.4.0,<2.0a0 + - libcxx >=14.0.6 - libzlib >=1.2.13,<2.0.0a0 - - sdl2 >=2.30.2,<3.0a0 - license: Zlib + license: BSD-3-Clause + license_family: BSD purls: [] - size: 152110 - timestamp: 1716857107234 -- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_image-2.8.2-h376e2e1_1.conda - sha256: 8c385478a7b6a6e34b3b3f3d48ed48f504698544987ad331f03a7b43b11d689a - md5: 247d2c5a873901ef51f378c69a2c708e + size: 2281852 + timestamp: 1668470370774 +- conda: https://prefix.dev/conda-forge/osx-arm64/libraqm-0.11.0-h45af499_0.conda + sha256: b110f7f9b2cec61ea793c521950414e00cd64826e18aeb4ab40369acf05c0039 + md5: 46ea0eb4e71bffa35ab7070678bcb053 depends: - __osx >=11.0 - - libavif16 >=1.0.4,<2.0a0 - - libcxx >=16 - - libjpeg-turbo >=3.0.0,<4.0a0 - - libpng >=1.6.43,<1.7.0a0 - - libtiff >=4.6.0,<4.8.0a0 - - libwebp-base >=1.4.0,<2.0a0 - - libzlib >=1.2.13,<2.0.0a0 - - sdl2 >=2.30.2,<3.0a0 - license: Zlib + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libharfbuzz >=14.2.1 + - fribidi >=1.0.16,<2.0a0 + license: MIT + license_family: MIT purls: [] - size: 118041 - timestamp: 1716857215118 -- conda: https://prefix.dev/conda-forge/linux-64/sdl2_mixer-2.6.3-hb8bcbd3_2.conda - sha256: 3a36f7d6349d132c571516514dc8cd771a705e93adef942c8eee38a09875d97a - md5: 97fbc8b1372f0000321d568c0e459e3c + size: 31333 + timestamp: 1784850348342 +- conda: https://prefix.dev/conda-forge/osx-arm64/librsvg-2.60.0-h9001022_1.conda + sha256: 9ba1531b46c75313736e2ef8ba1a4d3ef7d3ffd22efe8d593bfa99da7143a1cb + md5: b6c81d5b3324b9ff9fe8f39d25d8be66 depends: - - __glibc >=2.17,<3.0.a0 - - fluidsynth >=2.5.2,<2.6.0a0 - - libflac >=1.5.0,<1.6.0a0 - - libgcc >=14 - - libmad >=0.15.1b,<0.16.0a0 - - libogg >=1.3.5,<1.4.0a0 - - libstdcxx >=14 - - libvorbis >=1.3.7,<1.4.0a0 - - mpg123 >=1.32.9,<1.33.0a0 - - opusfile >=0.12,<0.13.0a0 - - sdl2 >=2.32.56,<3.0a0 - license: Zlib + - __osx >=11.0 + - cairo >=1.18.4,<2.0a0 + - gdk-pixbuf >=2.44.5,<3.0a0 + - libglib >=2.86.4,<3.0a0 + - libxml2-16 >=2.14.6 + - pango >=1.56.4,<2.0a0 + constrains: + - __osx >=11.0 + license: LGPL-2.1-or-later purls: [] - size: 205164 - timestamp: 1766614707552 -- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_mixer-2.6.3-h45fadf6_2.conda - sha256: b826d7fa6738d9fcc36bdcb299744246fe82d0f9d9d0d0f999f3111cb7b4d373 - md5: 890924faa4965ba3edb0cc5cc94db572 + size: 2357137 + timestamp: 1771302195666 +- conda: https://prefix.dev/conda-forge/osx-arm64/libsndfile-1.2.2-hf95f74e_2.conda + sha256: f549aafe57439ca7c362884968f24fcc35a26e4e1eb66bb6985aa9e553c25521 + md5: 27e1a5a9249833f98a739249c7d1518b depends: - __osx >=11.0 - - fluidsynth >=2.5.2,<2.6.0a0 + - lame >=3.100,<3.101.0a0 - libcxx >=19 - libflac >=1.5.0,<1.6.0a0 - - libmad >=0.15.1b,<0.16.0a0 - libogg >=1.3.5,<1.4.0a0 + - libopus >=1.5.2,<2.0a0 - libvorbis >=1.3.7,<1.4.0a0 - mpg123 >=1.32.9,<1.33.0a0 - - opusfile >=0.12,<0.13.0a0 - - sdl2 >=2.32.56,<3.0a0 - license: Zlib - purls: [] - size: 187456 - timestamp: 1766614943278 -- conda: https://prefix.dev/conda-forge/linux-64/sdl2_ttf-2.24.0-h287479f_0.conda - sha256: 431d19b666db6e7a4f09c37c43c83f115176a006b2ac321853ca26bee888c519 - md5: bccd5b74eb55a523dfcc66b857555714 - depends: - - __glibc >=2.17,<3.0.a0 - - freetype >=2.12.1,<3.0a0 - - harfbuzz >=10.1.0 - - libgcc >=13 - - libzlib >=1.3.1,<2.0a0 - - sdl2 >=2.30.10,<3.0a0 - license: Zlib + license: LGPL-2.1-or-later + license_family: LGPL purls: [] - size: 61954 - timestamp: 1736117956977 -- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_ttf-2.24.0-h443c5de_0.conda - sha256: 5dc56fd1de51dec2f7b63b1a9069ab35ab0494d9cd5af164ab0019cbd9564cf6 - md5: 3cf5cf83deccb663b4e932d3d4b28f57 + size: 321233 + timestamp: 1765182495193 +- conda: https://prefix.dev/conda-forge/osx-arm64/libsqlite-3.53.1-h1b79a29_0.conda + sha256: 49daec7c83e70d4efc17b813547824bc2bcf2f7256d84061d24fbfe537da9f74 + md5: 6681822ea9d362953206352371b6a904 depends: - __osx >=11.0 - - freetype >=2.12.1,<3.0a0 - - harfbuzz >=10.1.0 - - sdl2 >=2.30.10,<3.0a0 - license: Zlib + - libzlib >=1.3.2,<2.0a0 + license: blessing purls: [] - size: 45429 - timestamp: 1736118165229 -- conda: https://prefix.dev/conda-forge/linux-64/sdl3-3.4.8-hdeec2a5_0.conda - sha256: bec327fffc08369afe4c1384a5b50cac9b38e7af42ebdf5f89628633bd980dbd - md5: 508bad511e617479f0ad60cc49fba903 + size: 920047 + timestamp: 1777987051643 +- conda: https://prefix.dev/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda + sha256: 8bfe837221390ffc6f111ecca24fa12d4a6325da0c8d131333d63d6c37f27e0a + md5: b68e8f66b94b44aaa8de4583d3d4cc40 depends: - - libstdcxx >=14 - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - pulseaudio-client >=17.0,<17.1.0a0 - - libgl >=1.7.0,<2.0a0 - - libunwind >=1.8.3,<1.9.0a0 - - xorg-libxtst >=1.2.5,<2.0a0 - - xorg-libxcursor >=1.2.3,<2.0a0 - - libegl >=1.7.0,<2.0a0 - - xorg-libxfixes >=6.0.2,<7.0a0 - - libudev1 >=257.13 - - xorg-libxext >=1.3.7,<2.0a0 - - libusb >=1.0.29,<2.0a0 - - wayland >=1.25.0,<2.0a0 - - xorg-libxi >=1.8.2,<2.0a0 - - libvulkan-loader >=1.4.341.0,<2.0a0 - - liburing >=2.14,<2.15.0a0 - - xorg-libxscrnsaver >=1.2.4,<2.0a0 - - dbus >=1.16.2,<2.0a0 - - libxkbcommon >=1.13.1,<2.0a0 - - libdrm >=2.4.125,<2.5.0a0 - - xorg-libx11 >=1.8.13,<2.0a0 - license: Zlib + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.0,<4.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 2146080 - timestamp: 1777693555942 -- conda: https://prefix.dev/conda-forge/osx-arm64/sdl3-3.4.8-h6fa9c73_0.conda - sha256: 0c15a7f3f46d175c70ca7b032cee3eee9ef602492688a79a6e734f2efc466dad - md5: 53311362c6da21e58442bfb959991455 + size: 279193 + timestamp: 1745608793272 +- conda: https://prefix.dev/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda + sha256: e9248077b3fa63db94caca42c8dbc6949c6f32f94d1cafad127f9005d9b1507f + md5: e2a72ab2fa54ecb6abab2b26cde93500 depends: - __osx >=11.0 + - lerc >=4.0.0,<5.0a0 - libcxx >=19 - - libvulkan-loader >=1.4.341.0,<2.0a0 - - libusb >=1.0.29,<2.0a0 - - dbus >=1.16.2,<2.0a0 - license: Zlib + - libdeflate >=1.25,<1.26.0a0 + - libjpeg-turbo >=3.1.0,<4.0a0 + - liblzma >=5.8.1,<6.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND purls: [] - size: 1561566 - timestamp: 1777693640800 -- conda: https://prefix.dev/conda-forge/linux-64/secretstorage-3.4.1-py311h38be061_0.conda - sha256: 47f28b12e760ae3ce8a1e616c5b56f5e874e0e4a036bdd09516ebf263c19521f - md5: ec955e67147942a68469a46d0bdf0a7b - depends: - - cryptography >=2.0 - - dbus - - jeepney >=0.6 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - license: BSD-3-Clause - license_family: BSD - purls: - - pkg:pypi/secretstorage?source=hash-mapping - size: 32968 - timestamp: 1763045430433 -- conda: https://prefix.dev/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda - sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 - md5: 8e194e7b992f99a5015edbd4ebd38efd - depends: - - python >=3.10 - license: MIT - license_family: MIT - purls: - - pkg:pypi/setuptools?source=hash-mapping - size: 639697 - timestamp: 1773074868565 -- conda: https://prefix.dev/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda - sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b - md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + size: 373892 + timestamp: 1762022345545 +- conda: https://prefix.dev/conda-forge/osx-arm64/libusb-1.0.29-hbc156a2_0.conda + sha256: 5eee9a2bf359e474d4548874bcfc8d29ebad0d9ba015314439c256904e40aaad + md5: f6654e9e96e9d973981b3b2f898a5bfa depends: - - python >=3.10 - license: MIT - license_family: MIT - purls: - - pkg:pypi/shellingham?source=hash-mapping - size: 15018 - timestamp: 1762858315311 -- conda: https://prefix.dev/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda - sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d - md5: 3339e3b65d58accf4ca4fb8748ab16b3 + - __osx >=11.0 + license: LGPL-2.1-or-later + purls: [] + size: 83849 + timestamp: 1748856224950 +- conda: https://prefix.dev/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + sha256: 042c7488ad97a5629ec0a991a8b2a3345599401ecc75ad6a5af73b60e6db9689 + md5: c0d87c3c8e075daf1daf6c31b53e8083 depends: - - python >=3.9 - - python + - __osx >=11.0 license: MIT license_family: MIT - purls: - - pkg:pypi/six?source=hash-mapping - size: 18455 - timestamp: 1753199211006 -- conda: https://prefix.dev/conda-forge/noarch/snakeviz-2.2.2-pyhd8ed1ab_1.conda - sha256: 833326122c18887b338262c13365cb146b6702c79d72da74a1c6b8af4c50e162 - md5: 421b7a950e384949ca1b0f04f0751ce0 + purls: [] + size: 421195 + timestamp: 1753948426421 +- conda: https://prefix.dev/conda-forge/osx-arm64/libvorbis-1.3.7-h81086ad_2.conda + sha256: 95768e4eceaffb973081fd986d03da15d93aa10609ed202e6fd5ca1e490a3dce + md5: 719e7653178a09f5ca0aa05f349b41f7 depends: - - python >=3.9 - - tornado >=2.0 + - libogg + - libcxx >=19 + - __osx >=11.0 + - libogg >=1.3.5,<1.4.0a0 license: BSD-3-Clause license_family: BSD - purls: - - pkg:pypi/snakeviz?source=hash-mapping - size: 171545 - timestamp: 1735289409501 -- conda: https://prefix.dev/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda - sha256: dce518f45e24cd03f401cb0616917773159a210c19d601c5f2d4e0e5879d30ad - md5: 03fe290994c5e4ec17293cfb6bdce520 - depends: - - python >=3.10 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/sniffio?source=hash-mapping - size: 15698 - timestamp: 1762941572482 -- conda: https://prefix.dev/conda-forge/linux-64/svt-av1-4.0.1-hecca717_0.conda - sha256: 4a1d2005153b9454fc21c9bad1b539df189905be49e851ec62a6212c2e045381 - md5: 2a2170a3e5c9a354d09e4be718c43235 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - license: BSD-2-Clause - license_family: BSD purls: [] - size: 2619743 - timestamp: 1769664536467 -- conda: https://prefix.dev/conda-forge/osx-arm64/svt-av1-4.0.1-h0cb729a_0.conda - sha256: bdef3c1c4d2a396ad4f7dc64c5e9a02d4c5a21ff93ed07a33e49574de5d2d18d - md5: 8badc3bf16b62272aa2458f138223821 + size: 259122 + timestamp: 1753879389702 +- conda: https://prefix.dev/conda-forge/osx-arm64/libvulkan-loader-1.4.341.0-h3feff0a_0.conda + sha256: d2790dafc9149b1acd45b9033d02cfa3f3e9ee5af97bd61e0a5718c414a0a135 + md5: 6b4c9a5b130759136a0dde0c373cb0ea depends: - __osx >=11.0 - libcxx >=19 - license: BSD-2-Clause - license_family: BSD - purls: [] - size: 1456245 - timestamp: 1769664727051 -- conda: https://prefix.dev/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda - sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac - md5: cffd3bdd58090148f4cfcd831f4b26ab - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libzlib >=1.3.1,<2.0a0 constrains: - - xorg-libx11 >=1.8.12,<2.0a0 - license: TCL - license_family: BSD + - libvulkan-headers 1.4.341.0.* + license: Apache-2.0 + license_family: APACHE purls: [] - size: 3301196 - timestamp: 1769460227866 -- conda: https://prefix.dev/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda - sha256: 799cab4b6cde62f91f750149995d149bc9db525ec12595e8a1d91b9317f038b3 - md5: a9d86bc62f39b94c4661716624eb21b0 + size: 180304 + timestamp: 1770077143460 +- conda: https://prefix.dev/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda + sha256: a4de3f371bb7ada325e1f27a4ef7bcc81b2b6a330e46fac9c2f78ac0755ea3dd + md5: e5e7d467f80da752be17796b87fe6385 depends: - __osx >=11.0 - - libzlib >=1.3.1,<2.0a0 - license: TCL + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause license_family: BSD purls: [] - size: 3127137 - timestamp: 1769460817696 -- conda: https://prefix.dev/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda - sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd - md5: b5325cf06a000c5b14970462ff5e4d58 - depends: - - python >=3.10 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/tomli?source=hash-mapping - size: 21561 - timestamp: 1774492402955 -- conda: https://prefix.dev/conda-forge/noarch/tomli-w-1.2.0-pyhd8ed1ab_0.conda - sha256: 304834f2438017921d69f05b3f5a6394b42dc89a90a6128a46acbf8160d377f6 - md5: 32e37e8fe9ef45c637ee38ad51377769 + size: 294974 + timestamp: 1752159906788 +- conda: https://prefix.dev/conda-forge/osx-arm64/libxcb-1.17.0-hbffa61f_1.conda + sha256: 81f9b4fb64d977c19474d1b5616974757aaac21d55401ea105f21022b386bd28 + md5: 923bf656578743d064f352f0b56ee658 depends: - - python >=3.9 + - __osx >=11.0 + - pthread-stubs + - xorg-libxau >=1.0.12,<2.0a0 + - xorg-libxdmcp >=1.1.5,<2.0a0 license: MIT license_family: MIT - purls: - - pkg:pypi/tomli-w?source=hash-mapping - size: 12680 - timestamp: 1736962345843 -- conda: https://prefix.dev/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda - sha256: 1cd52f9ccb4854c4d731438afe0e833b6b71edaf5ede661152aa98efb3a7cc70 - md5: 42ef10a8f7f5d55a2e267c0d5daa6387 + purls: [] + size: 324264 + timestamp: 1787077544793 +- conda: https://prefix.dev/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda + sha256: ff75b84cdb9e8d123db2fa694a8ac2c2059516b6cbc98ac21fb68e235d0fd354 + md5: 19edaa53885fc8205614b03da2482282 depends: - - python >=3.10 + - __osx >=11.0 + - icu >=78.3,<79.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.3 license: MIT license_family: MIT - purls: - - pkg:pypi/tomlkit?source=compressed-mapping - size: 41169 - timestamp: 1778423744478 -- conda: https://prefix.dev/conda-forge/linux-64/tornado-6.5.5-py311h49ec1c0_0.conda - sha256: cd8bc08ca661291cfbb05581b79f7e6a6971a072a54a335abcea5460c1230880 - md5: 73b44a114241e564deb5846e7394bf19 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - python >=3.11,<3.12.0a0 - - python_abi 3.11.* *_cp311 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/tornado?source=hash-mapping - size: 876817 - timestamp: 1774358035290 -- conda: https://prefix.dev/conda-forge/osx-arm64/tornado-6.5.5-py311hc949640_0.conda - sha256: 572923958ec987f3f68e228dfec243c89ab94b50398731215d36e2e040db8703 - md5: 6f12d9ff025ab1875dff67ad779ca29d + purls: [] + size: 466360 + timestamp: 1776377102261 +- conda: https://prefix.dev/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda + sha256: 361415a698514b19a852f5d1123c5da746d4642139904156ddfca7c922d23a05 + md5: bc5a5721b6439f2f62a84f2548136082 depends: - __osx >=11.0 - - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython - - python_abi 3.11.* *_cp311 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/tornado?source=hash-mapping - size: 875022 - timestamp: 1774358570256 -- conda: https://prefix.dev/conda-forge/noarch/trove-classifiers-2026.5.7.17-pyhd8ed1ab_0.conda - sha256: b06931edfab2f6bde64fae1e7323216b74389b5a27242bf2b54b401246efb04d - md5: 58ad6f35e45eca7db0fd5da95aafc693 + constrains: + - zlib 1.3.2 *_2 + license: Zlib + license_family: Other + purls: [] + size: 47759 + timestamp: 1774072956767 +- conda: https://prefix.dev/conda-forge/osx-arm64/llvm-openmp-22.1.4-hc7d1edf_0.conda + sha256: a269273ccf48be6ac582bb958713ba8373262b9157a0fc76b7e5475e8a1d2a78 + md5: 46d04a647df7a4525e487d88068d19ef depends: - - python >=3.10 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/trove-classifiers?source=hash-mapping - size: 20076 - timestamp: 1778229720640 -- conda: https://prefix.dev/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731 - md5: 0caa1af407ecff61170c9437a808404d + - __osx >=11.0 + constrains: + - openmp 22.1.4|22.1.4.* + - intel-openmp <0.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + purls: [] + size: 286406 + timestamp: 1776846235007 +- conda: https://prefix.dev/conda-forge/osx-arm64/llvmlite-0.49.0-py311h4a78e08_2.conda + sha256: 42f645cb34752835a9e9a39da5f383c5d5341727f37f3d96741ac035cc94d164 + md5: 16e87603b33bbbff99352220dee440a6 depends: - - python >=3.10 - python - license: PSF-2.0 - license_family: PSF + - __osx >=11.0 + - libcxx >=21 + - zstd >=1.5.7,<1.6.0a0 + - python_abi 3.11.* *_cp311 + - libzlib >=1.3.2,<2.0a0 + license: BSD-2-Clause + license_family: BSD purls: - - pkg:pypi/typing-extensions?source=hash-mapping - size: 51692 - timestamp: 1756220668932 -- conda: https://prefix.dev/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda - sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c - md5: ad659d0a2b3e47e38d829aa8cad2d610 - license: LicenseRef-Public-Domain - purls: [] - size: 119135 - timestamp: 1767016325805 -- conda: https://prefix.dev/conda-forge/linux-64/ukkonen-1.1.0-py311hdf67eae_0.conda - sha256: 31ad759e2d7668f1615021bca0ae2358a284939e3ca3fcb971b3f7aa83c2a6d6 - md5: 5a715cf5e3dc6cd68717c50e47dd7b6b + - pkg:pypi/llvmlite?source=hash-mapping + size: 30512158 + timestamp: 1788013780870 +- conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-3.11.1-py311ha01d089_2.conda + sha256: 3e9381c800201853483185f7403d8ceb8f013d8a0dcda37c864a34e708158180 + md5: 7ce16f8bcf8a38405f1f09801e1bf832 depends: - - __glibc >=2.17,<3.0.a0 - - cffi - - libgcc >=14 - - libstdcxx >=14 + - matplotlib-base >=3.11.1,<3.11.2.0a0 - python >=3.11,<3.12.0a0 - python_abi 3.11.* *_cp311 - license: MIT - license_family: MIT - purls: - - pkg:pypi/ukkonen?source=hash-mapping - size: 14898 - timestamp: 1769438724694 -- conda: https://prefix.dev/conda-forge/osx-arm64/ukkonen-1.1.0-py311h572238d_0.conda - sha256: 1bf370d4d4698b339d54342b2d653d9ed26f5004af2da3e5556b641fb5e56e1b - md5: 2855259ce88c41c1b2297041ec75f540 + - tornado >=5 + license: PSF-2.0 + license_family: PSF + purls: [] + size: 14921 + timestamp: 1785211095125 +- conda: https://prefix.dev/conda-forge/osx-arm64/matplotlib-base-3.11.1-py311h3c3ad35_2.conda + sha256: 09330e68ce42c7ed076a296b04ce3ea0cb10d72fb5c31b68bf1aa93ecf553a07 + md5: e0a2569461d3cc107301cce6835cf0ba depends: - __osx >=11.0 - - cffi + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.28.2 + - freetype + - kiwisolver >=1.3.1 - libcxx >=19 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libraqm >=0.11.0,<0.12.0a0 + - numpy >=1.23,<3 + - numpy >=1.25 + - packaging >=20.0 + - pillow >=9 + - pyparsing >=3 - python >=3.11,<3.12.0a0 - - python >=3.11,<3.12.0a0 *_cpython + - python-dateutil >=2.7 - python_abi 3.11.* *_cp311 - license: MIT - license_family: MIT + - qhull >=2020.2,<2020.3.0a0 + license: PSF-2.0 + license_family: PSF purls: - - pkg:pypi/ukkonen?source=hash-mapping - size: 14760 - timestamp: 1769438970347 -- conda: https://prefix.dev/conda-forge/linux-64/unicodedata2-17.0.1-py311h49ec1c0_0.conda - sha256: 2bd8ee058dc98e614003591eb221a8b08449768b13aebe76dad8528bf0f5f88b - md5: 2889f0c0b6a6d7a37bd64ec60f4cc210 + - pkg:pypi/matplotlib?source=hash-mapping + size: 8811362 + timestamp: 1785211075697 +- conda: https://prefix.dev/conda-forge/osx-arm64/mpg123-1.32.9-hf642e45_0.conda + sha256: 070bbbbb96856c325c0b6637638ce535afdc49adbaff306e2238c6032d28dddf + md5: d2b4857bdc3b76c36e23236172d09840 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - python >=3.11,<3.12.0a0 + - __osx >=11.0 + - libcxx >=18 + license: LGPL-2.1-only + license_family: LGPL + purls: [] + size: 360712 + timestamp: 1730581491116 +- conda: https://prefix.dev/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda + sha256: 4ea6c620b87bd1d42bb2ccc2c87cd2483fa2d7f9e905b14c223f11ff3f4c455d + md5: 343d10ed5b44030a2f67193905aea159 + depends: + - __osx >=11.0 + license: X11 AND BSD-3-Clause + purls: [] + size: 805509 + timestamp: 1777423252320 +- conda: https://prefix.dev/conda-forge/osx-arm64/numba-0.67.0-py311hf682900_1.conda + sha256: fd613c23e421aa4b8700308951c90b7c4f5f3b78f85025e0c3af9366fdf5c4b0 + md5: 643ca1646acb686990d5febe0c0e5d63 + depends: + - python + - llvmlite >=0.49.0,<0.50.0a0 + - numpy >=1.22.3,<2.6 + - libcxx >=21 + - __osx >=11.0 + - llvm-openmp >=21.1.8 - python_abi 3.11.* *_cp311 - license: Apache-2.0 - license_family: Apache + - numpy >=1.23,<3 + constrains: + - tbb >=2021.6.0 + - libopenblas >=0.3.18,!=0.3.20 + - cuda-version >=11.2 + - cudatoolkit >=11.2 + - scipy >=1.0 + - cuda-python >=11.6 + license: BSD-2-Clause + license_family: BSD purls: - - pkg:pypi/unicodedata2?source=hash-mapping - size: 409682 - timestamp: 1770909108616 -- conda: https://prefix.dev/conda-forge/osx-arm64/unicodedata2-17.0.1-py311hc949640_0.conda - sha256: 984d3b0ddb0802c228c520db31d906b5b546b13da3eca1ce35c754d97c012497 - md5: a9d9010d246205c63f824b0bcf050acd + - pkg:pypi/numba?source=hash-mapping + size: 6273051 + timestamp: 1787145526945 +- conda: https://prefix.dev/conda-forge/osx-arm64/numpy-2.0.2-py311h649a571_1.conda + sha256: 3d4c508041d17007a56f79b593a6d6a69d4f4e2453f1f7ee29ecb48992cc3acc + md5: 417c4c5c4a4693156f5b878cf94bf7a0 depends: - __osx >=11.0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=18 + - liblapack >=3.9.0,<4.0a0 - python >=3.11,<3.12.0a0 - python >=3.11,<3.12.0a0 *_cpython - python_abi 3.11.* *_cp311 - license: Apache-2.0 - license_family: Apache - purls: - - pkg:pypi/unicodedata2?source=hash-mapping - size: 416024 - timestamp: 1770909604661 -- conda: https://prefix.dev/conda-forge/noarch/userpath-1.9.2-pyhd8ed1ab_0.conda - sha256: 26e53b42f7fa1127e6115a35b91c20e15f75984648b88f115136f27715d4a440 - md5: 946e3571aaa55e0870fec0dea13de3bf - depends: - - click - - python >=3.9 - license: MIT - license_family: MIT - purls: - - pkg:pypi/userpath?source=hash-mapping - size: 14292 - timestamp: 1735925027874 -- conda: https://prefix.dev/conda-forge/linux-64/uv-0.11.12-h29f5ae7_0.conda - sha256: 4fc1481bb6ecf5a1a755661483eb99a0ec2054cd02e5893b55f9c80bac9437a8 - md5: e86a95851fd53465f0657c068cb6c403 - depends: - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - - libstdcxx >=14 constrains: - - __glibc >=2.17 - license: Apache-2.0 OR MIT - purls: [] - size: 19190543 - timestamp: 1778287747008 -- conda: https://prefix.dev/conda-forge/osx-arm64/uv-0.11.12-h2c65d96_0.conda - sha256: e8050d5259b4f77b838ecc573643451593b39970f1b25412267db10919de2ca3 - md5: a5b3c646ec7fe96f192bb4f5fa8442f3 + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 6893464 + timestamp: 1732314808608 +- conda: https://prefix.dev/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda + sha256: 60aca8b9f94d06b852b296c276b3cf0efba5a6eb9f25feb8708570d3a74f00e4 + md5: 4b5d3a91320976eec71678fad1e3569b depends: - __osx >=11.0 - libcxx >=19 - constrains: + - libpng >=1.6.55,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 319697 + timestamp: 1772625397692 +- conda: https://prefix.dev/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda + sha256: c91bf510c130a1ea1b6ff023e28bac0ccaef869446acd805e2016f69ebdc49ea + md5: 25dcccd4f80f1638428613e0d7c9b4e1 + depends: - __osx >=11.0 - license: Apache-2.0 OR MIT + - ca-certificates + license: Apache-2.0 + license_family: Apache purls: [] - size: 16562936 - timestamp: 1778287818707 -- conda: https://prefix.dev/conda-forge/noarch/virtualenv-21.3.1-pyhcf101f3_0.conda - sha256: 8888b4725d4166ab54435ba4b6a24e9f089578301a88f8157d012dd38a88ac43 - md5: dd6a1f3ce9d1cfa8b5b1b32953a80a55 + size: 3106008 + timestamp: 1775587972483 +- conda: https://prefix.dev/conda-forge/osx-arm64/opusfile-0.12-h5643135_2.conda + sha256: 108dbee936a8e3c21d2aa5618326343844df8f1fe14067c4dc5a731d7945ecc0 + md5: e34e472ae04beeb642c5e937a2aeeebf + depends: + - libogg >=1.3.4,<1.4.0a0 + - libopus >=1.3.1,<2.0a0 + - openssl >=3.0.7,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 80128 + timestamp: 1670387790769 +- conda: https://prefix.dev/conda-forge/osx-arm64/pandas-3.0.1-py311h4a068b9_0.conda + sha256: 1a0f57d3c5fb08e97c8a92f560e1ce011f4ab5a1185eacb60e83c00458684dc4 + md5: e853dd807ee17d7d4f6c3c57b29456ac depends: - - python >=3.10 - - distlib >=0.3.7,<1 - - filelock <4,>=3.24.2 - - importlib-metadata >=6.6 - - platformdirs >=3.9.1,<5 - - python-discovery >=1 - - typing_extensions >=4.13.2 - python - license: MIT - license_family: MIT + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - __osx >=11.0 + - libcxx >=19 + - python 3.11.* *_cpython + - numpy >=1.23,<3 + - python_abi 3.11.* *_cp311 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 + - pyxlsb >=1.0.10 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 + license: BSD-3-Clause + license_family: BSD purls: - - pkg:pypi/virtualenv?source=hash-mapping - size: 5154970 - timestamp: 1777964652524 -- conda: https://prefix.dev/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda - sha256: ea374d57a8fcda281a0a89af0ee49a2c2e99cc4ac97cf2e2db7064e74e764bdb - md5: 996583ea9c796e5b915f7d7580b51ea6 + - pkg:pypi/pandas?source=hash-mapping + size: 14295353 + timestamp: 1771409101672 +- conda: https://prefix.dev/conda-forge/osx-arm64/pango-1.56.4-h875632e_0.conda + sha256: 705484ad60adee86cab1aad3d2d8def03a699ece438c864e8ac995f6f66401a6 + md5: 7d57f8b4b7acfc75c777bc231f0d31be depends: - - __glibc >=2.17,<3.0.a0 - - libexpat >=2.7.4,<3.0a0 - - libffi >=3.5.2,<3.6.0a0 - - libgcc >=14 - - libstdcxx >=14 - license: MIT - license_family: MIT + - __osx >=11.0 + - cairo >=1.18.4,<2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - fribidi >=1.0.10,<2.0a0 + - harfbuzz >=11.0.1 + - libexpat >=2.7.0,<3.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libglib >=2.84.2,<3.0a0 + - libpng >=1.6.49,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + license: LGPL-2.1-or-later purls: [] - size: 334139 - timestamp: 1773959575393 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda - sha256: ad8cab7e07e2af268449c2ce855cbb51f43f4664936eff679b1f3862e6e4b01d - md5: fdc27cb255a7a2cc73b7919a968b48f0 + size: 426931 + timestamp: 1751292636271 +- conda: https://prefix.dev/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda + sha256: 5e2e443f796f2fd92adf7978286a525fb768c34e12b1ee9ded4000a41b2894ba + md5: 9b4190c4055435ca3502070186eba53a depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libxcb >=1.17.0,<2.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD purls: [] - size: 20772 - timestamp: 1750436796633 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda - sha256: c2be9cae786fdb2df7c2387d2db31b285cf90ab3bfabda8fa75a596c3d20fc67 - md5: 4d1fc190b99912ed557a8236e958c559 + size: 850231 + timestamp: 1763655726735 +- conda: https://prefix.dev/conda-forge/osx-arm64/pillow-12.3.0-py311hd37aea2_0.conda + sha256: 3c680e002d0aadf9e21b6ee50929d8fec6ced9234b1340a027255b4518e6e49f + md5: 26ba3b773222fada6f89baf4846190e3 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libxcb >=1.13 + - python + - python 3.11.* *_cpython + - __osx >=11.0 + - openjpeg >=2.5.4,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + - python_abi 3.11.* *_cp311 + - libtiff >=4.7.1,<4.8.0a0 - libxcb >=1.17.0,<2.0a0 - - xcb-util-image >=0.4.0,<0.5.0a0 - - xcb-util-renderutil >=0.3.10,<0.4.0a0 - license: MIT - license_family: MIT - purls: [] - size: 20829 - timestamp: 1763366954390 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda - sha256: 94b12ff8b30260d9de4fd7a28cca12e028e572cbc504fd42aa2646ec4a5bded7 - md5: a0901183f08b6c7107aab109733a3c91 + - tk >=8.6.13,<8.7.0a0 + - lcms2 >=2.19.1,<3.0a0 + - libwebp-base >=1.6.0,<2.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=hash-mapping + size: 993213 + timestamp: 1782912213683 +- conda: https://prefix.dev/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda + sha256: 29c9b08a9b8b7810f9d4f159aecfd205fce051633169040005c0b7efad4bc718 + md5: 17c3d745db6ea72ae2fce17e7338547f depends: - - libgcc-ng >=12 - - libxcb >=1.16,<2.0.0a0 - - xcb-util >=0.4.1,<0.5.0a0 + - __osx >=11.0 + - libcxx >=19 license: MIT license_family: MIT purls: [] - size: 24551 - timestamp: 1718880534789 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda - sha256: 546e3ee01e95a4c884b6401284bb22da449a2f4daf508d038fdfa0712fe4cc69 - md5: ad748ccca349aec3e91743e08b5e2b50 + size: 248045 + timestamp: 1754665282033 +- conda: https://prefix.dev/conda-forge/osx-arm64/portaudio-19.7.0-h5833ebf_0.conda + sha256: 3d86803ade1ff3fd29ea1b61ce2e5ad65af0966d795ab8a7a2685fee75cf0f82 + md5: fb72bb70cfea298990d5e1a12317047c depends: - - libgcc-ng >=12 - - libxcb >=1.16,<2.0.0a0 + - __osx >=11.0 + - libcxx >=17 license: MIT license_family: MIT purls: [] - size: 14314 - timestamp: 1718846569232 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda - sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df - md5: 0e0cbe0564d03a99afd5fd7b362feecd + size: 58138 + timestamp: 1730364270871 +- conda: https://prefix.dev/conda-forge/osx-arm64/portmidi-2.0.8-haf25636_0.conda + sha256: 2a1fb2c2507a3b88ac68c4dac435a836be365446e66e995749d2188456fb4262 + md5: 2544b03efb37c9476f3ab4e993c224d1 depends: - - libgcc-ng >=12 - - libxcb >=1.16,<2.0.0a0 + - __osx >=11.0 + - libcxx >=19 license: MIT license_family: MIT purls: [] - size: 16978 - timestamp: 1718848865819 -- conda: https://prefix.dev/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda - sha256: 31d44f297ad87a1e6510895740325a635dd204556aa7e079194a0034cdd7e66a - md5: 608e0ef8256b81d04456e8d211eee3e8 + size: 41391 + timestamp: 1764706738148 +- conda: https://prefix.dev/conda-forge/osx-arm64/protobuf-3.20.2-py311ha397e9f_1.conda + sha256: 38ea7c727a352ae38199c9b87b5b5636cd6bb62de13491788d803e69611776da + md5: cfa15b242f40e62b78281a3b85b07eec depends: - - libgcc-ng >=12 - - libxcb >=1.16,<2.0.0a0 - license: MIT - license_family: MIT - purls: [] - size: 51689 - timestamp: 1718844051451 -- conda: https://prefix.dev/conda-forge/linux-64/xkeyboard-config-2.47-hb03c661_0.conda - sha256: 19c2bb14bec84b0e995b56b752369775c75f1589314b43733948bb5f471a6915 - md5: b56e0c8432b56decafae7e78c5f29ba5 + - libcxx >=14.0.6 + - libprotobuf 3.20.2.* + - libprotobuf >=3.20.2,<3.21.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - setuptools + - six + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/protobuf?source=hash-mapping + size: 348201 + timestamp: 1669119662437 +- conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-h84a0fba_1003.conda + sha256: 1c2338b9b0486af86883b9593d2f3e2845bbf216ea453dfe5d9a228e8dbe4057 + md5: d4852e6054b74645cf49ca10f6349191 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.13,<2.0a0 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 399291 - timestamp: 1772021302485 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda - sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b - md5: fb901ff28063514abb6046c9ec2c4a45 + size: 9238 + timestamp: 1786068031100 +- conda: https://prefix.dev/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + sha256: 8ed65e17fbb0ca944bfb8093b60086e3f9dd678c3448b5de212017394c247ee3 + md5: 415816daf82e0b23a736a069a75e9da7 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 58628 - timestamp: 1734227592886 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda - sha256: 277841c43a39f738927145930ff963c5ce4c4dacf66637a3d95d802a64173250 - md5: 1c74ff8c35dcadf952a16f752ca5aa49 + size: 8381 + timestamp: 1726802424786 +- conda: https://prefix.dev/conda-forge/osx-arm64/pygame-2.6.1-py311hc3e7c57_0.conda + sha256: e95e452aed4e6511b16f2650526c3e74438d5198a14e646832020d854dfa9964 + md5: db72b6d24c6c7ce1d80b8c659b4aeb2b depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libuuid >=2.38.1,<3.0a0 - - xorg-libice >=1.1.2,<2.0a0 - license: MIT - license_family: MIT - purls: [] - size: 27590 - timestamp: 1741896361728 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda - sha256: 516d4060139dbb4de49a4dcdc6317a9353fb39ebd47789c14e6fe52de0deee42 - md5: 861fb6ccbc677bb9a9fb2468430b9c6a + - __osx >=11.0 + - fontconfig >=2.14.2,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - libcxx >=17 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.44,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + - portmidi >=2.0.4,<3.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - sdl2 >=2.30.7,<3.0a0 + - sdl2_image >=2.8.2,<3.0a0 + - sdl2_mixer >=2.6.3,<3.0a0 + - sdl2_ttf >=2.22.0,<3.0a0 + license: LGPL-2.1-only + purls: + - pkg:pypi/pygame?source=hash-mapping + size: 2917534 + timestamp: 1727636756068 +- conda: https://prefix.dev/conda-forge/osx-arm64/python-3.10.20-h1b19095_0_cpython.conda + sha256: f0f6fcbb6cfdee5a6b9c03b5b94d2bbe737f3b17a618006c7685cc48992ae667 + md5: 55ec25b0d09379eb11c32dbe09ee28c4 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libxcb >=1.17.0,<2.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.4,<4.0a0 + - liblzma >=5.8.2,<6.0a0 + - libsqlite >=3.51.2,<4.0a0 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - openssl >=3.5.5,<4.0a0 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + constrains: + - python_abi 3.10.* *_cp310 + license: Python-2.0 purls: [] - size: 839652 - timestamp: 1770819209719 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda - sha256: 6bc6ab7a90a5d8ac94c7e300cc10beb0500eeba4b99822768ca2f2ef356f731b - md5: b2895afaf55bf96a8c8282a2e47a5de0 + size: 12468674 + timestamp: 1772730636766 +- conda: https://prefix.dev/conda-forge/osx-arm64/python-3.11.15-h8561d8f_0_cpython.conda + sha256: 9a846065863925b2562126a5c6fecd7a972e84aaa4de9e686ad3715ca506acfa + md5: 49c7d96c58b969585cf09fb01d74e08e depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - license: MIT - license_family: MIT + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.2,<6.0a0 + - libsqlite >=3.51.2,<4.0a0 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - openssl >=3.5.5,<4.0a0 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + constrains: + - python_abi 3.11.* *_cp311 + license: Python-2.0 purls: [] - size: 15321 - timestamp: 1762976464266 -- conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxau-1.0.12-h84a0fba_2.conda - sha256: 5c5ea38ceec008e4ff40111fc166b04086fca310b0aa9e5bd46f65e6b0dcb71d - md5: 31d71ce1b056f69b6ec67ee0712bdf97 + size: 14753109 + timestamp: 1772730203101 +- conda: https://prefix.dev/conda-forge/osx-arm64/pyyaml-6.0.3-py311hc290fe0_1.conda + sha256: 984e73d7957460689e10533059de8adb38a308853d298900a37acc58edd84cec + md5: e4b908da7cd496b3fa6798c0f60a2a19 depends: - __osx >=11.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT - purls: [] - size: 15124 - timestamp: 1786381585975 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda - sha256: 048c103000af9541c919deef03ae7c5e9c570ffb4024b42ecb58dbde402e373a - md5: f2ba4192d38b6cef2bb2c25029071d90 + purls: + - pkg:pypi/pyyaml?source=hash-mapping + size: 192948 + timestamp: 1770223655988 +- conda: https://prefix.dev/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda + sha256: 873ac689484262a51fd79bc6103c1a1bedbf524924d7f0088fb80703042805e4 + md5: 6483b1f59526e05d7d894e466b5b6924 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxfixes >=6.0.2,<7.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - libcxx >=16 + license: LicenseRef-Qhull purls: [] - size: 14415 - timestamp: 1770044404696 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda - sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a - md5: 2ccd714aa2242315acaf0a67faea780b + size: 516376 + timestamp: 1720814307311 +- conda: https://prefix.dev/conda-forge/osx-arm64/rav1e-0.8.1-h8246384_0.conda + sha256: 925e35b71fe513e0380ecd2fe137e3f4f248bf7ce4bad96946c7c704b7a50d26 + md5: 4706a8a71474c692482c3f86c2175454 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-libxfixes >=6.0.1,<7.0a0 - - xorg-libxrender >=0.9.11,<0.10.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + constrains: + - __osx >=11.0 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 32533 - timestamp: 1730908305254 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda - sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0 - md5: b5fcc7172d22516e1f965490e65e33a4 + size: 886953 + timestamp: 1772541394570 +- conda: https://prefix.dev/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda + sha256: a77010528efb4b548ac2a4484eaf7e1c3907f2aec86123ed9c5212ae44502477 + md5: f8381319127120ce51e081dce4865cf4 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - - xorg-libxfixes >=6.0.1,<7.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - ncurses >=6.5,<7.0a0 + license: GPL-3.0-only + license_family: GPL purls: [] - size: 13217 - timestamp: 1727891438799 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda - sha256: 25d255fb2eef929d21ff660a0c687d38a6d2ccfbcbf0cc6aa738b12af6e9d142 - md5: 1dafce8548e38671bea82e3f5c6ce22f - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 + size: 313930 + timestamp: 1765813902568 +- conda: https://prefix.dev/conda-forge/osx-arm64/rhash-1.4.3-hb547adb_2.conda + sha256: f20c9765768d0c61bbbb462dc83b55372328498a746f60e1e93c985e3436ef73 + md5: 24308c7e0949c572688900b8b2f2a3ba license: MIT license_family: MIT purls: [] - size: 20591 - timestamp: 1762976546182 -- conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-h84a0fba_2.conda - sha256: 2f6915f0897ace4a1b5d66d0463079f7bc9819b0048c03677e47764f0a743499 - md5: f51e9414bf1b7bb556aac1a0b74a75fe + size: 176444 + timestamp: 1693427792263 +- conda: https://prefix.dev/conda-forge/osx-arm64/ruff-0.15.12-hbd3f8a3_0.conda + noarch: python + sha256: 91992a557456cbe9980e8ffb0f0d1200f65f741adeefc7ecf568d1935690a7bc + md5: 7151a0851207b88c0031f388a7825e9b depends: + - python + - __osx >=11.0 + constrains: - __osx >=11.0 license: MIT license_family: MIT - purls: [] - size: 19486 - timestamp: 1786381546642 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda - sha256: 79c60fc6acfd3d713d6340d3b4e296836a0f8c51602327b32794625826bd052f - md5: 34e54f03dfea3e7a2dcf1453a85f1085 + purls: + - pkg:pypi/ruff?source=hash-mapping + size: 8485007 + timestamp: 1778119519471 +- conda: https://prefix.dev/conda-forge/osx-arm64/scipy-1.17.1-py311he9931d0_0.conda + sha256: f212138a7eb86cf8bcdb46f003ae552967cd7e48d2c539f7f8dd6e800c74b70d + md5: 40606bef4834281d5f746626338829dc depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - license: MIT - license_family: MIT - purls: [] - size: 50326 - timestamp: 1769445253162 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda - sha256: 83c4c99d60b8784a611351220452a0a85b080668188dce5dfa394b723d7b64f4 - md5: ba231da7fccf9ea1e768caf5c7099b84 + - __osx >=11.0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libcxx >=19 + - libgfortran + - libgfortran5 >=14.3.0 + - liblapack >=3.9.0,<4.0a0 + - numpy <2.7 + - numpy >=1.23,<3 + - numpy >=1.25.2 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/scipy?source=hash-mapping + size: 14107248 + timestamp: 1771880859933 +- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2-2.32.56-h248ca61_0.conda + sha256: 704c5cae4bc839a18c70cbf3387d7789f1902828c79c6ddabcd34daf594f4103 + md5: 092c5b693dc6adf5f409d12f33295a2a depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - license: MIT - license_family: MIT + - libcxx >=19 + - __osx >=11.0 + - sdl3 >=3.2.22,<4.0a0 + license: Zlib purls: [] - size: 20071 - timestamp: 1759282564045 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda - sha256: 1a724b47d98d7880f26da40e45f01728e7638e6ec69f35a3e11f92acd05f9e7a - md5: 17dcc85db3c7886650b8908b183d6876 + size: 542508 + timestamp: 1757842919681 +- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_image-2.8.2-h376e2e1_1.conda + sha256: 8c385478a7b6a6e34b3b3f3d48ed48f504698544987ad331f03a7b43b11d689a + md5: 247d2c5a873901ef51f378c69a2c708e depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - - xorg-libxfixes >=6.0.1,<7.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - libavif16 >=1.0.4,<2.0a0 + - libcxx >=16 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 + - libwebp-base >=1.4.0,<2.0a0 + - libzlib >=1.2.13,<2.0.0a0 + - sdl2 >=2.30.2,<3.0a0 + license: Zlib purls: [] - size: 47179 - timestamp: 1727799254088 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxinerama-1.1.6-hecca717_0.conda - sha256: 3a9da41aac6dca9d3ff1b53ee18b9d314de88add76bafad9ca2287a494abcd86 - md5: 93f5d4b5c17c8540479ad65f206fea51 + size: 118041 + timestamp: 1716857215118 +- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_mixer-2.6.3-h45fadf6_2.conda + sha256: b826d7fa6738d9fcc36bdcb299744246fe82d0f9d9d0d0f999f3111cb7b4d373 + md5: 890924faa4965ba3edb0cc5cc94db572 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - libstdcxx >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - fluidsynth >=2.5.2,<2.6.0a0 + - libcxx >=19 + - libflac >=1.5.0,<1.6.0a0 + - libmad >=0.15.1b,<0.16.0a0 + - libogg >=1.3.5,<1.4.0a0 + - libvorbis >=1.3.7,<1.4.0a0 + - mpg123 >=1.32.9,<1.33.0a0 + - opusfile >=0.12,<0.13.0a0 + - sdl2 >=2.32.56,<3.0a0 + license: Zlib purls: [] - size: 14818 - timestamp: 1769432261050 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda - sha256: 80ed047a5cb30632c3dc5804c7716131d767089f65877813d4ae855ee5c9d343 - md5: e192019153591938acf7322b6459d36e + size: 187456 + timestamp: 1766614943278 +- conda: https://prefix.dev/conda-forge/osx-arm64/sdl2_ttf-2.24.0-h443c5de_0.conda + sha256: 5dc56fd1de51dec2f7b63b1a9069ab35ab0494d9cd5af164ab0019cbd9564cf6 + md5: 3cf5cf83deccb663b4e932d3d4b28f57 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - - xorg-libxrender >=0.9.12,<0.10.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - freetype >=2.12.1,<3.0a0 + - harfbuzz >=10.1.0 + - sdl2 >=2.30.10,<3.0a0 + license: Zlib purls: [] - size: 30456 - timestamp: 1769445263457 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda - sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1 - md5: 96d57aba173e878a2089d5638016dc5e + size: 45429 + timestamp: 1736118165229 +- conda: https://prefix.dev/conda-forge/osx-arm64/sdl3-3.4.8-h6fa9c73_0.conda + sha256: 0c15a7f3f46d175c70ca7b032cee3eee9ef602492688a79a6e734f2efc466dad + md5: 53311362c6da21e58442bfb959991455 + depends: + - __osx >=11.0 + - libcxx >=19 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - libusb >=1.0.29,<2.0a0 + - dbus >=1.16.2,<2.0a0 + license: Zlib + purls: [] + size: 1561566 + timestamp: 1777693640800 +- conda: https://prefix.dev/conda-forge/osx-arm64/svt-av1-4.0.1-h0cb729a_0.conda + sha256: bdef3c1c4d2a396ad4f7dc64c5e9a02d4c5a21ff93ed07a33e49574de5d2d18d + md5: 8badc3bf16b62272aa2458f138223821 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - libcxx >=19 + license: BSD-2-Clause + license_family: BSD purls: [] - size: 33005 - timestamp: 1734229037766 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxscrnsaver-1.2.4-hb9d3cd8_0.conda - sha256: 58e8fc1687534124832d22e102f098b5401173212ac69eb9fd96b16a3e2c8cb2 - md5: 303f7a0e9e0cd7d250bb6b952cecda90 + size: 1456245 + timestamp: 1769664727051 +- conda: https://prefix.dev/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda + sha256: 799cab4b6cde62f91f750149995d149bc9db525ec12595e8a1d91b9317f038b3 + md5: a9d86bc62f39b94c4661716624eb21b0 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - license: MIT - license_family: MIT + - __osx >=11.0 + - libzlib >=1.3.1,<2.0a0 + license: TCL + license_family: BSD purls: [] - size: 14412 - timestamp: 1727899730073 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda - sha256: 752fdaac5d58ed863bbf685bb6f98092fe1a488ea8ebb7ed7b606ccfce08637a - md5: 7bbe9a0cc0df0ac5f5a8ad6d6a11af2f + size: 3127137 + timestamp: 1769460817696 +- conda: https://prefix.dev/conda-forge/osx-arm64/tornado-6.5.5-py311hc949640_0.conda + sha256: 572923958ec987f3f68e228dfec243c89ab94b50398731215d36e2e040db8703 + md5: 6f12d9ff025ab1875dff67ad779ca29d depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - xorg-libx11 >=1.8.10,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - - xorg-libxi >=1.7.10,<2.0a0 + - __osx >=11.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=hash-mapping + size: 875022 + timestamp: 1774358570256 +- conda: https://prefix.dev/conda-forge/osx-arm64/ukkonen-1.1.0-py311h572238d_0.conda + sha256: 1bf370d4d4698b339d54342b2d653d9ed26f5004af2da3e5556b641fb5e56e1b + md5: 2855259ce88c41c1b2297041ec75f540 + depends: + - __osx >=11.0 + - cffi + - libcxx >=19 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 license: MIT license_family: MIT + purls: + - pkg:pypi/ukkonen?source=hash-mapping + size: 14760 + timestamp: 1769438970347 +- conda: https://prefix.dev/conda-forge/osx-arm64/unicodedata2-17.0.1-py311hc949640_0.conda + sha256: 984d3b0ddb0802c228c520db31d906b5b546b13da3eca1ce35c754d97c012497 + md5: a9d9010d246205c63f824b0bcf050acd + depends: + - __osx >=11.0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 416024 + timestamp: 1770909604661 +- conda: https://prefix.dev/conda-forge/osx-arm64/uv-0.11.12-h2c65d96_0.conda + sha256: e8050d5259b4f77b838ecc573643451593b39970f1b25412267db10919de2ca3 + md5: a5b3c646ec7fe96f192bb4f5fa8442f3 + depends: + - __osx >=11.0 + - libcxx >=19 + constrains: + - __osx >=11.0 + license: Apache-2.0 OR MIT purls: [] - size: 32808 - timestamp: 1727964811275 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda - sha256: 64db17baaf36fa03ed8fae105e2e671a7383e22df4077486646f7dbf12842c9f - md5: 665d152b9c6e78da404086088077c844 + size: 16562936 + timestamp: 1778287818707 +- conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxau-1.0.12-h84a0fba_2.conda + sha256: 5c5ea38ceec008e4ff40111fc166b04086fca310b0aa9e5bd46f65e6b0dcb71d + md5: 31d71ce1b056f69b6ec67ee0712bdf97 depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 18701 - timestamp: 1769434732453 -- conda: https://prefix.dev/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda - sha256: 7a8c64938428c2bfd016359f9cb3c44f94acc256c6167dbdade9f2a1f5ca7a36 - md5: aa8d21be4b461ce612d8f5fb791decae + size: 15124 + timestamp: 1786381585975 +- conda: https://prefix.dev/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-h84a0fba_2.conda + sha256: 2f6915f0897ace4a1b5d66d0463079f7bc9819b0048c03677e47764f0a743499 + md5: f51e9414bf1b7bb556aac1a0b74a75fe depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 + - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 570010 - timestamp: 1766154256151 -- conda: https://prefix.dev/conda-forge/linux-64/xz-5.8.3-ha02ee65_0.conda - sha256: 2553fd3ec0a1020b2ca05ca10b0036a596cb0d4bf3645922fcf69dacce0e6679 - md5: 6a1b6af49a334e4e06b9f103367762bf - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - liblzma 5.8.3 hb03c661_0 - - liblzma-devel 5.8.3 hb03c661_0 - - xz-gpl-tools 5.8.3 ha02ee65_0 - - xz-tools 5.8.3 hb03c661_0 - license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later - purls: [] - size: 24360 - timestamp: 1775825568523 + size: 19486 + timestamp: 1786381546642 - conda: https://prefix.dev/conda-forge/osx-arm64/xz-5.8.3-hd0f0c4f_0.conda sha256: d5bb880876336f625523c022aa9bdc6be76a85df721d9e7b33c352f528619185 md5: 4df12be699991b97b66a85cc46ea75b5 @@ -6349,19 +6412,6 @@ packages: purls: [] size: 24348 timestamp: 1775825911109 -- conda: https://prefix.dev/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_0.conda - sha256: 8f139666ea18dc8340a44a54056627dd4e89e242e8cd136ab2467d6dc2c192ba - md5: 8f5e2c6726c1339287a3c76a2c138ac7 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - liblzma 5.8.3 hb03c661_0 - constrains: - - xz 5.8.3.* - license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later - purls: [] - size: 34213 - timestamp: 1775825548743 - conda: https://prefix.dev/conda-forge/osx-arm64/xz-gpl-tools-5.8.3-hd0f0c4f_0.conda sha256: 0864d53202f618b4c8a5f2c38b7029f14b900b852e99b6248813303f69ccfdee md5: 43d168a8c95a8fcdcc44c2a0a7887653 @@ -6374,19 +6424,6 @@ packages: purls: [] size: 34224 timestamp: 1775825884830 -- conda: https://prefix.dev/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_0.conda - sha256: 162ebd76803464b8c8ebc7d45df32edf0ec717b3bf369a437ae3b0254f22dc2e - md5: b62b615caa60812640f24db3a8d0fc87 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=14 - - liblzma 5.8.3 hb03c661_0 - constrains: - - xz 5.8.3.* - license: 0BSD AND LGPL-2.1-or-later - purls: [] - size: 95955 - timestamp: 1775825530484 - conda: https://prefix.dev/conda-forge/osx-arm64/xz-tools-5.8.3-h8088a28_0.conda sha256: beb7fb34d5517cce06f5f89710de7108a8ca65ed9c0324269fc0446807bcbd91 md5: b8c47eab4e58fe7015a12ceb9d5b114c @@ -6399,17 +6436,6 @@ packages: purls: [] size: 85931 timestamp: 1775825857949 -- conda: https://prefix.dev/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda - sha256: 6d9ea2f731e284e9316d95fa61869fe7bbba33df7929f82693c121022810f4ad - md5: a77f85f77be52ff59391544bfe73390a - depends: - - libgcc >=14 - - __glibc >=2.17,<3.0.a0 - license: MIT - license_family: MIT - purls: [] - size: 85189 - timestamp: 1753484064210 - conda: https://prefix.dev/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda sha256: b03433b13d89f5567e828ea9f1a7d5c5d697bf374c28a4168d71e9464f5dafac md5: 78a0fe9e9c50d2c381e8ee47e3ea437d @@ -6420,29 +6446,6 @@ packages: purls: [] size: 83386 timestamp: 1753484079473 -- conda: https://prefix.dev/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda - sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca - md5: e1c36c6121a7c9c76f2f148f1e83b983 - depends: - - python >=3.10 - - python - license: MIT - license_family: MIT - purls: - - pkg:pypi/zipp?source=hash-mapping - size: 24461 - timestamp: 1776131454755 -- conda: https://prefix.dev/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda - sha256: 245c9ee8d688e23661b95e3c6dd7272ca936fabc03d423cdb3cdee1bbcf9f2f2 - md5: c2a01a08fc991620a74b32420e97868a - depends: - - __glibc >=2.17,<3.0.a0 - - libzlib 1.3.2 h25fd6f3_2 - license: Zlib - license_family: Other - purls: [] - size: 95931 - timestamp: 1774072620848 - conda: https://prefix.dev/conda-forge/osx-arm64/zlib-1.3.2-h8088a28_2.conda sha256: 8dd2ac25f0ba714263aac5832d46985648f4bfb9b305b5021d702079badc08d2 md5: f1c0bce276210bed45a04949cfe8dc20 @@ -6454,18 +6457,6 @@ packages: purls: [] size: 81123 timestamp: 1774072974535 -- conda: https://prefix.dev/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda - sha256: 8b786bb4380fa69a718b08a400040b865bc9207eda337e0a1955717c3c3a9403 - md5: 1726acec19beeed1c764385cd8622405 - depends: - - __glibc >=2.17,<3.0.a0 - - libgcc >=15 - - libstdcxx >=15 - license: Zlib - license_family: Other - purls: [] - size: 123959 - timestamp: 1786736890973 - conda: https://prefix.dev/conda-forge/osx-arm64/zlib-ng-2.3.3-h31dac16_1.conda sha256: 489a29915a3e1b425cff4df10a448f55bbaaf29d777a0f8a9e381444e6a284f1 md5: 4621ded2fd5b36f51454d5f81bff4ec1 @@ -6477,17 +6468,6 @@ packages: purls: [] size: 95857 timestamp: 1786737243497 -- conda: https://prefix.dev/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda - sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 - md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 - depends: - - __glibc >=2.17,<3.0.a0 - - libzlib >=1.3.1,<2.0a0 - license: BSD-3-Clause - license_family: BSD - purls: [] - size: 601375 - timestamp: 1764777111296 - conda: https://prefix.dev/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda sha256: 9485ba49e8f47d2b597dd399e88f4802e100851b27c21d7525625b0b4025a5d9 md5: ab136e4c34e97f34fb621d2592a393d8 @@ -6499,3 +6479,33 @@ packages: purls: [] size: 433413 timestamp: 1764777166076 +- pypi: ./vendor/rSim + name: rc-robosim +- pypi: https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl + name: numpy + version: 2.0.2 + sha256: f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04 + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + name: numpy + version: 2.0.2 + sha256: 496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318 + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/fb/06/6a7c30c3519181263e1bbf0cbea67ef4a43a64443ee16717c7d760214943/lenses-1.2.0-py3-none-any.whl + name: lenses + version: 1.2.0 + sha256: e03c81e35500e12e1d35504f76c26489c0a4e08b0881e96fc4e8a1b707c53f16 + requires_dist: + - sphinx ; extra == 'docs' + - pyrsistent ; extra == 'lints' + - ufmt ; extra == 'lints' + - flake8 ; extra == 'lints' + - mypy ; implementation_name == 'cpython' and extra == 'lints' + - pyrsistent ; extra == 'optional' + - pyrsistent ; extra == 'tests' + - pytest ; extra == 'tests' + - pytest-sugar ; extra == 'tests' + - coverage ; extra == 'tests' + - pytest-coverage ; extra == 'tests' + - hypothesis ; extra == 'tests' + requires_python: '>=3.7,<4' From 38c2afc4356ad2d88a14fd77c8387230ec246c58 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:37:05 +0000 Subject: [PATCH 29/59] fix: a match's replay lands in its run dir, however deep run_match named the replay /, right only when run_dir sat directly under replays/. evaluate.py's round folders are eval_/round_/, so every run's replays went to replays/round_/, overwriting each other, and the round folders had none: no restarts or ball losses, no replay to link, nothing for find_bugs or pitch_maps. The test drives the real run_match up to the runner. Co-Authored-By: Claude Opus 5.5 --- tools/evaluation/match.py | 26 ++++++------ .../tests/tools/test_match_replay_path.py | 40 +++++++++++++++++++ 2 files changed, 52 insertions(+), 14 deletions(-) create mode 100644 utama_core/tests/tools/test_match_replay_path.py diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index 0bb84bf6..c8ad1bfd 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -19,6 +19,7 @@ from __future__ import annotations +import os from dataclasses import dataclass, field from pathlib import Path from typing import Optional @@ -31,6 +32,7 @@ sim_runner, ) from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy +from utama_core.config.settings import REPLAY_BASE_PATH from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.replay.columnar_writer import ColumnarReplayWriterConfig @@ -43,6 +45,13 @@ TICKS_PER_SECOND = 60 # matches rsim's default step rate + +def replay_name(run_dir: Path, match_tag: str) -> str: + """A match's replay name: its path under REPLAY_BASE_PATH, no suffix, so the replay lands in + `run_dir` as `.npz`.""" + return Path(os.path.relpath(Path(run_dir) / match_tag, REPLAY_BASE_PATH)).as_posix() + + # default is excluded from the auto-discovered catalog: # despite the name, it isn't a competitive team — it's the kernel's minimal # single-tactic smoke-test scaffold (see its docstring), used across the test @@ -173,21 +182,10 @@ def run_match( if run_dir is not None: extra_kwargs["match_log_path"] = str(run_dir / f"{match_tag}.intentions.jsonl") extra_kwargs["stats_path"] = str(run_dir / f"{match_tag}.stats.json") - # replay_name is relative to REPLAY_BASE_PATH, not run_dir, since replays - # live under a fixed replays/ root — nest it under the same tournament - # subdirectory so the two stay next to each other on disk. - # - # Columnar (.npz) rather than pickle (.pkl): ~13 MB/match in the old - # format vs. a fraction of that here, and every reader a tournament - # run's replays are actually fed through — `load_frames_in_range` - # (`replay_player.py`, used by `render_window`) and - # `find_stuck_windows` (`analysis/stuck_detector.py`) — already dispatches on - # `.npz` vs `.pkl` by extension, so nothing downstream of a - # tournament run breaks. Only the interactive `play_replay`/ - # `get_latest_replay_name` CLI helpers in `replay_player.py` still - # hardcode `.pkl`. + # The writer puts a replay at REPLAY_BASE_PATH / replay_name: name it so the .npz lands in + # run_dir beside the match's other files, however deep run_dir is (eval_/round_/). extra_kwargs["replay_writer_config"] = ColumnarReplayWriterConfig( - replay_name=f"{run_dir.name}/{match_tag}", overwrite_existing=True + replay_name=replay_name(run_dir, match_tag), overwrite_existing=True ) runner, _ = sim_runner( diff --git a/utama_core/tests/tools/test_match_replay_path.py b/utama_core/tests/tools/test_match_replay_path.py new file mode 100644 index 00000000..4203cdff --- /dev/null +++ b/utama_core/tests/tools/test_match_replay_path.py @@ -0,0 +1,40 @@ +"""Where `tools/evaluation/match.run_match` writes a match's replay: in its `run_dir`, beside the +match's stats and intentions, however deep `run_dir` sits under REPLAY_BASE_PATH. + +Before 2026-11-12 the replay was named `/`, right only when run_dir sat directly +under replays/: an evaluate.py round folder (eval_/round_/) put every run's replays in +replays/round_/, overwriting each other, and the round folders had none. +""" + +from __future__ import annotations + +import pytest + +from tools.evaluation import match + + +class _Stop(Exception): + pass + + +@pytest.mark.parametrize("depth", [("eval_20261112_120000", "round_1"), ("tournament_x",)]) +def test_the_replay_lands_in_the_run_dir_beside_the_stats(tmp_path, monkeypatch, depth): + base = tmp_path / "replays" + run_dir = base.joinpath(*depth) + seen = {} + + def fake_runner(a, b, **kwargs): + seen.update(kwargs) + raise _Stop + + monkeypatch.setattr(match, "REPLAY_BASE_PATH", base) + monkeypatch.setattr(match, "load_side", lambda name: object()) + monkeypatch.setattr(match, "sim_runner", fake_runner) + monkeypatch.setattr(match, "enable_sim_reuse", lambda: None) + with pytest.raises(_Stop): + match.run_match("pendulum", "breakwater", duration_seconds=1.0, run_dir=run_dir) + + replay = base / f"{seen['replay_writer_config'].replay_name}.npz" + stats = seen["stats_path"] + assert replay == run_dir / "pendulum_vs_breakwater.npz" + assert str(replay.with_suffix("")) + ".stats.json" == stats From 867a530b2c023746a331b4892522223fd3364915 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:37:06 +0000 Subject: [PATCH 30/59] fix: evaluate.py before its first real run - One player per code: right after a release the frozen champion is the working-tree champion's code; both played, the reference played itself and the store labelled their matches by either name (hash order), so a candidate could find no reference matches. A later duplicate is left out. - The reference is the champion players.json named at the release, so a promotion takes effect at the next release instead of breaking runs. - No release tag stops the run instead of comparing with today's code. - The noise fit uses rounds 1..k only, like the pairs, so a verdict doesn't depend on what earlier runs left in the store. - A run claims its folder with mkdir, so two runs in one second can't share it. - A crashed match is reported (summary/report "failed"), not stored, and the run finishes. - The docstring says the stopping-rule numbers come from a simulation of six opponents and SD 1.9, not re-checked for today's five and 1.6. Co-Authored-By: Claude Opus 5.5 --- tools/evaluation/evaluate.py | 99 ++++++++++++++++---- utama_core/tests/engine/test_evaluate_run.py | 90 +++++++++++++++++- 2 files changed, 169 insertions(+), 20 deletions(-) diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 3298c95b..b1018f64 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -43,8 +43,10 @@ - **worse** once P <= DROP (0.2), - **undecided** after `MAX_ROUNDS` (6) rounds: not clearly better, which for a search means drop it. -Thresholds come from simulating the rule (match noise SD 1.9 goals, six opponents, 6 rounds, paired -results correlated 0 to 1): two equal strategies are called "better" at most 3% of the time. Unrelated +Thresholds come from simulating the rule on 2026-11-11 (match noise SD 1.9 goals, six opponents, 6 +rounds, paired results correlated 0 to 1): two equal strategies were called "better" at most 3% of the +time. Today's core gives five opponents and `ratings.NOISE_SD` is 1.6; the rates below are from that +simulation, not re-checked for this setup. Unrelated strategies: one goal per match worse is dropped after ~2 rounds, one goal better found 61% of the time. A small change to a strategy (correlation ~0.9): one goal better found every time in ~3 rounds. @@ -54,11 +56,15 @@ Matches the match results store holds (replays/match_results/, `replay/match_results.py`) are taken from it, not played: after a change to one strategy only its matches play. Delete that folder to replay all. +A match that crashes is reported (`failed` in summary.json and report.json), not stored, and missing +from the verdict's pairs; the run goes on, and the next run plays it again. + Writes replays/eval_/: `report.json` (verdicts, round 1's signals), and per round `round_/` with each played match's replay, intention log and stats (`_vs_.*`), `summary.json` and `ball_losses.md` — the layout tools/find_bugs.py, tools/pitch_maps.py and goal_sources read. -Promoting is a decision, not a side effect: set the champion by hand in reference/players.json. +Promoting is a decision, not a side effect: set the champion by hand in reference/players.json. It is +the reference from the next release on: the reference is read from players.json as it was at the release. """ from __future__ import annotations @@ -148,8 +154,35 @@ def resolve_names(requested: list[str]) -> list[str]: def latest_release() -> str: - """The latest release tag reachable from HEAD.""" - return _git("describe", "--tags", "--abbrev=0") or "HEAD" + """The latest release tag reachable from HEAD. Without one there is no reference: stop rather + than quietly compare against today's code.""" + tag = _git("describe", "--tags", "--abbrev=0") + if not tag: + raise SystemExit("No release tag reachable from HEAD (a shallow clone?): fetch the tags or pass --at REF.") + return tag + + +def champion_at(ref: str, today: str) -> str: + """The champion that `reference/players.json` named at `ref`, or `today`'s if that commit has + none. The reference is the champion of the last release: a strategy promoted since (perhaps + one that didn't exist then) becomes the reference only at the next release.""" + text = _git("show", f"{ref}:tools/evaluation/reference/players.json") + try: + return json.loads(text)["champion"] if text else today + except (ValueError, KeyError, TypeError): + return today + + +def same_code(players: list[str], fps: dict[str, str]) -> dict[str, str]: + """Each player whose code is the same as an earlier player's in `players`, mapped to that + player. Right after a release the frozen champion is the working-tree champion's code: the two + would be one player under two names, so the later one is left out.""" + first: dict[str, str] = {} + out = {} + for n in players: + out.update({n: first[fps[n]]} if fps[n] in first else {}) + first.setdefault(fps[n], n) + return out def at_ref(name: str, ref: str) -> str: @@ -254,7 +287,8 @@ def main(argv: Optional[list[str]] = None) -> None: setup = load_players(args.players) if args.players else load_players() core = resolve_names(setup["core"]) reserve = [n for n in _CONFIG_NAMES if n not in core] if args.all else [] - reference = at_ref(resolve_names([setup["champion"]])[0], args.at or latest_release()) + ref = args.at or latest_release() + reference = at_ref(resolve_names([champion_at(ref, setup["champion"])])[0], ref) candidates = [c for c in resolve_names(args.candidates) if c != reference] noise = SimNoise.from_dict(reference_noise()).to_dict() @@ -266,16 +300,20 @@ def main(argv: Optional[list[str]] = None) -> None: graph = CodeGraph() env = match_results.environment(graph, **env_args) store = match_results.open_store(REPLAY_BASE_PATH) - everyone = {*candidates, reference, *core, *reserve} + everyone = list(dict.fromkeys([reference, *candidates, *core, *reserve])) fps = {n: graph.strategy_fingerprint(n)[:16] for n in everyone} - for c in list(candidates): - if fps[c] == fps[reference]: - print(f"{_short_name(c)} is skipped: it is the same code as the reference {_short_name(reference)}") - candidates.remove(c) + for n, first in (dupes := same_code(everyone, fps)).items(): + print(f"{_short_name(n)} is left out: it is the same code as {_short_name(first)}") + candidates, core, reserve = ([n for n in group if n not in dupes] for group in (candidates, core, reserve)) + fps = {n: fp for n, fp in fps.items() if n not in dupes} run_id = datetime.now(timezone.utc).strftime("eval_%Y%m%d_%H%M%S") - while (Path(REPLAY_BASE_PATH) / run_id).exists(): # two runs started in the same second - run_id += "b" + while True: # claim the folder: two runs (two worktrees) may start in the same second + try: + (Path(REPLAY_BASE_PATH) / run_id).mkdir(parents=True) + break + except FileExistsError: + run_id += "b" run_dir = Path(REPLAY_BASE_PATH) / run_id print(f"Reference {_short_name(reference)}; core {', '.join(_short_name(n) for n in core)}; environment {env}") @@ -292,6 +330,7 @@ def still_current(a: str, b: str) -> bool: rounds: list[dict] = [] opponents_so_far: set[str] = set() played = reused = 0 + failed: list[dict] = [] executor = ProcessPoolExecutor(max_workers=WORKERS) if WORKERS > 1 else None try: for k in range(1, MAX_ROUNDS + 1): @@ -329,6 +368,11 @@ def finish(a: str, b: str, rec: dict) -> None: flush=True, ) + def fail(a: str, b: str, err: BaseException) -> None: + """A match that crashed: reported, not stored, missing from the verdict's pairs.""" + print(f" round {k}: {tag(a, b)} CRASHED: {err!r}", flush=True) + failed.append({"round": k, "config_a": a, "config_b": b, "error": repr(err)}) + def submit(a: str, b: str, seed: int) -> tuple: kw = dict(a_fp=fps[a], b_fp=fps[b], env=env, seed=seed, source=run_id, run_dir=round_dir) kw.update(run_kwargs, sim_noise=SimNoise.from_dict({**noise, "seed": seed})) @@ -336,7 +380,12 @@ def submit(a: str, b: str, seed: int) -> tuple: if executor is None: for a, b, kw in (submit(*f) for f in todo): - finish(a, b, play_and_record(a, b, **kw)) + try: + rec = play_and_record(a, b, **kw) + except Exception as err: # noqa: BLE001 -- one bad match must not lose the run + fail(a, b, err) + else: + finish(a, b, rec) else: futures = { executor.submit(play_and_record, a, b, **kw): (a, b) for a, b, kw in (submit(*f) for f in todo) @@ -344,19 +393,26 @@ def submit(a: str, b: str, seed: int) -> tuple: while futures: done, _ = wait(futures, return_when=FIRST_COMPLETED) for future in done: - finish(*futures.pop(future), future.result()) + a, b = futures.pop(future) + try: + rec = future.result() + except Exception as err: # noqa: BLE001 -- one bad match must not lose the run + fail(a, b, err) + else: + finish(a, b, rec) rows = [result_row(rec, a, b, was_reused) for (a, b), (rec, was_reused) in recs.items()] names = sorted({n for pair in recs for n in pair}) summary = {"run_id": f"{run_id}/round_{k}", "round": k, "seed": k, "config_names": names} summary["results"] = sorted(rows, key=lambda r: (r["config_a"], r["config_b"])) + summary["failed"] = [f for f in failed if f["round"] == k] summary.update(signals(summary, {pair: rec for pair, (rec, _) in recs.items()}, round_dir)) (round_dir / "summary.json").write_text(json.dumps(summary, indent=2)) rounds.append(summary) if candidates: - fit = _fit(store, env, fps, {*open_, reference, *opponents_so_far}) ledger = _up_to_round(store.load(env, fps=fps), k) + fit = _fit(ledger, fps, {*open_, reference, *opponents_so_far}) for c in list(open_): diffs, h2h = paired(ledger, fps, c, reference, sorted(opponents_so_far)) margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) @@ -391,6 +447,8 @@ def submit(a: str, b: str, seed: int) -> tuple: for line in stall_lines(r["stalls"], "candidate"): print(f" {line}") + if failed: + print(f"\n{len(failed)} match(es) crashed (summary.json 'failed'); their pairs are missing from the verdicts.") out = run_dir / "report.json" out.write_text( json.dumps( @@ -402,6 +460,7 @@ def submit(a: str, b: str, seed: int) -> tuple: "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": MAX_ROUNDS}, "candidates": report, + "failed": failed, "rounds": [{"round": s["round"], "matches": len(s["results"])} for s in rounds], "signals": {k: v for k, v in health.items() if k not in ("results",)}, }, @@ -414,11 +473,13 @@ def submit(a: str, b: str, seed: int) -> tuple: # --- the verdict's arithmetic ----------------------------------------------------------------- -def _fit(store: match_results.MatchResults, env: str, fps: dict[str, str], players: set[str]) -> ratings.Ratings: - """Ratings over every stored match in `env` between `players` at their current code.""" +def _fit(ledger: dict, fps: dict[str, str], players: set[str]) -> ratings.Ratings: + """Ratings over the matches in `ledger` between `players` at their current code. Given the + matches of rounds 1..k only (`_up_to_round`), so the noise estimate, like the pairs, doesn't + depend on what earlier runs left in the store.""" matches = [ (e["a"], e["b"], e["score_a"] - e["score_b"]) - for e in store.load(env, fps=fps).values() + for e in ledger.values() if e["a"] in players and e["b"] in players and fps.get(e["a"]) == e["a_fp"] and fps.get(e["b"]) == e["b_fp"] ] return ratings.fit(matches, names=sorted(players)) diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index cdb7c807..0231acef 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -8,6 +8,7 @@ from __future__ import annotations import json +from pathlib import Path import pytest @@ -27,6 +28,9 @@ def base_fingerprint(self, entries): return "base" def strategy_fingerprint(self, name): + if name.endswith(".strategy"): # a frozen file: the code of the strategy it was built from, then + base = Path(name).stem.split("@")[0] + return f"{self.rig.frozen_version}-{base}" return f"{self.rig.version[name]}-{name}" # version first: the tool keeps 16 characters @@ -37,13 +41,21 @@ def rig(tmp_path, monkeypatch): rig.version = {n: 0 for n in [*CORE, *RESERVE, "c"]} rig.stats = {} # (a, b) -> stats of that match rig.on_play = None + rig.frozen_version = 0 # a frozen file's code is its strategy at version 0 + rig.score = lambda a, b, seed: (1, 0) + rig.crash = set() # (a, b) pairs whose match raises def fake_run_match(a, b, run_dir=None, **kwargs): rig.played.append((a, b, kwargs["sim_noise"].seed)) rig.kwargs.append(kwargs) if rig.on_play is not None: rig.on_play() - return MatchResult(config_a=a, config_b=b, score_a=1, score_b=0, stats=rig.stats.get((a, b), {"x": 1})) + if (a, b) in rig.crash: + raise RuntimeError("rsim died") + score_a, score_b = rig.score(a, b, kwargs["sim_noise"].seed) + return MatchResult( + config_a=a, config_b=b, score_a=score_a, score_b=score_b, stats=rig.stats.get((a, b), {"x": 1}) + ) players = tmp_path / "players.json" players.write_text(json.dumps({"champion": "a", "core": CORE})) @@ -153,3 +165,79 @@ def run_match_writing_files(a, b, run_dir=None, **kwargs): assert linked.is_symlink() and linked.resolve() == (first / "round_1" / "a_vs_b.npz").resolve() assert (second / "round_1" / "a_vs_b.stats.json").read_text() == "ab" assert len(list((second / "round_1").glob("*.npz"))) == 3 # every match of the round, played or reused + + +FROZEN_A = "replays/eval/frozen/a@v0.strategy" + + +def test_the_frozen_champion_and_the_unchanged_champion_are_one_player(rig, monkeypatch): + # Right after a release the frozen champion is the working-tree champion's code: two names, one + # fingerprint. Both playing made the reference play itself and its matches go by either name. + monkeypatch.setattr(evaluate, "at_ref", lambda name, ref: FROZEN_A) + run_dir = rig.run("c") + + assert not any("a" in (x, y) for x, y, _ in rig.played) # the working-tree "a" is left out + assert ("c", FROZEN_A) in {(x, y) for x, y, _ in rig.played} + report = json.loads((run_dir / "report.json").read_text()) + assert report["core"] == ["b", "d"] + assert report["candidates"]["c"]["per_opponent"]["b"]["matches"] >= 1 # paired against the reference + + rig.version["a"] += 1 # the champion edited since the release: two players again + rig.run() + assert {("a", "b"), ("a", "d")} <= {(x, y) for x, y, _ in rig.played} + + +def test_the_reference_is_the_champion_named_at_the_release_not_one_promoted_since(rig, monkeypatch): + real_git = evaluate._git + released = json.dumps({"champion": "b", "core": CORE}) + monkeypatch.setattr(evaluate, "_git", lambda *a: released if a[0] == "show" else real_git(*a)) + run_dir = rig.run() # today's players.json names "a" + assert json.loads((run_dir / "report.json").read_text())["reference"] == "b" + + +def test_the_champion_at_a_release_without_a_players_file_is_todays(monkeypatch): + monkeypatch.setattr(evaluate, "_git", lambda *a: None) + assert evaluate.champion_at("v2.5.0", "pendulum") == "pendulum" + + +def test_no_release_tag_stops_instead_of_using_todays_code(monkeypatch): + monkeypatch.setattr(evaluate, "_git", lambda *a: None) + with pytest.raises(SystemExit, match="No release tag"): + evaluate.latest_release() + + +def test_the_verdict_does_not_depend_on_later_rounds_already_in_the_store(rig, monkeypatch): + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 1) + first = json.loads((rig.run("c") / "report.json").read_text())["candidates"]["c"] + + # a later run leaves round 2 in the store, with very different scores + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + rig.score = lambda a, b, seed: (1, 0) if seed == 1 else (9, 0) + rig.run("c") + + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 1) + again = json.loads((rig.run("c") / "report.json").read_text())["candidates"]["c"] + assert rig.played == [] + assert (again["p_better"], again["margin"], again["margin_sd"]) == ( + first["p_better"], + first["margin"], + first["margin_sd"], + ) + + +def test_a_crashed_match_is_reported_not_stored_and_the_run_finishes(rig): + rig.crash = {("b", "d")} + run_dir = rig.run() + + summary = json.loads((run_dir / "round_1" / "summary.json").read_text()) + assert [(f["config_a"], f["config_b"]) for f in summary["failed"]] == [("b", "d")] + assert len(summary["results"]) == 2 + assert json.loads((run_dir / "report.json").read_text())["failed"][0]["error"] == "RuntimeError('rsim died')" + rig.crash = set() + rig.run() + assert [(x, y) for x, y, _ in rig.played] == [("b", "d")] # not stored, so played next time + + +def test_same_code_keeps_the_first_name_of_each_fingerprint(): + fps = {"ref": "1", "cand": "2", "a": "1", "b": "3", "c": "2"} + assert evaluate.same_code(["ref", "cand", "a", "b", "c"], fps) == {"a": "ref", "c": "cand"} From bbd2320f9f7a17e64f8ace664096dafb3cb6d497 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:37:08 +0000 Subject: [PATCH 31/59] docs: evaluate.py's round folders in usage lines; promotion in its own PR Usage lines point at replays/eval_/round_1 instead of tournament_; roadmap and sim_realism describe players.json, not opponents.json and the ledger. change-strategy promotes in a separate PR (CI rejects players.json on a strategy branch) and counts a strategy's matches right; debug-incident names the tools that take --findings. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 13 ++++++++----- .claude/skills/debug-incident/SKILL.md | 3 ++- AGENTS.md | 2 +- docs/roadmap.md | 2 +- docs/signals.md | 2 +- docs/sim_realism.md | 2 +- tools/evaluation/explain.py | 4 ++-- tools/find_bugs.py | 6 ++++-- tools/match_timeline.py | 2 +- tools/moments.py | 4 ++-- tools/pitch_maps.py | 2 +- tools/signal_report.py | 2 +- utama_core/analysis/matches.py | 4 ++-- 13 files changed, 27 insertions(+), 21 deletions(-) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index da2d3645..39338eac 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -46,8 +46,9 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] ``` - Read the first line of each round: "N matches, X from the match results store, M to play". - After a change to one strategy, M is about its own 5 matches per round. Much more means - shared code changed since the store was filled; say so before waiting on it. + After a change to one strategy, M is its own matches: one against each other player (5 with + today's core, 6 for a new strategy). Much more means shared code changed since the store was + filled (then the whole round robin plays); say so before waiting on it. - Round 1 is a round robin: a stall reported there is a bug. Fix it (the `debug-incident` skill) before reading the verdict. - The verdict is goals only: better (P ≥ 0.99), worse (P ≤ 0.2) or undecided after 6 rounds. @@ -56,10 +57,12 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] ## 5. Record and promote - Add or update the strategy's row in `docs/strategies.md` with the verdict and margin. -- Better than the champion: promoting is one line in `tools/evaluation/reference/players.json` - (`champion`, and the core if it should play every round), in the pull request. It becomes the - reference at the next release. - Open a draft pull request into `main` with the result. An agent never merges. +- Better than the champion: promoting is one line in `tools/evaluation/reference/players.json` + (`champion`, and the core if it should play every round), in its own small pull request after + the strategy's is merged: CI rejects a `strategy/*` branch that touches anything outside the + strategy files. It becomes the reference at the next release (evaluate.py reads the champion + from `players.json` as it was at that release). ## Rules diff --git a/.claude/skills/debug-incident/SKILL.md b/.claude/skills/debug-incident/SKILL.md index 4ee9c248..dbd3a368 100644 --- a/.claude/skills/debug-incident/SKILL.md +++ b/.claude/skills/debug-incident/SKILL.md @@ -22,7 +22,8 @@ then confirm with the numbers in its message. Only the friendly side (config_a) ## 2. Look at it -Pick the tool by the question; each picture tool takes `--findings` to write its flags as JSON. +Pick the tool by the question. `match_timeline.py`, `restart_picture.py` and `plan_trace.py` take +`--findings` to write their flags as JSON. | Question | Command | |---|---| diff --git a/AGENTS.md b/AGENTS.md index 6f8c0a24..fc3aee41 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -58,7 +58,7 @@ One term per thing; reuse these instead of coining new ones. while a candidate is undecided, decided on paired results (candidate and reference against the same opponent under the same noise, `analysis/ratings.py`) and stopping once the answer is clear. Every match goes to the match results store (`replays/match_results/`, `replay/match_results.py`); a match - the store holds is never played again. Promoting is a one-line change to `players.json` in a PR. + the store holds is never played again. Promoting is a one-line change to `players.json` in a PR; it takes effect as the reference at the next release. Goals only: shots, xG and the other signals were tested as rankers and rejected (`docs/signals.md`, "Ranking"). The day-to-day way to judge a strategy. - **Strategy file** — a `.strategy` file (`utama_core/bundle/`, `tools/build_strategy.py`) is a diff --git a/docs/roadmap.md b/docs/roadmap.md index a6b266e1..11de07f8 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -32,7 +32,7 @@ entry by its title, not its number. - **Tournament gate tooling** — `--strict`, `--stop-at-first-stall`, `--fuzz-restarts SEED` (`405693c`). - **`metric_correlation.py` reads `.npz`**. - **Repo root cleanup** — first decided not to move root scripts (~45 inbound citations; `1f542fd`), then overturned 2026-10-02 because the root had grown to a dozen scripts and `tools/` already held the other tooling: the tournament drivers and `match` are now `tools/evaluation/`, and `debug_match` and `repro_from_replay` are in `tools/` (`elo` and `plot_elo` were removed 2026-10-10). `main.py`, `conftest.py` and `dashboard_server.py` stay at the root (pinned by pixi tasks, pytest and the README); `start_test_env.sh` was removed 2026-10-09 (unused; its three commands are in `docs/setup_external.md`). -- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`: champion, six opponents, three held-out opponents; the simulated world and robots from `world.json` and `robots.json`; seeded sim noise). Candidate and champion meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 promotes, <= 0.2 drops, undecided after 6 rounds; `analysis/ratings.py` fits strengths over the ledger (`replays/eval/ledger.jsonl`), which never replays a fixture it already has, and `--explain` draws where the robots stand. The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. +- **Strategy evaluation** — `tools/evaluation/evaluate.py` judges a candidate against the champion at the last release (a frozen `.strategy` file) in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded sim noise (the simulated world and robots from `world.json` and `robots.json`). Candidate and reference meet the same opponents under the same noise seed, decided on paired **goals** — P(candidate stronger) >= 0.99 better, <= 0.2 worse, undecided after 6 rounds (`analysis/ratings.py`); the match results store (`replays/match_results/`) never replays a fixture it already has, and `tools/evaluation/explain.py` draws where the robots stand. Until 2026-11-12 it used `opponents.json` with held-out opponents and a ledger (`replays/eval/ledger.jsonl`). The situation bench and `ladder.py` were built, used and then retired — the bench because its estimate is biased per strategy, so it could not rank (Spearman -0.09, `docs/sim_realism.md` "Evaluation infrastructure"). How to use it: `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". `f48d4bad`, `1849d123`, `49f29ebf`. The screen was built and dropped on 2026-11-12 (see `docs/strategy_tools_plan.md`); `evaluate.py` is the only gate. - **Directional-tube enemy obstacle** — trajsample's moving-obstacle obstacle is a capsule expanded along the obstacle's velocity instead of an inflated circle (`utama_core/motion_planning/src/trajsampling/obstacles.py:132-149`) — `a1b8bdd6`. - **FastPathPlanner `mirror_swap` stall** — the 0.52 m shortfall was the defense-area keep-out clamp, not a planner local minimum: back-row targets moved to |x| = 2.9 and the xfail went (`5f97199b`, in #141); #147 separately cleared the detour-side-flip corner case (`fastpathplanner_corner_test.py`) — `0ce4e2a2`. trajsample passes all 29 scenarios of the current table; fpp passed all 19 of the one before it. - **Geometric intention overlays in the Replay tab** — `MatchLog.trace_if_changed` overlays drawn by `dashboard/static/field_canvas.js` with its `_drawArrow` primitive: `shadow_and_mark.marks`, `give_and_go.shot_lane`/`pass_target`, `defense.shadow_post`, `block_shape.screen_line`, `press_and_contain.press`, `clear_ball.clear_target`, `dribble.segment_target`, `decoy_and_overload.lure`, `committed_robot_ids` — `c47f7549`, `b6e69b44`. diff --git a/docs/signals.md b/docs/signals.md index 42999260..68c119c9 100644 --- a/docs/signals.md +++ b/docs/signals.md @@ -54,7 +54,7 @@ match results store (`replays/match_results/`). Every `tools/evaluation/evaluate.py` run prints round 1's sections and writes each round's data to `replays/eval_/round_/summary.json` (round 1's also in `report.json`; older round-robins: -`replays/tournament_/summary.json`, with `standings` and `ratings` too): +`replays/tournament_/summary.json`, which also had `standings` and `ratings`; evaluate.py has neither): | Printed section | `summary.json` key | Computed by | |---|---|---| diff --git a/docs/sim_realism.md b/docs/sim_realism.md index 6514bbf7..a61bc9e0 100644 --- a/docs/sim_realism.md +++ b/docs/sim_realism.md @@ -521,7 +521,7 @@ Writing `ball_seen` into converted logs would let a later pass tell hidden from Built instead of a cheaper outcome (V, shots, xG, stat combinations: all rejected, see `docs/signals.md`, "Ranking"): `tools/evaluation/evaluate.py` judges a candidate against the -champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`) in rounds of seeded +champion at the last release, in rounds of the same round robin of the core (`tools/evaluation/reference/players.json`) under seeded noisy matches, with ratings from goal margins (`analysis/ratings.py`) and a store of every match (`replays/match_results/`); see `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy". This covers Phase 4's "several seeds per pairing, paired seeds for A/B". diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index 2b43a2f2..700a5061 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -5,8 +5,8 @@ Explains a verdict; it never makes one. Goals (`evaluate.py`'s verdict) are the only ranking; these pictures and numbers show how the two strategies played, so a search agent can see WHY a candidate won or lost. Each strategy's view is every match it played in the run dir, against any -opponent (`find_matches`): a match file's stem is `_vs_` (round-robin) or -`_vs__s` (an evaluate.py run), and config_a is the friendly side. +opponent (`find_matches`): a match file's stem is `_vs_` (an evaluate.py round folder or an old round-robin; evaluate.py runs before +2026-11-12 added `_s`), and config_a is the friendly side. Writes to DIR: diff --git a/tools/find_bugs.py b/tools/find_bugs.py index 416f6fb7..d2bd97a2 100644 --- a/tools/find_bugs.py +++ b/tools/find_bugs.py @@ -32,7 +32,7 @@ restart), `--json` writes JSON. `out_of_bounds`, the ball leaving the field, is a stoppage and is left out unless `--include-stoppages` (`utama_core/analysis/fouls.py`; until 2026-11-11 `moments.py fouls`). - pixi run python tools/find_bugs.py replays/tournament_ --fouls [--rule keep_out] [--by strategy,rule] + pixi run python tools/find_bugs.py replays/eval_/round_1 --fouls [--rule keep_out] [--by strategy,rule] """ from __future__ import annotations @@ -420,7 +420,9 @@ def main() -> None: description=__doc__.split("\n\n")[0], formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument( - "run_dir", type=Path, help="a round-robin dir (replays/tournament_) or any dir of match .npz files" + "run_dir", + type=Path, + help="a round folder (replays/eval_/round_), an old replays/tournament_, or any dir of match .npz files", ) parser.add_argument( "--strategy", diff --git a/tools/match_timeline.py b/tools/match_timeline.py index 5db26e84..81d20868 100644 --- a/tools/match_timeline.py +++ b/tools/match_timeline.py @@ -2,7 +2,7 @@ # ruff: noqa: E402 """One match window as swimlanes: referee command, each robot's tactic, distance to the ball, events. - pixi run python tools/match_timeline.py replays/tournament_/_vs_.npz 100 160 --side friendly + pixi run python tools/match_timeline.py replays/eval_/round_1/_vs_.npz 100 160 --side friendly Stacked panels on one time axis (Gantt-style, no dual axes): 1. the referee command band: live play, STOP, kickoff, free kick, penalty, placement, HALT (goal and diff --git a/tools/moments.py b/tools/moments.py index 0985966c..5c380669 100644 --- a/tools/moments.py +++ b/tools/moments.py @@ -34,10 +34,10 @@ A moment comes from a replay (`capture`); `save` and `load` refuse an invalid one, naming each problem (ids, field lines, check and strategy names). Starting points: our side's fouls in a run, -`pixi run python tools/find_bugs.py replays/tournament_ --fouls` (until 2026-11-11 `moments.py fouls`). +`pixi run python tools/find_bugs.py replays/eval_/round_1 --fouls` (until 2026-11-11 `moments.py fouls`). Capture one from a replay (its noise and designated position come with it; `--out` writes elsewhere than utama_core/tests/moments/): - pixi run python tools/moments.py capture replays/tournament_/_vs_.npz --t 254.65 \\ + pixi run python tools/moments.py capture replays/eval_/round_1/_vs_.npz --t 254.65 \\ --name free_kick_defender_drives_in --check keeps_clear --strategy --opponent \\ --note "..." [--out PATH] Play one (`--seed N` replays its noise with another seed, the JSON untouched): diff --git a/tools/pitch_maps.py b/tools/pitch_maps.py index 683cfd4e..dcb57b80 100644 --- a/tools/pitch_maps.py +++ b/tools/pitch_maps.py @@ -1,6 +1,6 @@ """On-pitch pictures of how each strategy plays, from one round-robin run. - pixi run python tools/pitch_maps.py replays/tournament_ [--out docs/img/signals] + pixi run python tools/pitch_maps.py replays/eval_/round_1 [--out docs/img/signals] Every strategy gets one panel per figure, in `signal_report`'s order (points per match). All panels use one frame: the strategy attacks toward +x, its own goal is on the left (-x), and diff --git a/tools/signal_report.py b/tools/signal_report.py index 47871986..8b7bc1fe 100644 --- a/tools/signal_report.py +++ b/tools/signal_report.py @@ -1,6 +1,6 @@ """Figures of a round-robin's strategy signals (`docs/signals.md`) for `docs/signal_report.md`. - pixi run python tools/signal_report.py replays/tournament_ [--out docs/img/signals] + pixi run python tools/signal_report.py replays/eval_/round_1 [--out docs/img/signals] Replays the run's saved matches through `turnover_breakdown.analyse_match` (which carries `chances`), so it works on runs recorded before chances were measured; it covers the matches diff --git a/utama_core/analysis/matches.py b/utama_core/analysis/matches.py index 4bbf1ce2..3d277287 100644 --- a/utama_core/analysis/matches.py +++ b/utama_core/analysis/matches.py @@ -1,7 +1,7 @@ """The matches in a run dir: which two strategies a replay is between, and the score it ended on. -A match file's stem is `_vs_` (round-robin) or `_vs__s` (an -evaluate.py run). config_a is the friendly side (yellow) in every run. Shared by `tools/evaluation/explain.py` +A match file's stem is `_vs_` (an evaluate.py round folder, or an old round-robin); +evaluate.py runs before 2026-11-12 added `_s`, still read. config_a is the friendly side (yellow) in every run. Shared by `tools/evaluation/explain.py` and `tools/find_bugs.py`. """ From c030b4f64be946f0d80eddd73d614d281826997b Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 18:51:23 +0000 Subject: [PATCH 32/59] evaluate.py: --confirm on fresh seeds, a second estimate, "dropped" From the design review: - Every candidate meets the same reference results on seeds 1-6, so a search finds a false "better" now and then and can fit those seeds. --confirm plays seeds 101-106 instead; the verdict reads only its seeds. - The reference carries the release's shared code, so a "better" can be shared code. The report adds the candidate against today's champion (same opponents, seeds and colours, no extra matches). Today's champion is put first among the opponents so it meets them in the candidates' colour; otherwise most of those pairs never line up. - P <= 0.2 is "dropped" (not promising), not "worse": an equal strategy gets there about a third of the time. - tools/evaluation/verdict_sim.py plays the rule on simulated results; its test pins that equal strategies are rarely called better, replacing the unchecked figures in the docs. - change-strategy: a search section and how to judge a shared-code change. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 22 +++++- AGENTS.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 25 +++--- docs/strategies.md | 4 + docs/tools.md | 4 +- tools/evaluation/evaluate.py | 71 ++++++++++++----- tools/evaluation/verdict_sim.py | 81 ++++++++++++++++++++ utama_core/tests/engine/test_evaluate.py | 12 ++- utama_core/tests/engine/test_evaluate_run.py | 31 ++++++++ utama_core/tests/tools/test_verdict_sim.py | 32 ++++++++ 10 files changed, 251 insertions(+), 33 deletions(-) create mode 100644 tools/evaluation/verdict_sim.py create mode 100644 utama_core/tests/tools/test_verdict_sim.py diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index 39338eac..c053ccde 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -51,8 +51,12 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] filled (then the whole round robin plays); say so before waiting on it. - Round 1 is a round robin: a stall reported there is a bug. Fix it (the `debug-incident` skill) before reading the verdict. -- The verdict is goals only: better (P ≥ 0.99), worse (P ≤ 0.2) or undecided after 6 rounds. - Every other signal explains it (the `explain-result` skill), never overrules it. +- The verdict is goals only: better (P ≥ 0.99), dropped (P ≤ 0.2: not promising, not "worse") + or undecided after 6 rounds. Every other signal explains it (the `explain-result` skill), never + overrules it. +- On a "better", read the line "against today's ": the reference carries the release's + shared code, so if shared code changed since, that line is the strategy change alone. Then + confirm on fresh seeds before promoting (ask first): `evaluate.py NAME --confirm`. ## 5. Record and promote @@ -64,6 +68,20 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] strategy files. It becomes the reference at the next release (evaluate.py reads the champion from `players.json` as it was at that release). +## Searching (many candidates) + +- Every candidate meets the same reference results on seeds 1-6: try 20 and one may come out + "better" by luck, or by fitting those seeds. Only a "better" that holds under `--confirm` counts. +- Keep a list of every variant tried, with its verdict and margin, in the PR, so a reviewer sees + how many tries one winner came from. +- Change one idea per candidate; several candidates go in one `evaluate.py` call. + +## Judging a shared-code change + +Not on a strategy branch. Batch the changes, then (ask first) `evaluate.py `: today's +champion on today's shared code against itself frozen at the last release. Its margin is what the +shared code did. Every stored match replays, so it is a full run. + ## Rules - **Shared code is not a strategy change.** A change to `tactics/` (existing modules), `skills/`, diff --git a/AGENTS.md b/AGENTS.md index fc3aee41..73b5f650 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -52,7 +52,7 @@ One term per thing; reuse these instead of coining new ones. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. - **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate - stronger than the reference, the champion at the last release (`--at REF` for another + stronger than the reference, the champion at the last release (`--confirm` re-checks a "better" on fresh seeds; `--at REF` for another release)? Round k plays under sim-noise seed k in the simulated world and robots (`tools/evaluation/reference/world.json`, `robots.json`): every round the same round robin, repeated while a candidate is undecided, decided on paired results (candidate and reference against the same diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index d2676ab7..2af5aebd 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -231,7 +231,7 @@ kernel invariants. Give its partitioner pure-function tests in `tests/strategy/t **Evaluating one,** cheapest first; stop as soon as a step fails: 1. **Tests:** its own, `test_all_strategy_configs.py`, then the full suite `--headless`. 2. **Matches:** `tools/evaluation/evaluate.py ` (see [Evaluating a strategy](#evaluating-a-strategy)): - is it better than the champion at the last release, worse, or not clearly either? Several + is it better than the champion at the last release, dropped (not promising), or not clearly either? Several candidates go in one call. Its round 1 is a round robin, so the same run reports stalls and signals; a stall is a bug to fix before anything else. @@ -272,7 +272,7 @@ flowchart TD st["Every match stored in the match results
replays/match_results/"] d{"P(candidate stronger), paired
with the reference's results"} b["better: P >= 0.99
promote by hand in players.json"] - w["worse: P <= 0.2
drop it"] + w["dropped: P <= 0.2
not promising"] u["undecided after 6 rounds
drop it"] p --> r1 --> st0 st0 -- "yes: reuse" --> d @@ -303,11 +303,11 @@ flowchart TD opponent minus the reference's, same opponent, seed and colour, from rounds 1..k, plus their head-to-head matches. Paired results face the same noise, so much of it cancels: all of it for identical code, little for unrelated strategies. P(candidate stronger) >= 0.99 is **better**, - <= 0.2 **worse**, and after 6 rounds it is **undecided**: not clearly better, so drop it. - Simulated (match noise SD 1.9 goals): two equal strategies are called better at most 3% of the - time. An unrelated strategy one goal per match worse is dropped after ~2 rounds, one goal better - found 61% of the time, half a goal 20%. A small edit (paired results correlated ~0.9): one goal - better found every time in ~3 rounds, half a goal 55%. Check the per-opponent table: a candidate + <= 0.2 **dropped**, and after 6 rounds it is **undecided**: not clearly better, so drop it. + "Dropped" means not promising, not worse: an equal strategy gets there about a third of the time. + How often the rule is right, for each effect size and correlation: `tools/evaluation/verdict_sim.py` + (simulated results, no matches; its test pins that equal strategies are rarely called better). + Check the per-opponent table: a candidate far better against one opponent and worse against the rest is a matchup, not a better strategy. - **Stalls** are reported, never judged on. The watchdog watches config_a only (`run/strategy_runner.py` records stats for config_a), so the report says in how many matches each @@ -317,6 +317,13 @@ flowchart TD `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` read. A match taken from the store is linked in (symlinks) from the run that played it, so a round folder holds all of its matches; one played before 2026-11-12, or whose run was deleted, has none. +- **Two traps in a "better".** Seeds 1-6 are the same for every candidate, and the store keeps the + reference's results on them: across many candidates a false "better" turns up now and then, and a + search can fit to those seeds. Confirm with `evaluate.py NAME --confirm` (seeds 101-106) before + promoting. And the reference carries the release's shared code (tactics, skills, planner, engine), so + a "better" can come from shared code changed since: the report adds the candidate against today's + champion, same opponents, seeds and colours, no extra matches, where the shared code is the same on + both sides. `evaluate.py ` measures shared-code changes alone. - **Promoting** is a decision, not a side effect: change the champion line in `reference/players.json` in a pull request; the next release makes it the reference. - **Pictures** (`tools/evaluation/explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`): for a candidate, @@ -327,7 +334,7 @@ flowchart TD - **Cost.** A round is 15 matches (five core and the reference, plus one per extra candidate pair) of up to 1200 s, roughly 20 min on 12 workers, when nothing is stored. Once stored, editing one strategy replays only its 5 matches per round; a change to shared code replays everything. `--all` makes a - round 66 matches. A clearly worse candidate is decided after 1-2 rounds. + round 66 matches. A clearly worse candidate is dropped after 1-2 rounds. ### Strategy branches @@ -396,7 +403,7 @@ whoever runs it. or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. - **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. -- **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`); see +- **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`, `--confirm`); see [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: `tools/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and diff --git a/docs/strategies.md b/docs/strategies.md index 5b00c64b..94ddd874 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -19,6 +19,10 @@ from the seeded sim noise: `evaluate.py`'s round k plays with seed k. `--all` (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results below were played under the old names (column "Was"), which `catalog.RENAMED` still loads. +**Recording a verdict.** Write it as `evaluate.py` gives it: better / dropped / undecided, with +P(better), the margin ± SD in goals per match, the seeds (1-6, or 101-106 for `--confirm`) and the +run id. "Dropped" means not promising, not worse: an equal strategy is dropped about a third of the time. + | Strategy | Was | Role | Description | |---|---|---|---| | `avalanche` | `overload_press` | core | 4-robot overload/switch attack + 1 block, built to outnumber a shadow line. | diff --git a/docs/tools.md b/docs/tools.md index a55a2323..48e5e2b5 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -17,6 +17,7 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Does it break? | `pixi run test` (it includes the regression moments). Stalls: every match records them; `evaluate.py` reports them with how many matches checked them | | Is it better? | `tools/evaluation/evaluate.py CANDIDATE`, paired against the champion at the last release. The only verdict | | Does everything still run after a shared-code change? | `tools/evaluation/evaluate.py` with no candidate: one round robin of the core and the reference (15 matches); `--all` for the whole catalog, occasionally | +| Did a shared-code change help? | `tools/evaluation/evaluate.py `: today's champion, on today's shared code, against itself at the last release | | What went wrong in these matches (thrashing, stalls, restart geometry, fouls)? | `tools/find_bugs.py RUN_DIR --strategy NAME`, then the picture tools; `--fouls` lists our side's fouls. It finds bugs, not why a strategy loses | | Keep a fixed bug fixed? | A unit test at the cause. `tools/moments.py capture` writes a regression moment, which runs in `pixi run test` | | Look closely at one thing? | `tools/repro_from_replay.py`, `tools/replay_trace.py`, the picture tools, `tools/debug_match.py` | @@ -51,7 +52,8 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy; `--confirm`: seeds 101-106, to confirm a "better") and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/verdict_sim.py` | How often `evaluate.py`'s stopping rule is right, on simulated results (no matches): better / dropped / undecided rates per effect size, correlation and number of opponents. Rerun after changing the rule or `analysis/ratings.py` | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index b1018f64..314e2e8f 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -11,6 +11,8 @@ release tag), played from a `.strategy` file built once into replays/eval/frozen/ --all every strategy in the catalog plays, not only the core (occasionally, for a wider field) + --confirm play seeds 101-106 instead of 1-6: a second opinion on a "better" before + promoting it, on seeds no candidate was tuned or chosen on Matches play in parallel, one fewer than the CPUs (at most 12). To explain a result: find_bugs.py, goal_sources, pitch_maps.py and explain.py on the run's round folders. @@ -40,15 +42,21 @@ the same seed and colour, plus their head-to-head matches. P(candidate stronger than reference): - **better** once P >= PROMOTE (0.99), -- **worse** once P <= DROP (0.2), +- **dropped** once P <= DROP (0.2): not promising. An equal strategy gets here about a third of the + time, so this is a search filter, not "worse", - **undecided** after `MAX_ROUNDS` (6) rounds: not clearly better, which for a search means drop it. -Thresholds come from simulating the rule on 2026-11-11 (match noise SD 1.9 goals, six opponents, 6 -rounds, paired results correlated 0 to 1): two equal strategies were called "better" at most 3% of the -time. Today's core gives five opponents and `ratings.NOISE_SD` is 1.6; the rates below are from that -simulation, not re-checked for this setup. Unrelated -strategies: one goal per match worse is dropped after ~2 rounds, one goal better found 61% of the time. -A small change to a strategy (correlation ~0.9): one goal better found every time in ~3 rounds. +How often the rule is right, on simulated results: `tools/evaluation/verdict_sim.py` (no matches); its +test pins that two equal strategies are rarely called "better". + +Seeds 1-6 are the same for every candidate, and the store keeps the reference's results on them: a +search that tries many candidates will find a false "better" now and then, and can fit to those seeds. +Confirm a "better" with `--confirm` before promoting it. + +The reference is frozen with the shared code (tactics, skills, planner, engine) of the release, so a +"better" can come from shared code changed since. Today's champion plays the same opponents with the +same seeds and colours, so the report adds the candidate against it too, at no extra matches: there +the shared code is the same on both sides. `evaluate.py ` measures the shared code alone. Signals and stalls are reported, never judged on: they explain a result (docs/signals.md). The stall watchdog watches config_a only, so the report says how many matches each strategy was checked in. @@ -113,6 +121,7 @@ PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 +CONFIRM_SEED = 101 # --confirm's first seed: far from the 1..MAX_ROUNDS every run plays WORKERS = min(12, max(1, (os.cpu_count() or 1) - 1)) # 1 plays in this process (tests) FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results # A full match: two halves of 300 s of playing time, the clock stopped whenever no team may play the @@ -123,15 +132,19 @@ # --- who plays what --------------------------------------------------------------------------- -def round_fixtures(k: int, candidates: list[str], reference: str, opponents: list[str]) -> list[tuple[str, str, int]]: - """Round `k`'s (config_a, config_b, seed): every pair of candidates, reference and opponents once. +def round_fixtures( + k: int, candidates: list[str], reference: str, opponents: list[str], seed: Optional[int] = None +) -> list[tuple[str, str, int]]: + """Round `k`'s (config_a, config_b, seed): every pair of candidates, reference and opponents once, + under `seed` (k by default). The store holds every match whose code is unchanged, so only the matches of edited strategies, or of a seed not played before, are actually played. The earlier of the two in (candidates, reference, opponents) order is config_a in odd rounds, so candidates and reference face each opponent with the same colour.""" + seed = k if seed is None else seed order = list(dict.fromkeys([*candidates, reference, *opponents])) pairs = itertools.combinations(order, 2) - return [(x, y, k) if k % 2 else (y, x, k) for x, y in pairs] + return [(x, y, seed) if k % 2 else (y, x, seed) for x, y in pairs] def verdict(p_better: float, rounds: int, max_rounds: int) -> Optional[str]: @@ -139,7 +152,7 @@ def verdict(p_better: float, rounds: int, max_rounds: int) -> Optional[str]: if p_better >= PROMOTE: return "better" if p_better <= DROP: - return "worse" + return "dropped" return "undecided" if rounds >= max_rounds else None @@ -278,6 +291,7 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("candidates", nargs="*") parser.add_argument("--at", metavar="REF") parser.add_argument("--all", action="store_true") + parser.add_argument("--confirm", action="store_true") parser.add_argument("--players", type=Path, help=argparse.SUPPRESS) # tests: another players.json return parser @@ -289,6 +303,8 @@ def main(argv: Optional[list[str]] = None) -> None: reserve = [n for n in _CONFIG_NAMES if n not in core] if args.all else [] ref = args.at or latest_release() reference = at_ref(resolve_names([champion_at(ref, setup["champion"])])[0], ref) + today = resolve_names([setup["champion"]])[0] # today's champion, on today's shared code + first_seed = CONFIRM_SEED if args.confirm else 1 candidates = [c for c in resolve_names(args.candidates) if c != reference] noise = SimNoise.from_dict(reference_noise()).to_dict() @@ -337,8 +353,11 @@ def still_current(a: str, b: str) -> bool: if k > 1 and not open_: break opponents = [p for p in [*core, *reserve] if p not in candidates and p != reference] + # today's champion first: it then meets every other opponent in the candidates' colour + opponents.sort(key=lambda p: p != today) opponents_so_far |= set(opponents) - fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents) + seed = first_seed + k - 1 + fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents, seed) round_dir = run_dir / f"round_{k}" round_dir.mkdir(parents=True, exist_ok=True) recs: dict[tuple[str, str], tuple[dict, bool]] = {} @@ -403,7 +422,7 @@ def submit(a: str, b: str, seed: int) -> tuple: rows = [result_row(rec, a, b, was_reused) for (a, b), (rec, was_reused) in recs.items()] names = sorted({n for pair in recs for n in pair}) - summary = {"run_id": f"{run_id}/round_{k}", "round": k, "seed": k, "config_names": names} + summary = {"run_id": f"{run_id}/round_{k}", "round": k, "seed": seed, "config_names": names} summary["results"] = sorted(rows, key=lambda r: (r["config_a"], r["config_b"])) summary["failed"] = [f for f in failed if f["round"] == k] summary.update(signals(summary, {pair: rec for pair, (rec, _) in recs.items()}, round_dir)) @@ -411,7 +430,7 @@ def submit(a: str, b: str, seed: int) -> tuple: rounds.append(summary) if candidates: - ledger = _up_to_round(store.load(env, fps=fps), k) + ledger = _up_to_round(store.load(env, fps=fps), k, first_seed) fit = _fit(ledger, fps, {*open_, reference, *opponents_so_far}) for c in list(open_): diffs, h2h = paired(ledger, fps, c, reference, sorted(opponents_so_far)) @@ -437,8 +456,21 @@ def submit(a: str, b: str, seed: int) -> tuple: f" {_short_name(c):<28} {r['verdict'].upper():<10} P(better) {r['p_better']:.2f} " f"margin {r['margin']:+.2f} ± {r['margin_sd']:.2f} goals/match after {r['rounds']} round(s)" ) - upto = _up_to_round(ledger, r["rounds"]) + upto = _up_to_round(ledger, r["rounds"], first_seed) r["per_opponent"] = _per_opponent(upto, fps, c, reference, sorted(opponents_so_far)) + if today in fps and today not in (c, reference): # not the same code as the reference + others = sorted(opponents_so_far - {today}) + diffs, h2h = paired(upto, fps, c, today, others) + fit = _fit(upto, fps, {c, today, *others}) + margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) + r["vs_todays_champion"] = { + "name": today, "p_better": round(ratings.p_positive(margin, sd), 3), "margin": round(margin, 2), + "margin_sd": round(sd, 2), "pairs": len(diffs), "head_to_head": len(h2h), + } # fmt: skip + print( + f" against today's {_short_name(today)} (same shared code): P(better) " + f"{r['vs_todays_champion']['p_better']:.2f} margin {margin:+.2f} ± {sd:.2f}" + ) r["stalls"] = stall_coverage(upto, fps, c) print(f" {'opponent':<26} {'candidate GD':>12} {'reference GD':>12} {'matches':>8} (same seed and colour)") for o, row in r["per_opponent"].items(): @@ -459,6 +491,7 @@ def submit(a: str, b: str, seed: int) -> tuple: "core": core, "environment": env, "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": MAX_ROUNDS}, + "seeds": [first_seed, first_seed + len(rounds) - 1], "candidates": report, "failed": failed, "rounds": [{"round": s["round"], "matches": len(s["results"])} for s in rounds], @@ -485,10 +518,10 @@ def _fit(ledger: dict, fps: dict[str, str], players: set[str]) -> ratings.Rating return ratings.fit(matches, names=sorted(players)) -def _up_to_round(ledger: dict, k: int) -> dict: - """The stored matches of rounds 1..k (seeds 1..k): a verdict after round k uses those only, - whatever later rounds the store already holds, so it doesn't depend on earlier runs.""" - return {f: e for f, e in ledger.items() if e["seed"] is not None and e["seed"] <= k} +def _up_to_round(ledger: dict, k: int, first_seed: int = 1) -> dict: + """The stored matches of rounds 1..k (seeds first_seed..first_seed+k-1): a verdict after round k + uses those only, whatever other seeds the store already holds, so it doesn't depend on earlier runs.""" + return {f: e for f, e in ledger.items() if e["seed"] is not None and first_seed <= e["seed"] < first_seed + k} def _margins(ledger: dict, fps: dict, side: str, o: str) -> dict[tuple, int]: diff --git a/tools/evaluation/verdict_sim.py b/tools/evaluation/verdict_sim.py new file mode 100644 index 00000000..2740c525 --- /dev/null +++ b/tools/evaluation/verdict_sim.py @@ -0,0 +1,81 @@ +"""How often evaluate.py's stopping rule gets it right: the rule played on simulated match results. + + pixi run python tools/evaluation/verdict_sim.py [--trials 4000] [--opponents 4 5] + +No matches are played. A candidate and the reference meet each opponent once per round (same seed and +colour, so their results are correlated `rho`: ~0.9 for a small edit of one strategy, ~0 for +unrelated strategies) and each other once; every match's goal difference has SD `ratings.NOISE_SD`. +The rule is evaluate.py's: `ratings.paired_difference`, better at P >= PROMOTE, dropped at P <= DROP, +undecided after MAX_ROUNDS. Prints, per true effect (goals per match) and correlation, the share of +candidates called better and dropped, and the mean number of rounds. + +What it leaves out: the noise SD is given, not fitted (evaluate.py fits it from the store), and a +candidate's effect is the same against every opponent (no matchups). The test +(`tests/tools/test_verdict_sim.py`) pins the claim the docs make: two equal strategies are called +better rarely. +""" + +from __future__ import annotations + +import argparse +import sys +from pathlib import Path + +import numpy as np + +REPO_ROOT = Path(__file__).resolve().parents[2] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from utama_core.analysis import ratings # noqa: E402 + +# evaluate.py's rule; kept here so this needs no simulator (tests check they agree) +PROMOTE = 0.99 +DROP = 0.2 +MAX_ROUNDS = 6 + + +def simulate( + effect: float, rho: float, n_opponents: int, trials: int, seed: int = 0, sd: float = ratings.NOISE_SD +) -> dict: + """Share of `trials` candidates called better / dropped / undecided, and their mean rounds.""" + rng = np.random.default_rng(seed) + cov = sd**2 * np.array([[1.0, rho], [rho, 1.0]]) + out = {"better": 0, "dropped": 0, "undecided": 0, "rounds": 0} + for _ in range(trials): + diffs: list[float] = [] + h2h: list[float] = [] + for k in range(1, MAX_ROUNDS + 1): + pair = rng.multivariate_normal([effect, 0.0], cov, size=n_opponents) + diffs += list(pair[:, 0] - pair[:, 1]) + h2h.append(effect + rng.normal(0.0, sd)) + margin, msd = ratings.paired_difference(diffs, h2h, sd) + p = ratings.p_positive(margin, msd) + verdict = "better" if p >= PROMOTE else "dropped" if p <= DROP else None + if verdict is None and k == MAX_ROUNDS: + verdict = "undecided" + if verdict is not None: + out[verdict] += 1 + out["rounds"] += k + break + return {key: value / trials for key, value in out.items()} + + +def main(argv: list[str] | None = None) -> None: + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--trials", type=int, default=4000) + parser.add_argument("--opponents", type=int, nargs="+", default=[4, 5]) + args = parser.parse_args(argv) + print(f"{'opponents':>9} {'rho':>4} {'effect':>6} {'better':>7} {'dropped':>8} {'undecided':>9} {'rounds':>6}") + for n in args.opponents: + for rho in (0.0, 0.5, 0.9): + for effect in (-1.0, -0.5, 0.0, 0.5, 1.0): + r = simulate(effect, rho, n, args.trials) + print( + f"{n:>9} {rho:>4.1f} {effect:>+6.1f} {r['better']:>7.1%} {r['dropped']:>8.1%} " + f"{r['undecided']:>9.1%} {r['rounds']:>6.1f}" + ) + + +if __name__ == "__main__": + main() diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 0ac18196..50917a1d 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -22,7 +22,7 @@ def test_candidate_and_reference_meet_each_opponent_with_the_same_colour(): def test_verdict_thresholds_are_inclusive_and_cap_rounds(): assert evaluate.verdict(evaluate.PROMOTE, 1, 6) == "better" - assert evaluate.verdict(evaluate.DROP, 1, 6) == "worse" + assert evaluate.verdict(evaluate.DROP, 1, 6) == "dropped" assert evaluate.verdict(0.5, 5, 6) is None assert evaluate.verdict(0.5, 6, 6) == "undecided" @@ -65,6 +65,16 @@ def test_a_verdict_after_round_k_ignores_later_seeds_already_in_the_ledger(): assert list(evaluate._up_to_round(ledger, 1)) == ["1"] +def test_a_confirmation_run_uses_its_own_seeds_only(): + ledger = {"1": {"seed": 1}, "101": {"seed": 101}, "102": {"seed": 102}, "107": {"seed": 107}} + assert list(evaluate._up_to_round(ledger, 2, first_seed=101)) == ["101", "102"] + + +def test_a_rounds_seed_can_differ_from_its_number_but_colours_follow_the_round(): + fixtures = evaluate.round_fixtures(1, ["c"], "ref", ["o"], seed=101) + assert ("c", "o", 101) in fixtures and ("ref", "o", 101) in fixtures + + def test_the_players_load_and_the_core_is_in_the_catalog(): from tools.evaluation.match import _CONFIG_NAMES from tools.evaluation.sim_settings import load_players diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index 0231acef..342c4e8b 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -241,3 +241,34 @@ def test_a_crashed_match_is_reported_not_stored_and_the_run_finishes(rig): def test_same_code_keeps_the_first_name_of_each_fingerprint(): fps = {"ref": "1", "cand": "2", "a": "1", "b": "3", "c": "2"} assert evaluate.same_code(["ref", "cand", "a", "b", "c"], fps) == {"a": "ref", "c": "cand"} + + +def test_confirm_plays_fresh_seeds_and_ignores_the_usual_ones(rig, monkeypatch): + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + rig.run("c") + run_dir = rig.run("c", "--confirm") + + assert rig.played and {seed for *_, seed in rig.played} <= {101, 102} # nothing reused from seeds 1-2 + report = json.loads((run_dir / "report.json").read_text()) + assert report["seeds"][0] == 101 + assert json.loads((run_dir / "round_1" / "summary.json").read_text())["seed"] == 101 + + +def test_the_candidate_is_also_measured_against_todays_champion_when_shared_code_moved(rig, tmp_path, monkeypatch): + # today's champion "d" sits last in the core; the release froze it before a shared-code change + players = tmp_path / "players_d.json" + players.write_text(json.dumps({"champion": "d", "core": CORE})) + monkeypatch.setattr(evaluate, "at_ref", lambda name, ref: f"replays/eval/frozen/{name}@v0.strategy") + rig.version["d"] = 1 # differs from its frozen copy (version 0) + monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + run_dir = rig.run("c", "--players", str(players)) + + r = json.loads((run_dir / "report.json").read_text())["candidates"]["c"] + vs = r["vs_todays_champion"] + # paired against "a" and "b" in every round: "d" meets them in the candidate's colour + assert vs["name"] == "d" and vs["pairs"] == 2 * r["rounds"] and vs["head_to_head"] == r["rounds"] + + +def test_no_second_estimate_when_todays_champion_is_the_reference(rig): + run_dir = rig.run("c") # the stub reference is "a" itself + assert "vs_todays_champion" not in json.loads((run_dir / "report.json").read_text())["candidates"]["c"] diff --git a/utama_core/tests/tools/test_verdict_sim.py b/utama_core/tests/tools/test_verdict_sim.py new file mode 100644 index 00000000..0dbbdaf3 --- /dev/null +++ b/utama_core/tests/tools/test_verdict_sim.py @@ -0,0 +1,32 @@ +"""The stopping rule's error rate, on simulated results (`tools/evaluation/verdict_sim.py`): the docs +claim two equal strategies are called "better" rarely. Changing the rule or `ratings` is judged +against this.""" + +from __future__ import annotations + +import pytest + +from tools.evaluation import verdict_sim + + +def test_the_simulation_plays_evaluate_pys_rule(): + from tools.evaluation import evaluate + + assert (verdict_sim.PROMOTE, verdict_sim.DROP, verdict_sim.MAX_ROUNDS) == ( + evaluate.PROMOTE, + evaluate.DROP, + evaluate.MAX_ROUNDS, + ) + + +@pytest.mark.parametrize("rho", [0.0, 0.5, 0.9]) +@pytest.mark.parametrize("n_opponents", [4, 5]) +def test_an_equal_strategy_is_rarely_called_better(rho, n_opponents): + r = verdict_sim.simulate(0.0, rho, n_opponents, trials=1500, seed=1) + assert r["better"] <= 0.05 + + +def test_a_clearly_better_small_edit_is_found(): + # one goal per match better, results correlated like a small edit of one strategy + r = verdict_sim.simulate(1.0, 0.9, 5, trials=500, seed=2) + assert r["better"] >= 0.8 From 2da360195a55c9ad63cd658ba47ddead59a4a54d Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 19:26:46 +0000 Subject: [PATCH 33/59] evaluate.py: screen on seeds 1-6, accept only on fresh seeds (paired t-test) The verdict was a Bayesian posterior with three hand-set weights (a prior on the difference, a prior pulling the diffs' spread toward unpaired noise, head-to-head counted alongside the diffs) and P >= 0.99. Replaced by a rule with two settings: - screen, seeds 1..ROUNDS: from round 2, a mean paired diff <= 0 is dropped; the screen never accepts - confirm, seeds 101..100+ROUNDS, on their own diffs: the same drop rule, then better if the one-sided paired t-test gives p <= ALPHA, else undecided Only fresh seeds accept, so a candidate selected or fitted on seeds 1-6 is not accepted on that luck; --confirm is gone (confirm is automatic). Head-to-head is reported, not counted. ROUNDS = 6 and ALPHA = 0.05 are provisional, to be set from the store (spread of real diffs; base rate of better edits). The rule lives in analysis/ratings.py (paired_test, decide), so verdict_sim.py plays the same code without importing the simulator. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/change-strategy/SKILL.md | 17 +- .claude/skills/explain-result/SKILL.md | 3 +- AGENTS.md | 7 +- docs/STRATEGY_DEVELOPMENT.md | 59 ++++--- docs/strategies.md | 7 +- docs/tools.md | 4 +- tools/evaluation/evaluate.py | 139 +++++++--------- tools/evaluation/verdict_sim.py | 58 +++---- utama_core/analysis/ratings.py | 166 +++++++------------ utama_core/tests/analysis/test_ratings.py | 76 ++------- utama_core/tests/engine/test_evaluate.py | 23 ++- utama_core/tests/engine/test_evaluate_run.py | 53 +++--- utama_core/tests/tools/test_verdict_sim.py | 45 +++-- 13 files changed, 292 insertions(+), 365 deletions(-) diff --git a/.claude/skills/change-strategy/SKILL.md b/.claude/skills/change-strategy/SKILL.md index c053ccde..a36ea664 100644 --- a/.claude/skills/change-strategy/SKILL.md +++ b/.claude/skills/change-strategy/SKILL.md @@ -51,12 +51,12 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] filled (then the whole round robin plays); say so before waiting on it. - Round 1 is a round robin: a stall reported there is a bug. Fix it (the `debug-incident` skill) before reading the verdict. -- The verdict is goals only: better (P ≥ 0.99), dropped (P ≤ 0.2: not promising, not "worse") - or undecided after 6 rounds. Every other signal explains it (the `explain-result` skill), never - overrules it. +- The verdict is goals only, in two stages of 6 rounds. The screen (seeds 1-6) only drops: a mean + paired diff ≤ 0 is "dropped" (not promising, not "worse"). A survivor plays on fresh seeds 101-106 + in the same run: "better" if p ≤ 0.05 there, else "undecided". Every other signal explains the + verdict (the `explain-result` skill), never overrules it. - On a "better", read the line "against today's ": the reference carries the release's - shared code, so if shared code changed since, that line is the strategy change alone. Then - confirm on fresh seeds before promoting (ask first): `evaluate.py NAME --confirm`. + shared code, so if shared code changed since, that line is the strategy change alone. ## 5. Record and promote @@ -70,9 +70,10 @@ pixi run python tools/evaluation/evaluate.py NAME [NAME ...] ## Searching (many candidates) -- Every candidate meets the same reference results on seeds 1-6: try 20 and one may come out - "better" by luck, or by fitting those seeds. Only a "better" that holds under `--confirm` counts. -- Keep a list of every variant tried, with its verdict and margin, in the PR, so a reviewer sees +- Every candidate meets the same reference results on seeds 1-6, so a search can fit them; that is + why only seeds 101-106 accept. Those are shared too: the more candidates reach them, the likelier + one "better" is luck. +- Keep a list of every variant tried, with its verdict, stage and mean diff, in the PR, so a reviewer sees how many tries one winner came from. - Change one idea per candidate; several candidates go in one `evaluate.py` call. diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md index a9086d3c..dd418e9b 100644 --- a/.claude/skills/explain-result/SKILL.md +++ b/.claude/skills/explain-result/SKILL.md @@ -17,7 +17,8 @@ they suggest changing, never a new ranking. ## Steps, cheapest first 1. **Read the run's own report** (no tool to run). - `replays/eval_/report.json`: per candidate the verdict, P(better), margin ± SD, and + `replays/eval_/report.json`: per candidate the verdict, the stage that decided it + with its mean diff ± SE and p (`screen`, `confirm`), and `per_opponent` (candidate's and reference's goal difference against each opponent, same seed and colour). Which opponents moved the margin? `round_1/summary.json` has every signal and the stall coverage. Look up any signal in `docs/signals.md`: where it lives, its reference diff --git a/AGENTS.md b/AGENTS.md index 73b5f650..a512794b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -52,10 +52,11 @@ One term per thing; reuse these instead of coining new ones. - **Signal** — an interpretable measure of how a strategy plays (shots, danger conceded, real ball losses, stalls ...), for explaining results, never a target. All listed in `docs/signals.md`. - **Evaluation / reference / match results** — `tools/evaluation/evaluate.py`: is a candidate - stronger than the reference, the champion at the last release (`--confirm` re-checks a "better" on fresh seeds; `--at REF` for another - release)? Round k plays under sim-noise seed k in the simulated world and robots + stronger than the reference, the champion at the last release (`--at REF` for another + release)? A screen on seeds 1-6 only drops; a candidate that survives it is accepted or not on fresh + seeds 101-106 (paired t-test). Each round plays under one sim-noise seed in the simulated world and robots (`tools/evaluation/reference/world.json`, `robots.json`): every round the same round robin, repeated - while a candidate is undecided, decided on paired results (candidate and reference against the same + while a candidate is open, decided on paired results (candidate and reference against the same opponent under the same noise, `analysis/ratings.py`) and stopping once the answer is clear. Every match goes to the match results store (`replays/match_results/`, `replay/match_results.py`); a match the store holds is never played again. Promoting is a one-line change to `players.json` in a PR; it takes effect as the reference at the next release. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 2af5aebd..466eba49 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -267,20 +267,24 @@ goals, under the realistic sim noise? ```mermaid flowchart TD p["Players: core (reference/players.json); --all: every strategy
+ the reference: the champion at the last release, a .strategy file"] - r1["Round k, noise seed k: every pair once
(only the undecided candidates stay after round 1)"] + r1["One round, one noise seed: every pair once
(only open candidates stay after round 1)"] st0{"in the match results?"} st["Every match stored in the match results
replays/match_results/"] - d{"P(candidate stronger), paired
with the reference's results"} - b["better: P >= 0.99
promote by hand in players.json"] - w["dropped: P <= 0.2
not promising"] - u["undecided after 6 rounds
drop it"] + d{"mean paired diff against the reference,
this stage's seeds only"} + w["dropped: mean diff <= 0 from a stage's round 2
not promising"] + c["screen passed (seeds 1-6)
go on to seeds 101-106"] + t{"confirm stage done:
paired t-test p <= 0.05?"} + b["better
promote by hand in players.json"] + u["undecided
drop it"] p --> r1 --> st0 st0 -- "yes: reuse" --> d st0 -- "no: play, then store" --> st --> d - d -- "P >= 0.99" --> b - d -- "P <= 0.2" --> w - d -- "neither, rounds left: k + 1" --> r1 - d -- "neither, no rounds left" --> u + d -- "<= 0" --> w + d -- "> 0, stage not done" --> r1 + d -- "> 0, screen done" --> c --> r1 + d -- "> 0, confirm done" --> t + t -- yes --> b + t -- no --> u ``` - **Players** (`tools/evaluation/reference/players.json`): the champion and the core strategies, @@ -294,20 +298,27 @@ flowchart TD referee and simulator are today's for both sides. An older commit may know the champion by its old name (`catalog.RENAMED`); that is found. - **Rounds.** Every round is the same round robin, every pair of players once, under noise seed k; - after round 1 only the undecided candidates stay. The match results store makes it cheap: a match + after round 1 only the candidates not yet decided stay. The match results store makes it cheap: a match whose code is unchanged is never played again, so a run plays only the matches of edited strategies (and of a seed never played before). The candidate (then the reference) is config_a in odd rounds and config_b in even ones, so both meet each opponent in the same colour under the same noise (the noise is drawn per colour and robot, so one seed can favour a colour by half a goal). -- **The decision** (`ratings.paired_difference`): the candidate's goal difference against each - opponent minus the reference's, same opponent, seed and colour, from rounds 1..k, plus their - head-to-head matches. Paired results face the same noise, so much of it cancels: all of it - for identical code, little for unrelated strategies. P(candidate stronger) >= 0.99 is **better**, - <= 0.2 **dropped**, and after 6 rounds it is **undecided**: not clearly better, so drop it. - "Dropped" means not promising, not worse: an equal strategy gets there about a third of the time. - How often the rule is right, for each effect size and correlation: `tools/evaluation/verdict_sim.py` - (simulated results, no matches; its test pins that equal strategies are rarely called better). - Check the per-opponent table: a candidate +- **The decision** (`analysis/ratings.py`) is on diffs: the candidate's goal difference against an + opponent minus the reference's, same opponent, seed and colour. Paired results face the same noise, + so much of it cancels: all of it for identical code, little for unrelated strategies. Head-to-head + matches are reported, not counted. Two stages of ROUNDS (6) rounds each: + - **screen**, seeds 1-6: from round 2, a mean diff <= 0 is **dropped**. It never accepts; a + candidate that survives goes straight on to + - **confirm**, fresh seeds 101-106, on their diffs alone: the same drop rule, then **better** if a + one-sided paired t-test gives p <= ALPHA (0.05), else **undecided** (not clearly better: drop it). + + Only fresh seeds accept, so a candidate chosen because it looked good on seeds 1-6, or fitted to + them, is not accepted on that luck. "Dropped" means not promising, not worse: an equal strategy is + dropped at the first look about half the time. ROUNDS and ALPHA are provisional: ROUNDS is to be set + from the measured spread of real diffs (enough rounds to find a 0.3-goal improvement 80% of the + time), ALPHA from how often edits turn out better. How often the rule is right, per effect size and + correlation: `tools/evaluation/verdict_sim.py` (simulated results, no matches; its test pins that an + equal strategy is called better at most ALPHA of the time). Check the per-opponent table: a candidate far better against one opponent and worse against the rest is a matchup, not a better strategy. - **Stalls** are reported, never judged on. The watchdog watches config_a only (`run/strategy_runner.py` records stats for config_a), so the report says in how many matches each @@ -317,10 +328,10 @@ flowchart TD `summary.json` and `ball_losses.md`, the layout `find_bugs.py`, `pitch_maps.py` and `goal_sources` read. A match taken from the store is linked in (symlinks) from the run that played it, so a round folder holds all of its matches; one played before 2026-11-12, or whose run was deleted, has none. -- **Two traps in a "better".** Seeds 1-6 are the same for every candidate, and the store keeps the - reference's results on them: across many candidates a false "better" turns up now and then, and a - search can fit to those seeds. Confirm with `evaluate.py NAME --confirm` (seeds 101-106) before - promoting. And the reference carries the release's shared code (tactics, skills, planner, engine), so +- **Two traps in a "better".** The reference's results on every seed are stored and reused, so + candidates that reach the confirm stage share its luck on seeds 101-106: in a long search, count how + many candidates were confirmed for each "better" (few are; most are dropped in the screen). And the + reference carries the release's shared code (tactics, skills, planner, engine), so a "better" can come from shared code changed since: the report adds the candidate against today's champion, same opponents, seeds and colours, no extra matches, where the shared code is the same on both sides. `evaluate.py ` measures shared-code changes alone. @@ -403,7 +414,7 @@ whoever runs it. or full-pitch camera; sim ball teleports are never shown. Needs `ffmpeg`. Commands behind committed clips: `assets/clips/README.md`. - **`docs/strategies.md`** — every strategy, core or reserve, and the latest results. -- **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`, `--confirm`); see +- **`tools/evaluation/evaluate.py`** — every match run (`NAME ...`, `--at REF`, `--all`); see [Evaluating a strategy](#evaluating-a-strategy). To look again at one stalled match, use its replay: `tools/repro_from_replay.py` restarts it from any moment with tracing on. - **Ball losses** (`analysis/turnover_breakdown.py`) — runs after every saved tournament and diff --git a/docs/strategies.md b/docs/strategies.md index 94ddd874..02e84243 100644 --- a/docs/strategies.md +++ b/docs/strategies.md @@ -19,9 +19,10 @@ from the seeded sim noise: `evaluate.py`'s round k plays with seed k. `--all` (`tools/evaluation/reference/players.json`). Names changed on 2026-11-12; the results below were played under the old names (column "Was"), which `catalog.RENAMED` still loads. -**Recording a verdict.** Write it as `evaluate.py` gives it: better / dropped / undecided, with -P(better), the margin ± SD in goals per match, the seeds (1-6, or 101-106 for `--confirm`) and the -run id. "Dropped" means not promising, not worse: an equal strategy is dropped about a third of the time. +**Recording a verdict.** Write it as `evaluate.py` gives it: better / dropped / undecided, the +stage that decided it (screen, seeds 1-6, or confirm, seeds 101-106), its mean diff ± SE in goals per +match and p, and the run id. "Dropped" means not promising, not worse: an equal strategy is dropped +about half the time. | Strategy | Was | Role | Description | |---|---|---|---| diff --git a/docs/tools.md b/docs/tools.md index 48e5e2b5..a2d31d9a 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -52,8 +52,8 @@ For the four jobs that chain several of them, follow a skill in `.claude/skills/ | Script | Purpose | |---|---| -| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy; `--confirm`: seeds 101-106, to confirm a "better") and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the undecided candidates, until the paired results against the reference say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds. Round k uses sim-noise seed k in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | -| `tools/evaluation/verdict_sim.py` | How often `evaluate.py`'s stopping rule is right, on simulated results (no matches): better / dropped / undecided rates per effect size, correlation and number of opponents. Rerun after changing the rule or `analysis/ratings.py` | +| `tools/evaluation/evaluate.py` | Every match run. `evaluate.py [CANDIDATE ...]`: round 1 a round robin of the core strategies (`--all`: every strategy) and the reference, the champion at the last release played from a `.strategy` file (`--at REF` for another release); with candidates, the same round robin repeats under the next seed, with only the open candidates: a screen on seeds 1-6 that drops a candidate whose mean paired diff against the reference is <= 0, then the survivors on fresh seeds 101-106, better if a one-sided paired t-test gives p <= 0.05, else undecided (`analysis/ratings.py`). Each round uses one sim-noise seed in the reference world and robots; matches 1200 s at most. A match the store holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, never played again: to play everything again, delete the store. Reports stalls with how many matches checked them (the watchdog sees config_a only) and every signal, never a ranking. Writes `replays/eval_/report.json` and `round_/` (replays, `summary.json`, `ball_losses.md`). See `docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy" | +| `tools/evaluation/verdict_sim.py` | How often `evaluate.py`'s rule is right, on simulated results (no matches): better / dropped / undecided rates per effect size, correlation and number of opponents. Rerun after changing the rule or `analysis/ratings.py` | | `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py` builds the reference's itself | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (an `evaluate.py` round's, or an older round-robin's), plus `summary.json` with the numbers behind them; goals stay the verdict. | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index 314e2e8f..903ae47d 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -11,8 +11,6 @@ release tag), played from a `.strategy` file built once into replays/eval/frozen/ --all every strategy in the catalog plays, not only the core (occasionally, for a wider field) - --confirm play seeds 101-106 instead of 1-6: a second opinion on a "better" before - promoting it, on seeds no candidate was tuned or chosen on Matches play in parallel, one fewer than the CPUs (at most 12). To explain a result: find_bugs.py, goal_sources, pitch_maps.py and explain.py on the run's round folders. @@ -37,21 +35,25 @@ How it decides -------------- -After each round each candidate is compared with the reference on paired matches -(`ratings.paired_difference`): its goal difference minus the reference's against the same opponent with -the same seed and colour, plus their head-to-head matches. P(candidate stronger than reference): - -- **better** once P >= PROMOTE (0.99), -- **dropped** once P <= DROP (0.2): not promising. An equal strategy gets here about a third of the - time, so this is a search filter, not "worse", -- **undecided** after `MAX_ROUNDS` (6) rounds: not clearly better, which for a search means drop it. - -How often the rule is right, on simulated results: `tools/evaluation/verdict_sim.py` (no matches); its -test pins that two equal strategies are rarely called "better". - -Seeds 1-6 are the same for every candidate, and the store keeps the reference's results on them: a -search that tries many candidates will find a false "better" now and then, and can fit to those seeds. -Confirm a "better" with `--confirm` before promoting it. +One number per opponent and seed: the candidate's goal difference minus the reference's, against the +same opponent with the same seed and colour (a "diff", `paired`). The same opponent cancels its +strength and the same noise cancels part of the luck. Head-to-head matches are reported, not counted: +they answer "does it beat the champion?", the one matchup a search is most tempted to exploit. + +- **Screen**, seeds 1..ROUNDS: from round 2 on, a candidate whose mean diff is <= 0 is **dropped**. + One that survives ROUNDS rounds goes on to confirm; the screen never accepts. +- **Confirm**, fresh seeds 101..100+ROUNDS: the same drop rule, then **better** if the one-sided + paired t-test on these seeds' diffs gives p <= ALPHA, else **undecided** (`ratings.decide`). + +Only fresh seeds can accept, so a candidate picked because it looked good on seeds 1..ROUNDS, or tuned +to them, is not accepted on that luck; dropping early can never make a false "better". "Dropped" means +not promising, not worse: an equal strategy is dropped at the first look about half the time. +`tools/evaluation/verdict_sim.py` plays this rule on simulated results (no matches); its test pins +that an equal strategy is called better at most ALPHA of the time. + +ROUNDS and ALPHA (in `analysis/ratings.py`) are the rule's only settings; both are provisional. The reference's results on each +seed are stored and reused for every candidate, so a confirm stage that many candidates reach shares +the reference's luck on seeds 101..; few do, since most are dropped in the screen. The reference is frozen with the shared code (tactics, skills, planner, engine) of the release, so a "better" can come from shared code changed since. Today's champion plays the same opponents with the @@ -118,10 +120,7 @@ from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise # noqa: E402 from utama_core.strategy import catalog # noqa: E402 -PROMOTE = 0.99 -DROP = 0.2 -MAX_ROUNDS = 6 -CONFIRM_SEED = 101 # --confirm's first seed: far from the 1..MAX_ROUNDS every run plays +CONFIRM_SEED = 101 # the confirm stage's first seed: never one the screen plays WORKERS = min(12, max(1, (os.cpu_count() or 1) - 1)) # 1 plays in this process (tests) FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results # A full match: two halves of 300 s of playing time, the clock stopped whenever no team may play the @@ -147,13 +146,16 @@ def round_fixtures( return [(x, y, seed) if k % 2 else (y, x, seed) for x, y in pairs] -def verdict(p_better: float, rounds: int, max_rounds: int) -> Optional[str]: - """The candidate's verdict after `rounds` rounds, or None to play another.""" - if p_better >= PROMOTE: - return "better" - if p_better <= DROP: - return "dropped" - return "undecided" if rounds >= max_rounds else None +def seed_of(k: int) -> int: + """Round k's noise seed: k in the screen (rounds 1..ROUNDS), CONFIRM_SEED on in the confirm stage.""" + n = ratings.ROUNDS + return k if k <= n else CONFIRM_SEED + k - n - 1 + + +def stage_seeds(k: int) -> set[int]: + """The seeds of round k's stage played so far: the stage's diffs, and only those, decide.""" + first = 1 if k <= ratings.ROUNDS else ratings.ROUNDS + 1 + return {seed_of(j) for j in range(first, k + 1)} def resolve_names(requested: list[str]) -> list[str]: @@ -291,7 +293,6 @@ def build_parser() -> argparse.ArgumentParser: parser.add_argument("candidates", nargs="*") parser.add_argument("--at", metavar="REF") parser.add_argument("--all", action="store_true") - parser.add_argument("--confirm", action="store_true") parser.add_argument("--players", type=Path, help=argparse.SUPPRESS) # tests: another players.json return parser @@ -304,7 +305,6 @@ def main(argv: Optional[list[str]] = None) -> None: ref = args.at or latest_release() reference = at_ref(resolve_names([champion_at(ref, setup["champion"])])[0], ref) today = resolve_names([setup["champion"]])[0] # today's champion, on today's shared code - first_seed = CONFIRM_SEED if args.confirm else 1 candidates = [c for c in resolve_names(args.candidates) if c != reference] noise = SimNoise.from_dict(reference_noise()).to_dict() @@ -349,14 +349,14 @@ def still_current(a: str, b: str) -> bool: failed: list[dict] = [] executor = ProcessPoolExecutor(max_workers=WORKERS) if WORKERS > 1 else None try: - for k in range(1, MAX_ROUNDS + 1): + for k in range(1, 2 * ratings.ROUNDS + 1): if k > 1 and not open_: break opponents = [p for p in [*core, *reserve] if p not in candidates and p != reference] # today's champion first: it then meets every other opponent in the candidates' colour opponents.sort(key=lambda p: p != today) opponents_so_far |= set(opponents) - seed = first_seed + k - 1 + seed = seed_of(k) fixtures = round_fixtures(k, open_ if k > 1 else candidates, reference, opponents, seed) round_dir = run_dir / f"round_{k}" round_dir.mkdir(parents=True, exist_ok=True) @@ -430,17 +430,19 @@ def submit(a: str, b: str, seed: int) -> tuple: rounds.append(summary) if candidates: - ledger = _up_to_round(store.load(env, fps=fps), k, first_seed) - fit = _fit(ledger, fps, {*open_, reference, *opponents_so_far}) + confirming = k > ratings.ROUNDS + ledger = _with_seeds(store.load(env, fps=fps), stage_seeds(k)) for c in list(open_): - diffs, h2h = paired(ledger, fps, c, reference, sorted(opponents_so_far)) - margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) - p = ratings.p_positive(margin, sd) - print(f"after round {k}: {_short_name(c):<28} P(better) {p:.2f} margin {margin:+.2f} ± {sd:.2f}") - if (v := verdict(p, k, MAX_ROUNDS)) is not None: + test = ratings.paired_test(paired(ledger, fps, c, reference, sorted(opponents_so_far))[0]) + stage = "confirm" if confirming else "screen" + print(f"after round {k} ({stage}): {_short_name(c):<28} {_test_line(test)}") + v = ratings.decide(test, k - ratings.ROUNDS if confirming else k, confirming) + if v is None: + continue + report.setdefault(c, {})[stage] = _test_dict(test) + if v != "confirm": open_.remove(c) - report[c] = {"verdict": v, "rounds": k, "p_better": round(p, 3), "margin": round(margin, 2)} - report[c]["margin_sd"] = round(sd, 2) + report[c].update(verdict=v, rounds=k, decided_in=stage) finally: if executor is not None: executor.shutdown(cancel_futures=True) @@ -452,25 +454,17 @@ def submit(a: str, b: str, seed: int) -> tuple: print(f"\nVerdicts against {_short_name(reference)} ({played} matches played, {reused} from the store):") for c in candidates: r = report[c] + decided = r[r["decided_in"]] print( - f" {_short_name(c):<28} {r['verdict'].upper():<10} P(better) {r['p_better']:.2f} " - f"margin {r['margin']:+.2f} ± {r['margin_sd']:.2f} goals/match after {r['rounds']} round(s)" + f" {_short_name(c):<28} {r['verdict'].upper():<10} in the {r['decided_in']} after {r['rounds']} " + f"round(s): {_test_line(ratings.PairedTest(**decided))}" ) - upto = _up_to_round(ledger, r["rounds"], first_seed) + upto = _with_seeds(ledger, {seed_of(j) for j in range(1, r["rounds"] + 1)}) r["per_opponent"] = _per_opponent(upto, fps, c, reference, sorted(opponents_so_far)) if today in fps and today not in (c, reference): # not the same code as the reference - others = sorted(opponents_so_far - {today}) - diffs, h2h = paired(upto, fps, c, today, others) - fit = _fit(upto, fps, {c, today, *others}) - margin, sd = ratings.paired_difference(diffs, h2h, fit.noise_sd) - r["vs_todays_champion"] = { - "name": today, "p_better": round(ratings.p_positive(margin, sd), 3), "margin": round(margin, 2), - "margin_sd": round(sd, 2), "pairs": len(diffs), "head_to_head": len(h2h), - } # fmt: skip - print( - f" against today's {_short_name(today)} (same shared code): P(better) " - f"{r['vs_todays_champion']['p_better']:.2f} margin {margin:+.2f} ± {sd:.2f}" - ) + test = ratings.paired_test(paired(upto, fps, c, today, sorted(opponents_so_far - {today}))[0]) + r["vs_todays_champion"] = {"name": today, **_test_dict(test)} + print(f" against today's {_short_name(today)} (same shared code): {_test_line(test)}") r["stalls"] = stall_coverage(upto, fps, c) print(f" {'opponent':<26} {'candidate GD':>12} {'reference GD':>12} {'matches':>8} (same seed and colour)") for o, row in r["per_opponent"].items(): @@ -490,11 +484,10 @@ def submit(a: str, b: str, seed: int) -> tuple: "reference": reference, "core": core, "environment": env, - "rule": {"promote": PROMOTE, "drop": DROP, "max_rounds": MAX_ROUNDS}, - "seeds": [first_seed, first_seed + len(rounds) - 1], + "rule": {"rounds": ratings.ROUNDS, "alpha": ratings.ALPHA, "confirm_seed": CONFIRM_SEED}, "candidates": report, "failed": failed, - "rounds": [{"round": s["round"], "matches": len(s["results"])} for s in rounds], + "rounds": [{"round": s["round"], "seed": s["seed"], "matches": len(s["results"])} for s in rounds], "signals": {k: v for k, v in health.items() if k not in ("results",)}, }, indent=2, @@ -506,22 +499,18 @@ def submit(a: str, b: str, seed: int) -> tuple: # --- the verdict's arithmetic ----------------------------------------------------------------- -def _fit(ledger: dict, fps: dict[str, str], players: set[str]) -> ratings.Ratings: - """Ratings over the matches in `ledger` between `players` at their current code. Given the - matches of rounds 1..k only (`_up_to_round`), so the noise estimate, like the pairs, doesn't - depend on what earlier runs left in the store.""" - matches = [ - (e["a"], e["b"], e["score_a"] - e["score_b"]) - for e in ledger.values() - if e["a"] in players and e["b"] in players and fps.get(e["a"]) == e["a_fp"] and fps.get(e["b"]) == e["b_fp"] - ] - return ratings.fit(matches, names=sorted(players)) +def _with_seeds(ledger: dict, seeds: set[int]) -> dict: + """The stored matches with one of `seeds`: a decision uses its own stage's rounds only, whatever + other seeds the store already holds, so it doesn't depend on earlier runs.""" + return {f: e for f, e in ledger.items() if e["seed"] in seeds} + + +def _test_dict(test: ratings.PairedTest) -> dict: + return {"n": test.n, "mean": round(test.mean, 3), "se": round(test.se, 3), "p": round(test.p, 4)} -def _up_to_round(ledger: dict, k: int, first_seed: int = 1) -> dict: - """The stored matches of rounds 1..k (seeds first_seed..first_seed+k-1): a verdict after round k - uses those only, whatever other seeds the store already holds, so it doesn't depend on earlier runs.""" - return {f: e for f, e in ledger.items() if e["seed"] is not None and first_seed <= e["seed"] < first_seed + k} +def _test_line(test: ratings.PairedTest) -> str: + return f"mean diff {test.mean:+.2f} ± {test.se:.2f} goals/match over {test.n} diffs, p {test.p:.3f}" def _margins(ledger: dict, fps: dict, side: str, o: str) -> dict[tuple, int]: @@ -539,8 +528,8 @@ def _margins(ledger: dict, fps: dict, side: str, o: str) -> dict[tuple, int]: def paired(ledger: dict, fps: dict, candidate: str, reference: str, opponents: list[str]) -> tuple[list, list]: """The candidate's goal difference minus the reference's against each opponent, over the matches - both played with the same seed and colour, and the candidate's margins against the reference: - `ratings.paired_difference`'s inputs.""" + both played with the same seed and colour (the verdict's diffs), and the candidate's margins + against the reference (head-to-head, reported only).""" diffs = [] for o in opponents: c, ref = _margins(ledger, fps, candidate, o), _margins(ledger, fps, reference, o) diff --git a/tools/evaluation/verdict_sim.py b/tools/evaluation/verdict_sim.py index 2740c525..7d998263 100644 --- a/tools/evaluation/verdict_sim.py +++ b/tools/evaluation/verdict_sim.py @@ -1,18 +1,17 @@ -"""How often evaluate.py's stopping rule gets it right: the rule played on simulated match results. +"""How often evaluate.py's rule gets it right: the rule played on simulated match results. - pixi run python tools/evaluation/verdict_sim.py [--trials 4000] [--opponents 4 5] + pixi run python tools/evaluation/verdict_sim.py [--trials 4000] [--opponents 4 5] [--sd 1.6] No matches are played. A candidate and the reference meet each opponent once per round (same seed and colour, so their results are correlated `rho`: ~0.9 for a small edit of one strategy, ~0 for -unrelated strategies) and each other once; every match's goal difference has SD `ratings.NOISE_SD`. -The rule is evaluate.py's: `ratings.paired_difference`, better at P >= PROMOTE, dropped at P <= DROP, -undecided after MAX_ROUNDS. Prints, per true effect (goals per match) and correlation, the share of -candidates called better and dropped, and the mean number of rounds. +unrelated strategies); every match's goal difference has SD `sd`. The rule is `ratings.decide`, the +one evaluate.py runs: a screen of ROUNDS rounds that only drops, then ROUNDS fresh rounds that accept +at p <= ALPHA. Prints, per true effect (goals per match) and correlation, the share of candidates +called better, dropped and undecided, and the mean number of rounds played. -What it leaves out: the noise SD is given, not fitted (evaluate.py fits it from the store), and a -candidate's effect is the same against every opponent (no matchups). The test -(`tests/tools/test_verdict_sim.py`) pins the claim the docs make: two equal strategies are called -better rarely. +What it leaves out: a candidate's effect is the same against every opponent (no matchups), and diffs +are normal (real ones are whole goals, maybe heavy-tailed). The test (`tests/tools/test_verdict_sim.py`) +pins the claim the docs make: an equal strategy is called better at most ALPHA of the time. """ from __future__ import annotations @@ -29,35 +28,28 @@ from utama_core.analysis import ratings # noqa: E402 -# evaluate.py's rule; kept here so this needs no simulator (tests check they agree) -PROMOTE = 0.99 -DROP = 0.2 -MAX_ROUNDS = 6 - def simulate( effect: float, rho: float, n_opponents: int, trials: int, seed: int = 0, sd: float = ratings.NOISE_SD ) -> dict: """Share of `trials` candidates called better / dropped / undecided, and their mean rounds.""" rng = np.random.default_rng(seed) - cov = sd**2 * np.array([[1.0, rho], [rho, 1.0]]) + sd_diff = sd * np.sqrt(2 * (1 - rho)) # SD of one diff: candidate's margin minus the reference's out = {"better": 0, "dropped": 0, "undecided": 0, "rounds": 0} for _ in range(trials): - diffs: list[float] = [] - h2h: list[float] = [] - for k in range(1, MAX_ROUNDS + 1): - pair = rng.multivariate_normal([effect, 0.0], cov, size=n_opponents) - diffs += list(pair[:, 0] - pair[:, 1]) - h2h.append(effect + rng.normal(0.0, sd)) - margin, msd = ratings.paired_difference(diffs, h2h, sd) - p = ratings.p_positive(margin, msd) - verdict = "better" if p >= PROMOTE else "dropped" if p <= DROP else None - if verdict is None and k == MAX_ROUNDS: - verdict = "undecided" - if verdict is not None: - out[verdict] += 1 - out["rounds"] += k + verdict, k = None, 0 + for confirming in (False, True): + diffs: list[float] = [] # each stage decides on its own seeds' diffs only + for j in range(1, ratings.ROUNDS + 1): + k += 1 + diffs += list(rng.normal(effect, sd_diff, size=n_opponents)) + verdict = ratings.decide(ratings.paired_test(diffs), j, confirming) + if verdict is not None: + break + if verdict != "confirm": break + out[verdict] += 1 + out["rounds"] += k return {key: value / trials for key, value in out.items()} @@ -65,12 +57,14 @@ def main(argv: list[str] | None = None) -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--trials", type=int, default=4000) parser.add_argument("--opponents", type=int, nargs="+", default=[4, 5]) + parser.add_argument("--sd", type=float, default=ratings.NOISE_SD) args = parser.parse_args(argv) + print(f"ROUNDS {ratings.ROUNDS}, ALPHA {ratings.ALPHA}, match SD {args.sd}") print(f"{'opponents':>9} {'rho':>4} {'effect':>6} {'better':>7} {'dropped':>8} {'undecided':>9} {'rounds':>6}") for n in args.opponents: for rho in (0.0, 0.5, 0.9): - for effect in (-1.0, -0.5, 0.0, 0.5, 1.0): - r = simulate(effect, rho, n, args.trials) + for effect in (-0.5, 0.0, 0.3, 0.5, 1.0): + r = simulate(effect, rho, n, args.trials, sd=args.sd) print( f"{n:>9} {rho:>4.1f} {effect:>+6.1f} {r['better']:>7.1%} {r['dropped']:>8.1%} " f"{r['undecided']:>9.1%} {r['rounds']:>6.1f}" diff --git a/utama_core/analysis/ratings.py b/utama_core/analysis/ratings.py index c854751d..a785ef5b 100644 --- a/utama_core/analysis/ratings.py +++ b/utama_core/analysis/ratings.py @@ -1,118 +1,66 @@ -"""Strategy ratings with uncertainty, from match margins. +"""The verdict's test: is the candidate's mean paired difference above zero? -Model: a match's margin (goal difference, config_a minus config_b) is strength(a) - strength(b) -plus noise, normal with SD `noise_sd`; every strength has a normal prior, mean 0 and SD -`PRIOR_SD`. The posterior is normal and closed-form (Bayesian ridge regression), so a strength -comes with its SD, and two strengths with the probability one is the larger. +A paired difference ("diff") is the candidate's goal difference minus the reference's against the +same opponent, with the same seed and colour (`tools/evaluation/evaluate.py`'s `paired`). The same +opponent cancels its strength, and the same noise cancels part of the luck: much of it for a small +edit, little for an unrelated strategy. The test is a one-sided paired t-test on the diffs: it +estimates their spread from the diffs themselves, so it needs no assumed noise level, and a small +sample is paid for by the t distribution's wider tails, not by a hand-set prior. -A strength is in goals per match against an opponent of strength 0. The prior centres the -ratings of whoever has played on 0, so compare strengths within one fit (`p_better`), not -across fits. +The rule built on it (`decide`): a screen on seeds 1..ROUNDS that only drops (mean diff <= 0), then +a confirm stage on fresh seeds that accepts at p <= ALPHA. `tools/evaluation/verdict_sim.py` plays it +on simulated results. -`noise_sd` is fitted from the residuals, shrunk toward `NOISE_SD` (the per-match spread of -goal difference left after strengths in `tournament_20261016_201213`, 66 matches) with the -weight of `NOISE_PRIOR_N` matches, so a few matches cannot make it tiny. +Until 2026-11-12 this module held a Bayesian rating model with a prior on the diffs' spread +(weight 6) and head-to-head matches in the verdict; it was replaced by this test (git history). """ from __future__ import annotations import math from dataclasses import dataclass - -import numpy as np - -PRIOR_SD = 1.0 # goals per match; strengths in the 2026-10-16 baseline spread with SD ~0.7 -NOISE_SD = 1.6 -NOISE_PRIOR_N = 10 - - -@dataclass -class Ratings: - names: list[str] - mean: np.ndarray - cov: np.ndarray - noise_sd: float - n_matches: int - - def _i(self, name: str) -> int: - return self.names.index(name) - - def strength(self, name: str) -> tuple[float, float]: - """(mean, SD) of `name`'s strength.""" - i = self._i(name) - return float(self.mean[i]), math.sqrt(self.cov[i, i]) - - def diff(self, x: str, y: str) -> tuple[float, float]: - """(mean, SD) of strength(x) - strength(y): x's expected margin over y.""" - i, j = self._i(x), self._i(y) - var = self.cov[i, i] + self.cov[j, j] - 2 * self.cov[i, j] - return float(self.mean[i] - self.mean[j]), math.sqrt(max(var, 0.0)) - - def p_better(self, x: str, y: str) -> float: - """Posterior probability that x is stronger than y.""" - m, s = self.diff(x, y) - return 0.5 * (1 + math.erf(m / (s * math.sqrt(2)))) if s > 0 else float(m > 0) - - -def fit( - matches: list[tuple[str, str, float]], - names: list[str] | None = None, - prior_sd: float = PRIOR_SD, - noise_sd: float | None = None, -) -> Ratings: - """Ratings from `(config_a, config_b, margin)` triples. `names` adds strategies with no - matches yet (they keep the prior). `noise_sd`, if given, is used as is instead of fitted.""" - names = sorted(set(names or []) | {a for a, _, _ in matches} | {b for _, b, _ in matches}) - ix = {n: i for i, n in enumerate(names)} - A = np.zeros((len(matches), len(names))) - y = np.array([m for _, _, m in matches], float) - for row, (a, b, _) in enumerate(matches): - A[row, ix[a]] += 1.0 - A[row, ix[b]] -= 1.0 - prior_precision = np.eye(len(names)) / prior_sd**2 - - def posterior(sd: float) -> tuple[np.ndarray, np.ndarray]: - cov = np.linalg.inv(A.T @ A / sd**2 + prior_precision) - return cov @ A.T @ y / sd**2, cov - - sd = noise_sd - if sd is None: - sd = NOISE_SD - for _ in range(5): # a few fixed-point steps: the residuals depend on the fit - mean, _ = posterior(sd) - rss = float(np.sum((y - A @ mean) ** 2)) - dof = max(len(matches) - len(names) + 1, 0) - sd = math.sqrt((NOISE_PRIOR_N * NOISE_SD**2 + rss) / (NOISE_PRIOR_N + dof)) - mean, cov = posterior(sd) - return Ratings(names, mean, cov, sd, len(matches)) - - -PAIRED_PRIOR_N = 6 # weight, in paired differences, of the prior that pairing removes no noise - - -def paired_difference(diffs: list[float], head_to_head: list[float], noise_sd: float) -> tuple[float, float]: - """(mean, SD) of strength(candidate) - strength(baseline) from paired matches. - - `diffs`: for each opponent, seed and colour both played, the candidate's goal difference minus - the baseline's. Same opponent and same noise, so much of the noise cancels: all of it for - identical code, little for unrelated strategies. Their variance is estimated from the diffs - themselves, shrunk toward 2 * noise_sd^2 (no cancelling) with the weight of - `PAIRED_PRIOR_N` diffs, so a few equal results cannot make it tiny. - `head_to_head`: the candidate's margins against the baseline, each with variance noise_sd^2. - The prior on the difference is normal, mean 0, SD sqrt(2) * PRIOR_SD (two strengths).""" - precision = 1 / (2 * PRIOR_SD**2) - weighted = 0.0 - if diffs: - d = np.asarray(diffs, float) - ss = float(np.sum((d - d.mean()) ** 2)) - var_d = (PAIRED_PRIOR_N * 2 * noise_sd**2 + ss) / (PAIRED_PRIOR_N + len(d) - 1) - precision += len(d) / var_d - weighted += d.sum() / var_d - if head_to_head: - precision += len(head_to_head) / noise_sd**2 - weighted += float(np.sum(head_to_head)) / noise_sd**2 - return weighted / precision, math.sqrt(1 / precision) - - -def p_positive(mean: float, sd: float) -> float: - return 0.5 * (1 + math.erf(mean / (sd * math.sqrt(2)))) +from typing import Optional + +from scipy import stats + +# Rounds per stage (screen, then confirm). Provisional: set it from the measured spread s of real +# diffs so a 0.3-goal improvement is found 80% of the time (rough: s 0.5 -> 3, 0.7 -> 7, 1.0 -> 14). +ROUNDS = 6 +# One-sided error bar of the confirm stage: the share of equal candidates called better. Provisional: +# set it from how often edits turn out better (the rarer, the smaller ALPHA must be). +ALPHA = 0.05 +NOISE_SD = 1.6 # per-match spread of goal difference (tournament_20261016_201213); verdict_sim's default + + +@dataclass(frozen=True) +class PairedTest: + n: int # number of diffs + mean: float # mean diff, goals per match + se: float # its standard error + p: float # one-sided p-value for "mean > 0": how often an equal candidate would look this good + + +def paired_test(diffs: list[float]) -> PairedTest: + """The one-sided paired t-test of `diffs`. Fewer than two diffs, or none above zero, give p = 1.""" + n = len(diffs) + mean = sum(diffs) / n if n else 0.0 + if n < 2: + return PairedTest(n, mean, math.inf, 1.0) + sd = math.sqrt(sum((d - mean) ** 2 for d in diffs) / (n - 1)) + se = sd / math.sqrt(n) + if se == 0: # every diff the same: identical code (all zero), or an exact, repeated margin + return PairedTest(n, mean, 0.0, 0.0 if mean > 0 else 1.0) + return PairedTest(n, mean, se, float(stats.t.sf(mean / se, n - 1))) + + +def decide(test: PairedTest, rounds_in_stage: int, confirming: bool) -> Optional[str]: + """evaluate.py's rule after a round of a stage: "dropped" (mean diff <= 0, from the stage's second + round), "confirm" (the screen survived), "better" (confirm stage, p <= ALPHA), "undecided" + (confirm stage, p > ALPHA), or None to play another round. The screen never accepts.""" + if rounds_in_stage >= 2 and test.n and test.mean <= 0: + return "dropped" + if rounds_in_stage < ROUNDS: + return None + if not confirming: + return "confirm" + return "better" if test.p <= ALPHA else "undecided" diff --git a/utama_core/tests/analysis/test_ratings.py b/utama_core/tests/analysis/test_ratings.py index 84abf28a..5927739b 100644 --- a/utama_core/tests/analysis/test_ratings.py +++ b/utama_core/tests/analysis/test_ratings.py @@ -1,71 +1,31 @@ -import numpy as np import pytest +from scipy import stats from utama_core.analysis import ratings -def test_no_matches_keeps_the_prior(): - r = ratings.fit([], names=["x", "y"]) - assert r.strength("x") == pytest.approx((0.0, ratings.PRIOR_SD)) - assert r.p_better("x", "y") == pytest.approx(0.5) +def test_identical_code_gives_no_evidence(): + # identical code plays identical matches: every diff is exactly 0 + assert ratings.paired_test([0.0] * 30).p == 1.0 -def test_many_matches_recover_true_strengths(): - """With plenty of noisy matches the posterior mean lands on the true margins and its SD - shrinks like 1/sqrt(matches).""" - rng = np.random.default_rng(0) - true = {"x": 1.0, "y": 0.0, "z": -1.0} - pairs = [("x", "y"), ("y", "z"), ("z", "x")] - matches = [(a, b, true[a] - true[b] + rng.normal(0, 1.6)) for _ in range(400) for a, b in pairs] - r = ratings.fit(matches) - for n, s in true.items(): - assert r.strength(n)[0] == pytest.approx(s, abs=0.1) - assert r.noise_sd == pytest.approx(1.6, abs=0.1) - assert r.p_better("x", "z") > 0.999 +def test_too_few_diffs_give_no_evidence(): + assert ratings.paired_test([]).p == 1.0 + assert ratings.paired_test([3.0]).p == 1.0 -def test_margin_is_shrunk_toward_zero_by_the_prior(): - """One 3-0 win is not a 3-goal strength gap: the prior pulls it in.""" - r = ratings.fit([("x", "y", 3.0)], noise_sd=1.6) - m, sd = r.diff("x", "y") - assert 0 < m < 3.0 - expected = 2 * ratings.PRIOR_SD**2 / (2 * ratings.PRIOR_SD**2 + 1.6**2) * 3.0 - assert m == pytest.approx(expected) +def test_the_p_value_is_the_one_sided_t_test(): + diffs = [1.0, 0.0, 1.0, 1.0, 1.0] + t = ratings.paired_test(diffs) + assert t.mean == pytest.approx(0.8) + assert t.se == pytest.approx(0.2) # sample SD 0.447 over sqrt(5) + assert t.p == pytest.approx(stats.ttest_1samp(diffs, 0.0, alternative="greater").pvalue) -def test_noise_sd_cannot_collapse_on_few_matches(): - """Two matches that fit perfectly still leave noise_sd near its prior.""" - r = ratings.fit([("x", "y", 1.0), ("x", "y", 1.0)]) - assert r.noise_sd > 0.8 * ratings.NOISE_SD +def test_a_worse_candidate_has_a_large_p(): + assert ratings.paired_test([-1.0, -2.0, 0.0, -1.0]).p > 0.9 -def test_common_opponents_compare_two_strategies_that_never_met(): - """x beats o by more than y does, so x is likely stronger than y without x v y matches.""" - matches = [("x", "o", 2.0)] * 20 + [("y", "o", 0.0)] * 20 - r = ratings.fit(matches) - assert r.p_better("x", "y") > 0.99 - - -def test_identical_paired_results_pin_the_difference_near_zero(): - """The case that forced the paired test: a copy of the champion matches its results exactly - against every opponent, and a few lucky head-to-head wins must not make it 'better'.""" - m, sd = ratings.paired_difference([0.0] * 24, [1, 4, 1, 0], noise_sd=1.9) - assert abs(m) < 0.3 - assert ratings.p_positive(m, sd) < 0.9 - - -def test_paired_spread_is_shrunk_toward_no_cancelling(): - """Two equal diffs have zero spread, but the variance stays near 2 * noise_sd^2 * N0 / (N0 + 1).""" - m, sd = ratings.paired_difference([1.0, 1.0], [], noise_sd=1.9) - var_d = ratings.PAIRED_PRIOR_N * 2 * 1.9**2 / (ratings.PAIRED_PRIOR_N + 1) - assert sd == pytest.approx((1 / (2 * ratings.PRIOR_SD**2) + 2 / var_d) ** -0.5) - - -def test_consistent_paired_gains_are_decisive(): - m, sd = ratings.paired_difference([1.0, 2.0, 1.0, 1.5] * 6, [], noise_sd=1.9) - assert ratings.p_positive(m, sd) > 0.99 - - -def test_no_evidence_is_a_coin_flip(): - m, sd = ratings.paired_difference([], [], noise_sd=1.9) - assert ratings.p_positive(m, sd) == pytest.approx(0.5) +def test_a_repeated_exact_margin_is_decisive_either_way(): + assert ratings.paired_test([1.0, 1.0, 1.0]).p == 0.0 + assert ratings.paired_test([-1.0, -1.0, -1.0]).p == 1.0 diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index 50917a1d..71f743eb 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -1,6 +1,7 @@ import pytest from tools.evaluation import evaluate +from utama_core.analysis import ratings def test_every_round_is_every_pair_once_under_its_seed(): @@ -20,11 +21,11 @@ def test_candidate_and_reference_meet_each_opponent_with_the_same_colour(): assert (("ref", "o", k) in fixtures) == c_is_a -def test_verdict_thresholds_are_inclusive_and_cap_rounds(): - assert evaluate.verdict(evaluate.PROMOTE, 1, 6) == "better" - assert evaluate.verdict(evaluate.DROP, 1, 6) == "dropped" - assert evaluate.verdict(0.5, 5, 6) is None - assert evaluate.verdict(0.5, 6, 6) == "undecided" +def test_the_confirm_stage_plays_fresh_seeds_and_decides_on_them_alone(monkeypatch): + monkeypatch.setattr(ratings, "ROUNDS", 3) + assert [evaluate.seed_of(k) for k in range(1, 7)] == [1, 2, 3, 101, 102, 103] + assert evaluate.stage_seeds(2) == {1, 2} + assert evaluate.stage_seeds(5) == {101, 102} def test_per_opponent_compares_only_matches_with_the_same_seed_and_colour(): @@ -60,14 +61,10 @@ def e(a, b, sa, sb, seed): assert h2h == [-3] -def test_a_verdict_after_round_k_ignores_later_seeds_already_in_the_ledger(): - ledger = {"1": {"seed": 1}, "2": {"seed": 2}, "3": {"seed": None}} - assert list(evaluate._up_to_round(ledger, 1)) == ["1"] - - -def test_a_confirmation_run_uses_its_own_seeds_only(): - ledger = {"1": {"seed": 1}, "101": {"seed": 101}, "102": {"seed": 102}, "107": {"seed": 107}} - assert list(evaluate._up_to_round(ledger, 2, first_seed=101)) == ["101", "102"] +def test_a_decision_uses_its_stages_seeds_only(): + ledger = {"1": {"seed": 1}, "2": {"seed": 2}, "101": {"seed": 101}, "x": {"seed": None}} + assert list(evaluate._with_seeds(ledger, {1, 2})) == ["1", "2"] + assert list(evaluate._with_seeds(ledger, {101})) == ["101"] def test_a_rounds_seed_can_differ_from_its_number_but_colours_follow_the_round(): diff --git a/utama_core/tests/engine/test_evaluate_run.py b/utama_core/tests/engine/test_evaluate_run.py index 342c4e8b..f80ed5a3 100644 --- a/utama_core/tests/engine/test_evaluate_run.py +++ b/utama_core/tests/engine/test_evaluate_run.py @@ -14,12 +14,18 @@ from tools.evaluation import evaluate from tools.evaluation.match import MatchResult +from utama_core.analysis import ratings from utama_core.replay import match_results CORE = ["a", "b", "d"] RESERVE = ["r1", "r2", "r3"] +def candidate_wins(a, b, seed): + """The candidate "c" wins 2-0 whatever its colour; every other match is 1-0 to config_a.""" + return (2, 0) if a == "c" else (0, 2) if b == "c" else (1, 0) + + class _Graph: def __init__(self, rig): self.rig = rig @@ -107,18 +113,20 @@ def test_a_second_run_plays_nothing_and_after_an_edit_only_that_strategys_matche def test_a_later_round_is_the_same_round_robin_under_the_next_seed_with_colours_swapped(rig, monkeypatch): - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + monkeypatch.setattr(ratings, "ROUNDS", 2) run_dir = rig.run("c") - round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] # equal results: undecided after round 1 + round_2 = [(x, y) for x, y, seed in rig.played if seed == 2] # the screen never decides after one round assert sorted(round_2) == [("a", "c"), ("b", "a"), ("b", "c"), ("d", "a"), ("d", "b"), ("d", "c")] rig.version["c"] += 1 # edit the candidate: only its matches play again, in both rounds rig.run("c") assert all("c" in (x, y) for x, y, _ in rig.played) and len(rig.played) == 6 report = json.loads((run_dir / "report.json").read_text()) - assert report["candidates"]["c"]["verdict"] == "undecided" + # equal results: every diff 0, so the mean diff is <= 0 and the screen drops it at its second round + assert report["candidates"]["c"]["verdict"] == "dropped" assert report["candidates"]["c"]["rounds"] == 2 + assert {s["seed"] for s in report["rounds"]} == {1, 2} # a dropped candidate never reaches seed 101 def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): @@ -206,23 +214,20 @@ def test_no_release_tag_stops_instead_of_using_todays_code(monkeypatch): evaluate.latest_release() -def test_the_verdict_does_not_depend_on_later_rounds_already_in_the_store(rig, monkeypatch): - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 1) +def test_the_verdict_does_not_depend_on_other_seeds_already_in_the_store(rig, monkeypatch): + monkeypatch.setattr(ratings, "ROUNDS", 2) + rig.score = candidate_wins first = json.loads((rig.run("c") / "report.json").read_text())["candidates"]["c"] - # a later run leaves round 2 in the store, with very different scores - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) - rig.score = lambda a, b, seed: (1, 0) if seed == 1 else (9, 0) + # a longer run leaves seeds 3 and 103 in the store, with very different scores + monkeypatch.setattr(ratings, "ROUNDS", 3) + rig.score = lambda a, b, seed: (0, 9) if seed in (3, 103) else candidate_wins(a, b, seed) rig.run("c") - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 1) + monkeypatch.setattr(ratings, "ROUNDS", 2) again = json.loads((rig.run("c") / "report.json").read_text())["candidates"]["c"] assert rig.played == [] - assert (again["p_better"], again["margin"], again["margin_sd"]) == ( - first["p_better"], - first["margin"], - first["margin_sd"], - ) + assert (again["screen"], again["confirm"]) == (first["screen"], first["confirm"]) def test_a_crashed_match_is_reported_not_stored_and_the_run_finishes(rig): @@ -243,15 +248,17 @@ def test_same_code_keeps_the_first_name_of_each_fingerprint(): assert evaluate.same_code(["ref", "cand", "a", "b", "c"], fps) == {"a": "ref", "c": "cand"} -def test_confirm_plays_fresh_seeds_and_ignores_the_usual_ones(rig, monkeypatch): - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) - rig.run("c") - run_dir = rig.run("c", "--confirm") +def test_a_candidate_that_survives_the_screen_is_accepted_only_on_fresh_seeds(rig, monkeypatch): + monkeypatch.setattr(ratings, "ROUNDS", 2) + rig.score = candidate_wins + run_dir = rig.run("c") - assert rig.played and {seed for *_, seed in rig.played} <= {101, 102} # nothing reused from seeds 1-2 + assert {seed for *_, seed in rig.played} == {1, 2, 101, 102} report = json.loads((run_dir / "report.json").read_text()) - assert report["seeds"][0] == 101 - assert json.loads((run_dir / "round_1" / "summary.json").read_text())["seed"] == 101 + c = report["candidates"]["c"] + assert (c["verdict"], c["decided_in"], c["rounds"]) == ("better", "confirm", 4) + assert c["confirm"]["n"] == 2 * 2 # the confirm stage's own diffs: 2 opponents x 2 rounds, not the screen's + assert json.loads((run_dir / "round_3" / "summary.json").read_text())["seed"] == 101 def test_the_candidate_is_also_measured_against_todays_champion_when_shared_code_moved(rig, tmp_path, monkeypatch): @@ -260,13 +267,13 @@ def test_the_candidate_is_also_measured_against_todays_champion_when_shared_code players.write_text(json.dumps({"champion": "d", "core": CORE})) monkeypatch.setattr(evaluate, "at_ref", lambda name, ref: f"replays/eval/frozen/{name}@v0.strategy") rig.version["d"] = 1 # differs from its frozen copy (version 0) - monkeypatch.setattr(evaluate, "MAX_ROUNDS", 2) + monkeypatch.setattr(ratings, "ROUNDS", 2) run_dir = rig.run("c", "--players", str(players)) r = json.loads((run_dir / "report.json").read_text())["candidates"]["c"] vs = r["vs_todays_champion"] # paired against "a" and "b" in every round: "d" meets them in the candidate's colour - assert vs["name"] == "d" and vs["pairs"] == 2 * r["rounds"] and vs["head_to_head"] == r["rounds"] + assert vs["name"] == "d" and vs["n"] == 2 * r["rounds"] def test_no_second_estimate_when_todays_champion_is_the_reference(rig): diff --git a/utama_core/tests/tools/test_verdict_sim.py b/utama_core/tests/tools/test_verdict_sim.py index 0dbbdaf3..98191fe8 100644 --- a/utama_core/tests/tools/test_verdict_sim.py +++ b/utama_core/tests/tools/test_verdict_sim.py @@ -1,5 +1,5 @@ -"""The stopping rule's error rate, on simulated results (`tools/evaluation/verdict_sim.py`): the docs -claim two equal strategies are called "better" rarely. Changing the rule or `ratings` is judged +"""The rule's error rate, on simulated results (`tools/evaluation/verdict_sim.py`): the docs claim an +equal strategy is called "better" at most ALPHA of the time. Changing the rule or `ratings` is judged against this.""" from __future__ import annotations @@ -7,26 +7,43 @@ import pytest from tools.evaluation import verdict_sim - - -def test_the_simulation_plays_evaluate_pys_rule(): - from tools.evaluation import evaluate - - assert (verdict_sim.PROMOTE, verdict_sim.DROP, verdict_sim.MAX_ROUNDS) == ( - evaluate.PROMOTE, - evaluate.DROP, - evaluate.MAX_ROUNDS, - ) +from utama_core.analysis import ratings @pytest.mark.parametrize("rho", [0.0, 0.5, 0.9]) @pytest.mark.parametrize("n_opponents", [4, 5]) -def test_an_equal_strategy_is_rarely_called_better(rho, n_opponents): +def test_an_equal_strategy_is_called_better_at_most_alpha_of_the_time(rho, n_opponents): r = verdict_sim.simulate(0.0, rho, n_opponents, trials=1500, seed=1) - assert r["better"] <= 0.05 + # the screen drops about half of them first, so the rate is well under ALPHA; the slack is for 1500 trials + assert r["better"] <= ratings.ALPHA + 0.01 def test_a_clearly_better_small_edit_is_found(): # one goal per match better, results correlated like a small edit of one strategy r = verdict_sim.simulate(1.0, 0.9, 5, trials=500, seed=2) assert r["better"] >= 0.8 + + +def test_a_worse_strategy_is_dropped_in_the_screen(): + r = verdict_sim.simulate(-1.0, 0.9, 5, trials=300, seed=3) + assert r["better"] == 0.0 + assert r["rounds"] < 3 + + +def test_the_screen_never_accepts(): + perfect = ratings.paired_test([1.0, 2.0, 1.0, 3.0] * 10) + assert ratings.decide(perfect, ratings.ROUNDS, confirming=False) == "confirm" + assert ratings.decide(perfect, ratings.ROUNDS, confirming=True) == "better" + + +def test_a_stage_drops_only_from_its_second_round_and_at_a_mean_of_zero(): + zero = ratings.paired_test([1.0, -1.0, 0.0, 0.0]) + assert ratings.decide(zero, 1, confirming=False) is None + assert ratings.decide(zero, 2, confirming=False) == "dropped" + assert ratings.decide(zero, 2, confirming=True) == "dropped" + + +def test_the_confirm_stage_is_undecided_above_alpha(): + weak = ratings.paired_test([1.0, -1.0, 0.0, 0.5]) + assert weak.mean > 0 and weak.p > ratings.ALPHA + assert ratings.decide(weak, ratings.ROUNDS, confirming=True) == "undecided" From b9ee10f68460a9e79b56c981723bb56dda60dbf9 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 19:56:58 +0000 Subject: [PATCH 34/59] docs: a first-strategy tutorial; delete research tools and stale docs For onboarding new members: - docs/first_strategy.md: watch a match, write a toy strategy by hand, test it, evaluate it (read the verdict and the mean diff), then let an agent write one. tests/strategy/test_first_strategy_doc.py builds its code so it stays runnable. - README quick start: `pixi run main` and the tutorial; tools.md opens with the four commands a beginner needs. Deleted (questions answered; nothing runs them): - tools/metric_correlation.py and the five offline signals only it computed - tools/signal_report.py, docs/signal_report.md and its figures; the palette the figure tools shared moves to tools/figure_style.py, and pitch_maps orders panels by name instead of points per match (no rankings) - docs/strategy_tools_plan.md and the two investigation docs (code comments that cite them point into git history) evaluate.py's docstring is cut to usage and a pointer to STRATEGY_DEVELOPMENT. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/explain-result/SKILL.md | 3 - AGENTS.md | 2 + README.md | 13 +- docs/README.md | 7 +- docs/STRATEGY_DEVELOPMENT.md | 2 + docs/first_strategy.md | 188 ++ docs/img/architecture/make_match_data_flow.py | 5 +- docs/img/signals/ball_losses.png | Bin 54363 -> 0 bytes docs/img/signals/results.png | Bin 80361 -> 0 bytes docs/img/signals/shot_quality.png | Bin 80640 -> 0 bytes docs/img/signals/signals.png | Bin 172020 -> 0 bytes ...ion_ball_contact_orientation_divergence.md | 42 - ...stigation_default_vs_lowblock_stalemate.md | 41 - docs/roadmap.md | 1 - docs/signal_report.md | 156 -- docs/signals.md | 12 +- docs/strategies.md | 3 +- docs/strategy_tools_plan.md | 90 - docs/tools.md | 30 +- docs/visual_guide.md | 1 - tools/evaluation/evaluate.py | 88 +- tools/evaluation/explain.py | 2 +- tools/figure_style.py | 25 + tools/match_timeline.py | 2 +- tools/metric_correlation.py | 1536 ----------------- tools/motion_planning_benchmark.py | 2 +- tools/pitch_maps.py | 15 +- tools/signal_report.py | 413 ----- utama_core/analysis/plan_snapshot.py | 2 +- utama_core/analysis/plan_trace.py | 2 +- .../tests/analysis/test_signal_report.py | 52 - .../tests/strategy/test_first_strategy_doc.py | 17 + 32 files changed, 288 insertions(+), 2464 deletions(-) create mode 100644 docs/first_strategy.md delete mode 100644 docs/img/signals/ball_losses.png delete mode 100644 docs/img/signals/results.png delete mode 100644 docs/img/signals/shot_quality.png delete mode 100644 docs/img/signals/signals.png delete mode 100644 docs/investigation_ball_contact_orientation_divergence.md delete mode 100644 docs/investigation_default_vs_lowblock_stalemate.md delete mode 100644 docs/signal_report.md delete mode 100644 docs/strategy_tools_plan.md create mode 100644 tools/figure_style.py delete mode 100644 tools/metric_correlation.py delete mode 100644 tools/signal_report.py delete mode 100644 utama_core/tests/analysis/test_signal_report.py create mode 100644 utama_core/tests/strategy/test_first_strategy_doc.py diff --git a/.claude/skills/explain-result/SKILL.md b/.claude/skills/explain-result/SKILL.md index dd418e9b..e309c8e0 100644 --- a/.claude/skills/explain-result/SKILL.md +++ b/.claude/skills/explain-result/SKILL.md @@ -45,9 +45,6 @@ they suggest changing, never a new ranking. `pixi run python tools/evaluation/explain.py ROUND_DIR CANDIDATE REFERENCE --out DIR` (`positions.png`, `shots.png`, `fouls.png`, `summary.json`). REFERENCE is the name as `report.json` gives it (a frozen file is named by its stem, e.g. `split_shape@cffe3a28`). - - The whole field, for a doc figure: `pixi run python tools/signal_report.py ROUND_DIR`. - - The signals marked *offline* in `docs/signals.md` (replays the run at 10 Hz, slow): - `pixi run python tools/metric_correlation.py ROUND_DIR --out ROUND_DIR/offline.md`. Zones: use the names in `docs/pitch_zones.md` (defensive / middle / attacking third, wings, box). 5. **Write it up** in a few lines: the verdict and margin; which opponents decided it; the diff --git a/AGENTS.md b/AGENTS.md index a512794b..a013fb81 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -168,6 +168,8 @@ need most: cause with a test), `field-session` (a test day on real robots and its logs). The docs keep the reasons; the skills keep the steps. +- `docs/first_strategy.md` — the beginner tutorial (a toy strategy, then evaluation). Keep it short, + simple and runnable: `tests/strategy/test_first_strategy_doc.py` builds its code. - `docs/STRATEGY_DEVELOPMENT.md` — tactic-kernel model, referee handling, writing a `Tactic`, observability tooling. Read before any strategy-layer change. - `docs/tactic_model_design_decisions.md` — kernel/Tactic/Partitioner design rationale. diff --git a/README.md b/README.md index 23add710..675ca347 100644 --- a/README.md +++ b/README.md @@ -14,15 +14,9 @@ strategy layer that decides what every robot does. 2. `pixi install` in the repository root, then `pixi run precommit-install` so every commit is linted. 3. `pixi run test` runs the test suite (add `--headless` when calling pytest directly). -4. Play one headless match between two strategies: +4. `pixi run main` to watch a match in the simulator (Ctrl+C to stop). - pixi run python tools/debug_match.py --strategy pendulum --opponent riptide - - `pixi run python tools/evaluation/evaluate.py` plays a full round robin and keeps its replays - under `replays/eval_/`. - -5. `pixi run python dashboard_server.py` and open http://localhost:8080 to watch replays and - browse tournament results. +**New here? Write your first strategy: [docs/first_strategy.md](docs/first_strategy.md).** Everything runs in rsim with the in-process referee; grSim, the official GameController and real robots are optional ([external setup](docs/setup_external.md)). @@ -31,9 +25,10 @@ real robots are optional ([external setup](docs/setup_external.md)). | Task | Start here | |---|---| +| Your first strategy | [docs/first_strategy.md](docs/first_strategy.md) | | Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/strategies.md](docs/strategies.md) | | Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/find_bugs.py RUN_DIR` for a run's worst problems | -| Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md), [docs/signal_report.md](docs/signal_report.md) | +| Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md) | | The referee | [docs/custom_referee.md](docs/custom_referee.md) | | Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | | The simulator | [vendor/rSim/FORK_NOTES.md](vendor/rSim/FORK_NOTES.md) | diff --git a/docs/README.md b/docs/README.md index 34ce475f..6f60ba51 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,9 +1,10 @@ # Docs -Every doc in this folder, by kind. New to the repo: the [README](../README.md) first. +Every doc in this folder, by kind. Docs that code comments cite but that were deleted are in git history. New to the repo: the [README](../README.md) first. ## How to +- [first_strategy.md](first_strategy.md): start here. Write, watch and evaluate a toy strategy, then let an agent write one. - [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): writing and evaluating strategies and tactics: the tactic-kernel model, referee restarts, lessons from past tactic bugs, round-robins, observability tools. Read before any strategy-layer change. - [custom_referee.md](custom_referee.md): the in-process `CustomReferee`: architecture, usage, profiles, and its known gaps. - [custom_referee_gui.md](custom_referee_gui.md): the referee operator panel in the dashboard. @@ -30,15 +31,11 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f - [strategies.md](strategies.md): the strategy catalog: every strategy, its status, and its latest round-robin results. - [pitch_zones.md](pitch_zones.md): names for the parts of the pitch (thirds, wings, centre, the box, danger), with a diagram. - [signals.md](signals.md): every signal recorded about how a strategy plays, grouped by question, with reference ranges and what an off value means. -- [signal_report.md](signal_report.md): figures of the main signals for every strategy in the latest full round-robin. ## Open work - [roadmap.md](roadmap.md): larger open workstreams, and one-line pointers to finished ones. -- [strategy_tools_plan.md](strategy_tools_plan.md): design note, "one question, one tool": which strategy tool answers which question, what is planned and in what order, and the open names. - [sim_realism.md](sim_realism.md): how far rsim is from real matches, the realism scorecard, and the plan to close the gap with measured, randomized physics. - [in_house_vision.md](in_house_vision.md): our own vision stack for lab days (per-session tag calibration, tags on robots), the experiments that decide it, and the 2026-10-22 test day's vision findings. - [field_log_replay.md](field_log_replay.md): design for finding a moment in a field log and rerunning the decision code on its recorded inputs, and the physical setup's own errors (tag yaw and offset, kicker offset, cameras) as per-robot profiles. - [testing_gaps.md](testing_gaps.md): kinds of testing gap that let bugs through, numbered (code cites them by number). -- [investigation_default_vs_lowblock_stalemate.md](investigation_default_vs_lowblock_stalemate.md): why `default` vs `low_block` stays 0-0; partly fixed. -- [investigation_ball_contact_orientation_divergence.md](investigation_ball_contact_orientation_divergence.md): a robot pinned against the ball rotates away from contact; localized, not fixed. diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index 466eba49..240c00e6 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -1,5 +1,7 @@ # Strategy development +New to the repo? Start with [first_strategy.md](first_strategy.md); this page is the reference. + Context for work under `utama_core/engine/`, `utama_core/tactics/`, `utama_core/skills/`, `utama_core/strategy/`, or `tools/evaluation/`/`docs/strategies.md`. Assumes you've read the root `AGENTS.md`. Design rationale and rejected alternatives: `docs/tactic_model_design_decisions.md` diff --git a/docs/first_strategy.md b/docs/first_strategy.md new file mode 100644 index 00000000..340b0454 --- /dev/null +++ b/docs/first_strategy.md @@ -0,0 +1,188 @@ +# Your first strategy + +This page takes you from zero to a strategy of your own, playing in the simulator. +You need no knowledge of the codebase. Allow about an hour. + +First, install everything: follow steps 1 to 3 of the [README](../README.md#quick-start). + +## 1. Watch a match + +``` +pixi run main +``` + +A window opens and two strategies play football. Yellow plays `pendulum`. Blue plays `wolfpack`. +Press Ctrl+C to stop. + +You can pick any two strategies: + +``` +pixi run main riptide terrier +``` + +The strategies are listed in [strategies.md](strategies.md). + +## 2. Three words you need + +- **Strategy**: decides what the whole team does. One file in `utama_core/strategy/`. + The file's name is the strategy's name. +- **Tactic**: tells a group of robots what to do, every tick (60 times a second). + A strategy is made of one or more tactics. +- **Skill**: one robot action, like "go to the ball" or "go to this point". + Tactics use skills. + +The goalkeeper is handled for you. Your strategy controls the other five robots. +Restarts (kickoffs, free kicks, stops) are also handled for you. + +## 3. Make a branch + +``` +git switch main +git pull +git switch -c strategy/rookie +``` + +## 4. Write the strategy + +Create the file `utama_core/strategy/rookie.py` and paste this in: + +```python +# utama_core/strategy/rookie.py +"""`rookie`: the robot nearest the ball chases it and kicks it forward. The others follow the play.""" + +from utama_core.engine.context import TickContext +from utama_core.engine.strategy import Strategy +from utama_core.engine.tactic import BaseTactic, TacticTag +from utama_core.entities.data.vector import Vector2D +from utama_core.skills.src.go_to_ball import go_to_ball +from utama_core.skills.src.go_to_point import go_to_point +from utama_core.skills.src.kick_upfield import kick_upfield + +LANES = [-2.0, -0.7, 0.7, 2.0] # where the helpers stand across the pitch (y, metres) + + +class ChaseAndKick(BaseTactic[None]): + tag = TacticTag.ATTACK + + def initial_mem(self): + return None # this tactic remembers nothing between ticks + + def tick(self, game, ctx, robot_ids, mem): + if not robot_ids or game.ball is None: + return {}, mem + ball = game.ball.p + robots = game.friendly_robots + + # The robot nearest the ball is the chaser. + chaser = min(robot_ids, key=lambda i: robots[i].p.distance_to(ball)) + # +1 if our goal is on the right, -1 if it is on the left. + back = 1 if game.field.my_goal_line[0][0] > 0 else -1 + + commands = {} + if robots[chaser].has_ball: + commands[chaser] = kick_upfield(game, ctx.motion_controller, chaser) + else: + commands[chaser] = go_to_ball(game, ctx.motion_controller, chaser) + + # The helpers stand 1 m behind the ball, spread across the pitch. + helpers = [i for i in robot_ids if i != chaser] + x = ball.x + back * 1.0 + x = max(-3.3, min(3.3, x)) # stay out of the goal areas + for i, y in zip(helpers, LANES): + commands[i] = go_to_point(game, ctx.motion_controller, i, Vector2D(x, y)) + return commands, mem + + +def build(outfield_robot_ids, motion_controller): + return Strategy( + tactics={"chase": ChaseAndKick()}, + partitioner=Strategy.single_tactic_picker(lambda game, active: "chase"), + outfield_robot_ids=outfield_robot_ids, + ctx=TickContext(motion_controller=motion_controller), + ) +``` + +What it does: + +- `tick` runs 60 times a second. It gets the game (`game`) and the robots it controls (`robot_ids`). +- It returns one command per robot. +- `build` puts the tactic into a strategy. Every strategy file needs a `build` function. + +## 5. Watch it play + +``` +pixi run main rookie wolfpack +``` + +Your team is yellow. Does the chaser reach the ball? Do the helpers follow the play? + +## 6. Change something + +Try one small change, then watch again: + +- Move the helpers closer to the ball: change `1.0` to `0.5`. +- Put the helpers in front of the ball instead: change `back * 1.0` to `-back * 1.0`. +- Use fewer lanes, so one robot stays near your goal. + +Change one thing at a time, so you know what made the difference. + +## 7. Test it + +``` +pixi run pytest utama_core/tests/engine/test_all_strategy_configs.py --headless +pixi run test +pixi run lint +``` + +All three must pass before you open a pull request. + +## 8. Is it better? Run an evaluation + +Watching one match is not enough. Football is full of luck. +The evaluation plays many matches and tells you if your strategy beats the champion (our best strategy). + +``` +pixi run python tools/evaluation/evaluate.py rookie +``` + +This takes a while: matches play in the background, several at a time. +Matches that were already played are reused, so a second run is faster. + +At the end, look at the **verdict** line: + +``` +rookie DROPPED in the screen after 2 round(s): mean diff -1.20 ± 0.40 goals/match ... +``` + +Read two things: + +1. **The verdict.** + - `BETTER`: it beats the champion. Well done. + - `DROPPED`: it is not better. Most new strategies end here. That is normal. + - `UNDECIDED`: maybe a little better, but not clearly. Treat it as not better. +2. **The mean diff.** How many more goals per match your strategy scores than the champion, + against the same opponents. +0.5 means half a goal per match better. Negative means worse. + +Ignore everything else in the output for now. + +## 9. Now let an agent write one + +You know how a strategy works now. A coding agent (like Claude Code) can write and test new ones +much faster. This repo has a step-by-step guide for agents: the `change-strategy` skill. + +Open Claude Code in the repo and ask, for example: + +> Use the change-strategy skill. Make a new strategy where two robots always defend near our goal +> and three attack. + +The agent makes the branch, writes the strategy, runs the tests and asks you before it runs +an evaluation. Read what it wrote. Watch the strategy with `pixi run main wolfpack`. +You decide what to keep. + +## Where to go next + +- [strategies.md](strategies.md): every strategy and how it plays. +- [STRATEGY_DEVELOPMENT.md](STRATEGY_DEVELOPMENT.md): how strategies and tactics really work. + Read it when you want to write a proper tactic. +- `utama_core/tactics/`: real tactics to copy from. +- `utama_core/skills/src/`: every skill a robot can use. diff --git a/docs/img/architecture/make_match_data_flow.py b/docs/img/architecture/make_match_data_flow.py index afc0e578..4cbd7572 100644 --- a/docs/img/architecture/make_match_data_flow.py +++ b/docs/img/architecture/make_match_data_flow.py @@ -29,7 +29,6 @@ "utama_core/analysis/turnover_breakdown.py", "utama_core/analysis/restart_outcomes.py", "utama_core/analysis/stuck_detector.py", - "tools/signal_report.py", "tools/moments.py", "tools/replay_trace.py", "tools/repro_from_replay.py", @@ -98,8 +97,8 @@ "chances, turnover_breakdown,\nrestart_outcomes, stuck_detector", kind="output", ) -d.box(165, 48, 34, 18, "tools/", "signal_report.py, moments.py,\nreplay_trace.py,\nrepro_from_replay.py", kind="output") -d.box(165, 26, 34, 12, "ratings.py", "strengths and verdicts", kind="output") +d.box(165, 48, 34, 18, "tools/", "moments.py,\nreplay_trace.py,\nrepro_from_replay.py", kind="output") +d.box(165, 26, 34, 12, "ratings.py", "the verdict's test", kind="output") d.arrow((142, 98), (148, 92)) d.arrow((142, 94), (148, 72)) d.arrow((142, 80), (148, 70)) diff --git a/docs/img/signals/ball_losses.png b/docs/img/signals/ball_losses.png deleted file mode 100644 index 358312f3f2a27c2fed6ff88ce8309e30ef6e931f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 54363 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 diff --git a/docs/img/signals/results.png b/docs/img/signals/results.png deleted file mode 100644 index 1c8206525ea8849c8d06cfe925f78a592acd5572..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 80361 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
97H5yx=QqySG@GTpk_wRWn>P6^TYuuZVnre4 z#x~8MxLXV%?OgYA#e1oQZ)BTdH=VO|A%I`lwnl`~0OfT4^6XGwOL(xWSIJ{`yz&^C z;@AdXr&SAlCd3ZHh;c7$;eAUy>!RjO^&yPK`tio_9!}Wet83kR+<{#8W9_h)LDtb} zht;e+LA%!B^SL)QpQCu4xirx<(Kyi~y&utoPnR}gFF|tWBarwrqg*dJE(W&E+Cwgo@=k(rE7A24ria=Mm*u7_2%-2Az)`NIJ=PRlsVe5a znY+{X@qsQ7pp`|TEw#tjXDIk+84M~1ZGxB>uk}y{y~11LETut>Z72@eQkMSC*}`p0 zV2q(2{{dsCkMhh`rRtd*P1XkH40;{HsxgCet6Q}}2XkSbSGbvwq+4*4tMjP~BD?VM zCD=i?BC?nRZkD|Amwk}KF6i@a5X%0TZLV?ShoVhLCF$#h>IA~FJyyb`X)-uZ{R}E@ z2jI>0)5VZm(C^nU@*Eid=b$&u+~zJ%99raT>L)E`#L$UZl@lAJnP2A3b-C2okDk+A zIZfFUANI0EKjL`L@2ExEj|bT2$y#p(3`OS3kDr}R#|fdd8M{_c>(-wr;-6~$V`RHO zq~YUnXJnMPYu0|OWVo&x0TpPBlce7^>YtmlY_+O#b^eu9WLE7Y?w?$;hg*QN-3BMB zX8)G>m}8HETLH8$)&)2QN)rcZ5e z?Zg1p0gTqb#G@9F@T0!8fBS{-%_R}eGtvrUMcl{N9{S;1nZ>4FTtQ*wgQs%;vjp`R z8;g>Q@($N$8dE0QT39<*{c9{MhW(4lXi00itSo251K95``!f`vNugT>$_wlq%_4v@ z%94!Vo^LqoW9)HbUO^9A3l>(UBO+)~O;n{+2PL2$WVLkbTD|F}N$TZ$CRc4SEg_Va zV5v$68~1pAS`lgTj>nbf*Vz{U1-pXwF)6Pz?B#tHW=@{_I_^8}Hf0*c4&0bzu)4A= z!W*MdtW`43C;h-#-l@Bw376wO0QN4s|4z^7z-a3G9U?f3Pq?!f0JmMFw;B3;0hj(9 zpnpo-qU)RQ#&GpM4tbkVPOETqD681SbGpWy#&*bDv9)4Ls>?v>ok*B4fg<~U z+t>EfDj|IX<0G%4W|0>^rtH$8Ok~jeRy5XluM6=id5^24EKUV`&i;M6(!-C&YdspG zt^IEG5N@BZd*+<8qhV@2k=M%4I2OpoGwJtBhiX=D(v1y!Q!#tM!P+{n65|*$5-3>P z*pkB75#NM03>_h>em8eoXj-=KkG*$SCGBgtRHZ@-J$&fC{ZkGuV=SM^=3K9X0YGGh zeuQ>n=&MPz`#YI?A5vTv&bOQyw0H-uw*vHF+wM|pMpHA@gS`{G0j8YU-p-4P-%s0)6>>@M zwm{mRov8_1pWhE4RU0{sPs!7*RoU@JKwf{d4}P)@+#=O}LdYoq86VNtpk1_hepP;} z<`Ccd(D{Kffi2K=cCy4wGH2?>0r}%dyL_+RYo{Ya{y-$P6Zd=49z)(?Mz?`GvLB#k zk)L5&v>C_x(57I@l9Fk?x1FxZ)5BuF_?^zv zHh}S(IxQOmNNs>Rs=`n4Jd*inlBMKL-39LCs-X|}u)A>kQ_+oXv2G3O>#x z2x*3W>tF$>Nsov;Ou^3k{x%wgsqXg7Ya4z3NysJu{Jr~ur+Id3o9eu`#-($9o%bo; z_uD_745ZNp<>uW^{Rp~`zu|CbZgrzJO#EweYJ&ytR4*Z^6(BD6zWmue6So|?;JZj- zy4OY!sDv?JK`x^mv!&R|abQTj%-9&RVV4w0c%WLcFSzAFAU-Cj!pb^N2FS^O0F%t@ zT5kbbu73yg(DfvMb(HY_l3&-ieHTaX)qn+U)==b7-{gR9CGMEcHU*I0XY3HOm@vbr zN93c>(D=niOfRdy`S4H)#ugC#@gXXp&ilPbsz(YPx<6Z_ja697`{Nftr|v-tUeg*6 zY?K)*b$%}BAJ)Bu-T5C7@#jz;J=P)9>$eVgfnz*|76qK1r)yPFf4&`}O(%FI3F|~u z)}{*NkweUL+1V-`(31-O8w=g`P|nnQmD9 z{G<LQu87!E*zBUXVGO;gD22BO-e)6rxaI3&B&JoS`BTGmh~ z5|vg&OeJOv`Eem{mV1vaO@z<%7Q_~xDkIK<6-CI4+VS-;IcuwB)#+iX_Oo)yf8v1J z%~v~u3PRYFPG>Ej>YRafq^Wai62t)F#VZQquSU|G- zgz7;@?N8M|;DIrt|MQQ{o&_}Si%-ZF&9 zVJuUob?eL8-JV%r-B5qt=avxO|77Cc|m5v zip`to1L4b{@)!Vx`6T;k;JAYcD@VOv1ZW51_Vj2>LEUwmPmkV`_I$-5hg%Tpg#^_) z-KKIXzl=C4fJ01@+|RhrG|sDc!(Li+za3uEyNz24*0n*_y%>U(Obj)u!RRQ@$>tlE z?_Tn0H!`)TyMw73lI2wPw2}eG@Xmn8NGX*SgH7= zBL+|Mwkc7pWG$FI+%*q2G@v%X=Y+Tcmv=oXe=`ofYcaC(qg*~{-R>Dp21ZaS&{3J0 zkHYvj$T*o%tv2?DCn7P+F2MJ%hW5KOfKQj9erJ^5CJUl2y-?dE`|SwG1iS^iBx{L>AJr6FW?rHX zmNzpJxGzFe?{o|o1@8!1xGVD*K20CJ>;vL6KQ9UMP6Z$FL56E@ewEe8r2=9$srE_te3oa1#^nMR{-t!%|ezmjJtaG z{q;kgDtSo9_O0`EsZXoC!gupn*9Cen|F;1*!GOl|JteP9Y86>{&-1lD#Sv!up{QK$Em+!sDVHfd;mdn&& zTR2~^&;ek~Cw=NeIb9|}MBWq{AD8*k2a*j^pfKbX8o_S?=?}>_cj( z{FN&`DKRSmq55Io%tpREG;93Nj}!H(y7Oh1eYmgyT2tIy$#$LhnHi3vrIbgGP(x4b z>T!_rQmFhA6ZaDcV=sqUV6TgE@hZH&qjM=$-c=g-V;*Q3U`~gvf?x=f9zC?erd>x2 zt+a0;3|cy*&dsl+`uq7`4?eWDc%V|}(y0)}bJ{lXg=NRK?42wnnM^pEM(68gyE{@% za01=J@qQXZ;|yPS7Ub+S0q&3n=VD(D5D6=U3<{rsF}$0h)1Ae>^)JM;og& zYGbENY{g(eLX{A6#yy?2NuoBA(kg+M*wqcT#sv_=YA!TPg@COg@jdPg9ALL5DM#=s zN!9-}$aJPCxDO0(YZppCU;7L&O>z-X+ujqaIoeV7Km~X;ink|;l#`Cn6(nc{g+HqE z!E5#BI*N+lE&T}kPK+0AN53WrQG~sfrIcfRYw*LM6YwQurDnRZpz5@# z{DcmDyHD#N?LmN*^+W=_Z5w!e+|@#wO?zq@HM)^BevG3VIyEtVJu&jaWCdis38+u) zzG4%PO3cHz=WlfS+`;vKd~iWEV(X(R+S;KG+pe~#((OBmikuvPsk#qb@|O#aB^${RUD@zGp z7(TZ?KPdk=+Xyb5X*u}eUJ-!sApG)N7#lX56HJ&0#=iwsFlP9BPp)RTaZgzUZPmL! zd~FUY7$Kk)p^tPxivs6aUgtFc_hS)Aoi~Q5myMc3R%Y5BqX{4*SPddU)-7SR{%3de zsg@2fk%=bsWso42C-pdMtl!ltv#v?AZ4T+BP3&fP8t-L-OsN6Z(&0_g9`?z@U+sAs z9{qlTa_hYY{9^Z^GE&Bs2T!)?WV3pjLX@cKjy)hf!Z@T|D&VMwvt4!_Y^z5pEy}k6 z=HomoPvmO|r9R)L%}T2R>^^`5AUo4i!a`D+<^bG;n(lSQ$n6j;X_*KXDM<5~x}Zs$ zpl6Z+q$UYO7xf?Sr4fMNOO%Iwtd!ETh32aFfy)zU-9irrL6YRN3Exr&HR>C=@5LNG zWo+~e93}<dT~u#zYjR<<7P~EV_b2l)g5$0GK2?&Q_`F$fiA=0SN%(a5|~P8RTmsji|fnsh^4YeFz&%d6%@Hsv>L; z0eai>&o@f8ofApHYcPL;bAD4Xr!!NLtCoDhXM@5T3y3XL>^uR2!{E{?V*7ciOVmYW zyYofhL`%qBx6R7YcJ;#n<*Y4a!ctA)2cNa(vdjFX3 zjV%XD3l81|wiOm`66_4lQ#f!hL4^8^u5oP8jiL#q`LFl9NWbTbJKS?^CSs5Bs`M<5 zx58qtpGmmIe-OWE`kcbBc!m+ zxsIBjs1R`Qjdw+567zLqLG&vJ1g*4)!THcKkOQqDlvScfdUp5h--Vcjcl_1vD|D8j z`rjWx^Igp4Kt!;58_SLw;{==pvs(94)cc(}LRu}r-lb-gfOwP*WGRNz)cpbZ(_hHl zgxM2A76X69RpL^&^k#qny{!|e;4@Y?@%mJe)H!~~fH@?248IfH6%DxovW6ePobD=iLJITm{;E~*(ez3-DQn*_AioIKg9 zneq3YuuI_X?B_hwWfXAiFP>J}UwbJr8m$m3>ydvM)hXwbP;!t0Ln%tRXT_9)D^~q;3h>BaVOVGd;~l&%eyY% zb;WM$Dht<`r518u6<{CrP`+harAcEI21d%5o%+mKi_Lrq&C>!H=KvnDJ4wqh?UiKMw5i2rL4o>} zZe}TWo!w@^AYs24s1zabfj(6VMM-|5En$9ZlBjJleEs=7o~xj?>*2vn%Y}t zE=H(CZ|DQB!2}0<9GJ5fZs{cm-FbOr$~%RuCI%BbGP-2dY#r1@Q`^&|vS{H;*^I`u z$CJ~T2ObT@Pse2Jx8p)X08U0{qUMJ!FbP8S%}4Zjy5#Lfx%z?Ry~Z^|lMrZCc{CMW z_Lc?mh*{Dn1$LM?7|en?KCcxJvOM+p(0!M#>>KanLR2}QQ5dRUHepc<80u`E#&%E- z^)WdT)!4keJX?jtB*deqrQ8Al&$fxGX+`$qXH~nhcGS}u{eyi=W`$MNmw*DoJE>P`(oDq;yB^iXDRV$&4y{fN>NIiDx26+j zGF)?I9gma&w4S*Z!tv1-eP&VtE^a=mF_onmo`&ldAYZ;)ns_LT^i_{*4mPjzUhmw`rzax4juA5tj4r}mIc1}YzMhHa z-9eIvSmdwfmj7Iep6S~qp+V>VN)?f`xBGLES;=?Z;hRC4+40krr}uA6KddL^QV`NI z6&3vC$;b=ma&Q6T;t^D~; zU{KKTmhjC?*=M345&omyt>@ii+V-y71+sp-|LRe?T}GQ8EPc1s8!gB!}%gE#m-NPmS36&65{ZV`24gg$tfUg^la| zh>Y+0xAklK2ESD5k*ZL=G$o}PB)c^vo4e|wFDzrZ3(3X59pTRE1b=qtE zla3aB&Jj9NoqA|F5qqC}hg%|Y`+l(12 z7@^Ls+w{gjavdP9mXX`O#R^`d0})8YCS{+=i+Qk(j5VOQmnK^zzP~z^Y^u%tRtfd) zD|`u7fW^)DZL?i9pO(+f0j`?_SSUeVxDr#LmqOaD5kQ#80S(j7Yb3N6354xM6FUAc zt%Ekg00WvMZiJiBFM~=bABa^2hPr$vlo8kgPx<9 z@2jlik6r2F)u^#BP?o%#Kee%Zwksk(YjBN{*w;i&c(c}H(~kNy7fF4ZHl*GxQJ>p! zK)K~NQ@fggV2}p~o|b}1vM3_-BRSKhJk&c-NG)DnAge>R_+G%rmbx?3avANFXc4+@wZux3)e0icAg)Af+hMe4-UVa8Xk>r_xaxL(>3Pf z1iWMWdNddlGOHM_A%^s^)Iob;Cg1-Di)Ee0sOs!UULEqKfX#!o6?nA|uuZ1^s4z{^nulIVdpOSt{Q6 z-}lWEpBVb0h^EWbdIvZ;SSVcJ1ZbuE({76=Z(FjfiSF9aU~0(;jI8B+d&5TvGh53# zE@GITx%#@~*gDEnTCIiV!uom35cMNe-u>0T%p}_C z#0$TJAzT4)BEx}1KQk=GcK<0jSg;24XzmwLSZ0G*h!^S+*P@$gQ+OlT5X}(Y! zZ#VMGxvDfTGD|!qi?M@v6JXYjKxV#EtCHt+3peb_#t(MDzSdI(`AMcJ^^zXyJ0(H$@tBLeL! zOr6b@kOt9rZa>Fqt0f@V3LP=Gk}l}o`UR(m8$o;5=hYOXK$1KSjApjk29Q05KRz(~ zc>i27UeSFZ1rPxB4q90r6U3=p&Ngabuz^|=lR=B4Mqp-31V%q%R@_0A3tPh-=i%XT zY5|Z&=5%s6I3+OB9yb1tzV*tlgO>l6u%*;86OSLTl^*rZL1m90A`Y86^?-z_3{g z_$mefL3OO(0eJ)GjfD|=Avws%EL$`S*xsGl66=D7-8qm}w}yPXUU$`L!)`De8R@hH zU7xh*u2~!lP6UBnj$eITd`juzjn`rhXYFd2%V2cu8(H(M@(Hm>*LG!-r;}NL+1Tu2 zC->-IfgMEv#~A@o+ril7!Jxx`x-UK;6a@CHLAT}EE+pj&WSE2p4#^eN069vAHFmL< znkaNH^++&xYmG#TMeXb*Y7O~oNieR$E5{H(Qe1GQwg2^L;!5TvX=Gv18R!;Eb(e;O;zIPZ?pV`1)ILrwm@5 z6z^c*BW;}bUf-nPxvR6mZTMA>kK}V|;C@FLj2_1cK!!*h*e|Ux!_o@(PdIdhmRNf+WSCkwJn) zXt!4@h*SUia1Xt|sgsSz25cRJd7RHw?M9VHXy)a6?qKRSGt{k+kXH^E;ZJ3J#9{;s zME%US4r_5mdUYSBD`(ZX+j^my*N$cYy?GifwLLK2m4_V}ft(nu7L= zX9d!M4($jV1Zv~&Vfw~wZtd;c^bOdBpMHv^0Ze*e@)8iCS>%MCzCT;><=~=a#0HjI zRt9C+*Lw?OD0-xgDIlia(}-nPAMXXjzq|%O^Oe#*fd2LZ;9)%;5P*8bfk(O?3aVvp z54F-l4fHqKPsZ6#N!#iJow}qUL~aHxYhZcl??f;y@1kY=E0^|{d_iKypDZ`*Ag}j&^c9S?T{LV&WhTK zCc6Nxp$!+|->h)3NZB^*Lcth9S*20Zq`S^5N*_S-PTl%2(l9`;2j(&axMw2_ zEFYnWf#8sE!o)B7?QE->r)jPan7cFJX zipT&@M{vTowz#x}<@5q>-v1Cf*&OPU+p~JF5`^-2J&~NKo0}lG))A(dSd?nb|5(Cd zLzQhxdzAWoGJ&M|!s1y!wQ@4qt?l90=Wo2Ni)OvKqG!5tY(Tem2~7Gbrk)1#N}FlO zR1Q=}Px~Hv&IP@rS^m|zP3w^>aED0Q&+tSrmEV!g04UOV2&9Y7`bQ0e@Tu_Z&eU$# z+ZY^mV`nEE-Ed~$)j8h#{f4jf60{mH+n{@BcNcl89B>shf5y1-6o_n`#)HYdX=cK+vpTJZaotyZ~%iW@`Ns`ySysqdct~ z+U}&jdGTC>IX1;qi#ELPmMs7QMxrM4TVR#D5+!WvD#XoetD~p)q!cvsYHaD6d%Jo4 z0b1+VI~}3)%mK)r>k_B7Q22fzO*SH-nBL-4QSES-DTOvJ+ zJ%r0FD{&pVjTiLBCF1AmfX`uD?b_|#mo8y>3k)zHN5wGsmtG9 z;?*R;&`0thK@vnRcbT?0e)m}&Ab_&`I>cBf`&@Pi*3b#ZvQ6A4q*_WlKtAN~y-ioT{`A%C4pm@e6f-B>+nArVl(fs04GIA!j_fga0R$q6t% zzbIkTbZT{hL-^t-y4Dqbkks#iAB)Kudyhcy*M79cnD@aqP9YU;6AXo{tXmo$ExMbs z2P66INKo8WWVLg+9J5bk(>ok2v7_;^w)96mhhevim0gga`F*f6*%&z1CkLjWdaI3u zh$+%`HyeW%MM3B}6^uWI3%KeCt<61^@tL(kT>N9dVZpu1JY#t*InXVRRYXX$M!v#7Hc;`w1ty#u13sB8T&7<9f~Ht?Bntu`j;o>m65MI~YK2DRXW3U^gw%Et@ED?}M8vSF2}i&^@vN_6pZE)gNkWfkJG5 z_fuD2|5?;YnN`q3cb@Acr|a3!=RTQ^?%hr0ceUo#D#5!Po!N%LB)P(b^qk+?AIO1| zI8H#B@)Uk^zp3}V!r!l1f204@xKaO7dkrz?6lA(9`2rUhQe0J=Q2bxmd+V?)_jO$q z3q?gyED!;uC8d-OK?wm-0i~4?q*IU-Wq?I@8hjv12olm5NP~ic(n?E7NXNNf#~5qQ zHP5-$zUFn#+1K9ZEdCiOe7x^3p69M-WwlC;)3sN*(8JY*f-K9I{DSAIYblq`>~o3^ z)Mi?3Ij-u6%AxIh9Wc1i-7eA+ncZqIJe528!SO_hAxYO`o^QGTnu6=#*ZQ=4dku>~ z3;a%7uPI+v$!GHTvFg!X^SNBwqW@XA#}2Ze;*~d~q{y$A(KZzaxaL%-BP&2zNLy6Rjc1nAGhj4*}B)bE1c8IA@+2c8vyI`8{8(k%Fb~2p@NI@#M64g zn;ruapPlK{_Tw_CbRyZc&ogIV%;+6TdE-E3ZzYn{YjvV&`01tNmS6btC&P3Npc9F# z8nE!Z7F44%a;$RpM!?!8vY(mg6QVPWbNhn>HYdFfxVa(GvE;|L)2{tib+_>$hK1D> z2EDwJlsDg=b7v>@Iu8jp+G|v1ZOPF6JnqHR4j@xy%<52U^|5`VQpfvLhXQL`?LU9q zyNj&6EXQ5s`gq*%YJE6)pyTM_M%UakZP_OG+8xJMFBIKwe)!I5g8#7|mX za)%oD{0__Zyn6e#97~tgg+Y={_wh4YH$@w=0u-Ni7Hemj*0(V>J95cX=AEda84FOW z%-V{N(IxkWsknVti$~8;z}!csk&*;5X-hfAtP?w9F8~RwN>c2uMW3TG@&sW> zwQ5rJ6#SWzaUUmx0ZBI1rQAG3`DsZ0nLeWh!^e!=xSV!6k73`G0M{fVTC46-iBFCX z=vQ)wr?r7t$<+V4qPaBOqTNnwn0?OTqD83F=$C4)-o;-d*$#s|pp9J?xB1wJh0!Zfw15(KR!|AG3GgSND3g^i3&x^h1nAqM5zlqOCInPNHYGbR9|0 zucM3~7&Gu%G3jy(@WUHYSzEQKInCg~h4V~sXEhoWQ~Cj*h815AW$@+{H}M+|eF!uL z&tktYW%4p^r{n?S_w^sfujIyxwoaEhi=<2s6?A`m*2*y464j5zAIbDmRCyOVRH(_yAsA9ClpO0QxL1(bJbwOHm;A&u z9d|Sxt)Q9V>b0*k?KWl6L{N=c4WNR6Xr60_^j=>Rd3ZC3ZBA>lu0Ur43luHcB)t!h z<(1E;8g-X?nAS0Iw+}R~eRVg@#Yc&pU3@h6P@CSOK*Vu~DwOARWM-R2NmrwgRofY~ z=GHAwMw%yYlr33@2wHw&*Y&$EmB*B}RQ}Q4qW3-9+;Rqxlpd+^Lm?Za1xYebp}nb& zwb>Db<}*6-)(*2$+i$XpK|R$RYMall;N6j~HnsvaIXuv>v{}5B(eJ21sSiz{Ih0=m z{SRdl@9yQSf=AjfDg!=?TGW(thDJz!Q`5@5_SqQ6)44}JOJAt5&>YDh3-TqKHyxuqB=hX4LZuQYr?qNAv!cI4 zl&U!I{p=py(jUb)RtRftEdq1uYr~C}caTYc8JhPIwGMV}9KT_ZGI#0*!^~h}QG9a_ z|832-4@-=Po_}ySlZqgaPhNi=FcJ*!{3Wc_$}>ixHB zSHT2Q_O~a2e}M7`6dt_BU6ymE*`dJM3$_ER{0WP*au!S$BHzs9N0bX?p`15e=#P|d zX!(SM2qBX-s3SU?p7#%c8}?6G^QZss@YNG`MMn?navX@YTs-W zqw7q4wvRgo${r7s@te7CNX{HYxgW#RE-_I-Hz#HHeOW7@E?%rP>?UCfGkL5@m4*_M zOFQSog%2+tBXfwg1WPfEqZ=E-qUK;a`;Q+$Z-h+JHEBQDpK8^5Wqa7QKioRoWs>(> zq1wyrLx;IrgS7(q>mofK=A3)lH9b-&QL9B(PEC+1RQrzP{x*1rRMZlG93k1_YhFcHwVcA*&q~e{q1_Q@u8) zp%0Shnl_S2%Uw3yPIl~6_))dOP3-EAZv#MRy6^SSNR<#s2{_9-?up2XBLlE{nWmP4 zjLd7k=hjZ*n4W^;CfaT@>{c8=%K3Wt{diUWkIK1OFV($^HLuY$p{{oS2)^ zc=t~KQDZrd7>2%W3vVXhO!!Z48`L*Ycb4O+nW(Ci^miY3jbiqPkDre{TT21S`>x6NfPTMcb#kcmU-@etqc`a=gpsBu-cEk6+Ql zm;gPt?0fJ#dz(J{GKbm zfZwa0sy_kBrL5o0AnK?|k%F;K?ZYg%t8Bb5(KK@4uS1Y-& zpw};to|1NB5wcgWoF;M1&AHyb+@ZqUb)2(icez`sUaFU_|G1(5 z*kgg37=M|2?C+EadkCrn<>WKbbxTC4;;oM36s*KdaC|ZQAgsY5JbHyyhLDW7v`ISo8K!NxVL5q=&%WLGG|y^@sbj=jf2haw zQ`=m1eI%nMYR4tg*}QjIl8Iy)8f5c6Q+xgCU7Wp#?q{=pr}CE#gZzeO;a97P{cw|f zHNpTt0r|(3N1ZfM1o2eW_X_1RR76P}0tuyIwGGQf^4Rv8e3S{-%l)*f!{ z3*Zp?^0ph~!{_=W8y8`L`$9JQ^wYG*t+{Y{P#ZXnEoKj^HflgEKqQhPaO(%vEx8zS zjY3C`!5pOKDW#rcF~N#vm2!-I`*O#8VxG&?cG&_C&*{4zw5t@n4${hlSu#MGN}>gMJ}d>P|>!oV8bp6^7aOqXTizyl+<+~*}w^MlGUiErPR;8ec0UYK`>@Roks z`&++c%k9>(>W|Aat)H;}(RYWvM0x!NhFBv$oC>?ycI@=6-XE~v^K@x-0#gdYsX7-t zUk8l5#-qHYzRkHS$hrUVoJ+8@Wr5~5?ZZ=9JFj$0K6Kx7#lY2l>Rnk!tk{(Q;GSI} zJ3*D-liu?N!6B=~8 zLj(@T?VF=gR;(LjkJr^8)F1rl5lLWtt|d>T2cjS4Fz`y z632E^pP4do^IEbBcc1xqn%{Hzgey?Bdhvd z#a(_%@8i|yGVl=6mRz>=AI?)P`q+*$FzDAGc_p+5nlt9u2V@ULA9IkptMEJ9li!} zU3_ttaC;0`eR>)kJqtET#Woc^)D#*JpZhxfBceTCcIU5#oo?m56vcb1-HkHHv@VK6 zX<~OwaVRex?{dH!CUx1lh?eMc?<4OWKRF)LSQmLWd%HhR>rq`!Imua>(e}-MzDEJ$ zD(P1DwLp8`D^oYKS?%pk-)B$99h7a+s*1|lz!<0d6ww&rIA?>OnZI|Nh?#B0XCN%~ z29$krzBA_D)#1s?MMDnr$V9EbsECd*oLMpCL<+o+O(Qo>w(GBmn>R5x*rm|TAcet~ z1#Qpewl0vs3NUJ`jHE+7tc2uP*_D6*-*7?mbLL-OJaUM!eoh_($&I!4AJ`JdbVt0` zShzHl$LYHn7Trk}MJ2rIkHcK$P39&xSB2N^XR#{W9`d30roH8<(jYv6%je53ZvE;e z%J^yF$6jTc_d;a;Ll%2$-ua3xdo$C6i z_ep^8ar{YD5zs{8byz#Y+Qm2Tp!@0K^pl0dOtZL|B1UN{S@l;!*Qsae=L?lrcj8VTiEeyz#r1KFCzerk#72 z^vk&FXOeGF<^~pR6$3N$aOUsjnlz=Abd)_-7xstnlji(1A6aFRzZZNZWZpDq-QC>3 zI@^A9GFI28$a~j7-e0d&3&xr1~5=;))|+H2d<3anHn#aiZW> z83g8c(0urL^iJNs6W0GJEQenv(s^S4q0#t zNUH|bKBhmo)5;Bt($eSrM9EwNVY9JJOtt{a#maZ#$@^`Rq=|dHrF=5^xP|lqy+HQ?_HHiip?BBbvWt zWccqy0Tl4B1(2|5-2sC6!!a*UQ2PXb4tc!tW4ZB_+t+@gNwjBmQO_|`C-nEm4RK!= zTyfo-AV`9+Y-LUedB3zLkxNC?LfN8Hd-zZ#d+{)*?yI0nY7j7VmTKi$iU@Qb_F7%e z_E-|WRA5gc692)WaY29-0@_&_0@Pb+$8*LsU{7WS>JbL$tqRxOs#pB2Gb5Y^;Ry5K zF3F&~$xPDQ_QO3RJvyiTEfSVlN^X>xuD=|khH^U`6=lJu#k7nKyOeLK+$pS_UA@aZG1B}V*Z+0Q=Q=x+DE zL7IkwFp1K;cl!C_KX3S}q9-fg=UDG&#{DW|V)@&2qf{iaJvJ@5hO(+8xlFDVKD;;H zz71{h1pLqT6XS;zbK1<`@>rVfCZ~wjz znK6V}E%+R`M}<|U_jeh-0+;yni&40V?82MdcaDhBc&BfXJA4uReFStU%J^#)Nx^yO z!(kdR=eS~os^Q3qP*ASSGFq!Dc6I2V85SU7_&L-czv`dJ(8*WDU3&zDS13jrC}RmT z!{BE$pjgfM};l_`UF%9K!K^hDw0`3E%+KL42JqULDCoc zn#&u}Y3_F6M)*)tU)Vrf%3tL_34nv44G4`Pkm|7DA6{%+*6`zS0)!5B)H(u!E`iZUx zZ|=Vj%}sY=MV~OEFxVY#!DzRe?WM;`{LqkTrA@=Rp>7N^;AbG6$tAO+&na2^Q>Yi}1JlhhKs8e$mRu06xq&u{l#ZaV(Uz_&Xa>@9Sq zD2iP_i;R8zrEEVp?^%$4B?gzD?Ds(~!}i6w#8Nhil=xuIda*dzgv-^TX2*ZhJsKQ1w!zM&p3s%#c%$Q6=|wZ>@*9| z!E-ohTya5n4A7v*i<9(dTb6?Ch?w1B-jWubq!Rnys&w53as^c2Nf3-C|N4v(9uQWM zE1)+!sZ!KigcTHm*MghiYW-TQki}8J&bh?_gdUPeJ{fCr%(L!fRS?DW8!iwS7l941 zL(>uhRbQbK$Nsj#!(U6>@JobpbLQK}{ZtXY$9Q zs~IRogXaDO&+EfY1|;NLWkYF#i1}ye_~!s`8D(}a0o$#gLzd*gK7agxB8pcc>(#%h zBuZU)diHhS0=S+ynOfX)H82bVIX&9YqLv`T?gUXH2KhW=R*jRp5{u&HRtcYDiS+h= z>AEQfHzYw1sRY^oNspi~iPNeWG*dXe;&Z6=mdC~Z#ScnFV-{LGxfSUci4=U8t6x+G z7~K_mFL8^X`wbEe6CQ)Ma7=Vzeis zgsq+lxI9dEMulfns8tK-AbNmC+_m>XE9uh90oDUxfVlD-9d#cHS!l*ah?XuQm79n< zCln&C@VQc&e|Y!^h;ZgPgaA;rK3W$8z&rNXT}SaFpNp>ZQYYbCl@hSIX&bbCB-d%v zWE~MdsM`z>c5r#v;W>g6Ik6=j#_s{Xs{-T44F)OX}l;K zF$2{R+|P+T8ba#=%g`nN?n6j8qR{@FX`puH;8@DnCinJ;B0akI_YP{omp?JRXy5NS zC1!sydnuVT!QH6>v9|Zq0Q*BoD|!Et+@(_Bz`IjfoE_VZP>v>Z7Qz>7PcC`EXCnnO zAUS=9;Z}plYVg5em`fWN!*GP9yOu$A!gv!&p{J`r2lCyFM-5+H>apa*l@9~+<*l-* zc;OJrJ|+drC|I5J@Ee0~TRR zJdd1;kdacCU!TW`0DSz}2ev}Q2VzSFY$Gtyu#eNACPL6`QprkR3zf`xF#(uw~Y3YSMOnB!` zVIyQ@wmv}ahdzRblf)d;x2{@Vgb_SFB|uT&rfzDphv<0d|myTQ%9nK z=Yl-C7FL82I5kW|nC+@(4dRhGt(atROPN5XoDLOAK=~$QKGzX}pm;mm3Y z;#FUaaM%kO-5><-=L+mi1|6*^THrQ%$>0UKN^91WE4OZwu2pyTE}cxwbhOH!V^Ip@ z=XJt_7u^DP^`_)ns?n@Haf=n_s=AujJ!*g!#El9r5;=)~JOS}Wt}C>-!Vgkm4bZ)g zgi$VfAHOC-H{LCCU&>BG5pwiXizdFYZ7kNe^W^cyjMW^W7O>c{S$=7jf#j8FU`AU$ zKRix|{)DaCq9OyrHA>w#(ZC)d5JcTJsF~kSOw%asE?cXXzv+B=kjNp7mpORoR`s`u zvRnFR=9xUcJ(7{4Oq1|j{*rETUbhS|CwJMfQ!_V-bY>ILNXHWitc9AvVoUZW(8+@QmLe||pl$(7(Yptho z_Gw~lUaRBvrz1`u_L;_H62Z74W3VhtbzTo;2B+NckfiDc0J9&esN{oEovUBCRKFXC z6jv%ZtQ-0@4H(2VaF?m17_;&ot@qA#*XWg8pEOrGR$UuFW2UZivBt^gEE(B5@!*xT zbzPI&$+OmRKfZE!ti}q97KNi5L}oc*yartx*9r1rLc?vtvgu~Emn2A6&K0{*aA;-3 zQJ5`5L(BS&GDF2Z5o>&(>9cq42u>K=d0O4Or_u zQI!3@hYVjg{stx>QA#yI=8iEjiX?ghjBzOTY;5@_@C5a>hXJEDm3c|su|n0#m`c9J zye@WsEzsgR!$)muFNK3!+Z3G*4nTH!k>DS;IqOD}+^lOBMt0Umoozdm*b>FMWfPh7 zj7$M&;Ky%>%PN=lO5yLBiT6k4812oZuK+EypBYl8rejAqJ@p0K58i*|#Z8UgRV$hi zbNT6wI^*4a%Kr5JyG8}@IvkVXTp<#rlRTDY8(cBsjkV&g1ScW-ZZvOQw_9lFQ<;|+ z@-!aAiCu5m_%P>l#Pbg=kMzpT@9~U%=W!U|BBZcjvPAP;bA%$Dxm|w!&>+|bnx&dt zv4RhhJFC%qkdP)x9Mu8=O@L33Y2=dJE>6iMfuA<&y~f7cnSHkH}pd`U&W?;-6uCyZd=%WFpvgN#a`-wM?(P~R104= z2M2oeNQFJ8JHMQFqR~6MQtMb29V?ZuS@kY|T0TQ>xvLpBpMDXi50SF9V-VZQ?Zs$N z^_%dBGmNZir1|J3G>~x-$K^QTu zkT4WjX;0je`)l&0|5rfEhbgF8?jB1wAX6ilDcG&#@9yKK9UVmdBIJc}JM8Lu*d)x1 zJ)SQTQxro_VGVO*b_|Pb^WVcXrR5G&`LdG$XbtS8h7?6IJM`}lES+@a{y)>b|Mtwx z|2cg=*?<3-e+L|SM>L?JxF%xC{(8})d%FkvH;_@0-UTukgrq3Ye69ZLzg*b_>&xHE zp?qJCziiIb`-2{&D-~Ot(0Ojr83aJsUouCogg%*M_VMxV*s-=>DG=9a!ScdH3`v6R zFl(lyyj=QHu}ju(I2Ds0@uwmI?ADxDljs*tiu3pQH%;W3 zPd}!Rg_iE*);;WuWoxC{H3$qPrf8ytPmRWWfQf#L6%E06Rm7duPe3Iw;PGF6vypmP z33cg4OO7Kadpg^9zc9(_=q{C|Hz;BxC?ix{ijVCnnQ_s2>NKXi1scC@IGF7?2ZXuz zk+Bku!H@mQhgFo4LyYg3F=Aw?-WwhA)1Pv&f2A+lrhk{hdq8bT{Ys_RRkcoB!vOG_bEKhqS!H;c6Rl3~@^Unbd%%E-MCF;ZeuDj+a3%1-zd@22^ z_2t@(#IVTNecghUDv`18^{2Dv9KGH1$DiFF4$|0aqD(jb3$I`;;`J`4bo>p~KHcZ@ zT1`pSo!WAf;%ozqRK91&FwK)V$IwNFb6v_-dalV$I{Qerfyj>L0`L(j>2agTV*)0+ zrj*7J(^ZI%qs&3tVR%{`3+zThdYM9&Uq0k`+kFO4i4O9nI8-5oABUKRY78)r0O9yZ zYLuY+U^RR59|#NxTVaH4wJ_EK^Nk15_rZ~^^|8DI;DuX_r|%dY%=z^JW+Hxb&P&;0 zj-y{>fCU=5>Y$vo@Hx>Ys?gj4)gPmISC&x<#9s=3126bxl%Y)E^0M~bM@B#=C<+0c zi1)5~SkdI7!wPLIbeHhV$&GzZL^_P&u`5TlJb23evuliTXGDi&nXA0@gAra_@_RDc z8uB;LZ+0ac_*dYh=kz!3TTDN+vAr0%UTIF2F)OYWB@-(_mT~K04CE>lh)U9XX&#h( zj#QIeBuLrBPMPM83a=@5q}IAK#r&rc{6|ypR7TB}t<1)vDf_rFL6FZ0qHiLaVfz6- zf~gr??jk0pp$36nu$P2D_H)=TiZH%JHK#bniwXxnd0s+96yxGC9&RGRA#6A3PIx|> zrU|456Aw56kO|lR3b(#RuJJzLkVWB(=AKrtJ(lkkV=$0YAe*5n?}szyIqK-U_U}b0 zSPVyP$Fg3waTd`$)DfYf!ylid6eHG}5JgZAH5-QKaUDfV{WS6PZE!15z2CtEMSQPF z6lg}wmvw+2$S9HNHv(Ho00s`jz8iw`N=`w0R~8{on0*~GvLV@B{()m1XGXx9Q`|3JT^yOhTpNsaO(g&-BI$zK z*!=U4vd|yk2}wwZBXGo6?>Du)*NL>S7{=g}IN_3X^0feEythtwG;LfZU|TLYt9M*q zyzqdQ_mxM!!(e1z#eM_AKO~1WXpyW3ZtjmAhmN8^BLqbvgBGZMqXI$_J!6=V@@t=G zO|Xy`GFN@ftv+L*D^X}eYr#vkJZ1SQRoV1!r(j0tmE(Qo;8oO#jxv8 z)G383tb z4`W?Y9^2Bdy!Z)loXWOzLZiOk0F7xdY>-;3t4lV6;yBN1Hkt{}_dQH^f?4C(nbXR^ zj5-RbKUpsVcw+^ew9`o^cS&}vutC5(Stg56*ziDc(PhzP-g+CSmP5mnW?<=8ho}92 zB8j2dUZv<1h7M*xp`Zq|%xvm1ZiUyLHc+HYA;vOV^E_-C0WW5bd>=CGZ5eR0FBW4~ zh~j&bIT(ue!rFemA@TcD-0A6nG9KJ*Zwtrei0N!nL(;rHM&DM*s@0?my zN+g%X{0bg~{e%ERA|Um;J7ZWSz{Ru&=LGpk$RU21G1X^hqjy=uI#81)ActPend_6) z=jEmdX<9x9QYQ|D6xGfW~PtVFkpO|dlqRe?jv*Qy@y1!P0_n$2og zFHL95v9N?2H4=OnEW}?%Qqw`R_VN^FM2!j4hXt_pV|?*DRx{GNqpkhs&!4~8vSrI6 za)rhV;VS9KyXHx3=)MQIoNZVc+m>?<2j8?K6&?* zQLqSX=|77WHyXoAh@Nmb@548ov?!019Y)Qba~wLk?b!J@=W_eTCs!UdY8B?SFCm~L zI#T1;JyK9f$_Cl^O#Q5|h)8flqrA7?-uQjZ#wS>Glrb=B@fd{V4D&0<2G-9Miw{U@ek8DX_JE${^A%+fltL7gc zy9Pz}I*2u;+@#ciLw8X8=FOX!g{YZ7(chTZeWttUdSbhyRTlNWgzo0?b(k}EwUB@N zg8{!h&ugfUT9=y`!%rfJ=FHhaTn3?d?=hNM@aJYN7jz2#eEM4UkmJX2=ftOYPrQ7o zdOHC8)H&XHg)qkE!X3x7eiul01rIk+v&m~KUJ!PdX=Y_Puh?chDI3S8H|5flw2@$7 ze=h_%Jx(ly+nZXCu9CRl<^+3hXmq%;Z@u~!O`HlWh@P0jK&u+;|GFG>O|`f)4iolF zn1;Vvc^*<$yu}MUaX9`lx}@%kaa zq+%mZVIUG#l}Y}Q{xSr)duu&oMBe?OAAwlqCR+-ucd%8pYd6ix_5 zz&Z;+fK31wv&KIn#F5KC-)?tZ`E}eFaCY*q)^JX(ejGwgq*|}uQ|61vEHhdU$tfwE zAjbf*)nFP2m&f=$Leq;A|1=o8D>$}+M!s__I(}m&bR}gS+nB1FPE{^ukDReU?Rcqs zZFNqn*~tjo-UNqxvPPu!lim{_$sP^_)9*BJpOngXvf#{+xh45iq~3q=U%?o%gtqJ1 z!aA*O^{Y2tTwvF^a;f8ZKGzpJy@>Gwb8`9CN%kC0#&lm5DijfJxAV6LJheb0?fs%h zyP^z|4VLPV6uuG`4%~org!rH8z}Gv{pOU%FAX&Vuz1ai~)f~gg?Xn^m6)OYQg%{nC z@avs6goqm2r=WLtLKRRc)bZ=VLbP6>1PKc=rO$8fwBqQct;>oj-LQE_6(|*zvnMx* z5h`m~cN9Q^`Q-e-K=+rzTf))1#O_n9jm!)}H={j%RCO~Q9bbUs_^8e2)UR+&_c7IA2ib!JGtJ5I;Xc{j?>i} z`+0PY-!D&%T2KD?Y=M5Q+Y|v`eSAyhPEwFFHE%2|Cekl4EASUp^Y!u3)QjDb8ElIO z{@^{KPv9nN{uE^_{{;YJ+wd!WR54QW3C#~C;Ub0&6BK}Ng>5P24qy2bfBE9q>+Al_ zoa122JhzD*$n$LlkMNd--<;3iQ||`Z^v2k=hqjXV~@!gKm@*Z zRNqfGX056tJ3O!0)=%&K^mNg5@%6a?X4Q}j-z!rN{1xmy`i}ZU`DRh!@Bpj5aeyOZ z%COlF8{A|ED}UO4q=iy3N+DMG{Pw?~80YU4bUn8Q6Wkh#|NfEELkF0MLi5kBynhY) z`TIZoH+1puKo@^Kwf~hL+L2O;dz;d*$pVSgJsP1O%D_ag=2YbYV^#-gbQnZc#FsvZ zI|u@k&_obWC|sbN5O-|bgOa=aU@1CVafkXe21FeOm>&-0zZy|By$%_B+0ULuw8*#o1uC~ODG#+9s$xu9 z)>8JWMK069qY{T0yOHl^Bx)QEot~eY#7;H3Af4Vt#h&`-4d#Iv1|db2bG0RVo0&mi z?3TKE(>8N6lC@YL*VyBy+p6rNOIVWQTCe^>!_e>{@CP|G6Fj(IkIDR@r9aGyVtVVO zSlRN_JuZV%T|7KX?QckU(ZE4D7&izR4uNOI%Y@*zAqL?=P@^A$CQWp(z1a2T_JhK@ z?*kdwkR2HUAs+$k_j|1^C6Z<=l+%IU5IRW?G*2+UxN%pBUsk;5tcWJ-WnEq#;uQdR z59ZaOQH%M7T*LN)E}S8ohIfBZ()T^Sldhd4!_JsZs4Dtihd-~)r?0kXZmfb#@vTOz zD1ju%u;(}0=m+CbC_j5G^^qS`HT%T~ECz3j?4F+;Y~OeJ`=oakl+2vFN(cyNe*B6t z?O4C{K@(}uHbhXI=&9i(W6Sd z(Iy@v<24C`$>TPS7R$balEH{bvlMXpA$aMP?W1J`z@)+k=x_sdy~^3jSO(8|8Nyev zeiv#-f#w)tt0NFN2)};lG?K9KiXh*&uO2!e68lk|27~C^L{m0|l@Wf2y6hLn3avsL z<{?^km+DOo)Egy#PCc)KyV*+Be@AJu{H?QXZHhvO>)1gzuT#3Zc1jbOb5l4*3jhQHj-9G0~ zHSzTApcmg`TmYZ)Pmz^2k|9Jkac~;wZPmo|SwyD~31{+}n}2?m+r9+JPRzsjx9GV^ zkVrsCp@bRO@Q)A^?HQ7bw_4E86Agzkde9Jzq8rR1yg~%733+Y9!?@22R7Jyv0}%s7 zNy)6AYh*AeGBlS6%+$*fL~z6wga33_JVcHGNHL9O)uezcF(k9hWPp*(_zh?5ql-c~0GK+Hewwqe0`{$s)3QPrEC>|mR+ zbK2Q%wk;Buz{1R-Lu!gTheY1%PJy7+pT0gbl&KPQ1@g1x{@_~y&-)06bA?u0e}c2a zV6{U`rn%i%i`ww@oK4{)H&F9Y_qioBrwwShOqHvm_NEjLe8bOh#qU391!`-5_pF6p zQqmc^rR?U-CPBC9*RlKktvS$Bd()&=_zBh1Y(zhfWq<8Pt>yZfX|Kfm4BXR6Jg&P0kQ2y*Ny_0u8@ z05HQT;SPEISL2!I`Ko0D5+114O+@esU$Ji6(dcm`!K?k%IvzBEECibXgZ=68?y`yP zTthAjh#L4AqeZy(FqNQIY@(QR-MTgT{@js5Btx9&hTlPsm>mdk(%$(r(lTrXB0|b$ zhCaS^3_Xsl|G^xb8iy6GyRE7!V|ar~z8e&Hj;e4KSqEv#XigtJB2u_D?!=_nU=9`~ z?22yj6RnkPR0^ z2#)t!oLpAQ_cG=H7=&ZSZKPso>G2Wn^8*-}{t0dXj|NUJBC-PGvYs?}f5FVdm>EpV zz}|5UVW2hCh3Z9TTQaU>rS8%doH{QKg8 zz1)IVEeW%&x1P_7Y*WC^saQTxVehrH)zy9M@juD_$^6^?c_C;LnS;y6Pf!|eu=<(} z8kD;HLysZ^EpdtFJ;rDx&*fQO5)cl#l@}+985!WjRbe7Kg4>CrX{7@Qc^^XGgnQ3o z@Z|;Y6|AwsR{XWC5APEgGQ`2Bk=ykYOj0QBlH3y$hyNW`we|zTe!FW02?!u203$mrQ#XrTq z(^2!I5tA3$`zHxbaN(;b3u=y4*xZ}mKB!wmZ&2~hK1zBI)ut67**HI_6{Gkbxt0OY zXzuUCUSP5*9WK)}I7YF5F6+sMsm&k;?2HiT8hdiAe1 z{>A>A>~gQri`62>rfv;hQBJ}Tg+uM)YCvaNGRG05)6^ynBaQJvj$lWbS9c!{BE2)( zz?u#w_Y>)S?qwFO*80<(?ISqmJlnQPLv(W@HU8`RqvAT?Zxiz&LN{X1lJD2 zmr9SKFR)v(oF3q2ebp0XgQ}+qRR~q&;9~sGwDuo!=}8<%^q>n(8U|t%ob6d33TRL1 z&h83qpCkNUtL}tFps}{Vc`OFh)IodbaA23V4{{n3F2yifh@7nQ8{ytQIBq39y31uQ zZ=>ZUuDSfoAhdLKY#)~6rf&SFgD)+>~Q8E&|F%6&mq zVdT`8clY);_L*ac8@K0K@mqfR$;VBowL)+gx(-BN?ZW}7KUfViB#culK+l)Y)#bZ4 zOxkMeZS-t%Q%1IH~fpu$@fr&k%`YJ`n=NUX^g3&jLe3_8)Tt@o7VUVCji!Oj- z>tQj?*3Jw)x4|4Vm(_$U8JEQlr-B6YCY~v}TF@vNpkLLY*f-VYS-1jH%amrYF)BJ8>34^UW^@CYeVq#hpVvqYJ1a_HG9Tf*z z!Gt?IBADs)2Nqh(T`m*OLECoaH%@fzxpS~_Vb!_37u}&&q>V&KYjWZ-f@-Q!!~2k% zyef4(lVJSo-FNv8Dz|(%veh$^S#kG5&#gHX>8CioLEVRrPonwVf9<&2x^?SV&5#;O z9xX7)2AjXu)9y)=PJH^%rMV4tYeHr-wY>MB44NVw_#FDnBDKWt3tRDvmzyF2E(>0M zlh5xk5SVS(OHQ=Lq~b#Ng}dhFg2-Jqy`My+J`z!SgsYG1B}@kTWhnkcrX}?9pA&fw zvtwd$6KrRq7=hUfxk7F!gLz&_gj=3aU!cd)xWk@r(;Xq{u~_vy(>W4cyWfckbRH&< zmY^><=eoL(P4ISv+V3`L??)|M^sn{(pKkQ6QS8{Ww&}wD(O2}AR5d~eNS(8}oR!D6 zkdghpZW&JV9W|`ot*HB}?6Ou%+Jc^Hy!f|BLF2~Y^UpNX$K4yJSuC)sBdj}C151|3 zY@RKyomjQv;BJbL{ko~9>-;R$MtSMk-Rc)~*|!|!*Y$qNUUkm+UQZv}N%aeP-dnd+ z?G8&_pM5+hM?pt)wQ=sJnx$xSNPF_w(l2ojGi%k5&``lSd#QzlX2eEL7yTjJp!zcT z_1Q#8k24h?fg2>Z2(G7hVxb#hg97Y_d zy7`YeB+C-{IssmsfWRICaBxN6g_04U~*wLttD4s(#~(Uco}c#pN86TsH*1+_@vvJi3?bK-7Tb3UnU>rD(Odv@&i-IWHoJF;(qX zgD4vDm~FebG|9kZ!n3Y-bw$2}g_({pZML2ABdgQ`|)!JCINjWx)u<^T_>oE0CC z$bCB-p&Iu)T(53JhE#k-iJWs!beaF9IDQek-~g{!`Dxc`-xpyi0|H~~zi6x{D_<7#WqKAd1jyWL-2Se$WHh~Qr83gP}JZrD7l zeBl%2%dtm(i%BQK9|g#qQe*K?t1j|9Sm0^tmEBsI;IQ3U?9*&yNs4s_O=QSy?sP$t z7a5uH=20n}f;}07o}**59lDF}lC3)z2P(JHF^E+*S366`v|el4x}TCU?$MnYoPK9~ z&td9gU7<>b=P2YUQ5?hH{mv4o04&iKF-u8vB#W~Z`S7RQ@%LBIO2q8Caa-5HhC>70 z;Ko_MO0o|P+)zZtZu_Mal5ghrksNozT9u}^bPEwP=OeflwE1hEX>giAj5D=3@?=a3 zz)>Vf+n8>sUZO{>a*sgV?W~L*ia)Kas?a^ganH`R_0{@bMr-@-Jjj1&(t2av?x9%D ziY2b0Naey77I-whSBOiuW2GZ->gUcqiSG~br>PMyPG%3+w{PDLvnXw>h6^RGR0XJw zN`J8ClG#s(AD=iPC1>%oc<{dfC*pUjnylf>RKg}~>PTs~$uw%w&-OjPpI2Y-{K8(2 zbIf`kD6}8YNh}5~tYG}j)Ih9Jl6f;L1ZTIH+mBm!R9)CwpRjV%qaAm4E>G>FPGBC; zoQKY$Nj4Cc!XdPub7=lrcr&`U(RN4L^4n5`-AdfmTA(cQs76grv+bGI(Cj+_0m2q1 z4~e^+MRc;UqE~QX!%jyl7XUn|XS}V_+O71p(lbkd(OS5xxv@@E5 zKOe$!N1)fkdCDluHj_OKydr+73x?5$PySJZ#2g~){rlh`FK;p5#kSlfn;UsaX1O8c zQlO0^kQWrw?ZnNdCE>ibsun90ioU>deIgp#*t;pH^^#N7FnK#3sP^4PYv_8s)9lCD zm~7qSL<5J04hFF7@!n?s#bIV>*PXj}`87^xA4`&vx3zt-anq*gXGzFz_d6R*NjyPAFupaM9TsW0KzKH{t=rNqF*$2V-VJ!t^hC476;D9kTjC|j);(R31( zOTPx)j>}!6hmGhPo zmG>WrWFG3y)Kv4C+vauJz4YhT*aJ(S>MB;nrYC8QCG~IBRa*3jj%vB8P3Bh&Zci*2 zb!$2*Htv_|??YO@VVi>CLnHPkTd^ZiMOwa=}bc?z(m zT0f;%H-CK0e4HUDg6in#wWsrg+ZgZv)wgiHf3u&=o38);19rGjY^Ql~Ob}ld>brco zOgdiK5pz7)+&pR{u4C^P9~pmmIxs;|)nvby-cuqd4+j+qq!CTq@jw3@85#e2nLXKI zxK{}sP-uzdYM5K}7!piEhK7cWGh2TJI+n0rP0s$CnPTKT;x8LS+cnT>+%J`@HM$mHoXwG@u{~Y>^Bkcb7@XLW4UzJ1l*8ja?TWa1C0>+X& zSEeI6y;P~GshRS-^|i)Jmv|t8@+GD+%F4>d7p9Y|ZXg$D@>mo%^LbiT#lC>)z)1+p zo~qct7K%FZYdbxzKZ;$bRoIE!V18+-Hb&_A@3GSWt+eO2-%Rp7{jRD>Ps^ktfluVR zkoMhy>5v_{DU{6@g0Z}IV>|-$LMs#u z{lGzY@7%d_DQ}>Dg6}n4fX#G1PZ2{~ORej#B^%5 z@op#Jaxq;gm!F0UKb~ifMj9CznV>H*)qdqXHXiOeElEguD$g9tM=dPaUH0<)GEkNC z^e#Q?%n8{tC|9U6ql}AC>DCgpu-N#kw=>G-^ZahJmcwniv8nV;BVLe)`n6Y9R8&JN zPtwXe_KQZ0v20?YB3{qBW*C%2@l5wsSSKcqb#1 z-o5)OIVS@q&bi#*zPy}c9vSn>-{Q^=VY-Z+MO@!r{t<&>!#MIEFDX31NKdU%_v?66 z;$3!Q5vVO0Ty4T% zg*=F$pFe-%mlim`Y}Hvvm`Hgr3p(iOQw7XUcOtTF(AvDFPcthr@ajCushJjp5$j4m zK0bAg(3}#}5bTMtgt1(8LP$-Rvmk3%1U1Q+uG4L0EoD-(G=&{hEjDpK6m3NfjM;re zbg2w%T^*r6enrc_<)iEd%-&dPg+$t91AYC1{yS_5VW7B_393Nih9mU)i^kdp!2;Z! zG%=$)L{cELo%Y@9$g1wI zbXQYX#(TzvkbJ&s;d){`tV_v@80&dT)VTI-tGTj?>&R6Ow+Yd%#Dhe zFra{_WC6({Nkz#y3J9nq0RhR9%_u542N4wzBuLJ|NCpKY2PKNIKyrrfdbPV}W>3}L zr_PUa>f1F`P1V#)+p^Yr*Yn)>72{_^S2cE=rLUUD=wmoL+C4&blKQCWHA2q-1^Lxy zGkAjo1Z_nFLBPRWq8M(0Hy{{=*m->`0U407&o9r4^bEV$qQCr0V%X4k-aqPDzOT3x zW+5#RQ3!20rVQ|H>KMMe7mcU^YU7BM2s7$z7gMdzO85tnN{ z5*ilO91?V+{p_fVSC_}OsOs+7x%2Xwm!5R)E$&74+_1F8dEDM4#;GXsMUmfP;oK9K zQ76G`U!N9EH-&B;Avw*c9z#H!JbY!t!{))3nDr;JIf^|#z` z#F5!}O+DFLNqRP!L+(@5;8N}J>Ltbm)n{jY-vK7DV$7&W?zNlfldgyo$_X1_F9zsA ze7et7M;O!!uUkVqC{ErMB=xK=9w#B2F~zGnq+jSyj?GW*eF2f@uP8M*h!}wX1h3t& zSqiOHa=r~jI~hmTFpmo495p@~_d4x0*&5<;r(A6!)!Q_<&aag#xTCr;+tSSk*ODw` zZ&;m<(z2EM&zg&JW=I(%lGYaPOnngi^k^lI$Bqm#BQxR2y$X_wYsjwoEbC)yj&eUp zXGP~(HNu9S(^ofk_Ixv&CI?uTpX`b?AwOG$iprL9ybf*F@=iGt7?_)zdo;(K?0FDB zbB)(Te2w~`gBR>iLf`_Mj5t*TeoEifu(=pSh|sw!j6}!8&a@P z5+?e%AEra~R>VPPgicK3g_6dUIyu0`TyFI{8-NB&;a;eonfr33vUzsEe9!*y2!3n|<|ex6y0()I!54Tc21s7g)4gro1u?_?i9+6xo+=HfPV?8R;t0F>A7mwB%&L zuM;Hhxq`&u%FxZv?ue1UqqdkWKjKr~tk21%N>1pO8EO+y!X(}VrkEM{te4E(#`n^V}WkJ*JGCK@!yMYeFxyq4*S)R zJ%4=!gXaY}IBL^5`%Rj-#4x*xP}tiQ#Xy!LPe}bKg}~Ha9qM&?#HZH9!a7K)w&7A3-$-~WNH_lkw zy=j*vA+`5HJIe*6fEh?f-+VE*aJ{lx@>aFC0875x$9JdWbj^e(=DfOZIM$p#=ij`z z3IDYs4*3+VM*sS1`T3_4Cez!v#8fBgB}0W~#hpgd$_QPLvBgX1E6S@lOOA;x{k(nM zsXx1qi*SNMy%`8YM3@;f#Rbv%J_Cq<3=?xGwrvZ>or%SnQwAM=)om*D^zP-Cz|d|NK;*tK@CmxiB-sr&sUu-!sBzjfrZ+yO2_Cx|BZ?*<*oIA?>WdRYL-#dE z(3QmjL_nam5TWzQPzX`@5U;KT*e6)4gta(9wL1i>x)kD)Kw!K@dyk+gAWozb@zpGE zuvE|5>15ct#mI1|R!M8zB~xt*KHrxPQNl*7decB48SyG8X0R83OVx@x~l8-C;h>hkh@o>zXf>RJwSTu#1|^RU35& zXtY|3$(_R%hdJPATQCl&3`-SPhz#v=37@{Kk`g%%{}hpz)IttP*x5>H&&2kxG@Q8| z*!MP&ctsQzDqAd7oVS{!I7%RKA}ZYbcwQRB_c;k?ZSR$ol+6D{j~ZI6S1#Yd8|pmM zI#}H%uD#>M7k*r>fu;?i6Mu)Uz1n`3Uh-4rb2|6)2GJAp@p-a}A8Lq+9t4=ojC1nq z`fKL6s#PN`|EfK`5qaa#X2Hs2h54CJ;%;!My95+yF(s_8c~5a(2XP(9h-LWQPQX^JO*?yEAy&Te5(c$au6GCK}d9V zoz*g2P58rUAfv%%Ui*<-``y?3T3uLG1}t+A^U!YdH)F88_hLW$!rW={Xuh*OZ&O-w zKHSj@94?!YeIH);-m27ad~=FFi`zP~Lqcg2*KaICwRO#8)K%|&&4gqw_hl6 zAmyK>Vn;-fFDRq1A!35&zzpf1n|mTYMe%{cXa0+&JOi@;joaem8d%z}#TvMyKH`pC z*hF!Mbs5bJ%P?_4VD~yA>C@#(`{Vm(4`K`D>HU;uz%=RF?ctF~)SQ3gin182Zh6sI z7WjP*1VNRYpa23!ZRxbx1M3?dh(VjE&~g`>kkZFq1COTUxpT`8qWsNCEK;E0$kesTJx)(16zj{vSx!<^v+b$1s5nq}iF3KwlsBRs1%+ zqM{;Xs!7Y^krsm^zusT$!^%iOXT~p7u$5N${Afu@$lToA(bgG^cE%R5H*UDX*nfR| zwvGu(d_S1gD)E35rA0j?5<57Qu!~7n-ICQL-lvUZ<`_!j7AmW%s*)0>;dm||PW9R2 z*nrN+$pxe`X^AfV6t4*3j2`L8lMUurmVnWuo=f1RTYec9LYH*%YVm;@h-g52l*l}8IPy82QkEQVfk@x3wuiZ?@#5?_DD>ZL<*C-(-C~{dne)Db( zMqGL3H2dK_JR8D6BcvY`a*)H&W<&`uFm|D0s$s)Kz}u6(Lw)s6n<%?;JrdA4GKu>ZVx)wzkT+S=@D zeZ6GaO!3a$Y8^`{H+5C&+9h7q5ZMp-Tr+bTKBc%XZ#2$7NfEAw1TSUM><{i0dxd)P6>j&pb*HOwqyZ@oPTmOu>IAI~ZFl1r0&))U$E#E=Az>16#vzh@1I7WxM&OAQOY(QCuVX=?W+V{xGVR&&*p8gGM22a zxTvxiKELG2)7;IfQyR20d2>U;^wn?vl>tmXP8>s~#B&$xGc*k#D7=~1{d}xJd#vnU z)g43$Y};+-f{=J4Mc&R*49Uti0wOT3d=DG_hkV1K8lVftR~)>JcI13CGcZ`TYIIkJ9JQhe9_ahrRkzHU-Ve_i7(S7QR34@gAt2S3;Q75#%5S zW53lXQ%h8nCOmMxABzm)&cV82Xza+N!xCOsb*vOSD_NQD-IXY&rHDLr(JpUQRp$ZD z!(1_YRg0obR^D=u&=4Z{n9XNX3rY%aB)!+IeVFTPChA@B)%%ZU>A7s0XLec?pfqAP zYu|Mn{)B1IrRC-7aAAs9($vI1+lP4l^~xMg|F)YK&!_nVBeq#? zS!rzNyJBuC2C#KBNtpJc2M+9xu!6|Fpyr50KnjaNPt@0k`6;D%u-6a|HuchbM^YPK z2Cc6GTL?A9Q9Eh@3T|FGnYn=D7YGSR*fxb`ruxk^QQREt%}ixwOg{6P@rJUg(7soB z(+H8MWLY^l6hJ+Or#P6>9AM+S@=3{Iw8K=dea?Ml-b9t_#U<4xcdOR)508r2ubFk^ z`jOkf6n=GW1rQ=HA*frQf@1XO$&kN|gDFPtht|xOEWI1+7Y1a~DkLzucYHXc&*|~RVQ<=67SGl3ESXW~}NxO9Gj;CjYimtAJ zDHM6gCVfZK)&-RX4@2}lwS|Iu(?xVtFyZVB*+}stVrVhx!k~0Kk1N#72%FqQH)7CK zTtEJ05tT2?jIgPHSpQ1<+lJG8lYpY>t46aS*J_tzZpNu8s(-h4-1T5pVw*?k>j z1R&>9k>8Irnd3n1;JFJA47hXG#SK*TjON8>Y28S<{6U8C#V0GEB7d8GjZ{AFltkw|wc{yUw%vi%vHg?Vw%?U-%7}-gYG!c)K zaJ*>cPaQz`3UQKf8@sMuw~o*`7}KQ8VcceOcXwwrG_UU~$$D+)EJ~4LX{3#;onZ!m z*IAkYD4CbTBf~%t#cQJK`CdV_%uY`qV_Hli@+bKnw3ICqCSLt|wshvLdG5VTJe1jmw_Zt=e*dsD&*;xFcyD#M z(n*?VjWat?iuHA+Y~4s5H1a~WgTF5X?g&Y{smHn1qwDJ>_kK8l&Aw=}%qyv#8Z*ok z8+os#B{Kx>E-F%Z5VyutBlhUI+o7*tU)x3dVsN4Hid4)n?GUdG_4-zh;jug$L3bW{ zZtnUd#}_vvIQsUmWH!)s^;abDq@V-S@p)X~-Ikns4iMhru zk80vqI6JJwLVE5ktCE^ggE*s_$%k|jE6@rUN3rPMmS%fV--|PMn<{nN_sOQg)G6!f z<+wVgmB5=A|Gv2l{rGa6e5;(3S@vA*6G79~3;9|>Uu?IUs6X1$`*!he$q`Wlm5-u) zwrSCou7w-_L<@4aEvk2cffyHjXTq`gB(u_c@e=E^bn;|>X^zN0HgC51F>`lwY~epHTyGsmcw4>`+8f8HE>rx_cMg7d6s44YLR-a(_hN z!uLlnEF*wo}Kc4wo z0Mq>iVqN1`t(&|NR(ry$q_!kmzqu?<9WMr5PX9m0O!eiW1j4nkfT771C zS~)C2)SvuKeUIKdv^khnukgC}!EccZg@1t@_v;$I?fmQaAp3gwKN!JZZ^r*M7{UJw zxF_hgMMtjkty?lEqxU>o5Ptm9EkfUwUhwETJ1SXN5n%2Op-`!C6ZVbaDU0XNp97$; z7|2F6Yycs76lEd^4yT2ocqB)gsl=Q)mp4|dH-TLucP{L&caYml^Pb4g4h1{AM??=A zhJ>R9UXLF6|NLq0->J2%{bPCN`)6_InGt$$c0uvcqnrYkXNBArG4h{-XVCl?fsGhu ztiqe>lXV=4z9?R^#_~);7!G<^gUG?bVhfMvLzyF$=B&K=O2OfV6hdr;0Mu|H1K4+ouckaZ%ruta$mE}SYV3mUr1ZtnKr;Pe&Dzk zZVp2;I*cJBZUT$4kQGc-3=QgDxZA5N`97qz5#liU57ID2Ay9cwIx0%j zJq8{+W= zg<=h6h)zY*zDx^P&+weFn>r`Ge924@+)=a3urh~-R)db2GIZf4Us z7ShskeyAnw_PZI3dzBzYAg8IAR$@->HSZsY#BMx8qkXtDQ9x zhY-*Y;%+Gj$>sle`sLWk53NW!rin{EsyNts%zo^J8n<(tANiQG0D|BcAtWk3}Q z^Zb%r+;qJ?q1j=$Pn(XChE+wJ`6A@`VeLL>#|b$#-6q zKQFU_-L(JS3;L{P5}Yz0W8pqzUO zT}Dlh5Rpd+ytrTDA*wpwkf3Tpj5m3`-a?Vig*jc$I>k#9vhzRR2?AYICpuveGFMG@_uMeyqG{^{ z$6|judzC*$Opm9spH7JEli(umr=DbF=S#*ED1JS#Nwy=wkx6#NjP%};s*>A-C~6RO zvGmz}>a%c0tv8V+hf|B~L;Lh-rw*D94io8nkamY!U`RDi3;{N9iK7m{C}K!hk*&)^ z@A;#Bb_ZILpB9dPjHpNZ?fB21QdvIWzoD!&DM=b$y;2gw&i2bLJ~iB27vqK{u`jKR zmak;^(9d~ z#jm0E*I|`VrTzJEBtnt)AiDa2h?Fw4BQW7q?Y3%8))8p19Pi;IwG;A8))?Mn%G%3z zi=>=(apnkYe4%8+K>Z@!gY4RhYNHCI;NPpBa$R^HBuQ<@(3sL$Q6&IDPvGAC;~)`79K=atvxqGv%#zH|2gq20*g3lp$4L z_NEXVYb0G3=Q!VZ1UsZvcg+fhm{LBQHmALs->&o86W>=*n|^Wf5l7qfUi$VnULmJq z_SJ`1=Li9X?$z6OmGySPID2vL#D|86DyWb%xq! zm7OMQ1Q7T;i<-AnstjL{QTf0t-|uCSMWW~d4-XG=3JUpY!Mz+y`rCUe(;8T5qk@me z0N@M1crMjPe>^A>Qjc(!Atc@zuick??+4rqPD|ruHJLYt+zx6^*HQ5v+`2_}$zn4F zP0+?D0@#`$<;WVnzwd`cbSl+*ztNbvmyBy>h>tb_}&#wNB) zv`awD#R7!BU+AZY30<{39+lDHlMG|s9L-wvp;$4DGRWyOjGg2ow-ydRdF$m>saF^M z!#|Ep^f$)yyL`RbHSzVfn;{&%jCO>#v(@-{%uS7P*O}IM=`K;Lu0n-r<>u4%tcgg2 zX)2Z%yOOz+ktIR>-4!XnuEEGBX${vH5*+q&b_t(8Si;RlDC)Tz$n;9wb&-Y~k>E{@ zmXR=xF&KvAejhDQW9kv{U%j9M@NJ|W9U&8|&6?R(MAQ+0xwbpDGVgLhFG?f)0%a5Q z?-sVse)%V8fhPWTl1@(Xyt1;gpUr&zhToFc^&+FSe`@M~kf={+_^l=L4VvvV{Xje& zhlURpv>NvRegn=odF}ZY2p>wg(vic5-^N@-yj`2SH$F6p8KT1EtT=nCqo+-J|ek8 zuq%Zxwt$R47KkFEAHq@wg`tt%7oQ{%QgU*GM&mg%dlHo=cNOK+}|4{ExxW}RGr z=tgsp=Gh}{S+Yd3W;~r@JQLy;vW8L>!g7$GPDm5T{Vn^gFMKJd{t-v>)T~uR($m(>dIh+)`YL`IFSRt zn@vLw$GN<)h;0RKf~X%Pd)8v4r-XOolPWQtS3|&+5pH8fweJWfA*Z#=7o||(U2hY- zQ5yzxt_Cu*pA9dS#lvuGA*iKhLtS2BLi&C_vlm0{Fv;tRIv_L44;Mn%^ds0LEzb~X zz!i|m9md0Fw=lji>!FR)j8Rc!Ix}H~1(9Z3_kHRXUP%`AezmZ-yJ)tH&1GiEQlD}J zeW89tX4Cp})H1AYkuY*d8yW__voNU+<$y|G8)u;T6BB@(@;|RbKiATJWkaK`VLR~P&8~T|}M@RFKxQdE%WT2j`=CtBiceaD7D|t85Lf7Z!x*6)YL6Kb^ zBT@D<)fHE{Jd@ar;`8ivA6Q?yaJ}TG<9idi%3lfu)&D_(;2I`hgxuG3ms!hQJ1^wz zJPaus?=XW1%wIG7)Xqn9QUWX;84L5iY_DvhJV2q+vuR(p=ts(!t3DBGe+0c&bk;Ye zh>6@^FlV=9$=9dMa#txqL_sDs_SHiC@Og$Tj`MHFzgSe3S(2fW`zw+eOet`O7zxq?6k|2EhVo z+~h4&8^|&yovK%K^toU=r{?3R0`I^66xsf}hgc(I%@X-vA^EIx{fP=FEqx5{WzGz1 zl-25%{e>Fbcywm_h7j4|aJkkj{n3-aaex0920r2p`RgAdJLP@qKU##p-kSd@^$_|}!=nrb8AxlrkGWOu%!vI)(q!nW71mJ!XHld{SsU9Vs zkgqDvk6tm|p32>eQO%6{l#|Qi@lWMVFYm9leA8~_69k>^z>N`4mFh&- z1&-img>EpyDiV*K<>7xZv_xwuj~3wCXAbD*$(h3N4+R4TU|(FfQ#V zgOR5kzC_cuND&tebYC$+Ocunh!;b{*H3ZR0D7G=EXhWp?fh~yq?UBodLn*J)FDr&d z7ErUpr6}#$wo(tOU~b{3?nce~1@7`t6bHPdF+a-RS9l$q4+M+%6$89`{K}dce1PCy zE~ypW2L_wd`%7e5USJZOs1Md|QdF!{3z)k@vhzAwG@|hA`SY5Rwz9ss+6;M~!TumF zkIkk|!X^vR%2VS4SLa&)!XLiAxee9-7Wihv2<Dkm?-Vt^|NgFSn$<({BIafv zQpkP2=m${t^-x{7%e9fLgL`Ipa+X7y=NY$ya>HZwLJ#&0EnZ}Jx_%gms7UOK<|HCTO?9aWjTwE z;zJ3*7%5fcJZ*$b)15nZd~2LeAm)dmfE6^Vov#dLXM#aadiOKeMUvxyAe3(B(Pzd% z1iD~TtemW)3AZpMETXBmxbL=-`WQrLf5^P)Vx?w_(zx&Jw zM;2j;jqdJknc@rY&s~t+eMayCor4yj8$O`Gxl|*~t($NN&wfY?pF9!bZx4slSp;db zVxtX)7BM2r4f`#tZoVBNL>*+H8X%FfEtl0nNV9>E4urTR+=4)5L}oMbJ@6`rV}cO4 zRDsbpEWNQNZs+$0Otb3~6K~^PWSxZ0%42S#$sV3d zL`qE9>_d$&502_>KgrLpKy;@y`P5(Az29J{_LHIb%ehN|3hmAD6&}%B5Im))@ZglHg9m6Ug( zNE^)`=5Tqflznx-6Vhf$vjJ_>rs}!ZE)kJHhTqUrp)}8(Pueac(!8_{fA0~+pl4{ z?z^>|55{b0HT0j6AU>HHR>uU2?xx2!J@3hpMitl^_boPgvs^q${Npc+y93+I3EK7j z6H|eBYPDK2l3v+`ac>K;{|AbY%OL3X=TY?QJ=#gULy+wshDS5!UHDldGMC5_$+qxr zcxzhfcTJZ$>WqBzn)7t$DDrJlsv6&cEMGPN^Rgd7G zJ(}C`QEk1cy_)ty^p4&u{mxqBBGYPObfG4{%ugDKSiWt76Dcq(@4@S`ujX-G-EoOc_6w5z>chfyw+IkouY89+Zw zgy{k`54OfGX3g;f#(WL7gl{G6M_g&?T4R?ivoA0+zNZ_dj{FdRvjONKDFl<7$%3!% z#ey2mHU$!=s; z)-Kwcyrx8E(CD#vx>vDw#rJx1M{eV?xsZE}tKvq&_3=ZV7TP-km9Tn;IapTsr>Y#( ziV7xS!w5nSZY8!IdSs>t5iTJdO|Xwi#5%i~!5iL|G}xFkc4WpPzt%S;D{yy|11IrS zk+p&INlriZmbb|g%iL7@=FO~6;#PD-yi=57Wz?Zd++Z`_bIy}&G__=fzgG_xe~bK4 zYgOW19x2A(ZsdF6zj^JYD7es!#uCca+OtwgCrFoZxYqax{V5>+ts6LWuu|$T6M$9o zQ;U03o5+0Kj0TsToqxaFI|h7%b$GpSdAw5wV8}~ z9@CTS!e3r*Px&n@SP?j9qOy6R-#^8ESL*79!8zU`X4(}2wzUDh-{_b{9}69SL3Tsu zt$UQ)ap-~c555xgv1QTPdwREj(nTbPydi{{g06G-h3ESM2oXz$gQD3Jw;3&-yV{t0 zst7=gmsbs%{W3W|M>Ku5x7&|(i30>5>SR5Dl&NLKsqr(ABgia?0v+FQI zK2OA@go&+s>^yidGDXuBP>pe7ZahNig`=VIj2P6$Rb8*tqGtQ489K9<;zs zwAW9e%QEEGr#^1_M;v_s`__!0s*jXqnW-mrzri|b*d0e@Lxj?S|KO&Ny(jx?pSlFp zvHshN{Z0mP6hWA4@X(`O*p61cllwD;SghHXQ=er1|V8w<_f z#vM(arQBVzCV;^7EjRr69e1-%8W66HHPn@>@jMGy>JX@gAOM`9316YYV%7&uJ(&gyGmRxp09JaR`J?opcyEnrE}zY^A73smdPsy6s~_L&Mda&xtfNw;^6Q zhcSrp^y$-#XImkxf%!zJX6zZ@jiCKJ#^EbNy;CUpLGSBh-dWt6k5Vz_P9Uu(tUIet zQLM9jX*W=1$o&;Fbjy@eA9hQ|HmrlK{xl&YAwut9Q`Z8b%Zy66oSe_?A~P)pzuIcS z0M*#J64p5ABJTSr4#-Cb2dK08Nd^}wNkHotL{;J$c8<$l^m0_TB(cw1MrmH7BHveZ z{&3E*KS$YH|Kz~G@#?j{2_538JNA~D)%ISHY3kcS<9382Luk!x%$5!cI#D^yUQb$e zD}tda)L57yv7zNc67lF!t(_GbAo|0G%vW*`IBIRF==|Fi@JM<;VODqF{B^99=BHNQ zKaA=vvoF*gkaiOPo4_W2|6x2zo{a3G2r=*<=c7B=y}d#%Z&1OGJtk1}X+XGHo$f+V zhuRHdCF{6N+n~RNa+eid^wmiUHEbuvmL2!~UzSUaPfrd;(xhfBpCx?f8#A|IhcL^nbBEAu!_p{rkR%(lK@rNPm(i(OZ`t+eBG7vDZ4RFF2 zc{Ck5|D9kza&g%+cewee%`o?awls;$;*mOTD-hdH_O6u2PH;ofrA;@5ou zi42>#)|cHWXI`%yCKXRxh3bt&Qcq7$ABIa@TwQAI5)u+#K0bh4atkHp zUhpkQ^a^=re{w@Rf=&DjIq0LzYWb%lJUu<(HL6>R@Fj^(J3~M{IR}CBaBvwLU&_JT zfqD^l>XgeQ*xZ+vmg)g3KT3U7CLcWs1wr)~s6oXB3lxMf5sLrnsKpqyr1PJzx*)QP zsE#6->-KewChc#ENMcmKD9QqH_tO~a8IpU&tuCjwd(-0OnmE`xyt28EjpUWs^ z=91`l?sfQ3%+5IV?1EUf{^2H9MhM{^YF-PHBOM_-GEPWT8GWp0aT*L3}7W!4UbDgkZ#FeaWR)@sDc zDL-p3#$K49ofS^*AL(XswQd~Ase!~WzSM<<*lw1Sy?40Mx&YHeGXH9}C28N$EQ@vt zhp{epZ1%FMLb<5~A%EuO9LL?V^3poR2nRuFLe;;?^PdU%q>n3YZr2{+?cyHZcgx_6 zAusDQ?iNHFzc8s=e4!feoo@C;MwMj}lp$oO>$Z_#j${Un9ROWM_^BAXp^I82?nS~2 z-woo{O1wLOwq_^jCHXPO90QRNgu%TE(`>c&Dc}g)>U^Lte2CmT;_`+`f|;Oh3X!5T zfk1^y6k4u&%qgE8Et=Kab&&#BeivnOHBrcpOIp>{O_g(~u?#_bxyv?C3>VIJ?ao_W z=^AhfWY_r^v)q!_+jn!5a}}s!A~UeQ$b}N`UgB1olSk!ygQ!hDJ_YMwGZ^Jq30UKW zeu?`wb;XB!If;OuP%mZ^{R0sQ>6Jplj1ef13XMR)hF_2J#~P}YrAc2Xa!+mET|V}@ z2#T12ZX$LScuth%rr9hzlPl@;YD>pu;z`2|eI?EFzm@x|MXAYq_U<(oZO>fW@b2Ao zcNw!5>v`?$!YX$`o2qm}%55aK%>{_#`9;rP=%OPdOYd1Z$)jbTRLX_h@7e~YhxEAaDncQ$63%`;#E?A2H9bh^VAUnqG*hH@*F#7r4zk0*9aV@A;MiXlD%@}WnM?3y6mpYZZoYO4GX4s)iAjC z&$LHT9=CHYS(rY6(Ekr|9`@9NZja`Ig!vu2THk(4SD?HO0~fE4rdcG-ZB#*pRi;89 z($;?EZlJdnzM}P0Z7rEsTkDPfdimFEDPHBCZO^KgYds@`1JLcC_h|;9im3MS`R})4 zYVT9zT~ziVBb%dK9Ik%%Umgr_@yDZNQqSCt2;v{#uyK!FZqm(fchm9kP9TPwcCci=!cG&Rr2JwPJG&kmMV)hgk5jGmcseg=;|{3xzIjjSWK?I*2mMM& zijM+ME(X1ifDg}+h9829Z7tu!6;pmhXY>vyTHD@*E!gu=%}0%IFPh_HX*x9jdC8`= zva*U_QAn?BbQSFq-4-G;xtD9py||A&CB1|6Q13f=M1>`t)cAGB<=$ee<#{n1x?PI1 zOM3q?=9jsVV$mlaE1X~t+PIzixZ7k+GfP)=3hBl0npmLSx1<$Z>|q?BT!DusgECrXmW&1*R_t@f62`|gOk1w9S?8i#`l%jjNzE(u1f~PXll0UUx@YJe){71 z3g&-d*6&DY{Dku^g|0o?xnQFO`xx@uwT$pWxqqC$X#hu|uU6UiArZ#)^$+t>xX&Zu zp(b2>oK1{Z>U_zHq$k{DSwXmO)bY>-ji?zV%15{m$uBm2<)01dGN5rvw`g}jRK%@! zZs@bPixj?{m6=I9_|xL3tKw0YRoFzHs6SB}fbYkzzSjU59s zbNL-*?47)8q?dj$;i!Z{Y-BFqtfO9LF^Nj9IaNQ$s$jNj##p-uE1yuNE&}UdVtY@U zF4(?p^c5m*$fx85ue1NkrK{1}#3d?!60G{o-R;-sHhC%bZrk6)M0Tq7!+*VsZoS+} z`03&*zr!IHfX=l_0M>m&@r$xhH6CoEICw${7Yv(-^Hd-JpDLt<$S)G58&J8CNKc#w z_NzuUWSA%tMd9RG3ZB7maAa|2SyLr}>Nw6Mf4J8x zL%9s9cM~B&FxOL8H71O;x0_}W&D(}hr4mTkuFXWx!o96dZ`SX~W{oG@*l`^$eSV${ z+}tvRQL-x7jgt^}H%cb|!HRm2-4Fxe&xhc>OVt<4kf`sg7^^&BRmkGl@mX%5c3BDV zE+cXA7e(bbT4p@)zb86A)VMcaB)K;zJk$I1Sl4V7j-Sg-k7Q2p#bl()+texd*OH7< zGLnV*ul{~>BYH!pf&nOWE~U6N^JPvUl>QXXy`0vRFWSz!OT{n8d%L;ZuEUH-}D?(U#9Vtk7Nj z0mSFNel7Y1l-@faVKk-@zb1G8(XU0^&GrF(`$?FEiF*d$BPODe)7Wv-waQi=CZ4M` z(MgA&H=n6w-M9DS-Cs#@A74CjGaI-p7BqjIf}1Y&^gu7)HJX`Mh4FLkJ+}AiF3gCS z2GPvEQ#<>H10ou^rM@ubdzW_HP{fBv5b!$3&>^>b?G?0<;pzut`hB}DYEm-DZ$MX#xYoy-KWloddo z`|-ugvYH$p_XBR1*MEr6qNV5+v0~uaqga<|)CxdzC+y(ZbY;?XF{)oEc5Tg^oSrWF zK)cS{W^iT?!i(^VN#byqzU)ZIHcJOXdo_-3qAg( zIGHer;9jh}RK6v1V4YbN_cG};4`AHyNrP0?6afv^C?)$|Sq*Qu|T(TK8 z%iLWv$UtMZD2rrQNUrk7&b`+yVZ_2fSZyd?L8@!%+LPXV0n|t;pH-Tvg2u z;?Qlow21sX8MU@2`0rS zcA=HE*){N>qbB5vmCHbN%^>x@eay8B5Gi2iG@D0@g!~_|urRP}*>fxq?Pu}(&brNg zJNV$yqd>5wnnd7dHVVEA!MI8hM=n@Wo_4$Hy=Yx>#~N4A;3nSm`fr&(`^RF^zsvkB z=dJ&TC_7^zDr_Ex9qs~bw3<-*kKFF{966HVecIZ5E^#0C9gR6Vfc%7-AAou=D35Zy zT=^4*8Aermpa>r@PR#$sx|=LQBY1FB^7iJabou7}URKCHtxx=-J5z-+>Wghdy)#1% zWlMT-a$2eu&*^>JUSGORD5(c#0VTJ`e{7fzZzNC!Ja+*qvA1gMoSYZ2Sf89~ojF0& zI%0;4Fdf`TNgMg&deViwdfG0cyHI!(Nn8OIW7RE0f)H3%(~>2S|KY_Va~J6r`6=Ro z()UdTI`f-1uUuTQ_>vg=ZU)1!EPN=O;KyZVvYm_Wxs1O%4wQkN@bS+yuWM~4(gK(s z{zK^B>GdlI@9aP4;GIhEa~F8-&4zn&=FPbH%$vOEq=#P2=M}^WO(ud0vW&*M#9k09 zIZ%->VJCmBh>G_1_B)~{-E{C*8`gw>iMwn9_wNMWw+f4#PDVIB^z#ADv{(~1jSegJxYpi%|DK(ghGVuq;LE1xfOn>8{!^*ksGuo$jxxx%N6i5mfm0_6w_CY{zn z&o#XJ4Qd{yv5k;g8nf2JvGOF&8tRvl>V4mrKWIW+usYV;9mjf%MVlp#N}2rJ*|RcN zuO>k~c^(4wfVh=I=34nYysZJ}#ucfDrcSzrFKK4YAt|rF??G=xSKMz6e+k)10wz$r z_d$$hPo8~VpJ^+bJp71cCuGLl1+tc1%oZ1?em#s{-Q^*oB!I^Q$#q)BRVnq&eLkoB`8SW zl#nVLYdfegQ6nHLzddLt#VcN6)B#XJB@!V-jL+rpy&7Tr=Qb?gvaMm(G{`T5UQJt2 zh+lihG;pHoDbM_E4fsa(BZeUaVGHFTxnk{y3yj{~du*IojLeL<1WL`+d*SU2ePd%* zD-;wI(lgl<)Quq^J*$YAC4fuD5#A(d>}tjcr{|9?=}-DyB40V{q?L`|;6zSdq?iXs z>r8A_pmlE2%)FLzjH|vi;dhl-;^~$w767kb1!6H6-4fl8SiVvPk51Ev|DCu_t9AX z?yRi+VOKYe;|UmK@LHX<#9tDHh4_^bA5CNYLztpG^W=|#$+kndx1=+h)XjuNL~3$& z?yOH(QCm{th#}}awKs6K8xS~fRf=v&MS$WAkGUy})mR7d5@~f$btE{%c#~{gT;f~w zUhV2__`nji6_4lYQzaw*Q0843!bH{5>0d|8z- zDeew}M$UiIdFaV}H}B;*hI(b`%;oB^ zj5un^cUyzRR%<5C>kcxz-~EDhK(}p>$fhA!O)T!ViEb$unyB`k6ym4;N#qTnV(w^K znl0$na>uO zc9sPI$W_eMJ9kfF*f_}>( z4q_p0HDVIPLBr>vt>Kcz}NC*T*jtVm3U>oZL;(*S@`x!r!{L%MY50k9WL? zDw5NkSZ^(@;)BeHK@-<^U=u^jOVSJ$|zem z4Z5du#0}i;CxUhe11FJ9N$3yB*)a36?qZZXPVZaqMXf7&1<)jsz=P4rA9Q#nrC1Wz z>PKKdgM?kMKg?vK3^LY@;Mqqcy$_>Q`uKE>Ia)thpWLBR%I}nD=Et83MmmO;gRVlpAWeOb8X{nL6Z2!riCtXe5-JGBEH7;HHFcQ+h z%}+Es5V_* zY&*Zx#8LP?XXWT17CMZ$cOqnptNDWf*g9eYnAaUMS(q9cVDea53y0V}yIGpB)c@-I zCrh;DG;b|%H)vI7dibx-e}g?z%~>pV+J}}U9F_tuX@3dn$VbpoY1U$A()A0tanmWi z>C%0wPj38>JbvH1c!%S|*)?Qgqa$Gfg6ubfD3$C;#zk}d?vFl&(TxK0(S;?M@{KgaFrl@UHwtQTlY8_c$?)D#*{SW`K zmEenCx|V2oYiVgQOyxu%$K1T2LdB*-1|7LOjEc1gejGog&g+$LY#1$BbqClhJF`G| zT%qPTKJ)wkMhx@gLz`chBI;s4rq^FTr@YIk|9?oh(>N1R0SH%G`s``7|77a@`C0sb zA1U~CBe8&smALvxT{m*rbR!b@(iw#(!Yo9WiJK14qgXHmJ>CS*2km1p1_@&N4jyP9 zwp9mZDVNqsNYilm`GXUX!nR!B`PV94&WbRg_jO{??>~Hyb~wHL?m-fOzzJ;5kemm7 zK!(gaIuBHh!1r?vHk+3n4mz|MBsAEg#&JK9$o4+!LcX2!6ZiZQc*H(T&7wV)@CZ45 zyZc6=a|L640E}y4UuzKYM8w~X6$@!0a46hxQB$9Wo+#r2yR7Vh>XjaozkC;?G*U); zAsG2gG;hv!qf7+_Q7q~L&n1c&A&kx~gy3w(VtGLXe&YG~+z0>)av+MB5t-$=e&Zfr zqR7{II$z&wFDD}b@Q!EeyJek4inCxCB2-P0ZPz+8+wB4MSIN=+XP0rEKpw6yh4Yl% zMfA18f6M9%9l6@^-^K8Sb&7zOoj!kK`6zD7$`gBUP2I0LJ?NEgxILD^RQs{@vh$rl z4w_?6o=C5n44_se&H^ArK%pors|+9oW7bP>q3zPOir|o6=k@*jm4>Fex;nMnE#Ifx z6xf9Eik=J%K2!A>+HF|bj3B}wR+cUVpj!|Mwk3Ga_b+B+W~j_E|E2=JHIm@>a)eqZ zC_lf~Fq=Fx+Q|lgB$t>r{foMIV2|6V&cGcl(2y3yto&BEStlX!^WtYOy5#%PUfvnS z{L)#U+ff4~15tnf>t#e9VZ^5*_}RRJ)YN99@%YOJ1fx$_zb)L`Q&I~6DeiIoS4lSe zz%I$9GWnrACf9?c2yZ8|h95)AL&J%)$v)E<=^m!0rtY5&JSxDyu!3^E5+`@y4UR1u zPfxAkdHm#YF{hnOQDfZ4hgKkjiPkbglD+Fpg3D;0Bw~!%0C_8L-LEg%ksL|QZFnEK z*e4~V9|w4M6XK6LQ6VX;svPjTI^;)}yDlo8E9Z%h3a)CtJkri_=R56}H#b+$a@nh9( z${8+IKky;?w9elz@f3vuZVwmKO7ZD_E~#j{-07IZzeZWRaCzoDQKVO`h+1mI+WJo{ zP2MKO+z%JDy_d%!DiY&C1P3B)Va5Vq^?Sn8jjE>kR`$)hjs!N(ip@70?*H-*&y7N6 z(Ag451|AZ2RY9x+=Lm_OT)E#K=oI*SRUxY&5-b?6eJ*>rnxCv&pn-?L;)y20mWZY} z825QS7l~FfU=)Wx_rg`KbJB72a>)`@pJ5J2z(1a9jScICWv4SL33c*p7~W^1>pC6) zN5j&}#{*VvWisnnO`;1()|oO=`n%jph87w5h`91>1QTctuK_w_?OxV@+BJv}oaU=O`V^Bb z20m4Y&gd(nYnH`gFQ5BdHHm0;LvWYBVZX8pk?ZVP<*ZU78?;vS(+K6KeiFo~Uz^#`-JVk-AU|s{iPksSXi>^aRB0Scv_eLp;o28QRmB2S zLfIE3*^+j4N!nyiNLoFoN0_lE3Mxt;H6vt`lp3L7B=WQL_QWS~$_muP%D?6Y3Az8o zHQ%|#!2n4*65G&ttfVc!cYMLz+pVs244tM7lc!B_#)G7^RWUkr-y5^Stl-?Ej8qAN%9p^F=uha%S%Px~_Ar z^;`3nIHRT+-q@%DAL?VA;Uw~gXyS&7Y^~*(Etg@(H8uB~nn$C+l`<=5OrOi}8_xGQ z=Bd-H%kw!lZ%P%8@=9E_@Mx27SAxOm&bA#I^*}EEYJ5EVR=IxobUE9^MSRbUw)^r6 zql?jb#vBPKaHqM75)XQpJ-2&S_m>0B#8hbpXulIjI`4igGnc<#7rss}@I1CEfGMqC zft49}m1Y^?91tEqB-;92R5Ke7vy!O-MRho+V!g6Hzy!^cgDXtoa*osc3g{pKW+khF zaUYDM*R6TKl0lMJ;&K%nDq%)l1u5f!H!3W^r(}2s-9gE4ydJ(pVD4%29C|jnmm-SX z_k^$mxx-S4f|me(wkQQ1YET_vCKZ+5HD(8oPVD%yi+Ax!7?X9$KZuXUElZEG5?v39_zVJkZCo40Qg)mO3+8Vr7-Mlwhkc9 z`O*sqKzcAH=+(de1faZ$yfs8VL4(T%3wFl)NL_CDcv`#CY}4s-oJN0m*x@UvfM7`d z(GmhT$s|8{Btq-Q7%=_!e6IZaG^<9%(^VcO;Z-NHbdKOoiVSS5P&)Ub}Rq_cAlyGNN zmoPvb(L$Hu`2kv4-%Msv?0voUE?n9DOnr4(g|{Wm>81LTc@_M2mNSABeu6eAa?J zs&mMJT={U}Mz$rPyXSH|V2D$k{j8i6DRoh@%5%tTS$v7VvxGLy7)ly>^Z_0*c6g(8-J5C=Qb6FeJ&w<^*Qqw6Y=fB?4Gf8V8}2bIE%BjqA3IoO?!XgnS~81}V@YFpIu<_c z^BcJX8#~L-qX4K&%x(VSy<)JSRE6(sl`z$Pb-0ig+9H-ehA0Z&;|sJ6xOgryEdob) zcR}%hZ=DefXPeWxoEnwlD5c5z?rHrKgy)tb_F(>`BO>EvK!*Rtj0eABl>~B~v>ht7 zBJjEJ zPIrd7BTgaM4nwzvjhfEnnC<$r2n~I+XX*~`Z!sIRT`LNeTY))uu#(f%XMs70BzBz^ z#PMpGgHx0rW6RUuM)iM~=fp?jXAS+w_wq|_cl&_5-e}B`hSWQ~ zO?NTde!Jfvo@DjPPl)ihf0&PCoIn_y#S~uiL0n=QC?r2XmbZ!E_LSJZl z3}heBQM`w9`$X~&=dsN#Bge3Lm3K~GyI;0oPYwBhm21}#dtZ0e8?LL z9rlpqAj-VKh6}CBq;-4!#H;mN3qX0*#BO=nLj%8ljiII>{C@&o?E?=3cR}5*W%&JM<#~`D`GTd_3x@TG{FVw4Xkjhs7AHJ zZjk{7a$GG_0n|n5fJAG=0#4t^ng0ND&0ad@cLDvOwbt!J5FD^N!N&ZjsY(xKAI?v{ zYJ%SuZ-|}#w95c%Bkz{lROMT()r4(n)*Lw5^liOS*(~{&yU2aAGr*@V+fsM=^OFkv z42HYk+L2{~+%z}9CSyJgkdsU2{2D0m6K$I*#Ukgd$CY7z;`*(QFgr;3y72SZoB$@> zl05r)252W%P&>$E%+q)Kg+p{7EVccWNe}G_|(wcgau)2bLkI;Xr<$7%^<-tgW6VxBzId#0l7Tt?#2(5`Xgq%ru}PZ-~K7Uq4yQxA_VIuZk+RDGF5br>Uxc5YdP^JzD^4!C8-<@y2AiaGF%&5u>*qqlEyRPj9 zK-o%b@bU3u03VhJZuPAhz+=gaf(8Pmyp6ERX#%{M&T+|$iKA)%CSt?*UbARA*IpF0 zV*vAi>P?g&$NhKg=sI_QmvL3wETDxe-C(R?H-? z*q4VGWPh<8D3I9%_*3**Dx}X9eNOG0un_)AEG7(EyN47e_)YuqqFDiCW-~2=?O8$l zRQ5c!<%XhK#{iu%0*{3#>F-xCe}2%{&m!Vj z2cMjN3u))P(CW;Eg_A)X@wo^JeWz+%e~+k!-#w8QbW!kqUz}+~_ zz&R_QLvdEzsq24TNWXHtvHZVtWYrd1>Y4>t`83cA-F*RGhw6O_{J*!$nxxB*BPsO+ z)^(z=s8&qB+eL9=ERKZYL6DW!LUx@qBH;fXNAjADj~86o|9XhKkdWAp78c%zcUM9j zaOAXLLYBCG;Nx?4xO%Cg95k9F-r#7pawBGLw60Qn?SH;-m`Ggr-)SiB-oGBjO2IxS zc1}?4V2wYLS#36^&}L=u6@cvG*AF1+_PNp)spmk}@t;^zqy~T+W!?TfyRy&BHh}|Q zj&=N7E~|6`B-GVYtXAl`xHSHs*% z#%P29EYT^M7+-ikx_=B3cF>>ipf?9*Z8UMCK9`LZwu)|cRy0}_7&D@0&Hwh)b$Lx3 z@V;zGb}wJ^WGT9X*Aali@uiwrte`DAQ3t_TbM_ZBNrI;_W?}~R?u#B`+mV-W;<`$s zj5DsD>*^mb0nU}czdltDgfLKr^s(c~*sIt3*Eeg!h&m&B0cvle^Y^^}?#@wkpqS@@ zwh3u4xcdw-Y5#He^%j?$Kl$-JMi-8o-yU)jH*)+r>AIhB+k7VPrsVmq-Nr@-d5F5+ zVj@h;M3T9>{(AN69~`g#pLIo|!~CQOv@5s-yZ!~`ZRH&=*-f9b4H+O6b(}zzQZ;w) zVKD!B*PJ`217%|Wy#D`7ZK{#GKMua!z==na@0Z$bpI=+=21rC*xz#j~jK&9Nrg;Bw zf1$$mVn-C}man!~|8`PuGvnSRlXgtP-<+Y|b)|oP0`*BI?f>ED{pa)k4>hgZ?oP{ySCyL%*wnf0WI<$8hK$#S4S;`ff8$balaMfax@=)-58dD+`r6woj~%b23A%!h zx7Wx8HQkX5ZUs2=M1ehm%cqU5yIYS6oebDzmZ3w&bg!pm{5G@#npO&-g}ODPjrx#K zq{Ct^if8KO<5-^26#x+aW1(JE&wdNAQik)@NbAeJ6VCS`&R8v;V0fUo5B3?1Z%>JQ60k6A>}-UQK}2 zIFs`7+Lc+puM0g*xz{&Fu(uqgU!MLP=py_`rXOR+Pba1 z%?Kb2yD-pQ!?b35ge4E3oXtjaP`A!Pf%D$(Dq}_$h^p8Uf??E-HYzJ+W(bEHV4$E$F@UYMGLb}6GO}D`o2w) z*VmC8kbX|UUmi%pY>O+WM?^!TTU`t4;?rUscL9e#rC$3(Iulinc>;cY`TJs?DZWQi zn`W~*0rCgfF$C0~vbrxWCM+C`A!Fs@Sml-Sd?l!Sg$GhO=eK0(*w#N|@yV3#*(L1{ z7Y`2NQWcO?SltH_ckEC($p-v+hr?-2&FycP@3M&?Nxf@8VAy3N+HoZNq z-*`?cc6OIk&?%9}YJ{nxAz@?YH1tYT-pP$f59hn>V)|k&3Tw|@KvD2q*c%Y#Wn|s| zx(ypEI==h&RfR-c?m!}a?^yU`dT(g~BK+QTz?YA9?NE-LvT0yfJI=TZWe{OUyXt$y z>gb_l2g#{IzDl{uDGa7c8S$pL*SV}87wbg1c7(+QQTn{V z633LT-`Cj=-1pvpaDp}yS1okgVIzN>50NmU)+(^YwIBXreDu6TlU=M>pHU)+0A3`H zu9GcgtZ#Qhxp9r;g6Pqod+zHyjOCJ-bH0SUjjX2veJ2;v2pV%RxT$IYH62`tYjYcr zqI!Ya-;RVbUY0pOsS3oG|4QZ|2`G~cgW$&hisAliJgiuk;IyWhw)4R|NPSxGz0b5%kus81c z?)U@YbYQ;0HlfGzi8ZF)9*DTHpoppcd@^<{$sVa&C6??YqZ zMc}0wg@g#Gjy%eui6ZiE34DiUP2d2)aBbACb4DSZM|IO2@dSvD#^Jg=wds7$pD9Ef zBq_sDzP|x|V|4gegy?bN6~_a76|&hUPb6h}HC&VUJf^^`(zQ*ZKcb+`phUp|7V7w8 z0l{rtxJtdF)>pX&EVs%^H!i?@K8A*cRrw=FVr z_m81>pR9QRQ&hxKAMY~*QFku|zu*)`%%@9sl_q@_d)8l3$P5drl*fViDFf++t%qTN ztC{Kn%As}j>XjU^8+W;W_-VOEZj*bKzO~iUhpm|3+ae;2*!UpFOFC01>;qM)WpM^I z%g;Cvn=a#JBJQi%WRWxF%__pWI+;@dcG~vSGdQm>S08L|FKo5_fZ%d4tsw|o~4F*BV6GWjjfM2&rnLP9+0`1`_0>2y@U(bTZeq`P5uZHo|j~2bMjmtFlxE)b5Iv= zByTV(r*f8{{mu_`K^X?`RJvDr#`;u^GBMkq$9i5n#-8K(`i-M6<$Rklo7&uKVH(8w z5KVajH(-G3aBytqLO5#Itx-jDpk;-P_n2P9Tj|)HR9|i@_#=iQE;3T3u4D|ogho_p z^OK$&YUf^+L%Ndv@jhBKaCiPHv$OBia{C?6n^0s)KU_8}TIieV89|hMW2=rs-bJ`m z)mItQnxqHBzGqaa)yK{N0Rj3>PTg;sxrb{8DE_?Trc~_(m zKaxwsLnTklBMVoiyXSUqpD0rSu9Kihyb^wvT6{;I+M^Zq2ghL|)QprI=HglBW7*$4 z#iqbmp0T9Za>H5U~1h^~F~8u$8^F@fs- zACEPRujmR1(xLOjq=nLSszW2MYt*)QP4>qdwNhj0)wQBmsqAlR!d_c@S>4X4-jHuTehS^8Hx-BC?urc@2r#1fKdPPcIUN#K zlgd(iRi6S*gh>e|@*=(A_r-sfDV#>n-xhQF@xThKTI*+EN;_{v72@`zWvBCT0>wkH zvk7lwe#JMeqDBzGEac9Zto~HRsUs5a{^L4}l--f3DQRd5pkKnU5{jYs4fkqP%M9ks zjb{#0Lu>;kBq8Ul4D)J-EKCTm&G6StZg|%zWe!9#D{5AFN|g^idx|2;04W%`xT3`; zC+{_nuuWazXE-327Wb0%j`0On>=H5n2cPT3&QjHAzQaDXelPepM3_qucut$cKTbPu zV1{f9|O>s90i2X0xe;F&S8c(vGxA7LV3+ z8;I{q=(*_?>qkV=N?nz&5K2yQel@d`GN38tu%#_hmTws~uJmUIQ@k*CIyk@h21E7Z zGj-9+vM_CMwDcu2ctn?hMp*s}S_0+bJ}(KTwaMqPtc{e#7~z3sk`LK2#!>m~lgc9i z&YI*VR}57-@Wj^Dc;i(N=O_t`mLd9!&Eiq2HSzi zN5mky@s}x)Ng>9*sZJ-`?p4KTq=wQ8&?d%a)5M?Y=K7xVB^-3H<{@WyT>T_N|DpO* z8aH>`l2#q>9ABMKAZ=~7$?B=;uxgnk;%RI7_gk*tMC4OSZ;@E_uy+&puVT*wN* z?0MhcI&j#!;mA;OdLMNn(0MQAa?6SKEXsR!**!Zp7AK67ILH4D)(^3q%2cuJkzOdT zSul1-ZX#138YGF()1Tv5dEN!B6YAHM%pG((Z`LnuZ*<2vblz>*VX_W)yzmGo7A^V2 zSmvY31`W)HNJ&Zi&t#ZT?*ybXM7@PCkcpO^J*`?f?u}zT;<7L*G%{TVv0Wo(iCxPg zNg2^g-c)e$VsF=S#@3)8;?O!n2F#T_FN1Hk=%W#;ac$2jM4e<#cB{7rhXleO3|!M8 zDz>5_kW9Ht>RaV-}1)lPp$B)-%G7|lnXm(Tksd1AJ@dq; zd-zbMSNG}AmEnp$%4lrndo+;En(oxs_b5d229-^3@^nob)Y|<5H4|r0&H% z$UAW(D&2m~<~6cWW0;gZyl}X?SVf`i=Jw_i4z8Tm*q!RWco`0t11OT1= zau%`O>@%+ch0{YtH`%dVF#k8y@Qz21wsE^`{7q#&W3z%=jImAa1^^GX*tYI|m}02ZVZRe(42VvrfHt*(m9zck|B%M4oZ)l48AT ziA$Pbe?$WNbESHhH3n=VY^o8L53wPep(qI|j z(~w~*{Qac3RU#gT!zRBjvwi)h7*jUiab&&4##7d5@IA3?-pNj3>}y9jTY050BYS zZMPR!AvJuWPW|WQug9c$cl*Y}JY^+4T7B;W zpoY;4u;WOjFbu|LLe zAbsX(vlov0W}TRvB$4!CV%ma{Y42Kz@|fQ=K8NJ(BdFrp2%*5IU_32m`tpt|a0&HD z`}%2JV#?a|xk`t{t0Ja@($_SNYLQ+*&hIk5YdItd?tae4ER1^xh7u@{85&B<9Q+0p z3JQsul6ajKWcJ6Lj1a-Q`T9j;gx2UMS#(;)p>~1F?9TTu2A?c{-lRWL5xqnZx6!}e z`gJa-Ahiv}I$nC+*W8fz(bxW8AV_xok_dmw;Isyd;_Q6A-*hU4?lo}+(V1h*iy}vU zV;z0aGTNe?P6sydc(@8kRtMVL6RIpb={x5g1qA9mw(P_r6bY~T=cNg?4C2VB-)k*{ zS;*K7hG`=3o4S6BlD%!H*|2(VX=Z35D;rlzn0yF{FHi*c<(N$}DX)l4G9YE1yzLAfv^0mpL<4?pu}NCi z=WGd#8CE&uEIKr1M!eNs-F?hlHJo-^oSoOnakXlEkgMO2IY1UscqIOwy;&T;+ zu$}l#A|m>7=^LaE&E8RdyqlkIz<5pauc(0s&T2cHjtBD-6~}}QB?WRu)Rq^k0#9z- zF`JqkrYCrP=5eqY1Cf^yG1Tc7YMa5<^ZjD_n@Eo30Zg{-M~Vx&hQx&mAJu*LrpS2V z7~SQ-$j~E{h1)!nG^?^X@NBR7BsDIeoq4G-69NBLg+7C0qWP1ogh=L$ zdQ;crN}tbRlz2w5nU#BI=v4!fai+7S!Xz>kGErd-ZgJZ;S4wrZNF#1GVb24H5p7j| zK20+X(!URe>f}lKBqbPdF2R`Cosj8i-VMa#lw<1yzjn;XMA<5_T&5Jnao(8xMs~kI%1;s2FuY~z64(b0|T)` z^7pZGU+yn+oBBiw-gh3{_-y|o5f?#d=N#8;n=#5_yRs}YFL%}D5v9m62YZ|p{Y9c9 zFe;eY%8p5u!Sx5jU&W*H*ho+;axIqbbSdTDacG&t+#mZ1hyX*;kUo;X^ZYVi zEW1=nt6ksE(-O6s;>G2J`--EUB68bF$U3WE_MDwelim>OjOs04;v|%k6ur{W)%@oaf9CcDv)^Ij7j4?CRunfykK78N z`t}9lLqqLI6UuemJc#U@Nev+}t-{8Rk`4W(Q&|utc${YslvPR%qt4l$Xw96ZObFo% z6{~!tRJrPWv};`7dsWCCU6({2Abrv>)u#t`H#>SClmU4D4gXSR*RGINAp?F5_xN}b%x?JLW;tFJ*8U)Pl zm5QH&@nL1}gG5j`J$gRQK zS!a{5o(1$cu8%p)8WU(<=?uS{;Jo(KX^3e4UTn3^2$OnSTboET<@t@A?rts!gPEEO zN=KyP3sOqk;V!P0Qm@KybNlWO5qGm(tEB!Joye*D`p?RYq4C;i1P^((_lcz;-TJJu zygY)MfFl2O3JymVFwR7+=VY}*%Z{{Vc4_o+L zA~530-Ljo(?mK#*Zx8%u&HXQr+4J8b|3abIQ~0~%*;A^#bgSC@vRS83#LnCb_P6+3 zkIJ6VgzeY2quR@+%kDiRn^+M3A^^Q;w+OC=lA)iL&711XgJBVh#E@eVcG;>N&hJ3BqUW>4@7Om@gI0Y>S!6dqE)>d)=Vw6)Y+U74|{tuYL><>Ogg zUS1Mrl)K)h%%j<<7}drNH6BGc>Z_{W^k zY*yZkta#30y|5C2yT8S#shI?+TGRF(r8J?F4TGDw1t4UPr19rE;kr;duTI8=2-$Gv zw_ZR`y9dves1O^qzdb15h>381>A7Q&zUj0vnE5(BuvCp`B--!koh|kk)MBT0Pqv!i z&W)%)Te-W4Z-@4+UAd@B(Pl|XsPaTm6kQqbPqWo-unk99tS%#%`(^HGf7)i0h|`$J z%<0L*_R6bc7rj|20M5JJ?Gpi#+sc&N+n<^S>Gzm|0v~+vpVhx|Wp4rUBFCb{8AJHJ zEb|xr6P%fuZ}OuLXpJ*4aZxlCCf_VuiA3IJWxbVqQES>-L1#5t`-o(ehMQY0AmGA* z=^NFL(w22np_YV+KRHbb`eydMA`Kx37M z6k=e|VA1$YN6#*LMsVcSd7Z%TLuGjZ=oJJ?q>1u0hL^uQcWi_Wi1mc%xq+4)j)=H? zwfXF~@;FyxHPT4MBrd+VlR^FP?0ZF8b~X*?Xn|?=nZo$@`RhqO>{Ol#NG16xdS=Tp zi}R2=E6tMQ&E5?a6NoxCcX)!x^nqvmEn0(_C&X%-`+T+ zcxJI7vXw1(B=T1oKG(#tb}I02L{Ry8I4>2<*qNEQqiUN%JcdgoYzHMpgloDVl z{c#Jp{OCzP+`rBzR@-88d0~0B_4J~@QfO3&=gfwicWrYxNO~=`Ho=bM=Xoje=JeE3 z`MX4=s^aHFBRs>>E~wyMR0TKQKaYjmhgT9nP5$Shn%^dV>z|L{KkhjH^H;!5_`f`& oo?{o=|MJlL^8flbpqt&s>`+!;of}aLz?v&$rIaL#AHNLvZxptm5&!@I diff --git a/docs/img/signals/shot_quality.png b/docs/img/signals/shot_quality.png deleted file mode 100644 index e927333b48e20a972617899c13805fbab2c7007a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 80640 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 f|9)W(&} diff --git a/docs/img/signals/signals.png b/docs/img/signals/signals.png deleted file mode 100644 index 68da04c38cf4c6bc86fab87328613116558fd3ca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 172020 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

s|M=$svBb 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 delta 104934 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 --opponent [--dump-ticks PATH]` — one diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index 7f97b1c9..f8e67509 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -24,7 +24,7 @@ links back here. | Question | Tool | Status | |---|---|---| -| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the ledger for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | +| Does it break? | `pixi run test`, which includes the regression moments in `utama_core/tests/moments/`. Stalls: recorded in the match results for every match and reported by `evaluate.py` with coverage; the round-robin's STALLS section and `--strict` | Today | | Is it better? | `tools/evaluation/evaluate.py`: paired against the champion, through the reference opponents. `--held-out` before promoting. The only verdict | Today | | Does everything still run, after a shared-code change? | `round_robin.py --vs-champion`: each strategy plays the champion once (12 matches), under reference noise seed 2, so each (strategy, champion) match is the fixture `evaluate.py` plays in round 2 and is not wasted. A full round-robin (66 matches) only occasionally, for example before a release. A round-robin is not an evaluation: it gives one unpaired match per pair | Today | | What went wrong in these matches (bugs: thrashing, stalls, restart geometry, fouls)? | `tools/triage.py` (`--fouls` for our side's fouls), then the picture tools. Triage finds bugs, not why a strategy loses in football terms. For that, see `ball_losses.md` in the run folder, `docs/signals.md`, and the goal ledger (`utama_core/analysis/goal_ledger.py`) | Today | @@ -59,11 +59,11 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: 1. **Fix `main.py`'s import.** Done: it loads strategies through `strategy/catalog.py`. Its runner set-up is still one of the five hand-built ones above. 2. **This note and the docs.** `docs/strategy_tools_plan.md`, the "Which tool?" table in - `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the `--reuse` counts. -3. **Stalls in the ledger.** Done. Stalls are recorded in `replays/eval/ledger.jsonl`, and `evaluate.py` + `tools.md`, the debugging entry point in `STRATEGY_DEVELOPMENT.md`, the round-robin's "taken from" counts. +3. **Stalls in the match results.** Done. Stalls are recorded in `replays/match_results/`, and `evaluate.py` reports them with coverage: how many of the matches it used were checked for stalls. The - stall watchdog covers config_a only, so coverage is partial. Old ledger entries count as - **unknown, not clean**. + stall watchdog covers config_a only, so coverage is partial. A match whose stats were not + collected counts as **unknown, not clean**. 4. **`round_robin.py --vs-champion`.** Done. One match per strategy against the champion, plus the champion against the first reference opponent, under reference noise seed 2 by default. `evaluate.py` puts the side under test second in even rounds, so each (strategy, champion) @@ -74,7 +74,7 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: strategies through it but keeps its own runner for the dashboard. So all four play `.strategy` files. `match.py` is unchanged, and moves onto `sim_setup` with the next change that replays every match anyway: editing `match.py`, or anything it imports, changes the - fingerprint of every cached match, so every match replays and the ledger is invalidated + fingerprint of every stored match, so every match replays and the store is invalidated (`utama_core/replay/fingerprint.py`). If it must change, batch it with other changes to shared code and say so in the commit. 6. **The screen.** The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. diff --git a/docs/tools.md b/docs/tools.md index 138babb8..c38e6596 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -48,8 +48,8 @@ says why the tools are split this way. | Script | Purpose | |---|---| -| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every config not in `RETIRED` (12 of the 22 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the evaluation ledger. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; `--reuse` replays only matches whose code changed, plus a 5% spot-check of reused ones; `summary.json`'s `reuse.mismatches` lists any that came out different, which means a match no longer replays exactly. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | -| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the evaluation ledger `replays/eval/ledger.jsonl` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; ledger lines from before stalls were recorded count as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | +| `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every config not in `RETIRED` (12 of the 22 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the match results store. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; A match the store already holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played: automatic, with no flag, so only matches whose code changed play. To play every match again, delete the store. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | +| `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the match results store `replays/match_results/` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; a match whose stats were not collected counts as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | | `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | diff --git a/tools/evaluation/evaluate.py b/tools/evaluation/evaluate.py index f1d57731..7a46c3e0 100644 --- a/tools/evaluation/evaluate.py +++ b/tools/evaluation/evaluate.py @@ -30,8 +30,8 @@ After each round the candidate is compared with the champion on paired matches (`ratings.paired_difference`): its goal difference minus the champion's against the same -opponent with the same seed and colour, from every match in the ledger (`replay/eval_ledger.py`: -this run's, earlier runs', round-robins'), plus their head-to-head matches. Paired results share +opponent with the same seed and colour, from every match in the match results store +(`replay/match_results.py`: this run's, earlier runs', round-robins'), plus their head-to-head matches. Paired results share the opponent and the noise, so their difference cancels much of it: all of it for identical code, little for unrelated strategies; the spread is estimated from the differences themselves. P(candidate stronger than champion) decides: @@ -49,11 +49,11 @@ Stalls (the stall watchdog's `StallEvent`s, see `engine/match_stats.py`) are reported for post-analysis only: each candidate's and the champion's stalls, and how many of their matches -were checked (the watchdog covers config_a only; ledger lines from before stalls were recorded -count as unchecked). They never change a verdict or stop a run. +were checked (the watchdog covers config_a only; a match whose stats were not collected counts as +unchecked). They never change a verdict or stop a run. -A fixture already in the ledger is never played again, so the champion's matches are played -once per seed and reused by every candidate. Replays are not kept: a match is a pure function +A fixture already in the match results store is never played again, so the champion's matches are +played once per seed and reused by every candidate. Replays are not kept: a match is a pure function of its fixture, so `round_robin.py --pair A B --sim-noise reference:` plays it again. Promoting is a decision, not a side effect: a candidate called better should pass `--held-out` @@ -76,11 +76,12 @@ if str(REPO_ROOT) not in sys.path: sys.path.insert(0, str(REPO_ROOT)) -from tools.evaluation.match import _short_name, run_match # noqa: E402 +from tools.evaluation.match import _short_name # noqa: E402 from tools.evaluation.round_robin import ( # noqa: E402 MAX_MATCH_SECONDS, _resolve_config_names, _run_metadata, + play_and_record, ) from tools.evaluation.sim_settings import ( # noqa: E402 DEFAULT_OPPONENTS, @@ -90,14 +91,14 @@ from utama_core.analysis import ratings # noqa: E402 from utama_core.bundle.strategy_file import frozen # noqa: E402 from utama_core.config.settings import REPLAY_BASE_PATH # noqa: E402 -from utama_core.replay import eval_ledger # noqa: E402 +from utama_core.replay import match_results # noqa: E402 from utama_core.replay.fingerprint import CodeGraph # noqa: E402 from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise # noqa: E402 PROMOTE = 0.99 DROP = 0.2 MAX_ROUNDS = 6 -FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the ledger +FROZEN_DIR = Path("replays/eval/frozen") # relative: a file's path is its name in the match results def round_fixtures(candidates: list[str], champion: str, opponents: list[str], k: int) -> list[tuple[str, str, int]]: @@ -121,39 +122,28 @@ def verdict(p_better: float, rounds: int, max_rounds: int) -> str | None: return "undecided" if rounds >= max_rounds else None -def play(a: str, b: str, seed: int, noise: dict, run_dir: Path, keep: bool = False) -> dict: - """One fixture's `MatchResult` as a dict. The match is recorded like a round-robin's (same - play), then its files are deleted unless `keep` (`--explain` reads them): only the result is kept.""" - tag = f"{_short_name(a)}_vs_{_short_name(b)}_s{seed}" - result = run_match( +def play(a: str, b: str, seed: int, noise: dict, run_dir: Path, keep: bool, fps: dict, env: str, source: str) -> dict: + """One fixture's stored record, played as a round-robin's match is (`round_robin.play_and_record`). + Its replay files are deleted unless `keep` (`--explain` reads them).""" + return play_and_record( a, b, - duration_seconds=MAX_MATCH_SECONDS, + a_fp=fps[a], + b_fp=fps[b], + env=env, + seed=seed, + source=source, run_dir=run_dir, + keep_files=keep, match_tag_suffix=f"_s{seed}", + duration_seconds=MAX_MATCH_SECONDS, sim_noise=SimNoise.from_dict({**noise, "seed": seed}), ) - if not keep: - for f in run_dir.glob(f"{tag}.*"): - f.unlink() - return { - "config_a": result.config_a, - "config_b": result.config_b, - "score_a": result.score_a, - "score_b": result.score_b, - "stats": { - "shots": (result.stats or {}).get("shots"), - # config_a's stall watchdog; None when the match's stats were not collected - "stall_events": eval_ledger.stall_summary( - (result.stats or {}).get("stall_events") if result.stats is not None else None - ), - }, - } def stall_coverage(ledger: dict, fps: dict, side: str) -> dict: - """Stalls `side` was checked for over the ledger's matches at current code: the watchdog only - watches config_a, so a match counts as checked when `side` was config_a and its ledger line + """Stalls `side` was checked for over the stored matches at current code: the watchdog only + watches config_a, so a match counts as checked when `side` was config_a and its record has a stall record (None, an older line, is unknown). `total` counts every match of `side`.""" checked, total, stalls = 0, 0, [] for e in ledger.values(): @@ -216,7 +206,8 @@ def main() -> None: noise.pop("seed", None) graph = CodeGraph() - env = eval_ledger.environment(graph, duration_seconds=MAX_MATCH_SECONDS, sim_noise=noise) + env = match_results.environment(graph, duration_seconds=MAX_MATCH_SECONDS, sim_noise=noise) + store = match_results.open_store(REPLAY_BASE_PATH) fps = {n: graph.strategy_fingerprint(n)[:16] for n in {*candidates, champion, *opponents}} for c in list(candidates): twin = next((r for r in [champion, *opponents] if fps[r] == fps[c]), None) @@ -226,7 +217,7 @@ def main() -> None: def fixture_id(f: tuple[str, str, int]) -> str: a, b, seed = f - return eval_ledger.fixture_id(env, fps[a], fps[b], seed) + return match_results.fixture_id(env, fps[a], fps[b], seed) run_id = datetime.now(timezone.utc).strftime("eval_%Y%m%d_%H%M%S") run_dir = Path(REPLAY_BASE_PATH) / run_id # replay files must sit directly under replays/ @@ -244,24 +235,24 @@ def fixture_id(f: tuple[str, str, int]) -> str: for k in range(1, args.max_rounds + 1): if not open_: break - ledger = eval_ledger.load(env, fps=fps) + ledger = store.load(env, fps=fps) todo = [f for f in round_fixtures(open_, champion, opponents, k) if fixture_id(f) not in ledger] reused += len(round_fixtures(open_, champion, opponents, k)) - len(todo) - futures = {executor.submit(play, *f, noise, run_dir, args.explain): f for f in todo} + futures = {executor.submit(play, *f, noise, run_dir, args.explain, fps, env, run_id): f for f in todo} while futures: done, _ = wait(futures, return_when=FIRST_COMPLETED) for future in done: a, b, seed = futures.pop(future) result = future.result() - eval_ledger.append([eval_ledger.entry(env, graph, result, seed, source=run_id)]) + store.put(result) played += 1 print( f" round {k}: {_short_name(a):<24} {result['score_a']} - {result['score_b']} {_short_name(b)}", flush=True, ) - fit = _fit(env, fps, {*open_, champion, *opponents}) - ledger = _up_to_round(eval_ledger.load(env, fps=fps), k) + fit = _fit(store, env, fps, {*open_, champion, *opponents}) + ledger = _up_to_round(store.load(env, fps=fps), k) for c in list(open_): margin, sd = ratings.paired_difference(*paired(ledger, fps, c, champion, opponents), fit.noise_sd) p = ratings.p_positive(margin, sd) @@ -274,11 +265,11 @@ def fixture_id(f: tuple[str, str, int]) -> str: print() if args.explain: _explain(run_dir, run_id, candidates, champion) - shutil.rmtree(run_dir, ignore_errors=True) # this run's own scratch dir; results are in the ledger + shutil.rmtree(run_dir, ignore_errors=True) # this run's own scratch dir; results are in the match results store - final = _fit(env, fps, {*candidates, champion, *opponents}) - ledger = eval_ledger.load(env, fps=fps) - print(f"Verdicts ({played} matches played, {reused} reused from the ledger):") + final = _fit(store, env, fps, {*candidates, champion, *opponents}) + ledger = store.load(env, fps=fps) + print(f"Verdicts ({played} matches played, {reused} reused from the match results):") for c in candidates: r = report[c] print( @@ -345,19 +336,19 @@ def _explain(run_dir: Path, run_id: str, candidates: list[str], champion: str) - print(f"explain: {_short_name(c)} failed ({type(exc).__name__}: {exc}); verdicts are unaffected") -def _fit(env: str, fps: dict[str, str], players: set[str]) -> ratings.Ratings: - """Ratings over every ledger match in `env` between `players` at their current code.""" +def _fit(store: match_results.MatchResults, env: str, fps: dict[str, str], players: set[str]) -> ratings.Ratings: + """Ratings over every stored match in `env` between `players` at their current code.""" matches = [ (e["a"], e["b"], e["score_a"] - e["score_b"]) - for e in eval_ledger.load(env, fps=fps).values() + for e in store.load(env, fps=fps).values() if e["a"] in players and e["b"] in players and fps.get(e["a"]) == e["a_fp"] and fps.get(e["b"]) == e["b_fp"] ] return ratings.fit(matches, names=sorted(players)) def _up_to_round(ledger: dict, k: int) -> dict: - """The ledger's matches of rounds 1..k (seeds 1..k): a verdict after round k uses those only, - whatever later rounds the ledger already holds, so it doesn't depend on earlier runs.""" + """The stored matches of rounds 1..k (seeds 1..k): a verdict after round k uses those only, + whatever later rounds the store already holds, so it doesn't depend on earlier runs.""" return {f: e for f, e in ledger.items() if e["seed"] is not None and e["seed"] <= k} diff --git a/tools/evaluation/explain.py b/tools/evaluation/explain.py index e8ffa6c6..6ff27abb 100644 --- a/tools/evaluation/explain.py +++ b/tools/evaluation/explain.py @@ -193,7 +193,7 @@ def explain(run_dir, candidate: str, champion: str, out_dir, workers: int = 2) - "paired": paired_rows(matches, cand, champ), "fouls_rules_shown": pm.top_rules(views), "notes": ( - "Matches are those in the run dir; fixtures reused from the ledger have no replay here. " + "Matches are those in the run dir; fixtures taken from the match results store have no replay here. " "Positions and fouls exclude the goalkeeper and out-of-bounds (as pitch_maps.py)." ), } diff --git a/tools/evaluation/round_robin.py b/tools/evaluation/round_robin.py index 3fcfd4c5..bd5eb411 100644 --- a/tools/evaluation/round_robin.py +++ b/tools/evaluation/round_robin.py @@ -15,10 +15,10 @@ champion (reference/opponents.json), plus champion vs the first opponent; --sim-noise defaults to reference:2: evaluate.py's round 2 puts the side under test second, so (strategy, champion) are its champion-row fixtures - and land in the ledger. Not with --pair - --reuse take unchanged matches from replays/match_cache/; check the - "N reused ... M to play" line it prints before waiting on M - --spot-check F with --reuse, replay this fraction of reused matches to verify + and are taken from the match results store. Not with --pair + (no flag) a match the match results store holds (replays/match_results/, + `replay/match_results.py`) is taken from it, not played; delete that + folder to play every match again --strict fail on any stall --stop-at-first-stall stop the run at the first stall --both-sides play each pair twice, sides swapped @@ -111,21 +111,21 @@ MatchResult, _short_name, _stats_to_dict, + run_match, ) -from tools.evaluation.match import run_match as _lib_run_match from tools.evaluation.sim_settings import load_opponents, sim_noise_from_spec from utama_core.analysis import ratings, restart_outcomes, turnover_breakdown from utama_core.analysis.strategy_table import strategy_table from utama_core.bundle.strategy_file import SUFFIX from utama_core.config.settings import REPLAY_BASE_PATH -from utama_core.replay import eval_ledger, match_cache -from utama_core.replay.fingerprint import CodeGraph, match_key +from utama_core.replay import match_results +from utama_core.replay.fingerprint import CodeGraph from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.strategy.catalog import plain_name # Left out of a round-robin unless named: the bottom ten of the 2026-10-05 full round-robin # (docs/strategies.md). Their code stays, since kept strategies and tests build on some of them. -# Named here, outside the match cache key, so retiring one reruns nothing. +# Named here, outside the match results' fixtures, so retiring one reruns nothing. RETIRED = { "tiki_taka", "counter_press", @@ -151,30 +151,68 @@ MAX_MATCH_SECONDS = 1200.0 -def run_match( - config_a_name: str, - config_b_name: str, +def analyse_replay(npz: Path) -> tuple[list[dict], dict]: + """A played match's restart episodes and ball-loss record, from its replay. Kept out of + `match.py` (the environment's entry point), so changing an analysis replays no match; a stored + record keeps the analysis it was stored with (delete the store to refresh them).""" + return restart_outcomes.analyse_match(npz), turnover_breakdown.analyse_match(str(npz)) + + +def play_and_record( + config_a: str, + config_b: str, + *, + a_fp: str, + b_fp: str, + env: str, + seed: Optional[int], + source: str, run_dir: Optional[Path] = None, - control_scheme: str = "fpp", - fuzz_seed: Optional[int] = None, - fuzz_interval_s: tuple[float, float] = (25.0, 45.0), - max_match_seconds: float = MAX_MATCH_SECONDS, - sim_noise: Optional[SimNoise] = None, -) -> MatchResult: - """Play one full match (capped at `max_match_seconds`), config_a - fixed to the right side and kickoff (this module's historical, un-swept - convention). Thin wrapper over `match.run_match`; see its - docstring for what each parameter does. - """ - return _lib_run_match( - config_a_name, - config_b_name, - duration_seconds=max_match_seconds, - run_dir=run_dir, - control_scheme=control_scheme, - fuzz_seed=fuzz_seed, - fuzz_interval_s=fuzz_interval_s, - sim_noise=sim_noise, + keep_files: bool = True, + match_tag_suffix: str = "", + **run_kwargs, +) -> dict: + """Play one match and return its record (`match_results.record`): the one place the tools play a + match for the store, so the round-robin and `evaluate.py` store the same thing. `run_kwargs` go to + `match.run_match`. With a `run_dir` the replay is analysed (restarts, ball losses) and, unless + `keep_files`, its files are deleted afterwards.""" + a_is_right = run_kwargs.get("a_is_right", True) + a_kicks_off = run_kwargs.get("a_kicks_off", True) + result = run_match(config_a, config_b, run_dir=run_dir, match_tag_suffix=match_tag_suffix, **run_kwargs) + restarts = losses = None + if run_dir is not None: + run_dir = Path(run_dir) + tag = f"{_short_name(config_a)}_vs_{_short_name(config_b)}{match_tag_suffix}" + npz = run_dir / f"{tag}.npz" + if npz.exists(): # no replay: crashed before it was written + restarts, losses = analyse_replay(npz) + if not keep_files: + for f in run_dir.glob(f"{tag}.*"): + f.unlink() + return match_results.record( + env, + a_fp, + b_fp, + dataclasses.asdict(result), + seed=seed, + source=source, + restarts=restarts, + losses=losses, + a_is_right=a_is_right, + a_kicks_off=a_kicks_off, + ) + + +def result_of(rec: dict, config_a: str, config_b: str) -> MatchResult: + """A stored or just-played record as a `MatchResult`, under this run's names for the two players.""" + return MatchResult( + config_a=config_a, + config_b=config_b, + score_a=rec["score_a"], + score_b=rec["score_b"], + a_is_right=rec["a_is_right"], + a_kicks_off=rec["a_kicks_off"], + stats=rec["stats"], ) @@ -243,14 +281,10 @@ def main() -> None: # catalog/seed/control-scheme reproduces the same way every run. Implies # `--strict`. In pool mode, in-flight matches still finish (their cost is # already sunk) but no further matches are submitted. - # `--reuse` takes a match's result from `replays/match_cache/` instead of - # playing it when nothing that match runs has changed since it was stored - # (`utama_core.replay.fingerprint.match_key`; rsim is deterministic, so the - # stored result is what the match would play). After a change to one - # strategy only its matches play. `--spot-check F` (default 0.05) also - # replays that fraction of the reusable matches, at least one, and compares - # them with their stored records: a difference means the fingerprint missed - # a dependency, is printed loudly, evicts those records, and fails `--strict`. + # A match the match results store holds (`replay/match_results.py`) is taken from it instead of + # played, whenever nothing it runs has changed since it was stored (its fixture: the environment, + # both fingerprints, the sides and the seed). rsim is deterministic, so the stored result is what + # the match would play. After a change to one strategy only its matches play. args = sys.argv[1:] if "-h" in args or "--help" in args: print(__doc__) @@ -274,17 +308,6 @@ def main() -> None: args = args[:idx] + args[idx + 2 :] no_save = "--no-save" in args args = [a for a in args if a != "--no-save"] - reuse = "--reuse" in args - args = [a for a in args if a != "--reuse"] - spot_check = 0.05 - if "--spot-check" in args: - idx = args.index("--spot-check") - spot_check = float(args[idx + 1]) - args = args[:idx] + args[idx + 2 :] - if reuse and no_save: - # A stored record is a recorded match's (the match log and stats recorder - # live), and the post-run analyses it carries are read from saved replays. - raise SystemExit("--reuse stores and reads recorded matches; drop --no-save") # `--strict` exits non-zero when any match in this run recorded a stall # event (see the STALLS section below) — for CI/pre-merge gating, so a # stall regression fails the run instead of only showing up if someone @@ -351,8 +374,8 @@ def main() -> None: sim_noise = sim_noise_from_spec(args[idx + 1]) args = args[:idx] + args[idx + 2 :] elif vs_champion: - # evaluate.py's round-2 champion fixtures (see vs_champion_pairs), so these matches are in the ledger (`_append_to_ledger` - # keeps only seeded, unfuzzed matches for the ratings) and count toward the champion's rating. + # evaluate.py's round-2 champion fixtures (see vs_champion_pairs), so these matches are the store's + # fixtures and count toward the champion's rating. sim_noise = sim_noise_from_spec("reference:2") print("--vs-champion: --sim-noise not given, using reference:2 (evaluate.py's round-2 champion fixtures)") sim_noise_dict = sim_noise.to_dict() if sim_noise is not None else None @@ -412,39 +435,28 @@ def main() -> None: all_pairs = pairs - def _keys() -> dict[tuple[str, str], str]: - graph = CodeGraph() - return { - (a, b): match_key( - graph, - a, - b, - duration_seconds=match_seconds, - control_scheme=control_scheme, - fuzz_seed=fuzz_seed, - fuzz_interval_s=fuzz_interval_s, - sim_noise=sim_noise_dict, - ) - for a, b in all_pairs - } - - cache = match_cache.MatchCache() - keys: dict[tuple[str, str], str] = _keys() if reuse else {} - stored = {p: rec for p in pairs if reuse and (rec := cache.get(keys[p])) is not None} - spot_checked = { - p for p in stored if keys[p] in match_cache.spot_check_sample([keys[q] for q in stored], spot_check) + graph = CodeGraph() + env_args = { + "duration_seconds": match_seconds, + "sim_noise": sim_noise_dict, + "control_scheme": control_scheme, + "fuzz_seed": fuzz_seed, + "fuzz_interval_s": fuzz_interval_s, } - reused = {p: rec for p, rec in stored.items() if p not in spot_checked} - pairs = [p for p in pairs if p not in reused] + env = match_results.environment(graph, **env_args) + fps = {name: graph.strategy_fingerprint(name)[:16] for name in config_names} + seed = sim_noise_dict.get("seed") if sim_noise_dict else None + store = match_results.open_store(REPLAY_BASE_PATH) + hits: dict[tuple[str, str], dict] = {} + for a, b in pairs: + if (rec := store.get(env, match_results.fixture_id(env, fps[a], fps[b], seed))) is not None: + hits[(a, b)] = rec + pairs = [p for p in pairs if p not in hits] print( f"Round-robin: {len(config_names)} configs, {len(all_pairs)} matches" + (" (both sides)" if both_sides else "") ) - if reuse: - print( - f"--reuse: {len(reused)} stored result(s) reused, {len(spot_checked)} replayed as a spot-check, " - f"{len(pairs) - len(spot_checked)} to play" - ) + print(f"{len(hits)} taken from {store.root} (not played), {len(pairs)} to play") print(f"{N_OUTFIELD + 1}v{N_OUTFIELD + 1}, two 300 s halves of playing time per match, headless rsim") if no_save: print("--no-save: not recording replay/intention-log/stats for this run") @@ -495,47 +507,48 @@ def _record(result: MatchResult) -> None: if line: print(line, flush=True) - # Each played match's restart and ball-loss analyses, made as it finishes: the end of the run - # reads them from here rather than replaying every saved match again. - analysed: dict[str, tuple[list[dict], dict]] = {} - - def _analyse(result: MatchResult) -> None: - # Stored in the match cache straight away too, not only once the whole run ends, so a crash - # (WSL running out of memory killed two runs on 2026-10-09) loses only the matches still - # playing. A spot-checked match is left to `_store_played`, which compares it with its - # stored record; so is any match whose key changed since the run started (code edited mid-run). - pair = (result.config_a, result.config_b) - npz = run_dir / f"{_tag(pair)}.npz" if run_dir is not None else None - if npz is None or not npz.exists(): # no run dir, or crashed without a replay - return - restarts = restart_outcomes.analyse_match(npz) - losses = turnover_breakdown.analyse_match(str(npz)) - analysed[_tag(pair)] = (restarts, losses) - if reuse and pair not in spot_checked and _keys()[pair] == keys[pair]: - cache.put(keys[pair], {"result": dataclasses.asdict(result), "restarts": restarts, "losses": losses}) - - for (a, b), rec in reused.items(): - _record(MatchResult(**rec["result"])) + # The records of this run's matches, taken and played, by pair: the end of the run reads their + # restart and ball-loss analyses from here. + recs: dict[tuple[str, str], dict] = dict(hits) + + def _still_current(pair: tuple[str, str]) -> bool: + """A played match is stored only if the code it ran is still the code on disk: an edit made + while the run played would otherwise be stored under the fingerprints it started with.""" + now = CodeGraph() + return match_results.environment(now, **env_args) == env and all( + now.strategy_fingerprint(n)[:16] == fps[n] for n in pair + ) + def _finish(rec: dict) -> MatchResult: + pair = (rec["a"], rec["b"]) + recs[pair] = rec + if run_dir is not None: + if _still_current(pair): + store.put(rec) + else: + print(f"--- {_tag(pair)} not stored: its code changed while the run played", flush=True) + result = result_of(rec, *pair) + _record(result) + return result + + for (a, b), rec in hits.items(): + _record(result_of(rec, a, b)) + + play_kwargs = { + "env": env, + "seed": seed, + "source": run_id, + "run_dir": run_dir, + "keep_files": True, + "duration_seconds": match_seconds, + "control_scheme": control_scheme, + "fuzz_seed": fuzz_seed, + "fuzz_interval_s": fuzz_interval_s, + "sim_noise": sim_noise, + } if sequential: - for config_a_name, config_b_name in pairs: - match_kwargs = { - "run_dir": run_dir, - "control_scheme": control_scheme, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": fuzz_interval_s, - } - if match_seconds != MAX_MATCH_SECONDS: - match_kwargs["max_match_seconds"] = match_seconds - if sim_noise is not None: - match_kwargs["sim_noise"] = sim_noise - result = run_match( - config_a_name, - config_b_name, - **match_kwargs, - ) - _record(result) - _analyse(result) + for a, b in pairs: + result = _finish(play_and_record(a, b, a_fp=fps[a], b_fp=fps[b], **play_kwargs)) if stop_at_first_stall and _stalled(result): tag = f"{_short_name(result.config_a)}_vs_{_short_name(result.config_b)}" print(f"\n--stop-at-first-stall: stopping after {tag}", flush=True) @@ -547,16 +560,9 @@ def _analyse(result: MatchResult) -> None: # slowest in-flight match. Final standings are still sorted, so the # only user-visible reordering is the interleaved progress log. with ProcessPoolExecutor(max_workers=n_workers) as pool: - futures = [ - pool.submit( - run_match, a, b, run_dir, control_scheme, fuzz_seed, fuzz_interval_s, match_seconds, sim_noise - ) - for a, b in pairs - ] + futures = [pool.submit(play_and_record, a, b, a_fp=fps[a], b_fp=fps[b], **play_kwargs) for a, b in pairs] for future in as_completed(futures): - result = future.result() - _record(result) - _analyse(result) + result = _finish(future.result()) if stop_at_first_stall and _stalled(result): tag = f"{_short_name(result.config_a)}_vs_{_short_name(result.config_b)}" print( @@ -641,7 +647,7 @@ def _match_tag_of(r: MatchResult) -> str: "winner": r.winner, "stats": r.stats, "possession_backstop": id(r) in backstop_match_ids, - "reused": (r.config_a, r.config_b) in reused, + "reused": (r.config_a, r.config_b) in hits, } for r in results ], @@ -649,39 +655,23 @@ def _match_tag_of(r: MatchResult) -> str: "stalled_match_count": len(stalled_matches), "stall_incidents": incidents, "possession_backstop_match_count": len(backstop_matches), - "reuse": ( - {"reused": len(reused), "spot_checked": len(spot_checked), "played": len(pairs) - len(spot_checked)} - if reuse - else None - ), } real_losses_by_match: Optional[dict[str, dict[str, int]]] = None chances_by_match: dict[str, dict] = {} - mismatches: list[tuple[str, str]] = [] if run_dir is not None: summary_path = run_dir / "summary.json" with open(summary_path, "w") as f: json.dump(summary, f, indent=2) # RESTARTS: what became of every restart -- taken, or voided/stopped/timed out. - restarts_by_match = {tag: restarts for tag, (restarts, _) in analysed.items()} - restarts_by_match.update({_tag(p): rec["restarts"] for p, rec in reused.items()}) + restarts_by_match = {_tag(p): r["restarts"] for p, r in recs.items() if r["restarts"] is not None} summary["restarts"] = restart_outcomes.summarise( [e for m in sorted(restarts_by_match) for e in restarts_by_match[m]] ) _print_restarts(summary["restarts"]) # BALL LOSSES: how the friendly side (config_a) gave the ball away, by kind, foul rule # and tactic — `MatchStats.turnovers` alone is mostly two robots on one ball flipping - # "nearest robot". Analysed as each match finished (`_analyse`). - losses = [loss for _, loss in analysed.values()] - losses = sorted(losses + [rec["losses"] for rec in reused.values()], key=lambda r: r["match"]) - if reuse: - mismatches = _store_played( - cache, keys, _keys(), results, reused, spot_checked, stored, restarts_by_match, losses - ) - # Kept in the summary, not only printed: a spot-check is also the run's check that - # rsim replays a match exactly. Mismatches were seen once (2026-09-23, under load - # ~30) and not reproduced since; a non-empty list is the evidence to chase. - summary["reuse"]["mismatches"] = sorted(_tag(p) for p in mismatches) + # "nearest robot". Analysed as each match was played (`analyse_replay`). + losses = sorted((r["losses"] for r in recs.values() if r["losses"] is not None), key=lambda r: r["match"]) if losses: # no replays saved (e.g. every match crashed): nothing to break down summary["ball_losses"] = turnover_breakdown.breakdown(losses) (run_dir / "ball_losses.md").write_text(turnover_breakdown.report(run_id, losses, summary)) @@ -702,10 +692,7 @@ def _match_tag_of(r: MatchResult) -> str: with open(summary_path, "w") as f: json.dump(summary, f, indent=2) print(f"\nFull results + stats: replays/{run_id}/summary.json") - _append_to_ledger(results, run_id, match_seconds, control_scheme, fuzz_seed, sim_noise_dict) - if strict and reuse and mismatches: - raise SystemExit(f"--strict: {len(mismatches)} spot-checked match(es) differ from their stored records") if strict and (stalled_matches or backstop_matches): raise SystemExit( f"--strict: {len(stalled_matches)} match(es) with stall events, " @@ -713,94 +700,11 @@ def _match_tag_of(r: MatchResult) -> str: ) -def _append_to_ledger( - results: list[MatchResult], - run_id: str, - match_seconds: float, - control_scheme: str, - fuzz_seed: Optional[int], - sim_noise_dict: Optional[dict], -) -> None: - """Add the run's matches to the evaluation ledger (`replay/eval_ledger.py`), so - `evaluate.py`'s ratings count them. Only matches in `evaluate.py`'s setting: config_a on - the right kicking off, no restart fuzzing.""" - if fuzz_seed is not None: - return - graph = CodeGraph() - env = eval_ledger.environment( - graph, duration_seconds=match_seconds, sim_noise=sim_noise_dict, control_scheme=control_scheme - ) - seed = sim_noise_dict.get("seed") if sim_noise_dict else None - eval_ledger.append( - ( - eval_ledger.entry(env, graph, dataclasses.asdict(r), seed, source=run_id) - for r in results - if r.a_is_right and r.a_kicks_off - ), - Path(REPLAY_BASE_PATH) / "eval" / "ledger.jsonl", # this module's, so tests can redirect it - ) - - def _tag(pair: tuple[str, str]) -> str: """A match's file stem in a run directory (`match.run_match`'s `match_tag`).""" return f"{_short_name(pair[0])}_vs_{_short_name(pair[1])}" -def _store_played( - cache: match_cache.MatchCache, - keys: dict[tuple[str, str], str], - keys_now: dict[tuple[str, str], str], - results: list[MatchResult], - reused: dict, - spot_checked: set, - stored: dict, - restarts_by_match: dict[str, list[dict]], - losses: list[dict], -) -> list[tuple[str, str]]: - """Store every match this run played, and compare each spot-checked one with its stored - record. Returns the spot-checked pairs that differ; their records are evicted, not - replaced, since their key no longer names one result, and so is every record this run - reused. Stores nothing if any key changed while the run played (code edited mid-run).""" - if keys_now != keys: - print("\n--reuse: the code changed while this run played; storing nothing", flush=True) - return [] - losses_by_match = {r["match"]: r for r in losses} - mismatches: list[tuple[str, str]] = [] - for r in results: - pair = (r.config_a, r.config_b) - if pair in reused or _tag(pair) not in losses_by_match: # reused, or crashed without a replay - continue - record = { - "result": dataclasses.asdict(r), - "restarts": restarts_by_match.get(_tag(pair), []), - "losses": losses_by_match[_tag(pair)], - } - if pair in spot_checked: - parts = match_cache.differences(stored[pair], record) - if parts: - mismatches.append(pair) - cache.evict(keys[pair]) - print( - f"\n*** --reuse SPOT-CHECK MISMATCH: {_tag(pair)} differs from its stored record in {parts}. " - "The fingerprint missed something this match depends on; its record is evicted. ***", - flush=True, - ) - continue - cache.put(keys[pair], record) - if spot_checked: - print(f"\n--reuse: spot-check {len(spot_checked) - len(mismatches)}/{len(spot_checked)} identical", flush=True) - if mismatches: - # The records this run reused were trusted on the same fingerprints that just failed. - for pair in reused: - cache.evict(keys[pair]) - print( - f"*** --reuse: this run's {len(reused)} reused result(s) are evicted too and its standings can't be " - "trusted; rerun without --reuse. ***", - flush=True, - ) - return mismatches - - def _resolve_config_names(requested_names: list[str]) -> list[str]: """The strategies named, in catalog order, then any `.strategy` files as given.""" files = [name for name in requested_names if name.endswith(SUFFIX)] diff --git a/tools/package_logs.py b/tools/package_logs.py index 099c02b7..1df7162d 100644 --- a/tools/package_logs.py +++ b/tools/package_logs.py @@ -2,7 +2,7 @@ Modes: 1. Tournament Results (Tier 1): packages summary.json, *.stats.json, *.timeline.json, - ledger entries, and reports while stripping large columnar *.npz arrays (reducing + and reports while stripping large columnar *.npz arrays (reducing ~1 GB to ~3 MB). 2. Real Field Logs (Tier 2): compresses raw .log files to .log.gz and bundles them with calibration files and hardware configurations for sharing. @@ -40,7 +40,7 @@ def collect_tournament_files(run_dir: Path, with_intentions: bool = False) -> li files: list[Path] = [] # Core summaries and stats - for pattern in ("summary.json", "*.stats.json", "*.timeline.json", "*.md", "ledger.jsonl"): + for pattern in ("summary.json", "*.stats.json", "*.timeline.json", "*.md"): files.extend(sorted(run_dir.glob(pattern))) if with_intentions: diff --git a/utama_core/replay/eval_ledger.py b/utama_core/replay/eval_ledger.py deleted file mode 100644 index 4fb1d70c..00000000 --- a/utama_core/replay/eval_ledger.py +++ /dev/null @@ -1,124 +0,0 @@ -"""Every evaluation match's result, in one append-only file, for ratings across runs. - -`tools/evaluation/evaluate.py` and `round_robin.py` append one JSON line per match they play: -the environment it ran in, both sides with the fingerprint of their code, the noise seed, the -score, the shots and the stall events. A rating fit reads back the matches of one environment, so each result -counts in every later evaluation until the code that played it changes. - -- **Environment** (`environment`): the shared code and machine (`fingerprint.base_fingerprint` - of the match runner), the match length, the planner and the sim noise without its seed. - Matches from different environments are never mixed: a planner or sim change replays all. -- **Player**: the `fingerprint.strategy_fingerprint` of its code, with the name it had when it - played as a label. Editing a strategy makes it a new player; its old matches stay in the file - but no longer count. -- **Fixture** (`fixture_id`): environment, both fingerprints, sides and seed. An rsim match is a - pure function of it, so a fixture already in the ledger is never played again. -""" - -from __future__ import annotations - -import json -from pathlib import Path -from typing import Iterable, Optional - -from utama_core.config.settings import REPLAY_BASE_PATH -from utama_core.replay.fingerprint import ROUND_ROBIN_ENTRY, CodeGraph, _digest - -LEDGER_PATH = Path(REPLAY_BASE_PATH) / "eval" / "ledger.jsonl" - - -def environment( - graph: CodeGraph, - *, - duration_seconds: float, - sim_noise: Optional[dict], - control_scheme: str = "fpp", -) -> str: - """Id of what every match of an evaluation shares; `sim_noise` is `SimNoise.to_dict()`, - its seed left out.""" - noise = {k: v for k, v in (sim_noise or {}).items() if k != "seed"} - return _digest( - [ - "evaluation environment", - graph.base_fingerprint([ROUND_ROBIN_ENTRY]), - json.dumps( - {"duration_seconds": duration_seconds, "control_scheme": control_scheme, "sim_noise": noise}, - sort_keys=True, - ), - ] - )[:16] - - -def fixture_id(env: str, a_fp: str, b_fp: str, seed: Optional[int]) -> str: - """config_a is always yellow and starts on the right, kicking off (`match.run_match`'s defaults). - Fingerprints, not names: a `.strategy` file and the same code in the repo are one player.""" - return _digest([env, a_fp, b_fp, json.dumps(seed)])[:16] - - -def stall_summary(events: Optional[Iterable[dict]]) -> Optional[list[dict]]: - """A match's stall events as ledger rows (kind, sim time, and the diagnosis if there is one), - or None when the match's stats were not collected: unknown, which is not "no stalls". - The watchdog only watches config_a, so these are config_a's stalls.""" - if events is None: - return None - rows = [] - for e in events: - row = {"kind": e["kind"], "sim_time": e["sim_time"]} - if e.get("diagnosis"): - row["diagnosis"] = e["diagnosis"] - rows.append(row) - return rows - - -def entry(env: str, graph: CodeGraph, result: dict, seed: Optional[int], source: str) -> dict: - """A ledger line for `result` (a `match.MatchResult` as a dict, with its stats). `stalls` is - config_a's stall events, or None when the match's stats do not say.""" - a, b = result["config_a"], result["config_b"] - a_fp, b_fp = graph.strategy_fingerprint(a)[:16], graph.strategy_fingerprint(b)[:16] - stats = result.get("stats") or {} - shots = stats.get("shots") or {} - return { - "fixture": fixture_id(env, a_fp, b_fp, seed), - "env": env, - "a": a, - "a_fp": a_fp, - "b": b, - "b_fp": b_fp, - "seed": seed, - "score_a": result["score_a"], - "score_b": result["score_b"], - "shots_a": shots.get("friendly"), - "shots_b": shots.get("enemy"), - "stalls": stall_summary(stats.get("stall_events") if stats else None), - "source": source, - } - - -def append(entries: Iterable[dict], path: Path = LEDGER_PATH) -> None: - """One line per entry; each write is a single append, so concurrent writers interleave - whole lines.""" - path.parent.mkdir(parents=True, exist_ok=True) - with open(path, "a") as f: - for e in entries: - f.write(json.dumps(e, sort_keys=True) + "\n") - f.flush() - - -def load(env: str, path: Path = LEDGER_PATH, fps: Optional[dict[str, str]] = None) -> dict[str, dict]: - """The ledger's entries for `env`, by fixture id (the last one wins if a fixture was played - twice). With `fps` (name -> fingerprint), a player it knows goes by that name, whatever the - name was when the match was played.""" - names = {fp: name for name, fp in (fps or {}).items()} - out: dict[str, dict] = {} - if not path.exists(): - return out - for line in path.read_text().splitlines(): - try: - e = json.loads(line) - except json.JSONDecodeError: - continue # a torn last line from a crash - if e.get("env") == env: - e.setdefault("stalls", None) # lines written before stalls were recorded: unknown - e["a"], e["b"] = names.get(e["a_fp"], e["a"]), names.get(e["b_fp"], e["b"]) - out[e["fixture"]] = e - return out diff --git a/utama_core/replay/fingerprint.py b/utama_core/replay/fingerprint.py index edd19110..8ad8837f 100644 --- a/utama_core/replay/fingerprint.py +++ b/utama_core/replay/fingerprint.py @@ -15,7 +15,8 @@ name, version and build), the installed robosim binary, the CPU model and the environment variables that change numerics. Not the code behind the process boundary (`PLAYER_SIDE`): a `.strategy` file brings its own, so editing a skill replays no match between two files. -- `match_key(...)`: those fingerprints plus every run setting. +- The run settings (duration, planner, sim noise, restart fuzzing, sides) and the two players' + fingerprints make up a match's fixture in `replay/match_results.py`. `audit()` lists every place the code reaches outside the import graph (environment, files, subprocesses, dynamic imports, module-level state); @@ -479,43 +480,3 @@ def environment_pin(root: Path = REPO_ROOT) -> dict: "cpu": _cpu_model(), "env": {k: v for k, v in sorted(os.environ.items()) if k.startswith(ENV_PREFIXES)}, } - - -def match_key( - graph: CodeGraph, - config_a: str, - config_b: str, - *, - duration_seconds: float, - a_is_right: bool = True, - a_kicks_off: bool = True, - control_scheme: str = "fpp", - fuzz_seed: Optional[int] = None, - fuzz_interval_s: tuple[float, float] = (25.0, 45.0), - recorded: bool = True, - sim_noise: Optional[dict] = None, -) -> str: - """Key of one `match.run_match` call: same key, same result. `recorded` is - whether it ran with a `run_dir` (the match log and stats recorder are then live). - `sim_noise` (`SimNoise.to_dict()`) enters the key only when set, so matches without it - keep their keys.""" - settings = { - "duration_seconds": duration_seconds, - "a_is_right": a_is_right, - "a_kicks_off": a_kicks_off, - "control_scheme": control_scheme, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": list(fuzz_interval_s) if fuzz_seed is not None else None, - "recorded": recorded, - } - if sim_noise is not None: - settings["sim_noise"] = sim_noise - return _digest( - [ - "round-robin match", - graph.base_fingerprint([ROUND_ROBIN_ENTRY]), - graph.strategy_fingerprint(config_a), - graph.strategy_fingerprint(config_b), - json.dumps(settings, sort_keys=True), - ] - ) diff --git a/utama_core/replay/match_cache.py b/utama_core/replay/match_cache.py deleted file mode 100644 index ff7d6fc5..00000000 --- a/utama_core/replay/match_cache.py +++ /dev/null @@ -1,75 +0,0 @@ -"""Stored round-robin match results, reused while the code a match runs is unchanged. - -An rsim match is deterministic, so a result is a function of `fingerprint.match_key`: -both sides' code, the shared code and environment, and the run settings. A record holds -everything `round_robin.py` reads from a played match: the result and its stats, the -restart episodes (`restart_outcomes.analyse_match`) and the ball-loss record -(`turnover_breakdown.analyse_match`, with its `chances`). No replay is stored; `--pair A B` -plays any match again, byte for byte. The analysis code is not in the key: a record keeps -the analysis it was stored with, so after changing it, refresh the records from a run's -replays or the spot-check will report the difference. - -A fingerprint can miss a dependency (see `fingerprint.py`'s "Known gaps"), so a run also -replays a sample of the matches it would reuse (`spot_check_sample`) and compares the -fresh record with the stored one (`differences`). -""" - -from __future__ import annotations - -import json -import os -import random -from pathlib import Path -from typing import Iterable, Optional - -from utama_core.config.settings import REPLAY_BASE_PATH - -CACHE_DIR = Path(REPLAY_BASE_PATH) / "match_cache" -RECORD_PARTS = ("result", "restarts", "losses") - - -def _plain(value): - """`value` as it reads back from JSON (tuples become lists, keys become strings).""" - return json.loads(json.dumps(value)) - - -class MatchCache: - def __init__(self, root: Path = CACHE_DIR): - self.root = Path(root) - - def path(self, key: str) -> Path: - return self.root / key[:2] / f"{key}.json" - - def get(self, key: str) -> Optional[dict]: - try: - return json.loads(self.path(key).read_text()) - except (OSError, json.JSONDecodeError): - return None - - def put(self, key: str, record: dict) -> None: - path = self.path(key) - path.parent.mkdir(parents=True, exist_ok=True) - # One temp file per process: several round-robins (one per strategy branch) can share - # this cache and store the same match at once. A shared temp file could be renamed away - # mid-write by one of them, leaving a torn record and failing the other's rename. - tmp = path.with_suffix(f".{os.getpid()}.tmp") - tmp.write_text(json.dumps(_plain(record), sort_keys=True)) - tmp.replace(path) - - def evict(self, key: str) -> None: - self.path(key).unlink(missing_ok=True) - - -def spot_check_sample(keys: Iterable[str], fraction: float, seed: int = 0) -> set[str]: - """The cached keys a run replays to check them: `fraction` of them, at least one when - there are any and `fraction` > 0. Seeded, so a rerun checks the same matches.""" - keys = sorted(keys) - if not keys or fraction <= 0: - return set() - n = min(len(keys), max(1, round(fraction * len(keys)))) - return set(random.Random(seed).sample(keys, n)) - - -def differences(stored: dict, fresh: dict) -> list[str]: - """The record parts where a replayed match disagrees with its stored record.""" - return [part for part in RECORD_PARTS if _plain(stored.get(part)) != _plain(fresh.get(part))] diff --git a/utama_core/replay/match_results.py b/utama_core/replay/match_results.py new file mode 100644 index 00000000..0a9a1059 --- /dev/null +++ b/utama_core/replay/match_results.py @@ -0,0 +1,175 @@ +"""Every match result the evaluation tools have played, in one store: `replays/match_results/`. + +An rsim match is deterministic, so its result is a function of its fixture: the environment (the +shared code and machine, the match length, the planner, the sim noise without its seed and the +restart fuzzing), both players' code fingerprints (`fingerprint.py`), their sides and the noise +seed. `tools/evaluation/match.py`'s `play_and_record` plays a fixture and returns its record; the +callers (`round_robin.py`, `evaluate.py`) look a fixture up first and play it only when the store +does not hold it, then store the record. Reuse is automatic: there is no flag. A player whose code +changed has new fingerprints, so only its matches play again. + +Layout: one JSON file per fixture, under its environment: `replays/match_results//.json`. +A record holds the score, the shots, the stall events, the full per-match stats, the restart +episodes and the ball-loss record of the match, the names of both players as labels, the run it came +from, and the fingerprints it was played with. Names are labels only: `load(env, fps)` relabels a +player by its fingerprint, so a `.strategy` file and the same code in the repo are one player. + +To force replays, delete the store, or one environment's folder inside it. The store does not check +itself: if a fingerprint misses a dependency (see `fingerprint.py`, "Known gaps"), the stale results +stay until the store is deleted. The earlier stores (`replays/match_cache/`, `replays/eval/ledger.jsonl`) +are no longer read or written. +""" + +from __future__ import annotations + +import json +import os +from pathlib import Path +from typing import Iterable, Optional + +from utama_core.replay.fingerprint import ROUND_ROBIN_ENTRY, CodeGraph, _digest + +STORE_NAME = "match_results" + + +def open_store(replay_base: Path) -> "MatchResults": + """The store under a replay base directory (`REPLAY_BASE_PATH` for the tools).""" + return MatchResults(Path(replay_base) / STORE_NAME) + + +def environment( + graph: CodeGraph, + *, + duration_seconds: float, + sim_noise: Optional[dict], + control_scheme: str = "fpp", + fuzz_seed: Optional[int] = None, + fuzz_interval_s: tuple[float, float] = (25.0, 45.0), +) -> str: + """Id of what every match of one evaluation or round-robin shares. `sim_noise` is + `SimNoise.to_dict()`, its seed left out (the seed is part of the fixture).""" + noise = {k: v for k, v in (sim_noise or {}).items() if k != "seed"} + settings = { + "duration_seconds": duration_seconds, + "control_scheme": control_scheme, + "sim_noise": noise, + "fuzz_seed": fuzz_seed, + "fuzz_interval_s": list(fuzz_interval_s) if fuzz_seed is not None else None, + } + return _digest( + [ + "evaluation environment", + graph.base_fingerprint([ROUND_ROBIN_ENTRY]), + json.dumps(settings, sort_keys=True), + ] + )[:16] + + +def fixture_id( + env: str, + a_fp: str, + b_fp: str, + seed: Optional[int], + *, + a_is_right: bool = True, + a_kicks_off: bool = True, +) -> str: + """One match: environment, both players' fingerprints, the sides and the noise seed. The sides + default to the tools' convention (config_a yellow, on the right, kicking off).""" + sides = {"a_is_right": a_is_right, "a_kicks_off": a_kicks_off} + return _digest([env, a_fp, b_fp, json.dumps(seed), json.dumps(sides, sort_keys=True)])[:16] + + +def stall_summary(events: Optional[Iterable[dict]]) -> Optional[list[dict]]: + """A match's stall events as stored rows (kind, sim time, and the diagnosis if there is one), + or None when the match's stats were not collected: unknown, which is not "no stalls". + The watchdog only watches config_a, so these are config_a's stalls.""" + if events is None: + return None + rows = [] + for e in events: + row = {"kind": e["kind"], "sim_time": e["sim_time"]} + if e.get("diagnosis"): + row["diagnosis"] = e["diagnosis"] + rows.append(row) + return rows + + +def record( + env: str, + a_fp: str, + b_fp: str, + result: dict, + *, + seed: Optional[int], + source: str, + restarts: Optional[list[dict]], + losses: Optional[dict], + a_is_right: bool = True, + a_kicks_off: bool = True, +) -> dict: + """The stored record of one played match. `result` is a `match.MatchResult` as a dict; `restarts` + and `losses` are the replay analyses (None when the replay was not kept to analyse).""" + stats = result.get("stats") or {} + shots = stats.get("shots") or {} + rec = { + "fixture": fixture_id(env, a_fp, b_fp, seed, a_is_right=a_is_right, a_kicks_off=a_kicks_off), + "env": env, + "a": result["config_a"], + "a_fp": a_fp, + "b": result["config_b"], + "b_fp": b_fp, + "a_is_right": a_is_right, + "a_kicks_off": a_kicks_off, + "seed": seed, + "source": source, + "score_a": result["score_a"], + "score_b": result["score_b"], + "shots_a": shots.get("friendly"), + "shots_b": shots.get("enemy"), + "stalls": stall_summary(stats.get("stall_events") if stats else None), + "stats": result.get("stats"), + "restarts": restarts, + "losses": losses, + } + return json.loads(json.dumps(rec)) # the shape it reads back in, tuples as lists + + +class MatchResults: + def __init__(self, root: Path): + self.root = Path(root) + + def path(self, env: str, fixture: str) -> Path: + return self.root / env / f"{fixture}.json" + + def get(self, env: str, fixture: str) -> Optional[dict]: + try: + return json.loads(self.path(env, fixture).read_text()) + except (OSError, json.JSONDecodeError): + return None + + def put(self, rec: dict) -> None: + path = self.path(rec["env"], rec["fixture"]) + path.parent.mkdir(parents=True, exist_ok=True) + # One temp file per process: several runs (one per strategy branch) can share the store and + # store the same match at once; a shared temp file could be renamed away mid-write. + tmp = path.with_suffix(f".{os.getpid()}.tmp") + tmp.write_text(json.dumps(rec, sort_keys=True)) + tmp.replace(path) + + def load(self, env: str, fps: Optional[dict[str, str]] = None) -> dict[str, dict]: + """The stored matches of `env`, by fixture id. With `fps` (name -> fingerprint), a player it + knows goes by that name, whatever the name was when the match was played.""" + names = {fp: name for name, fp in (fps or {}).items()} + out: dict[str, dict] = {} + folder = self.root / env + if not folder.is_dir(): + return out + for path in sorted(folder.glob("*.json")): + try: + rec = json.loads(path.read_text()) + except (OSError, json.JSONDecodeError): + continue # a torn write from a crash, or a file someone edited: not a result + rec["a"], rec["b"] = names.get(rec["a_fp"], rec["a"]), names.get(rec["b_fp"], rec["b"]) + out[rec["fixture"]] = rec + return out diff --git a/utama_core/tests/engine/test_evaluate.py b/utama_core/tests/engine/test_evaluate.py index aa0a6506..581a57c5 100644 --- a/utama_core/tests/engine/test_evaluate.py +++ b/utama_core/tests/engine/test_evaluate.py @@ -1,9 +1,6 @@ -import json - import pytest from tools.evaluation import evaluate -from utama_core.replay import eval_ledger def test_round_fixtures_pair_candidate_and_champion_on_the_same_opponents_and_seed(): @@ -29,32 +26,6 @@ def test_verdict_thresholds_are_inclusive_and_cap_rounds(): assert evaluate.verdict(0.5, 6, 6) == "undecided" -def test_ledger_round_trip_keeps_the_last_entry_per_fixture_and_skips_torn_lines(tmp_path): - path = tmp_path / "ledger.jsonl" - base = {"env": "e", "a": "x", "b": "y", "a_fp": "1", "b_fp": "2", "seed": 1} - eval_ledger.append([{**base, "fixture": "f", "score_a": 1}, {**base, "env": "other", "fixture": "g"}], path) - eval_ledger.append([{**base, "fixture": "f", "score_a": 2}], path) - with open(path, "a") as f: - f.write('{"env": "e", "fixt') - loaded = eval_ledger.load("e", path) - assert list(loaded) == ["f"] and loaded["f"]["score_a"] == 2 - - -def test_fixture_id_depends_on_seed_and_code(): - f = eval_ledger.fixture_id - assert f("e", "1", "2", 1) != f("e", "1", "2", 2) - assert f("e", "1", "2", 1) != f("e", "9", "2", 1) - - -def test_a_ledger_player_goes_by_this_runs_name_for_the_same_code(tmp_path): - """A frozen file and the same code in the repo are one player, whichever played the match.""" - path = tmp_path / "ledger.jsonl" - row = {"env": "e", "fixture": "f", "a": "split_shape", "a_fp": "1", "b": "other", "b_fp": "2"} - eval_ledger.append([row], path) - loaded = eval_ledger.load("e", path, fps={"frozen/split_shape@abc.strategy": "1"}) - assert (loaded["f"]["a"], loaded["f"]["b"]) == ("frozen/split_shape@abc.strategy", "other") - - def test_per_opponent_compares_only_matches_with_the_same_seed_and_colour(): """The champion's seed-1 match as config_a pairs with the candidate's seed-1 match as config_a; the candidate's seed-1 match as config_b has no partner and is left out.""" @@ -135,57 +106,6 @@ def test_sim_noise_spec_forms(): assert sim_noise_from_spec('{"seed": 2, "kick_speed_sd": 0.3}').kick_speed_sd == 0.3 -class _Graph: - """Stands in for CodeGraph: entry() only asks for a strategy's fingerprint.""" - - def strategy_fingerprint(self, name): - return "fp-" + name - - -_FROZEN_EVENT = { - "kind": "COMMITTED_FROZEN", - "sim_time": 12.5, - "tick": 1250, - "referee_command": "NORMAL_START", - "duration_s": 9.0, - "tactic_ids": ["t1"], - "robot_ids": [1, 2], - "diagnosis": "ball held by enemy 3", -} - - -def _result(a, b, stats): - return {"config_a": a, "config_b": b, "score_a": 1, "score_b": 0, "stats": stats} - - -def test_entry_stores_the_stall_events_compactly(): - row = eval_ledger.entry("e", _Graph(), _result("c", "o", {"shots": {}, "stall_events": [_FROZEN_EVENT]}), 1, "run") - assert row["stalls"] == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5, "diagnosis": "ball held by enemy 3"}] - - -def test_entry_stores_an_empty_list_when_the_stats_show_no_stall(): - row = eval_ledger.entry("e", _Graph(), _result("c", "o", {"stall_events": []}), 1, "run") - assert row["stalls"] == [] - - -def test_entry_stores_none_when_stall_events_are_unknown(): - """No stats at all, or stats without the stall field: unknown, not 'no stalls'.""" - assert eval_ledger.entry("e", _Graph(), _result("c", "o", None), 1, "run")["stalls"] is None - assert eval_ledger.entry("e", _Graph(), _result("c", "o", {"shots": {}}), 1, "run")["stalls"] is None - - -def test_stall_summary_drops_the_detail_a_ledger_line_does_not_need(): - rows = eval_ledger.stall_summary([{**_FROZEN_EVENT, "diagnosis": ""}]) - assert rows == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5}] - assert json.loads(json.dumps(rows)) == rows - - -def test_an_old_ledger_line_without_stalls_reads_as_unknown(tmp_path): - path = tmp_path / "ledger.jsonl" - path.write_text(json.dumps({"env": "e", "fixture": "f", "a": "c", "a_fp": "1", "b": "o", "b_fp": "2"}) + "\n") - assert eval_ledger.load("e", path)["f"]["stalls"] is None - - FPS = {"c": "fc", "o": "fo", "ch": "fch"} diff --git a/utama_core/tests/engine/test_tournament_cli_args.py b/utama_core/tests/engine/test_tournament_cli_args.py index 2432d12a..722663c1 100644 --- a/utama_core/tests/engine/test_tournament_cli_args.py +++ b/utama_core/tests/engine/test_tournament_cli_args.py @@ -10,9 +10,29 @@ import json +import pytest + from tools.evaluation import round_robin as tournament +class _Graph: + """Stands in for CodeGraph: the store needs only the fingerprints' names.""" + + def base_fingerprint(self, entries): + return "base" + + def strategy_fingerprint(self, name): + return f"fp-{name}" + + +@pytest.fixture(autouse=True) +def _no_real_fingerprints(monkeypatch, tmp_path): + """Every test here runs with a fake CodeGraph and its own replay folder, so the match results + store is written under tmp_path.""" + monkeypatch.setattr(tournament, "CodeGraph", _Graph) + monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) + + def _stub_result(config_a_name, config_b_name, **_kwargs): return tournament.MatchResult(config_a=config_a_name, config_b=config_b_name, score_a=1, score_b=0, stats=None) @@ -20,21 +40,18 @@ def _stub_result(config_a_name, config_b_name, **_kwargs): def test_fuzz_restarts_and_interval_parsed_and_passed_to_run_match(tmp_path, monkeypatch): calls = [] - def _fake_run_match( - config_a_name, config_b_name, run_dir=None, control_scheme="fpp", fuzz_seed=None, fuzz_interval_s=(25.0, 45.0) - ): + def _fake_run_match(config_a_name, config_b_name, **kwargs): calls.append( { "config_a": config_a_name, "config_b": config_b_name, - "fuzz_seed": fuzz_seed, - "fuzz_interval_s": fuzz_interval_s, + "fuzz_seed": kwargs.get("fuzz_seed"), + "fuzz_interval_s": kwargs.get("fuzz_interval_s"), } ) return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr( "sys.argv", [ @@ -67,14 +84,11 @@ def _fake_run_match( def test_fuzz_restarts_off_by_default(tmp_path, monkeypatch): calls = [] - def _fake_run_match( - config_a_name, config_b_name, run_dir=None, control_scheme="fpp", fuzz_seed=None, fuzz_interval_s=(25.0, 45.0) - ): - calls.append({"fuzz_seed": fuzz_seed, "fuzz_interval_s": fuzz_interval_s}) + def _fake_run_match(config_a_name, config_b_name, **kwargs): + calls.append({"fuzz_seed": kwargs.get("fuzz_seed"), "fuzz_interval_s": kwargs.get("fuzz_interval_s")}) return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr( "sys.argv", [ @@ -96,10 +110,10 @@ def _fake_run_match( summary = json.loads((run_dirs[0] / "summary.json").read_text()) assert summary["fuzz_seed"] is None assert summary["fuzz_interval_s"] is None - # The run's matches go to the evaluation ledger under REPLAY_BASE_PATH, so a test run never + # The run's matches go to the match results store under REPLAY_BASE_PATH, so a test run never # writes into the real one. - (line,) = (tmp_path / "eval" / "ledger.jsonl").read_text().splitlines() - assert json.loads(line)["source"] == run_dirs[0].name + (path,) = (tmp_path / "match_results").rglob("*.json") + assert json.loads(path.read_text())["source"] == run_dirs[0].name def test_pair_plays_exactly_that_one_pairing_in_the_given_order(tmp_path, monkeypatch): @@ -107,12 +121,11 @@ def test_pair_plays_exactly_that_one_pairing_in_the_given_order(tmp_path, monkey not the sorted order a round-robin over those two configs would use.""" calls = [] - def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): + def _fake_run_match(config_a_name, config_b_name, **_kwargs): calls.append((config_a_name, config_b_name)) return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--no-save", "--pair", "tiki_taka", "low_block"]) tournament.main() @@ -130,7 +143,7 @@ def _no_match(*_args, **_kwargs): monkeypatch.setattr("sys.argv", ["round_robin.py", flag]) tournament.main() out = capsys.readouterr().out - assert "--pair A B" in out and "--reuse" in out + assert "--pair A B" in out and "replays/match_results/" in out def test_no_configs_plays_every_config_but_the_retired_and_a_named_retired_one_still_plays(tmp_path, monkeypatch): @@ -142,7 +155,6 @@ def _fake_run_match(config_a_name, config_b_name, *_args, **_kwargs): names = ["a", "b", "c"] monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr(tournament, "_CONFIG_NAMES", names) monkeypatch.setattr(tournament, "RETIRED", {"c"}) @@ -166,7 +178,6 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): return _stub_result(config_a_name, config_b_name) monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr( "sys.argv", [ @@ -186,43 +197,20 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): assert json.loads(summary_path.read_text())["sim_noise"]["seed"] == 3 -def test_match_seconds_keys_the_match_cache_and_is_recorded_in_the_summary(tmp_path, monkeypatch): - # A shortened run's matches must not be cached under the full-length key, or a later - # full-length `--reuse` run would serve them as full matches. - durations = [] - - def _fake_match_key(_graph, _a, _b, *, duration_seconds, **_kwargs): - durations.append(duration_seconds) - return f"key-{duration_seconds}" - - class _EmptyCache: - def get(self, _key): - return None - - def put(self, _key, _record): - pass - +def test_match_seconds_is_part_of_the_environment_so_each_length_has_its_own_results(tmp_path, monkeypatch): + # A shortened run's matches must not be taken for full-length ones: each match length is its own + # environment in the store, and the length is recorded in the summary. monkeypatch.setattr(tournament, "run_match", _stub_result) - monkeypatch.setattr(tournament, "match_key", _fake_match_key) - monkeypatch.setattr(tournament, "CodeGraph", lambda: None) - monkeypatch.setattr(tournament, "_append_to_ledger", lambda *a: None) # needs real fingerprints - monkeypatch.setattr(tournament.match_cache, "MatchCache", _EmptyCache) - monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr( - "sys.argv", - [ - "tournament.py", - "--sequential", - "--reuse", - "--match-seconds", - "300", - "low_block", - "tiki_taka", - ], + "sys.argv", ["tournament.py", "--sequential", "--match-seconds", "300", "low_block", "tiki_taka"] ) - tournament.main() - - assert durations and set(durations) == {300.0} (summary_path,) = tmp_path.glob("tournament_*/summary.json") assert json.loads(summary_path.read_text())["max_match_seconds"] == 300.0 + + monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "low_block", "tiki_taka"]) + tournament.main() + + envs = sorted((tmp_path / "match_results").iterdir()) + assert len(envs) == 2 + assert all(len(list(env.glob("*.json"))) == 1 for env in envs) diff --git a/utama_core/tests/engine/test_tournament_reuse.py b/utama_core/tests/engine/test_tournament_reuse.py index e88ddbc3..967de553 100644 --- a/utama_core/tests/engine/test_tournament_reuse.py +++ b/utama_core/tests/engine/test_tournament_reuse.py @@ -1,9 +1,8 @@ -"""`round_robin.py --reuse`: a match whose key is stored is not played again. +"""Round-robin reuse: a match the match results store holds is taken from it, not played. -Matches, keys and the replay analyses are stubbed: `fingerprint.match_key` is replaced by -a key built from a per-config version number, so "editing" a config is bumping its -version. `tests/replay/test_fingerprint.py` covers the real keys and -`tests/replay/test_match_cache.py` the store. +Matches, fingerprints and the replay analyses are stubbed: a config's fingerprint is its name +plus a version number, so "editing" a config is bumping its version. `tests/replay/test_fingerprint.py` +covers the real fingerprints and `tests/replay/test_match_results.py` the store. """ from __future__ import annotations @@ -13,17 +12,22 @@ import pytest from tools.evaluation import round_robin as tournament -from utama_core.replay.match_cache import MatchCache +from utama_core.replay import match_results _CONFIGS = ["tiki_taka", "low_block", "high_press"] -class _Always5(dict): - def get(self, key, default=None): - return 5 +class _Graph: + """Stands in for CodeGraph: fingerprints follow the rig's versions.""" + def __init__(self, rig): + self.rig = rig -_EVERY_PAIR_SCORES_5 = _Always5() + def base_fingerprint(self, entries): + return "base" + + def strategy_fingerprint(self, name): + return f"fp-{name}-{self.rig.version[name]}" @pytest.fixture @@ -32,50 +36,47 @@ def rig(tmp_path, monkeypatch): rig.played = [] rig.version = {c: 0 for c in _CONFIGS} rig.score = {} # pair -> score_a, to make a replay disagree with its stored record - rig.cache = MatchCache(tmp_path / "cache") rig.on_play = None - def fake_run_match(a, b, run_dir=None, *_args, **_kwargs): + def fake_run_match(a, b, run_dir=None, match_tag_suffix="", **_kwargs): rig.played.append((a, b)) - (run_dir / f"{tournament._tag((a, b))}.npz").write_bytes(b"") + if run_dir is not None: + (run_dir / f"{a}_vs_{b}{match_tag_suffix}.npz").write_bytes(b"") if rig.on_play is not None: rig.on_play() return tournament.MatchResult(config_a=a, config_b=b, score_a=rig.score.get((a, b), 1), score_b=0, stats={}) - def fake_losses(npz_path): - return {"match": npz_path.rsplit("/", 1)[-1][: -len(".npz")], "turnovers": [], "restarts": []} + def fake_analyse(npz): + return [], {"match": npz.name[: -len(".npz")], "turnovers": []} monkeypatch.setattr(tournament, "run_match", fake_run_match) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "CodeGraph", lambda: None) - monkeypatch.setattr(tournament, "_append_to_ledger", lambda *a: None) # needs real fingerprints - monkeypatch.setattr(tournament, "match_key", lambda _g, a, b, **_kw: f"{a}{rig.version[a]}{b}{rig.version[b]}") - monkeypatch.setattr(tournament.match_cache, "MatchCache", lambda: rig.cache) - monkeypatch.setattr(tournament.restart_outcomes, "analyse_match", lambda path: []) - monkeypatch.setattr(tournament.turnover_breakdown, "analyse_match", fake_losses) + monkeypatch.setattr(tournament, "CodeGraph", lambda: _Graph(rig)) + monkeypatch.setattr(tournament, "analyse_replay", fake_analyse) + monkeypatch.setattr(tournament, "_print_ball_losses", lambda *a: None) monkeypatch.setattr(tournament.turnover_breakdown, "breakdown", lambda losses: {}) monkeypatch.setattr(tournament.turnover_breakdown, "report", lambda *a: "") monkeypatch.setattr(tournament.turnover_breakdown, "real_loss_kinds", lambda r: {}) - monkeypatch.setattr(tournament, "_print_ball_losses", lambda *a: None) def run(*flags): rig.played.clear() - monkeypatch.setattr("sys.argv", ["tournament.py", "--sequential", "--reuse", *flags, *_CONFIGS]) + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", *flags, *_CONFIGS]) tournament.main() (summary_path,) = sorted(tmp_path.glob("tournament_*/summary.json"))[-1:] return json.loads(summary_path.read_text()) rig.run = run + rig.store = match_results.open_store(tmp_path) return rig -def test_a_second_run_reuses_every_stored_match_and_reports_the_same_results(rig): - first = rig.run("--spot-check", "0") - second = rig.run("--spot-check", "0") +def test_a_second_run_takes_every_stored_match_and_reports_the_same_results(rig): + first = rig.run() + second = rig.run() assert rig.played == [] - assert second["reuse"] == {"reused": 3, "spot_checked": 0, "played": 0, "mismatches": []} assert all(r["reused"] for r in second["results"]) + assert not any(r["reused"] for r in first["results"]) key = lambda r: (r["config_a"], r["config_b"]) # noqa: E731 strip = lambda rs: sorted(({k: v for k, v in r.items() if k != "reused"} for r in rs), key=key) # noqa: E731 assert strip(second["results"]) == strip(first["results"]) @@ -83,10 +84,10 @@ def test_a_second_run_reuses_every_stored_match_and_reports_the_same_results(rig def test_after_one_config_changes_only_its_matches_play(rig): - rig.run("--spot-check", "0") + rig.run() rig.version["low_block"] += 1 - rig.run("--spot-check", "0") + rig.run() assert sorted(rig.played) == [ ("high_press", "low_block"), @@ -94,43 +95,47 @@ def test_after_one_config_changes_only_its_matches_play(rig): ] -def test_a_spot_check_mismatch_evicts_the_run_s_records_and_fails_strict(rig): - rig.run("--spot-check", "0") - rig.score = _EVERY_PAIR_SCORES_5 # whichever match is spot-checked now disagrees +def test_a_stored_match_keeps_the_restarts_and_losses_its_replay_gave(rig, monkeypatch): + losses = {"match": "x", "turnovers": [{"kind": "pass"}]} + monkeypatch.setattr(tournament, "analyse_replay", lambda npz: ([], losses)) + rig.run() + rig.played.clear() - with pytest.raises(SystemExit, match="differ from their stored records"): - rig.run("--spot-check", "0.34", "--strict") + rig.run() + + assert rig.played == [] + stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] + assert len(stored) == 3 and all(r["losses"] == losses and r["restarts"] == [] for r in stored) - assert len(rig.played) == 1 # one of three replayed as the spot-check - assert list(rig.cache.root.rglob("*.json")) == [] # the mismatch and the two it reused +def test_a_match_is_stored_only_if_its_code_is_unchanged_when_it_finishes(rig): + # Editing tiki_taka during the first match leaves that match's code as it was, so it is stored. + # The two tiki_taka matches finish under changed code, so neither is stored. + def edit(): + rig.version["tiki_taka"] = 9 -def test_a_spot_check_mismatch_is_recorded_in_the_summary(rig): - rig.run("--spot-check", "0") - rig.score = _EVERY_PAIR_SCORES_5 + rig.on_play = edit - summary = rig.run("--spot-check", "0.34") + rig.run() - (pair,) = rig.played - assert summary["reuse"]["mismatches"] == [tournament._tag(pair)] + stored = [json.loads(p.read_text()) for p in rig.store.root.rglob("*.json")] + assert [(r["a"], r["b"]) for r in stored] == [("high_press", "low_block")] -def test_a_match_is_stored_only_if_its_key_is_unchanged_when_it_finishes(rig): - # Matches are stored as they finish, so a crash keeps them. Editing tiki_taka during the first - # match (high_press vs low_block, sorted pairs played in order) leaves that match's key as it - # was: it is stored. Both tiki_taka matches finish under a changed key: neither is. - def edit(): - rig.version["tiki_taka"] = 9 +def test_a_no_save_run_plays_and_stores_nothing(rig, monkeypatch): + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--no-save", *_CONFIGS]) + tournament.main() - rig.on_play = edit + assert len(rig.played) == 3 + assert not list(rig.store.root.rglob("*.json")) - rig.run("--spot-check", "0") - stored = [json.loads(p.read_text())["result"] for p in rig.cache.root.rglob("*.json")] - assert [(r["config_a"], r["config_b"]) for r in stored] == [("high_press", "low_block")] +def test_a_run_with_other_match_seconds_plays_every_match_again(rig, monkeypatch): + rig.run() + rig.played.clear() + monkeypatch.setattr("sys.argv", ["round_robin.py", "--sequential", "--match-seconds", "300", *_CONFIGS]) + tournament.main() -def test_reuse_with_no_save_is_refused(monkeypatch): - monkeypatch.setattr("sys.argv", ["tournament.py", "--reuse", "--no-save", *_CONFIGS]) - with pytest.raises(SystemExit, match="--reuse"): - tournament.main() + assert len(rig.played) == 3 + assert len(list(rig.store.root.iterdir())) == 2 # one environment per match length diff --git a/utama_core/tests/engine/test_tournament_vs_champion.py b/utama_core/tests/engine/test_tournament_vs_champion.py index 7f3bceb4..05c5eab3 100644 --- a/utama_core/tests/engine/test_tournament_vs_champion.py +++ b/utama_core/tests/engine/test_tournament_vs_champion.py @@ -5,12 +5,29 @@ from __future__ import annotations +import json + import pytest from tools.evaluation import round_robin as tournament from tools.evaluation.sim_settings import sim_noise_from_spec +class _Graph: + """Stands in for CodeGraph: the config names here are not strategies.""" + + def base_fingerprint(self, entries): + return "base" + + def strategy_fingerprint(self, name): + return f"fp-{name}" + + +@pytest.fixture(autouse=True) +def _no_real_fingerprints(monkeypatch): + monkeypatch.setattr(tournament, "CodeGraph", _Graph) + + def _stub_result(config_a_name, config_b_name, **_kwargs): return tournament.MatchResult(config_a=config_a_name, config_b=config_b_name, score_a=1, score_b=0, stats=None) @@ -41,17 +58,13 @@ def test_vs_champion_pairs_refuses_a_missing_champion_or_first_opponent(): def test_vs_champion_plays_active_strategies_against_champion_with_reference_seed_one(tmp_path, monkeypatch, capsys): - calls, ledger_calls = [], [] + calls = [] def _fake_run_match(config_a_name, config_b_name, **kwargs): calls.append((config_a_name, config_b_name, kwargs.get("sim_noise"))) return _stub_result(config_a_name, config_b_name) - def _fake_append(results, run_id, match_seconds, control_scheme, fuzz_seed, sim_noise_dict): - ledger_calls.append((fuzz_seed, sim_noise_dict)) - monkeypatch.setattr(tournament, "run_match", _fake_run_match) - monkeypatch.setattr(tournament, "_append_to_ledger", _fake_append) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "b", "c", "champ"]) monkeypatch.setattr(tournament, "RETIRED", {"c"}) @@ -63,10 +76,9 @@ def _fake_append(results, run_id, match_seconds, control_scheme, fuzz_seed, sim_ seeded = sim_noise_from_spec("reference:2") assert calls == [("a", "champ", seeded), ("b", "champ", seeded), ("champ", "a", seeded)] assert "reference:2" in capsys.readouterr().out - # Same conditions as evaluate.py's round-2 champion fixtures, so `_append_to_ledger` keeps these matches. - ((fuzz_seed, sim_noise_dict),) = ledger_calls - assert fuzz_seed is None - assert sim_noise_dict["seed"] == 2 + # Same conditions as evaluate.py's round-2 champion fixtures, so the store keeps these matches as those fixtures. + stored = [json.loads(p.read_text()) for p in (tmp_path / "match_results").rglob("*.json")] + assert len(stored) == 3 and {r["seed"] for r in stored} == {2} # Output still lands in replays/tournament_, which downstream tools read. assert list(tmp_path.glob("tournament_*/summary.json")) @@ -80,7 +92,6 @@ def _fake_run_match(config_a_name, config_b_name, **kwargs): monkeypatch.setattr(tournament, "run_match", _fake_run_match) monkeypatch.setattr(tournament, "REPLAY_BASE_PATH", tmp_path) - monkeypatch.setattr(tournament, "_append_to_ledger", lambda *_a, **_k: None) monkeypatch.setattr(tournament, "_CONFIG_NAMES", ["a", "champ"]) monkeypatch.setattr(tournament, "RETIRED", set()) monkeypatch.setattr(tournament, "load_opponents", lambda *_a, **_k: {"champion": "champ", "opponents": ["a"]}) diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index 2691c432..a23fbc28 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -12,12 +12,8 @@ import pytest from utama_core.replay import fingerprint as fp -from utama_core.replay.fingerprint import ( - REPO_ROOT, - ROUND_ROBIN_ENTRY, - CodeGraph, - match_key, -) +from utama_core.replay import match_results +from utama_core.replay.fingerprint import REPO_ROOT, ROUND_ROBIN_ENTRY, CodeGraph from utama_core.strategy import catalog PICKERS = """\ @@ -167,13 +163,46 @@ def test_a_tactic_no_strategy_imports_changes_nothing(repo): assert _changed_after(repo, "utama_core/tactics/orphan.py", "pass", "x = 1") == set() -def test_editing_shared_infrastructure_changes_the_base_and_every_match_key(repo): +def _fixture( + g, + a, + b, + *, + duration=65.0, + control_scheme="fpp", + fuzz_seed=None, + fuzz_interval_s=(25.0, 45.0), + sim_noise=None, + a_is_right=True, + a_kicks_off=True, +): + """The fixture id `match_results` gives a match of `a` (config_a) against `b`.""" + env = match_results.environment( + g, + duration_seconds=duration, + sim_noise=sim_noise, + control_scheme=control_scheme, + fuzz_seed=fuzz_seed, + fuzz_interval_s=fuzz_interval_s, + ) + seed = sim_noise.get("seed") if sim_noise else None + return match_results.fixture_id( + env, + g.strategy_fingerprint(a)[:16], + g.strategy_fingerprint(b)[:16], + seed, + a_is_right=a_is_right, + a_kicks_off=a_kicks_off, + ) + + +def test_editing_shared_infrastructure_changes_the_base_and_every_fixture(repo): g = CodeGraph(repo) - keys = {(a, b): match_key(g, a, b, duration_seconds=65.0) for a in CONFIGS for b in CONFIGS if a < b} + fixtures = {(a, b): _fixture(g, a, b) for a in CONFIGS for b in CONFIGS if a < b} changed = _changed_after(repo, "utama_core/planning/planner.py", "return 1", "return 2") assert changed == {"base"} g = CodeGraph(repo) - assert all(match_key(g, a, b, duration_seconds=65.0) != k for (a, b), k in keys.items()) + assert all(_fixture(g, a, b) != k for (a, b), k in fixtures.items()) def _runner_also_imports(repo: Path, module: str) -> None: @@ -244,27 +273,26 @@ def test_a_relative_import_resolves(repo): assert "utama_core.planning.planner" in g.closure(["utama_core.run.runner"]) -def test_match_key_covers_every_setting(repo): +def test_the_fixture_covers_every_setting(repo): g = CodeGraph(repo) a, b = CONFIGS[:2] - ref = match_key(g, a, b, duration_seconds=65.0) + ref = _fixture(g, a, b) variants = [ - match_key(g, b, a, duration_seconds=65.0), - match_key(g, a, b, duration_seconds=20.0), - match_key(g, a, b, duration_seconds=65.0, a_is_right=False), - match_key(g, a, b, duration_seconds=65.0, a_kicks_off=False), - match_key(g, a, b, duration_seconds=65.0, control_scheme="dwa"), - match_key(g, a, b, duration_seconds=65.0, fuzz_seed=1), - match_key(g, a, b, duration_seconds=65.0, recorded=False), - match_key(g, a, b, duration_seconds=65.0, sim_noise={"seed": 1}), - match_key(g, a, b, duration_seconds=65.0, sim_noise={"seed": 2}), + _fixture(g, b, a), + _fixture(g, a, b, duration=20.0), + _fixture(g, a, b, a_is_right=False), + _fixture(g, a, b, a_kicks_off=False), + _fixture(g, a, b, control_scheme="dwa"), + _fixture(g, a, b, fuzz_seed=1), + _fixture(g, a, b, sim_noise={"seed": 1}), + _fixture(g, a, b, sim_noise={"seed": 2}), ] assert len({ref, *variants}) == 1 + len(variants) # the fuzz interval only matters when fuzzing is on - assert match_key(g, a, b, duration_seconds=65.0, fuzz_interval_s=(1.0, 2.0)) == ref - assert match_key(g, a, b, duration_seconds=65.0, fuzz_seed=1, fuzz_interval_s=(1.0, 2.0)) != variants[5] - # matches without sim noise keep the keys they had before the setting existed - assert match_key(g, a, b, duration_seconds=65.0, sim_noise=None) == ref + assert _fixture(g, a, b, fuzz_interval_s=(1.0, 2.0)) == ref + assert _fixture(g, a, b, fuzz_seed=1, fuzz_interval_s=(1.0, 2.0)) != variants[5] + # the noise seed is per match, the rest of the noise per environment + assert _fixture(g, a, b, sim_noise={"seed": 1, "kick_speed_sd": 0.2}) != variants[6] def test_numerics_env_vars_change_the_base(repo, monkeypatch): diff --git a/utama_core/tests/replay/test_match_cache.py b/utama_core/tests/replay/test_match_cache.py deleted file mode 100644 index 14a5b01d..00000000 --- a/utama_core/tests/replay/test_match_cache.py +++ /dev/null @@ -1,70 +0,0 @@ -from utama_core.replay.match_cache import MatchCache, differences, spot_check_sample - -_RECORD = { - "result": {"config_a": "a", "config_b": "b", "score_a": 1, "score_b": 0, "stats": {"shots": (3, 1)}}, - "restarts": [{"match": "a_vs_b", "kind": "kickoff"}], - "losses": {"match": "a_vs_b", "turnovers": []}, -} - - -def test_a_stored_record_reads_back_and_matches_the_one_written(tmp_path): - cache = MatchCache(tmp_path) - cache.put("ab12", _RECORD) - - assert differences(cache.get("ab12"), _RECORD) == [] - - -def test_an_unknown_or_evicted_key_has_no_record(tmp_path): - cache = MatchCache(tmp_path) - assert cache.get("ab12") is None - cache.put("ab12", _RECORD) - cache.evict("ab12") - assert cache.get("ab12") is None - - -def test_a_corrupt_record_is_a_miss_not_an_error(tmp_path): - cache = MatchCache(tmp_path) - cache.path("ab12").parent.mkdir(parents=True) - cache.path("ab12").write_text("{not json") - assert cache.get("ab12") is None - - -def test_differences_names_each_part_that_disagrees(): - fresh = {**_RECORD, "result": {**_RECORD["result"], "score_a": 2}, "losses": {"turnovers": [1]}} - assert differences(_RECORD, fresh) == ["result", "losses"] - - -def test_spot_check_sample_takes_the_fraction_and_at_least_one(): - keys = [f"k{i}" for i in range(200)] - assert len(spot_check_sample(keys, 0.05)) == 10 - assert len(spot_check_sample(keys[:3], 0.05)) == 1 - assert spot_check_sample(keys, 0.0) == set() - assert spot_check_sample([], 0.05) == set() - - -def test_spot_check_sample_is_the_same_every_run_and_independent_of_order(): - keys = [f"k{i}" for i in range(50)] - assert spot_check_sample(keys, 0.1) == spot_check_sample(list(reversed(keys)), 0.1) - - -def test_two_processes_storing_the_same_match_use_different_temp_files(tmp_path, monkeypatch): - # Round-robins on different strategy branches share the cache. With one shared temp file, - # one process could rename away the other's half-written file and fail the other's rename. - import os - from pathlib import Path - - temps = [] - real_replace = Path.replace - - def _recording_replace(self, target): - temps.append(self.name) - return real_replace(self, target) - - monkeypatch.setattr(Path, "replace", _recording_replace) - cache = MatchCache(tmp_path) - for pid in (101, 202): - monkeypatch.setattr(os, "getpid", lambda pid=pid: pid) - cache.put("ab" * 32, {"result": {"score_a": 1}}) - assert len(set(temps)) == 2 - assert cache.get("ab" * 32) == {"result": {"score_a": 1}} - assert not list(tmp_path.rglob("*.tmp")) diff --git a/utama_core/tests/replay/test_match_results.py b/utama_core/tests/replay/test_match_results.py new file mode 100644 index 00000000..38ae375a --- /dev/null +++ b/utama_core/tests/replay/test_match_results.py @@ -0,0 +1,158 @@ +"""`replay/match_results.py`: the one store of match results, its fixtures and its records.""" + +from __future__ import annotations + +import json + +from utama_core.replay import match_results as mr +from utama_core.replay.match_results import MatchResults + +_FROZEN_EVENT = { + "kind": "COMMITTED_FROZEN", + "sim_time": 12.5, + "tick": 1250, + "referee_command": "NORMAL_START", + "duration_s": 9.0, + "tactic_ids": ["t1"], + "robot_ids": [1, 2], + "diagnosis": "ball held by enemy 3", +} + + +class _Graph: + """Stands in for CodeGraph: the store asks a graph only for the base fingerprint.""" + + def __init__(self, base="base"): + self.base = base + + def base_fingerprint(self, entries): + return self.base + + +def _result(a="a", b="b", score_a=1, score_b=0, stats=None): + return {"config_a": a, "config_b": b, "score_a": score_a, "score_b": score_b, "stats": stats} + + +def _rec(env="e", a_fp="fa", b_fp="fb", seed=None, a="a", b="b", stats=None, **kw): + losses = {"match": "a_vs_b", "turnovers": []} + return mr.record( + env, a_fp, b_fp, _result(a, b, stats=stats), seed=seed, source="run", restarts=[], losses=losses, **kw + ) + + +def test_a_stored_record_reads_back_as_it_was_written(tmp_path): + store = MatchResults(tmp_path) + rec = _rec(stats={"shots": {"friendly": 3, "enemy": 1}, "stall_events": [], "possession_pct": (0.5, 0.5)}) + store.put(rec) + + assert store.get("e", rec["fixture"]) == rec + assert rec["shots_a"] == 3 and rec["shots_b"] == 1 + assert rec["losses"] == {"match": "a_vs_b", "turnovers": []} and rec["restarts"] == [] + + +def test_an_unknown_fixture_and_a_corrupt_file_are_misses_not_errors(tmp_path): + store = MatchResults(tmp_path) + assert store.get("e", "ab12") is None + store.path("e", "ab12").parent.mkdir(parents=True) + store.path("e", "ab12").write_text("{not json") + assert store.get("e", "ab12") is None + + +def test_a_fixture_depends_on_environment_players_order_sides_and_seed(): + f = mr.fixture_id + base = f("e", "1", "2", 1) + assert f("e", "1", "2", 2) != base # the noise seed + assert f("e", "9", "2", 1) != base # config_a's code + assert f("e", "2", "1", 1) != base # who is config_a + assert f("other", "1", "2", 1) != base # the environment + assert f("e", "1", "2", 1, a_is_right=False) != base + assert f("e", "1", "2", 1, a_kicks_off=False) != base + assert f("e", "1", "2", 1) == base + + +def test_the_environment_covers_every_setting_but_the_noise_seed(): + g = _Graph() + noise = {"seed": 1, "latency_s": [0.05, 0.1]} + base = mr.environment(g, duration_seconds=1200.0, sim_noise=noise) + assert mr.environment(g, duration_seconds=1200.0, sim_noise={**noise, "seed": 2}) == base + assert mr.environment(g, duration_seconds=300.0, sim_noise=noise) != base + assert mr.environment(g, duration_seconds=1200.0, sim_noise=None) != base + assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, control_scheme="dwa") != base + assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1) != base + assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1, fuzz_interval_s=(1.0, 2.0)) != ( + mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_seed=1) + ) + # the fuzz interval only matters when fuzzing is on + assert mr.environment(g, duration_seconds=1200.0, sim_noise=noise, fuzz_interval_s=(1.0, 2.0)) == base + # shared code edits move the environment + assert mr.environment(_Graph("edited"), duration_seconds=1200.0, sim_noise=noise) != base + + +def test_load_reads_only_the_environment_asked_for(tmp_path): + store = MatchResults(tmp_path) + mine = _rec(env="e", seed=1) + store.put(mine) + store.put(_rec(env="other", seed=1)) + + assert list(store.load("e")) == [mine["fixture"]] + assert store.load("nowhere") == {} + + +def test_load_names_a_player_by_its_fingerprint(tmp_path): + """A frozen file and the same code in the repo are one player, whichever played the match.""" + store = MatchResults(tmp_path) + store.put(_rec(a="split_shape", a_fp="1", b="other", b_fp="2")) + + loaded = store.load("e", fps={"frozen/split_shape@abc.strategy": "1"}) + (rec,) = loaded.values() + assert (rec["a"], rec["b"]) == ("frozen/split_shape@abc.strategy", "other") + + +def test_a_torn_file_is_skipped_and_the_rest_still_load(tmp_path): + store = MatchResults(tmp_path) + good = _rec(seed=1) + store.put(good) + (tmp_path / "e" / "torn.json").write_text('{"env": "e", "fixt') + + assert list(store.load("e")) == [good["fixture"]] + + +def test_stall_events_are_stored_compactly_with_their_diagnosis(): + rec = _rec(stats={"shots": {}, "stall_events": [_FROZEN_EVENT]}) + assert rec["stalls"] == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5, "diagnosis": "ball held by enemy 3"}] + + +def test_no_stall_events_is_an_empty_list_and_unknown_is_none(): + assert _rec(stats={"stall_events": []})["stalls"] == [] + assert _rec(stats=None)["stalls"] is None # no stats at all: unknown, not "no stalls" + assert _rec(stats={"shots": {}})["stalls"] is None # stats without the stall field: unknown + + +def test_stall_summary_drops_the_detail_a_record_does_not_need(): + rows = mr.stall_summary([{**_FROZEN_EVENT, "diagnosis": ""}]) + assert rows == [{"kind": "COMMITTED_FROZEN", "sim_time": 12.5}] + assert json.loads(json.dumps(rows)) == rows + + +def test_two_processes_storing_the_same_match_use_different_temp_files(tmp_path, monkeypatch): + # Round-robins on different strategy branches share the store. With one shared temp file, + # one process could rename away the other's half-written file and fail the other's rename. + import os + from pathlib import Path + + temps = [] + real_replace = Path.replace + + def _recording_replace(self, target): + temps.append(self.name) + return real_replace(self, target) + + monkeypatch.setattr(Path, "replace", _recording_replace) + store = MatchResults(tmp_path) + rec = _rec(seed=1) + for pid in (101, 202): + monkeypatch.setattr(os, "getpid", lambda pid=pid: pid) + store.put(rec) + assert len(set(temps)) == 2 + assert store.get("e", rec["fixture"]) == rec + assert not list(tmp_path.rglob("*.tmp")) From ea83269471f4fa21c5601f29bec44febe49fec01 Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 13:51:50 +0000 Subject: [PATCH 15/59] tools: one match set-up in sim_setup for every tool match.py, repro_from_replay.py, moments.py, debug_match.py and main.py build their referee and rsim runner through tools/sim_setup.py: sim_referee (kickoff team, seeded restart fuzzing) and sim_runner (the StrategyRunner). main.py keeps its dashboard: the referee is built before it attaches, the runner after. load_side plays a .strategy file with the robots it was built for. The fingerprints of every match change with this, so the next round-robin replays everything once. Co-Authored-By: Claude Opus 5.5 --- docs/strategy_tools_plan.md | 25 +++---- docs/tools.md | 4 +- main.py | 21 +----- tools/evaluation/match.py | 75 ++++++------------- tools/sim_setup.py | 61 +++++++++++---- .../tests/engine/test_tournament_match_end.py | 5 +- utama_core/tests/replay/test_fingerprint.py | 3 +- utama_core/tests/tools/test_sim_setup.py | 17 +++++ 8 files changed, 107 insertions(+), 104 deletions(-) diff --git a/docs/strategy_tools_plan.md b/docs/strategy_tools_plan.md index f8e67509..e9569d09 100644 --- a/docs/strategy_tools_plan.md +++ b/docs/strategy_tools_plan.md @@ -11,10 +11,10 @@ links back here. different ways. A reader cannot tell which one to run first, or which result to believe. - **The docs list scripts, not jobs.** `tools.md` says what each script is. It does not say which question the script answers, so a reader has to work that out. -- **Runner set-up was written five times** (step 5 fixed four of them). Each of these builds its own strategy runner, - referee and dashboard: - `tools/evaluation/match.py`, `tools/debug_match.py`, `tools/repro_from_replay.py`, - `tools/moments.py` and `main.py`. +- **Runner set-up was written five times** (step 5 fixed them all). Each of these built its own strategy runner, + referee and dashboard: `tools/evaluation/match.py`, `tools/debug_match.py`, + `tools/repro_from_replay.py`, `tools/moments.py` and `main.py`. Now they all build their referee and + runner in `tools/sim_setup.py`. Before step 5 only `match.py` loaded `.strategy` files (`utama_core/bundle/`), so the other four could not run a frozen baseline. @@ -68,15 +68,14 @@ played by `pixi run test`. Changes to `tools/moments.py`, done 2026-11-11: the champion against the first reference opponent, under reference noise seed 2 by default. `evaluate.py` puts the side under test second in even rounds, so each (strategy, champion) match is its round-2 fixture (not with `--frozen`, whose opponents are packed files). -5. **One shared match and runner construction** for the other tools. Done as `tools/sim_setup.py` - (`load_side`: a catalog name, a `.strategy` file or `PATH.py:FUNCTION`; `sim_runner`: the referee and - rsim runner), used by `repro_from_replay.py`, `moments.py` and `debug_match.py`; `main.py` loads its - strategies through it but keeps its own runner for the dashboard. So all four play `.strategy` files. - `match.py` is unchanged, and moves onto `sim_setup` with the next change that replays every match - anyway: editing `match.py`, or anything it imports, changes the - fingerprint of every stored match, so every match replays and the store is invalidated - (`utama_core/replay/fingerprint.py`). If it must change, batch it with other changes to shared - code and say so in the commit. +5. **One shared match and runner construction** for every tool. `tools/sim_setup.py` has `load_side` (a + catalog name, a `.strategy` file or `PATH.py:FUNCTION`), `sim_referee` (the referee, its kickoff team and + seeded restart fuzzing) and `sim_runner` (the rsim `StrategyRunner`). `repro_from_replay.py`, `moments.py`, + `debug_match.py`, `main.py` and `tools/evaluation/match.py` all build through them, so every tool plays + `.strategy` files and the referee and runner exist in one place. `main.py` keeps its dashboard: the + referee is built before the dashboard attaches, the runner after. `match.py`'s fingerprint changed with + this (its set-up is now in `sim_setup.py`), so every stored match replays once. The match results store + (`replay/match_results.py`) changed the same fingerprints, so one replay covers both. 6. **The screen.** The screen was built and dropped on 2026-11-12: any code change made the paired starts diverge within 0.1 s, and goals in 20 s starts were too rare to say "skip", so it could not save evaluations. `evaluate.py` stays the only gate. 7. **Triage takes the foul listing.** Done: `triage.py --fouls`; `moments.py` lost `fouls` and `new`, and `--against` no longer uses a dated folder. diff --git a/docs/tools.md b/docs/tools.md index c38e6596..e5d4d3a6 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -50,10 +50,10 @@ says why the tools are split this way. |---|---| | `tools/evaluation/round_robin.py` | The whole-catalog health and stall check: every config not in `RETIRED` (12 of the 22 today) against every other, one full match per pair (two halves of 300 s of playing time); writes `replays/tournament_/` with `summary.json`, and adds its matches to the match results store. `--pair A B` plays one match; `--vs-champion` plays each strategy once against the champion (plus the champion against the first reference opponent), defaulting to `--sim-noise reference:2` so those matches are `evaluate.py`'s round-2 fixtures, the day-to-day health check; A match the store already holds (`replays/match_results/`, `replay/match_results.py`) is taken from it, not played: automatic, with no flag, so only matches whose code changed play. To play every match again, delete the store. `--sim-noise JSON` (inline or a file, or `reference` / `reference:` for the reference world and robots) plays every match with the same seeded latency, kick speed and direction noise, ball friction, motion limits and vision noise (`SimNoise`, `docs/STRATEGY_DEVELOPMENT.md`). A single strategy is judged with `evaluate.py`, not by its place here | | `tools/evaluation/evaluate.py` | One or more candidates against the champion of a fixed set of reference opponents (`tools/evaluation/reference/opponents.json`; `--opponents PATH` takes another file), in rounds under seeded sim noise, until its paired results against the champion say better (P >= 0.99), worse (P <= 0.2) or undecided after 6 rounds; `--held-out` plays the reference's held-out opponents before promoting. Results go to the match results store `replays/match_results/` (round-robins add theirs too), reports to `replays/eval/reports/`; no replays kept. Stalls are reported after each verdict with how many matches were checked (the watchdog sees config_a only; a match whose stats were not collected counts as unchecked); they never change a verdict. The way to judge a strategy (`docs/STRATEGY_DEVELOPMENT.md`, "Evaluating a strategy"). `--explain` (off by default) also writes pictures and a `summary.json` of each candidate against the champion to `replays/eval/explain/` (`tools/evaluation/explain.py`); they explain the verdict, never change it | -| `tools/sim_setup.py` | Not a script: the one way the debugging tools (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`) load a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and set up an rsim match. `match.py` still builds its own, to keep cached matches valid | +| `tools/sim_setup.py` | Not a script: the one way every tool loads a strategy (a catalog name, a `.strategy` file, or `PATH.py:FUNCTION` from a scratch file) and sets up an rsim match: `sim_referee` (the referee, with the kickoff team and seeded restart fuzzing) and `sim_runner` (the `StrategyRunner`). `match.py`, `repro_from_replay.py`, `moments.py`, `debug_match.py` and `main.py` all build their referee and runner here, and nothing else does | | `tools/build_strategy.py` | `build_strategy.py NAME OUT.strategy [--ref COMMIT]`: pack one strategy and the code it runs on into a file that plays in its own process (`utama_core/bundle/`). `evaluate.py --frozen` builds its own | | `tools/evaluation/explain.py` | `explain.py RUN_DIR CANDIDATE CHAMPION --out DIR`: positions (with and without the ball), shots for and against, and fouls by rule, for two strategies from the matches in a run dir (a round-robin's or an `evaluate.py` run's), plus `summary.json` with the numbers behind them; goals stay the verdict. Used by `evaluate.py --explain` | -| `tools/evaluation/match.py` | Match construction shared by the two above (not run directly) | +| `tools/evaluation/match.py` | Plays one match (`run_match`: the step loop to full time, the score and the stats) for the two above, with the set-up from `tools/sim_setup.py` (not run directly) | | `tools/evaluation/sim_settings.py` | Not a script: loads the reference opponents and the simulated world and robots (`tools/evaluation/reference/opponents.json`, `world.json`, `robots.json`) for `evaluate.py` and `round_robin.py --sim-noise reference[:seed]`. Kept in `reference/` so a new champion does not rerun every cached match | | `dashboard_server.py` | Standalone browser dashboard at http://localhost:8080: replays and tournament results | diff --git a/main.py b/main.py index 3154661e..d53b3e48 100644 --- a/main.py +++ b/main.py @@ -13,14 +13,11 @@ import argparse -from tools.sim_setup import N_ROBOTS, UnknownStrategy, load_side -from utama_core.custom_referee import CustomReferee +from tools.sim_setup import UnknownStrategy, load_side, sim_referee, sim_runner from utama_core.custom_referee.profiles.profile_loader import load_profile from utama_core.dashboard import attach_dashboard from utama_core.dashboard.views import referee as referee_view from utama_core.engine.abstract_strategy import AbstractStrategy -from utama_core.entities.referee.referee_command import RefereeCommand -from utama_core.run import StrategyRunner def _strategy(name: str) -> AbstractStrategy: @@ -39,23 +36,11 @@ def main() -> None: yellow, blue = _strategy(args.yellow), _strategy(args.blue) # fail on a bad name before the dashboard starts profile = load_profile("simulation") - referee = CustomReferee(profile, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) + referee = sim_referee() server = attach_dashboard() referee_view.attach(server, referee, profile) - runner = StrategyRunner( - strategy=yellow, - opp_strategy=blue, - my_team_is_yellow=True, - my_team_is_right=True, - mode="rsim", - exp_friendly=N_ROBOTS, - exp_enemy=N_ROBOTS, - exp_ball=True, - referee=referee, - referee_initial_command=RefereeCommand.PREPARE_KICKOFF_YELLOW, - show_live_status=True, - ) + runner, _ = sim_runner(yellow, blue, referee=referee, show_live_status=True) runner.run() diff --git a/tools/evaluation/match.py b/tools/evaluation/match.py index dd5c5969..a54f09ab 100644 --- a/tools/evaluation/match.py +++ b/tools/evaluation/match.py @@ -13,22 +13,24 @@ the other and could easily have been missed. This module is the single place that logic lives now; each script above is a thin CLI over it, differing only in which strategies it selects, what duration it uses, and whether it sweeps -side/kickoff as independent axes. +side/kickoff as independent axes. The strategies, referee and rsim runner of a +match come from `tools/sim_setup.py`, the one set-up the debugging tools share. """ from __future__ import annotations -import dataclasses -import os from dataclasses import dataclass, field from pathlib import Path from typing import Optional +from tools.sim_setup import ( # noqa: F401 -- re-exported + N_OUTFIELD, + OUTFIELD_ROBOT_IDS, + load_side, + sim_referee, + sim_runner, +) from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy -from utama_core.custom_referee import CustomReferee -from utama_core.custom_referee.profiles.profile_loader import load_profile -from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee -from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.entities.referee.stage import Stage from utama_core.replay.columnar_writer import ColumnarReplayWriterConfig @@ -36,12 +38,9 @@ enable_sim_reuse, ) from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise -from utama_core.run import StrategyRunner from utama_core.strategy import catalog from utama_core.strategy.catalog import plain_name -N_OUTFIELD = 5 # + 1 goalkeeper per side -OUTFIELD_ROBOT_IDS = tuple(range(1, N_OUTFIELD + 1)) TICKS_PER_SECOND = 60 # matches rsim's default step rate # default is excluded from the auto-discovered catalog: @@ -59,13 +58,6 @@ def _short_name(config_name: str) -> str: return plain_name(config_name) -def _load_strategy(config_name: str) -> AbstractStrategy: - """A strategy by name, or a `.strategy` file by path.""" - if config_name.endswith(SUFFIX): - return BundledStrategy(config_name) - return AbstractStrategy(build=catalog.builder(config_name, OUTFIELD_ROBOT_IDS)) - - def _stats_to_dict(stats) -> dict: """`MatchStats.__dict__`, but with `stall_events` (a list of `StallEvent` dataclasses) turned into plain dicts so the result round-trips through @@ -172,9 +164,8 @@ def run_match( `tools/motion_planning_benchmark.py` for that). `fuzz_seed`, if set, swaps in `RestartFuzzingReferee` (see - `utama_core/custom_referee/restart_fuzzer.py`) instead of plain - `CustomReferee`, so this match's referee injects extra seeded-random - legal restarts during live play. + `utama_core/custom_referee/restart_fuzzer.py`), so this match's referee, built by + `sim_setup.sim_referee`, injects extra seeded-random legal restarts during live play. `sim_noise`, if set, plays the match with seeded latency, kick speed noise and vision noise (`utama_core/rsoccer_simulator/src/Utils/sim_noise.py`, `docs/sim_realism.md`). The draws @@ -183,26 +174,12 @@ def run_match( """ enable_sim_reuse() - strategy_a = _load_strategy(config_a_name) - strategy_b = _load_strategy(config_b_name) - - # "simulation" profile's kickoff_team defaults to "yellow"; override it to - # "blue" when B kicks off. Neither CustomReferee.from_profile_name nor - # RestartFuzzingReferee.from_profile_name takes a kickoff_team override, - # so build the profile by hand, then construct the referee from it directly. - profile = load_profile("simulation") - if not a_kicks_off: - profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, kickoff_team="blue")) - if fuzz_seed is not None: - referee = RestartFuzzingReferee( - profile, - seed=fuzz_seed, - interval_s=fuzz_interval_s, - n_robots_yellow=N_OUTFIELD + 1, - n_robots_blue=N_OUTFIELD + 1, - ) - else: - referee = CustomReferee(profile, n_robots_yellow=N_OUTFIELD + 1, n_robots_blue=N_OUTFIELD + 1) + strategy_a = load_side(config_a_name) + strategy_b = load_side(config_b_name) + # config_a kicks off unless told otherwise; the referee's kickoff team and the ceremony follow it. + referee = sim_referee( + kickoff_team="yellow" if a_kicks_off else "blue", fuzz_seed=fuzz_seed, fuzz_interval_s=fuzz_interval_s + ) initial_command = RefereeCommand.PREPARE_KICKOFF_YELLOW if a_kicks_off else RefereeCommand.PREPARE_KICKOFF_BLUE match_tag = f"{_short_name(config_a_name)}_vs_{_short_name(config_b_name)}{match_tag_suffix}" @@ -229,20 +206,14 @@ def run_match( resolved_scheme = None if control_scheme in (None, "auto") else control_scheme - runner = StrategyRunner( - strategy=strategy_a, - opp_strategy=strategy_b, - my_team_is_yellow=True, - my_team_is_right=a_is_right, - mode="rsim", - exp_friendly=N_OUTFIELD + 1, - exp_enemy=N_OUTFIELD + 1, - exp_ball=True, + runner, _ = sim_runner( + strategy_a, + strategy_b, + sim_noise=sim_noise, + initial_command=initial_command, referee=referee, - enable_vision_stream=False, - referee_initial_command=initial_command, + my_team_is_right=a_is_right, control_scheme=resolved_scheme, - sim_noise=sim_noise, **extra_kwargs, ) diff --git a/tools/sim_setup.py b/tools/sim_setup.py index ac7f30f1..a8226cab 100644 --- a/tools/sim_setup.py +++ b/tools/sim_setup.py @@ -1,32 +1,38 @@ -"""One way to load a strategy and set up a simulated match, for the tools that play from a position or -for a while (`repro_from_replay.py`, `moments.py`, `debug_match.py`, `main.py`). +"""The one way to load a strategy and to set up a simulated match. Every tool that plays one uses these: +`tools/evaluation/match.py` (round-robin, `evaluate.py`), `repro_from_replay.py`, `moments.py`, +`debug_match.py` and `main.py`. - `load_side(name)`: a strategy by catalog name, a `.strategy` file by path, or `PATH.py:FUNCTION` (a `build(outfield_robot_ids, motion_controller)` in a scratch file, to try a tactic without a repo change). -- `sim_runner(strategy, opponent, ...)`: the referee and the `StrategyRunner` for a 6-a-side rsim match, - our side yellow on the right, vision stream off. +- `sim_referee(...)`: the referee of an rsim match: the "simulation" profile, with the kickoff team and, + for a seeded run, the restart fuzzing (`custom_referee/restart_fuzzer.py`). +- `sim_runner(strategy, opponent, ...)`: the `StrategyRunner` for a 6-a-side rsim match against a referee + (`sim_referee()` by default), our side yellow on the right, vision stream off. -`tools/evaluation/match.py` still builds its own runner: it is part of every cached match's fingerprint -(`utama_core/replay/fingerprint.py`), so changing it replays every cached match and starts the -evaluation ledger afresh. Move it onto these helpers together with the next change that forces that anyway. +Nothing else constructs the referee or the rsim runner of a match. Changing this module changes the +fingerprint of every match (`utama_core/replay/fingerprint.py`), so a round-robin plays them all again. """ from __future__ import annotations +import dataclasses import importlib.util from functools import partial from pathlib import Path from typing import Callable, Optional -from tools.evaluation.match import N_OUTFIELD, OUTFIELD_ROBOT_IDS from utama_core.bundle.strategy_file import SUFFIX, BundledStrategy from utama_core.custom_referee import CustomReferee +from utama_core.custom_referee.profiles.profile_loader import load_profile +from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee from utama_core.engine.abstract_strategy import AbstractStrategy from utama_core.entities.referee.referee_command import RefereeCommand from utama_core.rsoccer_simulator.src.Utils.sim_noise import SimNoise from utama_core.run import StrategyRunner from utama_core.strategy import catalog +N_OUTFIELD = 5 # + 1 goalkeeper per side +OUTFIELD_ROBOT_IDS = tuple(range(1, N_OUTFIELD + 1)) N_ROBOTS = N_OUTFIELD + 1 # per side, the goalkeeper included @@ -59,13 +65,33 @@ def factory_for(name: str) -> Callable: return lambda outfield_robot_ids: partial(factory, outfield_robot_ids) -def load_side(name: str, outfield_robot_ids: tuple[int, ...] = OUTFIELD_ROBOT_IDS) -> AbstractStrategy: - """A strategy to play: a `.strategy` file by path, `PATH.py:FUNCTION`, or a catalog name.""" +def load_side(name: str, outfield_robot_ids: Optional[tuple[int, ...]] = None) -> AbstractStrategy: + """A strategy to play: a `.strategy` file by path, `PATH.py:FUNCTION`, or a catalog name. The robots + are the outfield ones unless given; a `.strategy` file plays the robots it was built for unless given.""" if name.endswith(SUFFIX): if not Path(name).is_file(): raise UnknownStrategy(f"{name}: no such strategy file") return BundledStrategy(name, outfield_robot_ids) - return AbstractStrategy(build=factory_for(name)(outfield_robot_ids)) + return AbstractStrategy(build=factory_for(name)(outfield_robot_ids or OUTFIELD_ROBOT_IDS)) + + +def sim_referee( + *, + kickoff_team: str = "yellow", + fuzz_seed: Optional[int] = None, + fuzz_interval_s: tuple[float, float] = (25.0, 45.0), +) -> CustomReferee: + """The referee of an rsim match: the "simulation" profile, `kickoff_team` taking the first kickoff. + With `fuzz_seed`, a `RestartFuzzingReferee` injecting seeded extra legal restarts `fuzz_interval_s` + apart.""" + profile = load_profile("simulation") + if kickoff_team != profile.game.kickoff_team: + profile = dataclasses.replace(profile, game=dataclasses.replace(profile.game, kickoff_team=kickoff_team)) + if fuzz_seed is not None: + return RestartFuzzingReferee( + profile, seed=fuzz_seed, interval_s=fuzz_interval_s, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS + ) + return CustomReferee(profile, n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) def sim_runner( @@ -74,19 +100,22 @@ def sim_runner( *, sim_noise: Optional[SimNoise] = None, initial_command: Optional[RefereeCommand] = RefereeCommand.PREPARE_KICKOFF_YELLOW, + referee: Optional[CustomReferee] = None, + my_team_is_right: bool = True, **runner_kwargs, ) -> tuple[StrategyRunner, CustomReferee]: - """The referee ("simulation" profile) and a `StrategyRunner` for `strategy` (yellow, on the right) - against `opponent` in rsim. `initial_command=None` keeps the runner's own default. Other keyword - arguments go to `StrategyRunner` (`match_log_path`, `stats_path`, `control_scheme`, ...).""" - referee = CustomReferee.from_profile_name("simulation", n_robots_yellow=N_ROBOTS, n_robots_blue=N_ROBOTS) + """A `StrategyRunner` for `strategy` (yellow) against `opponent` in rsim, refereed by `referee` (default + `sim_referee()`). `initial_command=None` keeps the runner's own default. Other keyword arguments go to + `StrategyRunner` (`match_log_path`, `stats_path`, `control_scheme`, `show_live_status`, ...).""" + if referee is None: + referee = sim_referee() if initial_command is not None: runner_kwargs["referee_initial_command"] = initial_command runner = StrategyRunner( strategy=strategy, opp_strategy=opponent, my_team_is_yellow=True, - my_team_is_right=True, + my_team_is_right=my_team_is_right, mode="rsim", exp_friendly=N_ROBOTS, exp_enemy=N_ROBOTS, diff --git a/utama_core/tests/engine/test_tournament_match_end.py b/utama_core/tests/engine/test_tournament_match_end.py index 1dac918d..18759f4c 100644 --- a/utama_core/tests/engine/test_tournament_match_end.py +++ b/utama_core/tests/engine/test_tournament_match_end.py @@ -5,6 +5,7 @@ from types import SimpleNamespace +from tools import sim_setup from tools.evaluation import match from utama_core.entities.referee.stage import Stage @@ -34,7 +35,7 @@ def close(self): def test_a_match_ends_at_full_time_not_at_the_sim_time_cap(monkeypatch): - monkeypatch.setattr(match, "StrategyRunner", _FakeRunner) + monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) result = match.run_match("tiki_taka", "low_block", duration_seconds=1200.0) @@ -44,7 +45,7 @@ def test_a_match_ends_at_full_time_not_at_the_sim_time_cap(monkeypatch): def test_the_cap_still_ends_a_match_that_never_reaches_full_time(monkeypatch): monkeypatch.setattr(_FakeRunner, "full_time_ticks", 10**9) - monkeypatch.setattr(match, "StrategyRunner", _FakeRunner) + monkeypatch.setattr(sim_setup, "StrategyRunner", _FakeRunner) match.run_match("tiki_taka", "low_block", duration_seconds=1.0) diff --git a/utama_core/tests/replay/test_fingerprint.py b/utama_core/tests/replay/test_fingerprint.py index a23fbc28..790f5324 100644 --- a/utama_core/tests/replay/test_fingerprint.py +++ b/utama_core/tests/replay/test_fingerprint.py @@ -356,7 +356,8 @@ def test_all_code_taken_out_of_the_base_is_in_every_players_fingerprint(graph): # Every place the match process calls into `PLAYER_SIDE`. A new one fails this test: is it behind # the boundary (then a `.strategy` file must do it in its own process), or `RUNNER_SIDE`? _RUNNER_REACHES_INTO_PLAYER_SIDE = { - "tools.evaluation.match": {"utama_core.engine", "utama_core.strategy"}, # builds the code-named ones + "tools.evaluation.match": {"utama_core.strategy"}, # the catalog's names + "tools.sim_setup": {"utama_core.engine", "utama_core.strategy"}, # builds the code-named ones (load_side) "utama_core.bundle.strategy_file": {"utama_core.engine"}, "utama_core.run.side_runtime": {"utama_core.engine", "utama_core.motion_planning"}, "utama_core.run.strategy_runner": { diff --git a/utama_core/tests/tools/test_sim_setup.py b/utama_core/tests/tools/test_sim_setup.py index 3110a8ae..e5bbd02c 100644 --- a/utama_core/tests/tools/test_sim_setup.py +++ b/utama_core/tests/tools/test_sim_setup.py @@ -61,3 +61,20 @@ def test_sim_runner_plays_us_yellow_on_the_right_with_six_a_side(): assert runner.referee is referee finally: runner.close() + + +def test_sim_referee_gives_the_first_kickoff_to_the_team_asked(monkeypatch): + profiles = [] + monkeypatch.setattr(sim_setup, "CustomReferee", lambda profile, **_kw: profiles.append(profile) or object()) + + sim_setup.sim_referee(kickoff_team="blue") + sim_setup.sim_referee() + + assert [p.game.kickoff_team for p in profiles] == ["blue", "yellow"] + + +def test_sim_referee_injects_restarts_only_for_a_seeded_run(): + from utama_core.custom_referee.restart_fuzzer import RestartFuzzingReferee + + assert isinstance(sim_setup.sim_referee(fuzz_seed=3), RestartFuzzingReferee) + assert not isinstance(sim_setup.sim_referee(), RestartFuzzingReferee) From c44a34ee2ca44f43449d4731798134264680c1db Mon Sep 17 00:00:00 2001 From: isaac0804 Date: Thu, 12 Nov 2026 13:57:15 +0000 Subject: [PATCH 16/59] tools: rename triage to find_bugs, goal ledger to goal sources tools/triage.py is tools/find_bugs.py (all flags kept; default output RUN_DIR/find_bugs/). utama_core/analysis/goal_ledger.py is goal_sources.py (python -m utama_core.analysis.goal_sources); its output is goal_sources.json. Tests, dashboard, docs, the glossary and the match data flow picture follow. Historical notes keep the old names. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 6 +- README.md | 2 +- docs/STRATEGY_DEVELOPMENT.md | 12 ++-- docs/img/architecture/make_match_data_flow.py | 4 +- docs/img/architecture/match_data_flow.png | Bin 143524 -> 143939 bytes docs/roadmap.md | 2 +- docs/signals.md | 8 +-- docs/strategy_tools_plan.md | 8 +-- docs/tools.md | 8 +-- docs/visual_guide.md | 4 +- tools/evaluation/explain.py | 6 +- tools/{triage.py => find_bugs.py} | 18 +++--- tools/moments.py | 2 +- utama_core/analysis/findings.py | 2 +- utama_core/analysis/fouls.py | 2 +- .../{goal_ledger.py => goal_sources.py} | 8 +-- utama_core/analysis/matches.py | 2 +- utama_core/dashboard/static/timeline.js | 4 +- utama_core/dashboard/views/replay.py | 8 +-- .../{test_triage.py => test_find_bugs.py} | 52 +++++++++--------- utama_core/tests/analysis/test_fouls.py | 6 +- ...st_goal_ledger.py => test_goal_sources.py} | 2 +- .../engine/test_check_strategy_branch.py | 2 +- utama_core/tests/engine/test_explain.py | 2 +- 24 files changed, 85 insertions(+), 85 deletions(-) rename tools/{triage.py => find_bugs.py} (96%) rename utama_core/analysis/{goal_ledger.py => goal_sources.py} (98%) rename utama_core/tests/analysis/{test_triage.py => test_find_bugs.py} (68%) rename utama_core/tests/analysis/{test_goal_ledger.py => test_goal_sources.py} (99%) diff --git a/AGENTS.md b/AGENTS.md index d3bccc2c..1e3b9e85 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -71,13 +71,13 @@ One term per thing; reuse these instead of coining new ones. dribbler, motors) is assumed good at league level, and real robots' shortfalls are compensated in the control layer. The test: would better robots change it? `tools/evaluation/reference/ world.json`, `robots.json`; field sessions in `tools/field_sessions.json`. -- **Situation / goal ledger** — a situation starts when a restart goes live or a side wins the - ball in open play; the goal ledger (`utama_core/analysis/goal_ledger.py`) gives each goal to +- **Situation / goal sources** — a situation starts when a restart goes live or a side wins the + ball in open play; the goal sources (`utama_core/analysis/goal_sources.py`) gives each goal to the latest situation less than 10 s before it, so goals per match = Σ situations per match × P(goal). Situation types: own / opponent ball won or free kick in each third, own / opponent kickoff or penalty, force start. See `docs/signals.md`. - **Situation rates** — how often each situation type happens per team per live minute, from - real Division B matches or our round-robin (`goal_ledger --rates PATH`). + real Division B matches or our round-robin (`goal_sources --rates PATH`). ## Repo map diff --git a/README.md b/README.md index 3b8e019b..a5a8ff99 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ real robots are optional ([external setup](docs/setup_external.md)). | Task | Start here | |---|---| | Writing or changing a strategy, tactic or skill | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/strategies.md](docs/strategies.md) | -| Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/triage.py RUN_DIR` for a run's worst problems | +| Seeing what the robots did, and why | [docs/visual_guide.md](docs/visual_guide.md); `tools/find_bugs.py RUN_DIR` for a run's worst problems | | Judging whether a strategy is better | [docs/STRATEGY_DEVELOPMENT.md](docs/STRATEGY_DEVELOPMENT.md), [docs/signals.md](docs/signals.md), [docs/signal_report.md](docs/signal_report.md) | | The referee | [docs/custom_referee.md](docs/custom_referee.md) | | Motion planning | [docs/motion_planning_comparison.md](docs/motion_planning_comparison.md) | diff --git a/docs/STRATEGY_DEVELOPMENT.md b/docs/STRATEGY_DEVELOPMENT.md index f389f6c7..26bf2567 100644 --- a/docs/STRATEGY_DEVELOPMENT.md +++ b/docs/STRATEGY_DEVELOPMENT.md @@ -462,9 +462,9 @@ A foul or failure seen in a match is a symptom: the cause may be the robot, the override, the planner, the referee itself, or the check that flagged it. Of the first six found this way (table below), two were the referee or the check, not the robot. -Start with `tools/triage.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind +Start with `tools/find_bugs.py RUN_DIR --strategy NAME`: open its `index.md` for the worst matches, the finding counts by kind and the pictured findings. Filter `findings.jsonl` on the kind you care about, open that finding's picture to see what it -means, and confirm with the numbers in its message (or `replay_trace.py --events`) before concluding anything. Triage reads only the friendly side of +means, and confirm with the numbers in its message (or `replay_trace.py --events`) before concluding anything. `find_bugs.py` reads only the friendly side of each match (the intentions log is written for it): a strategy's matches where it is config_a. In a round-robin each pair plays once, so a strategy gets only the pairs where it comes first in the config order. @@ -472,7 +472,7 @@ The same steps as a flowchart; the moment branch is the optional step 5. ```mermaid flowchart TD - find["1. Find it
triage.py RUN_DIR --strategy NAME
(index.md, then findings.jsonl)"] + find["1. Find it
find_bugs.py RUN_DIR --strategy NAME
(index.md, then findings.jsonl)"] look["2. Look at it
replay_trace.py REPLAY T0 T1 --events
repro_from_replay.py REPLAY --t S --summary IDS"] q{"Restart or placement geometry?
a field state alone decides it"} moment["Capture a moment
moments.py capture REPLAY --t S
play --seeds 0-4 must fail on 4 of 5"] @@ -488,9 +488,9 @@ flowchart TD The picture tools (`match_timeline.py`, `restart_picture.py`, `plan_trace.py`, `pitch_maps.py`) write their flags as JSON with `--findings`: filter on that, open the picture to understand a flag, and never conclude from a picture alone. -1. **Find it.** `tools/triage.py` is the one starting point for "what went wrong in a run" (see the +1. **Find it.** `tools/find_bugs.py` is the one starting point for "what went wrong in a run" (see the start of this section). It flags thrashing and stalls, and restart geometry with `--restarts`. - For our side's fouls by rule, `pixi run python tools/triage.py replays/tournament_ --fouls --by + For our side's fouls by rule, `pixi run python tools/find_bugs.py replays/tournament_ --fouls --by strategy,rule` counts our side's fouls (any of strategy, rule, tactic, restart; `out_of_bounds`, the ball leaving the field, is a stoppage and left out unless `--include-stoppages`); without `--by` it lists each with its time, robot, tactic and the referee command then active @@ -642,4 +642,4 @@ What a converted match holds, and where it differs from a sim replay (the detail filtering (ghost robots, ball jumps), and their referee also sends `GOAL_*` and `INDIRECT_FREE_*`. The corpus above starts in 2022. -The scenario bench (retired 2026-10-17) replayed 10 s starts harvested from replays; to look at one point in a replay use `tools/repro_from_replay.py --t `, and to pin a failure there add a regression moment ("Debugging a foul or failure", above), and `analysis/goal_ledger.py` lists a replay's situations and goals. +The scenario bench (retired 2026-10-17) replayed 10 s starts harvested from replays; to look at one point in a replay use `tools/repro_from_replay.py --t `, and to pin a failure there add a regression moment ("Debugging a foul or failure", above), and `analysis/goal_sources.py` lists a replay's situations and goals. diff --git a/docs/img/architecture/make_match_data_flow.py b/docs/img/architecture/make_match_data_flow.py index 4ad49dd9..26ac28b5 100644 --- a/docs/img/architecture/make_match_data_flow.py +++ b/docs/img/architecture/make_match_data_flow.py @@ -24,7 +24,7 @@ "utama_core/engine/match_stats.py", "utama_core/replay/match_results.py", "utama_core/replay/fingerprint.py", - "utama_core/analysis/goal_ledger.py", + "utama_core/analysis/goal_sources.py", "utama_core/analysis/ratings.py", "utama_core/analysis/chances.py", "utama_core/analysis/turnover_breakdown.py", @@ -89,7 +89,7 @@ d.arrow((40, 73), (100, 62), "round_robin.py", lx=0.0, ly=2.0) # --- readers -------------------------------------------------------------------------------------- -d.box(165, 92, 34, 12, "goal_ledger.py", "goal_ledger.json", kind="output") +d.box(165, 92, 34, 12, "goal_sources.py", "goal_sources.json", kind="output") d.box( 165, 70, diff --git a/docs/img/architecture/match_data_flow.png b/docs/img/architecture/match_data_flow.png index 9c7ef55be69712a51f24110d22a96a11684bc33c..a1a13f1fe3f0ffb72d0bcfe954c01f3d73285b68 100644 GIT binary patch literal 143939 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 GU;QsKVdifD literal 143524 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