| """Independent solvers: read only the input files and the instruction, as an agent would, and must |
| score 1 on every level of every new science family. They show the instruction is enough to get the |
| answer and that the stated tolerances are reachable with ordinary methods.""" |
|
|
| import csv |
| import io |
| import json |
| import math |
| import os |
| import re |
| import statistics |
| import tempfile |
|
|
| import numpy as np |
| import pytest |
| from scipy.signal import lombscargle |
|
|
| os.environ.setdefault("TERMINAL_DESK_APP", tempfile.mkdtemp(prefix="td-solve-")) |
|
|
| from terminal_desk.families import FAMILIES |
| from terminal_desk.models import Tbench2Action |
| from terminal_desk.server.environment import TerminalDeskEnvironment |
|
|
|
|
| def rows(text): |
| return list(csv.DictReader(io.StringIO(text))) |
|
|
|
|
| def solve_units(files, instruction): |
| conv = {} |
| canon = {} |
| for r in rows(files["conversions.txt"]): |
| canon[r["test"]] = r["canonical_unit"] |
| conv[(r["test"], norm_unit(r["other_unit"]))] = float(r["multiply_by"]) |
| latest = {} |
| for r in rows(files["labs.csv"]): |
| unit = norm_unit(r["unit"]) |
| value = float(r["value"]) |
| if unit != norm_unit(canon[r["test"]]): |
| value *= conv[(r["test"], unit)] |
| latest[(r["sample_id"], r["test"])] = value |
| if "qc_notes.txt" in files: |
| m = re.search(r"the (\w+) result for (\w+) was", files["qc_notes.txt"]) |
| latest.pop((m.group(2), m.group(1)), None) |
| out = "sample_id,test,value\n" + "".join(f"{s},{t},{v:.4f}\n" for (s, t), v in latest.items()) |
| return "harmonized.csv", out |
|
|
|
|
| def norm_unit(u): |
| return u.strip().lower().replace("µ", "u").replace("micro", "u").replace(" per ", "/") |
|
|
|
|
| def solve_protein(files, instruction): |
| table = rows(files["expression.csv"]) |
| if "samples.csv" in files: |
| cond = {r["run"]: r["condition"] for r in rows(files["samples.csv"])} |
| else: |
| cond = {c: ("control" if c.startswith("ctrl") else "treated") for c in table[0] if c != "protein"} |
| top_n = int(re.search(r"the (\d+) proteins", instruction).group(1)) |
| out = [] |
| for r in table: |
| c = [float(r[k]) for k, v in cond.items() if v == "control" and r[k] != ""] |
| t = [float(r[k]) for k, v in cond.items() if v == "treated" and r[k] != ""] |
| if len(c) < 2 or len(t) < 2: |
| continue |
| if "Welch" in instruction: |
| lc, lt = np.log2(c), np.log2(t) |
| tstat = (lt.mean() - lc.mean()) / math.sqrt(lc.var(ddof=1) / len(lc) + lt.var(ddof=1) / len(lt)) |
| if abs(tstat) < 4: |
| continue |
| out.append((r["protein"], math.log2(statistics.mean(t) / statistics.mean(c)))) |
| out.sort(key=lambda kv: -abs(kv[1])) |
| return "top_hits.csv", "protein,log2_fc\n" + "".join(f"{p},{v:.4f}\n" for p, v in out[:top_n]) |
|
|
|
|
| def solve_flood(files, instruction): |
| w0, w1 = re.findall(r"\d{4}-\d\d-\d\d", instruction)[:2] |
| thr = {} |
| for r in rows(files["stations.csv"]): |
| if "unit" in r: |
| thr[r["station_id"]] = float(r["flood_stage"]) * (3.28084 if r["unit"] == "m" else 1) |
| else: |
| thr[r["station_id"]] = float(r["flood_stage_ft"]) |
| count = {} |
| for r in rows(files["gauge.csv"]): |
| if r["stage_ft"] == "" or not (w0 <= r["date"] <= w1): |
| continue |
| if float(r["stage_ft"]) >= thr[r["station_id"]]: |
| count[r["station_id"]] = count.get(r["station_id"], 0) + 1 |
| return "flood_results.csv", "station_id,flood_days\n" + "".join(f"{s},{n}\n" for s, n in count.items()) |
|
|
|
|
| def solve_trend(files, instruction): |
| data = rows(files["water_temperature.csv"]) |
| if "month" in data[0]: |
| by_year = {} |
| for r in data: |
| by_year.setdefault(int(r["year"]), []).append(float(r["surface_temp_c"])) |
| pts = sorted((y, sum(v) / 12) for y, v in by_year.items() if len(v) == 12) |
| else: |
| pts = [(int(r["year"]), float(r["surface_temp_c"])) for r in data] |
| x = np.array([p[0] for p in pts], float) |
| y = np.array([p[1] for p in pts]) |
| ols = np.polyfit(x, y, 1)[0] * 10 |
| sen = float(np.median([(y[j] - y[i]) / (x[j] - x[i]) for i in range(len(x)) for j in range(i + 1, len(x))])) * 10 |
| out = {"ols_slope_c_per_decade": ols, "sen_slope_c_per_decade": sen} |
| if "mk_z" in instruction: |
| n = len(y) |
| s = sum(np.sign(y[j] - y[i]) for i in range(n) for j in range(i + 1, n)) |
| sd = math.sqrt(n * (n - 1) * (2 * n + 5) / 18) |
| z = (s - 1) / sd if s > 0 else (s + 1) / sd if s < 0 else 0.0 |
| out.update({"mk_z": z, "significant": "yes" if abs(z) > 1.96 else "no"}) |
| return "trend.json", json.dumps(out) |
|
|
|
|
| def solve_quake(files, instruction): |
| b = rows(files["boundary.csv"]) |
| verts = [(float(r["lat"]), float(r["lon"])) for r in b] |
| best = None |
| for r in rows(files["quakes.csv"]): |
| if "magnitude 5.0" in instruction and float(r["mag"]) < 5.0: |
| continue |
| if "70 km" in instruction and float(r["depth_km"]) > 70: |
| continue |
| lat, lon = float(r["latitude"]), float(r["longitude"]) |
| d = min(hav(lat, lon, a, o) for a, o in verts) |
| if best is None or d > best[1]: |
| best = (r["id"], d) |
| return "answer.json", json.dumps({"id": best[0], "distance_km": best[1]}) |
|
|
|
|
| def hav(la1, lo1, la2, lo2): |
| p1, p2 = math.radians(la1), math.radians(la2) |
| a = math.sin((p2 - p1) / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(math.radians(lo2 - lo1) / 2) ** 2 |
| return 2 * 6371 * math.asin(math.sqrt(a)) |
|
|
|
|
| def solve_period(files, instruction): |
| data = rows(files["tess_lc.csv"]) |
| col = "flux_e_per_s" if "flux_e_per_s" in data[0] else "normalized_flux" |
| t = np.array([float(r["time_mjd"]) for r in data]) |
| f = np.array([float(r[col]) for r in data]) |
| good = np.array([r["quality"] == "0" for r in data]) if "quality 0" in instruction else np.ones(len(t), bool) |
| if "two sectors" in instruction: |
| gap = int(np.argmax(np.diff(t))) + 1 |
| for sl in (slice(0, gap), slice(gap, None)): |
| seg = f[sl].copy() |
| f[sl] = seg / np.median(seg[good[sl]]) |
| t, f = t[good], f[good] |
| freqs = np.linspace(1 / 15, 1 / 0.5, 5000) |
| power = lombscargle(t, f - f.mean(), 2 * np.pi * freqs) |
| return "period.json", json.dumps({"period_days": 1 / freqs[np.argmax(power)]}) |
|
|
|
|
| def pick(x): |
| e = x ** 2 |
| c = np.concatenate([[0.0], np.cumsum(e)]) |
| sta, lta = 50, 500 |
| r = np.zeros(len(x)) |
| for i in range(sta + lta, len(x)): |
| r[i] = ((c[i] - c[i - sta]) / sta) / max((c[i - sta] - c[i - sta - lta]) / lta, 1e-12) |
| p = int(np.argmax(r > 4)) |
| sta_e = np.array([(c[i] - c[i - sta]) / sta if i >= sta else 0 for i in range(len(x))]) |
| p_e = sta_e[p:p + 200].max() |
| cand = [i for i in range(p + 200, len(x)) if r[i] > 3 and sta_e[i] > 2 * p_e] |
| return p, cand[0] |
|
|
|
|
| def solve_picking(files, instruction): |
| if "trace.csv" in files: |
| x = np.array([float(r["amplitude"]) for r in rows(files["trace.csv"])]) |
| p, s = pick(x) |
| out = {"p_index": p} if "s_index" not in instruction else {"p_index": p, "s_index": s} |
| return "picks.json", json.dumps(out) |
| lines = ["station,p_index,s_index"] |
| for name, text in files.items(): |
| x = np.array([float(r["amplitude"]) for r in rows(text)]) |
| p, s = pick(x) |
| lines.append(f"{name.split('/')[-1][:-4]},{p},{s}") |
| return "picks.csv", "\n".join(lines) + "\n" |
|
|
|
|
| def vitals(t, x): |
| fs = 1 / (t[1] - t[0]) |
| x = x - np.polyval(np.polyfit(t, x, 1), t) |
| n = 1 << 16 |
| spec = np.abs(np.fft.rfft(x, n)) |
| f = np.fft.rfftfreq(n, 1 / fs) |
| out = [] |
| for lo, hi in ((0.1, 0.6), (0.8, 2.0)): |
| band = (f >= lo) & (f <= hi) |
| out.append(float(f[band][np.argmax(spec[band])] * 60)) |
| return out |
|
|
|
|
| def solve_vitals(files, instruction): |
| if "chest.csv" in files: |
| d = rows(files["chest.csv"]) |
| t = np.array([float(r["t_s"]) for r in d]) |
| x = np.array([float(r["displacement_mm"]) for r in d]) |
| br, hr = vitals(t, x) |
| out = {"breaths_per_min": br} |
| if "heart_bpm" in instruction: |
| out["heart_bpm"] = hr |
| return "vitals.json", json.dumps(out) |
| lines = ["recording,breaths_per_min,heart_bpm"] |
| for name, text in sorted(files.items()): |
| first, rest = text.split("\n", 1) |
| fs = float(first.split("=")[1]) |
| x = np.array([float(v) for v in rest.split("\n")[1:] if v]) |
| br, hr = vitals(np.arange(len(x)) / fs, x) |
| lines.append(f"{name.split('/')[-1][:-4]},{br:.2f},{hr:.2f}") |
| return "vitals.csv", "\n".join(lines) + "\n" |
|
|
|
|
| SOLVERS = { |
| "sci_units": solve_units, |
| "sci_protein": solve_protein, |
| "sci_flood": solve_flood, |
| "sci_trend": solve_trend, |
| "sci_quake": solve_quake, |
| "sci_period": solve_period, |
| "sci_picking": solve_picking, |
| "sci_vitals": solve_vitals, |
| } |
| CASES = [(fid, lv, inst) for fid in SOLVERS for lv in FAMILIES[fid].levels for inst in range(4)] |
|
|
|
|
| @pytest.mark.parametrize("family,level,instance", CASES) |
| def test_independent_solver_scores_one(family, level, instance): |
| env = TerminalDeskEnvironment() |
| task_id = f"{family}-L{level}-i{instance}" |
| obs = env.reset(task_id=task_id) |
| built = env._ep["built"] |
| files = {k: (v if isinstance(v, str) else v.decode()) for k, v in built.files.items()} |
| path, content = SOLVERS[family](files, obs.instruction) |
| assert path == built.artifact.path |
| assert env.step(Tbench2Action(action_type="write_file", file_path=path, content=content)).success |
| result = env.step(Tbench2Action(action_type="evaluate")) |
| assert result.reward == 1.0, (task_id, result.output, content[:400]) |
|
|
