PyPI - opal-optimizer - Versions diffs - 0.3.5__py3-none-any.whl - Mend

opal-optimizer 0.3.5__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (49) hide show

opal/__init__.py +7 -0
opal/_version.py +3 -0
opal/agent.py +394 -0
opal/backends/__init__.py +31 -0
opal/backends/_codex_client.py +450 -0
opal/backends/_privacy.py +116 -0
opal/backends/base.py +248 -0
opal/backends/claude.py +665 -0
opal/backends/codex.py +356 -0
opal/backends/mailbox.py +1034 -0
opal/backends/unavailable.py +161 -0
opal/cli.py +396 -0
opal/context.py +111 -0
opal/defaults.json +11 -0
opal/defaults.py +54 -0
opal/estimate.py +120 -0
opal/hf.py +109 -0
opal/misc/__init__.py +2 -0
opal/misc/aggressive.py +157 -0
opal/misc/audit.py +84 -0
opal/misc/boundary.py +226 -0
opal/misc/checkpoint.py +399 -0
opal/misc/ddp.py +147 -0
opal/misc/integrity.py +263 -0
opal/misc/nested.py +67 -0
opal/misc/neutral_analysis.py +166 -0
opal/misc/precision.py +210 -0
opal/misc/recovery.py +231 -0
opal/misc/schedulers.py +214 -0
opal/misc/setup.py +253 -0
opal/misc/skip.py +165 -0
opal/misc/taskfacts.py +293 -0
opal/misc/waiting.py +58 -0
opal/programs.py +482 -0
opal/prompts/example_updater.py +252 -0
opal/prompts/neutral.md +206 -0
opal/report.py +1001 -0
opal/report_page.py +175 -0
opal/report_privacy.py +159 -0
opal/results.py +80 -0
opal/schedule.py +134 -0
opal/summaries.py +224 -0
opal/wrapper.py +1674 -0
opal_optimizer-0.3.5.dist-info/METADATA +232 -0
opal_optimizer-0.3.5.dist-info/RECORD +49 -0
opal_optimizer-0.3.5.dist-info/WHEEL +5 -0
opal_optimizer-0.3.5.dist-info/entry_points.txt +2 -0
opal_optimizer-0.3.5.dist-info/licenses/LICENSE +21 -0
opal_optimizer-0.3.5.dist-info/top_level.txt +1 -0

opal/report_page.py ADDED Viewed

@@ -0,0 +1,175 @@
+"""Self-contained report presentation. Used only by opal.report."""
+import re
+def render(values):
+    # One pass: record text containing a placeholder must remain literal text.
+    return re.sub(r"@([a-z_]+)@", lambda m: values[m[1]], PAGE)
+PAGE = r"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'">
+@refresh@<title>OPAL run report</title>
+<style>
+:root {color-scheme:light dark; --bg:#fff; --ink:#202124; --muted:#63676d; --rule:#d9dce0; --accent:#1f4e8c; --code:#f5f6f7; --add:#e8f2ea; --del:#f8e9e7}
+@media(prefers-color-scheme:dark) {:root {--bg:#17191c; --ink:#eaedf0; --muted:#b0b5bc; --rule:#3c4249; --accent:#94baf0; --code:#202429; --add:#223d2c; --del:#482a29}}
+* {box-sizing:border-box}
+body {margin:0; background:var(--bg); color:var(--ink); font:16px/1.55 ui-sans-serif,system-ui,-apple-system,sans-serif}
+main {max-width:1040px; margin:auto; padding:30px 22px 65px; overflow-wrap:anywhere}
+header {display:flex; justify-content:space-between; align-items:baseline; gap:12px}
+h1 {font-size:1.65rem; line-height:1.25; margin:0; font-weight:650}
+h2 {font-size:1.15rem; margin:1.7rem 0 .6rem; font-weight:650}
+h3 {font-size:1rem; margin:1.2rem 0 .3rem}
+p {margin:.55rem 0}
+.goal {color:var(--muted); margin:.4rem 0 1.2rem}
+#overview p {margin:.65rem 0; max-width:92ch}
+a {color:var(--accent); text-underline-offset:3px}
+button {font:inherit; color:var(--accent); background:none; border:0; padding:0; cursor:pointer; text-decoration:underline; text-underline-offset:3px}
+button[aria-pressed=true] {color:var(--ink); text-decoration:none}
+nav {white-space:nowrap; font-size:.85rem}
+[data-lang=zh] {display:none}
+html[lang=zh-CN] [data-lang=en] {display:none}
+html[lang=zh-CN] [data-lang=zh] {display:revert}
+figure {margin:.5rem 0 1.4rem}
+svg {display:block; width:100%; height:auto; overflow:visible}
+svg text {font:12px ui-sans-serif,system-ui,sans-serif; fill:var(--muted)}
+.grid {stroke:var(--rule); stroke-width:.6}
+.loss {fill:none; stroke:var(--ink); stroke-width:1.5; stroke-linejoin:round}
+.loss.alt {stroke:var(--accent)}
+.mark {cursor:pointer; outline-offset:3px}
+.mark line {stroke:var(--accent); stroke-width:1; opacity:.5}
+.mark circle {stroke:var(--accent); stroke-width:1.5; fill:var(--bg)}
+.mark text {fill:var(--accent); font-size:11px; font-weight:650; pointer-events:none}
+.mark:hover circle,.mark:focus circle {stroke-width:3}
+.kept {stroke:var(--muted); opacity:.3}
+#readout,figcaption,.muted {font-size:.85rem; color:var(--muted)}
+#readout {min-height:3.2em; margin:.4rem 0}
+#readout a {margin-left:.5em; white-space:nowrap}
+details {border-top:1px solid var(--rule); padding:.85rem 0}
+details details {margin-top:.5rem; padding:.65rem 0}
+summary {cursor:pointer; font-weight:550}
+summary .muted {font-weight:400}
+pre {white-space:pre-wrap; overflow-wrap:anywhere; font:12px/1.55 ui-monospace,Menlo,monospace; background:var(--code); padding:12px; margin:.5rem 0}
+pre.diff .a {background:var(--add); display:block}
+pre.diff .r {background:var(--del); display:block}
+.flag b {color:var(--ink)}
+table {width:100%; border-collapse:collapse; font-size:.86rem; line-height:1.5}
+th {text-align:left; font-weight:600; border-bottom:1px solid var(--ink); padding:.55rem .45rem; vertical-align:bottom}
+td {vertical-align:top; border-bottom:1px solid var(--rule); padding:.7rem .45rem}
+td.number,td.when {white-space:nowrap}
+td.what {width:35%} td.why {width:32%} td.tags {width:14%; color:var(--muted); font-size:.8rem}
+dt {font-weight:550; margin-top:.7rem} dd {margin:.1rem 0 .5rem; font-size:.9rem}
+noscript {display:block; color:var(--muted)}
+@media(max-width:640px) {
+ main {padding:22px 16px 50px} h1 {font-size:1.4rem} body {font-size:15px}
+ table thead {display:none} table tr {display:grid; grid-template-columns:2.2em 1fr; padding:.55rem 0; border-bottom:1px solid var(--rule)}
+ table td {display:block; border:0; padding:.15rem 0; width:auto!important}
+ td.number {grid-column:1; grid-row:1 / span 4} td.when,td.what,td.why,td.tags {grid-column:2; white-space:normal}
+ td[data-label]::before {content:attr(data-label) ": "; color:var(--muted)}
+ #readout {min-height:4.5em}
+}
+</style></head><body><main>
+<header><h1><span data-lang="en">OPAL run report</span><span data-lang="zh">OPAL 运行报告</span></h1>
+</header>
+<p class="goal">@goal@</p>
+<section id="overview" aria-label="Run overview">@overview@</section>
+<h2><span data-lang="en">Training loss</span><span data-lang="zh">训练损失</span></h2>
+<figure>
+<svg id="chart" role="group" aria-label="Training loss and applied decisions"></svg>
+<p id="readout" role="status" aria-live="polite"></p>
+<figcaption>@caption@</figcaption>
+<noscript>Enable JavaScript to draw the loss and analysis plots. The overview, changes and full records below are available without it.</noscript>
+</figure>
+@table@
+<details id="analysis"><summary><span data-lang="en">Analysis plots</span><span data-lang="zh">分析图表</span></summary><div id="small"></div></details>
+<details id="decision-details"><summary><span data-lang="en">Decision messages and answers</span><span data-lang="zh">决策消息与回答</span></summary>@decisions@</details>
+<details id="code-details"><summary><span data-lang="en">Code diffs</span><span data-lang="zh">代码改动</span></summary>@diffs@</details>
+<details id="facts"><summary><span data-lang="en">Run facts</span><span data-lang="zh">运行记录</span></summary>@facts@</details>
+</main>
+<script>
+'use strict';
+const L = @losses@, D = @ticks@, S = @small@, T = @total@;
+const ns = 'http://www.w3.org/2000/svg';
+let lang = 'en', selected = null;
+const tr = (en, zh) => lang === 'zh' ? zh : en;
+const fmt = v => Math.abs(v) > 0 && (Math.abs(v) < .001 || Math.abs(v) >= 1e5) ? v.toExponential(2) : Number(v.toPrecision(4)).toString();
+function readout(d) {
+ const out = document.getElementById('readout'); out.replaceChildren();
+ if (!d) {out.textContent = tr('Hover, focus or tap a number for the change and the agent’s reason.', '悬停、聚焦或轻触编号，查看改动与 agent 的理由。'); return;}
+ out.textContent = tr('Decision ', '决策 ') + d.k + ': ' + d.label;
+ const link = document.createElement('a'); link.href = '#d' + d.k; link.textContent = tr('Read full decision', '查看完整决策'); out.append(link);
+}
+function draw(svg, series, label, main) {
+ svg.replaceChildren();
+ const W = Math.max(280, svg.clientWidth || 860), H = main ? 300 : 205;
+ svg.setAttribute('viewBox', `0 0 ${W} ${H}`);
+ const m = {l:59, r:18, t:main ? 64 : 26, b:42};
+ const el = (t, a, txt, parent=svg) => {const e=document.createElementNS(ns,t); for(const k in a)e.setAttribute(k,a[k]); if(txt!=null)e.textContent=txt; parent.appendChild(e); return e;};
+ const pts = series.flatMap(s=>s.points).filter(p=>Number.isFinite(p[0]) && Number.isFinite(p[1]));
+ if (!pts.length) {el('text',{x:8,y:36},tr('No training loss recorded.', '未记录训练损失。')); return;}
+ // Use the full recorded range; do not clip spikes or replace non-finite losses with zero.
+ let x1=1, y0=Infinity, y1=-Infinity;
+ for(const p of pts) {x1=Math.max(x1,p[0]); y0=Math.min(y0,p[1]); y1=Math.max(y1,p[1]);}
+ if(main)for(const d of D)for(const x of [d.requested,d.applied])if(Number.isFinite(x))x1=Math.max(x1,x);
+ x1=Math.max(x1,T || 0);
+ if(y0===y1) {const pad=Math.abs(y0)*.05 || .5; y0-=pad; y1+=pad;}
+ const X=v=>m.l+v/x1*(W-m.l-m.r), Y=v=>H-m.b-(v-y0)/(y1-y0)*(H-m.t-m.b);
+ for(let i=0;i<=3;i++) {const v=y0+(y1-y0)*i/3; el('line',{x1:m.l,x2:W-m.r,y1:Y(v),y2:Y(v),class:'grid'}); el('text',{x:m.l-7,y:Y(v)+4,'text-anchor':'end'},fmt(v));}
+ const nx=W<500?2:4;
+ for(let i=0;i<=nx;i++) {const v=Math.round(x1*i/nx); el('text',{x:X(v),y:H-23,'text-anchor':'middle'},v.toLocaleString());}
+ el('text',{x:m.l,y:15},label);
+ el('text',{x:(m.l+W-m.r)/2,y:H-3,'text-anchor':'middle'},tr('Update','更新步'));
+ for(let i=0;i<series.length;i++) {
+  let path='', pen=false;
+  for(const p of series[i].points) {
+   if(!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {pen=false; continue;}
+   path+=(pen?'L':'M')+X(p[0]).toFixed(2)+','+Y(p[1]).toFixed(2); pen=true;
+  }
+  el('path',{class:i?'loss alt':'loss',d:path});
+  if(pts.length===1)el('circle',{cx:X(pts[0][0]),cy:Y(pts[0][1]),r:3,fill:'var(--ink)'});
+  if(series.length>1) {const last=series[i].points.filter(p=>Number.isFinite(p[1])).at(-1); if(last)el('text',{x:W-m.r,y:Y(last[1])-5,'text-anchor':'end'},series[i].name);}
+ }
+ if(!main)return;
+ let previous=-Infinity, lane=0;
+ for(const d of D) {
+  const u=d.applied ?? d.requested; if(!Number.isFinite(u))continue;
+  const x=X(u);
+  if(!d.changed) {
+   if(d.status==='kept') {const tick=el('line',{x1:x,x2:x,y1:H-m.b-7,y2:H-m.b,class:'kept'}); el('title',{},tr('Decision ','决策 ')+d.k+': '+d.label,tick);}
+   continue;
+  }
+  lane=x-previous<28?(lane+1)%2:0; previous=x;
+  const y=32+lane*24;
+  const near=pts.reduce((a,p)=>Math.abs(p[0]-u)<Math.abs(a[0]-u)?p:a,pts[0]);
+  const g=el('g',{class:'mark',tabindex:0,role:'button','aria-label':tr('Decision ','决策 ')+d.k+': '+d.label});
+  el('title',{},d.label,g);
+  el('line',{x1:x,x2:x,y1:y+10,y2:Y(near[1])},null,g);
+  el('circle',{cx:x,cy:y,r:11},null,g); el('text',{x:x,y:y+4,'text-anchor':'middle'},d.k,g);
+  const show=()=>{selected=d; readout(d);};
+  g.addEventListener('mouseenter',show); g.addEventListener('focus',show); g.addEventListener('click',show);
+  g.addEventListener('keydown',e=>{if(e.key==='Enter'||e.key===' ') {e.preventDefault(); show();}});
+ }
+}
+function charts() {
+ draw(document.getElementById('chart'),[{name:'loss',points:L}],tr('Training loss ↓','训练损失 ↓'),true);
+ const box=document.getElementById('small'); box.replaceChildren();
+ if(document.getElementById('analysis').open) {
+  if(!S.length) {const p=document.createElement('p'); p.textContent=tr('No additional metric series recorded.','未记录其他指标序列。'); box.append(p);}
+  for(const s of S) {const svg=document.createElementNS(ns,'svg'); svg.setAttribute('role','img'); svg.setAttribute('aria-label',s.label); box.append(svg); draw(svg,s.series,s.label,false);}
+ }
+ readout(selected);
+}
+function language(value) {
+ lang=value; document.documentElement.lang=value==='zh'?'zh-CN':'en';
+ charts();
+}
+function reveal(id) {const target=document.getElementById(id); if(!target)return; let p=target; while(p) {if(p.tagName==='DETAILS')p.open=true; p=p.parentElement;} target.scrollIntoView({block:'start'});}
+document.addEventListener('click',e=>{const a=e.target.closest('a[href^="#d"]'); if(a) {e.preventDefault(); reveal(a.getAttribute('href').slice(1));}});
+document.getElementById('analysis').addEventListener('toggle',charts);
+let resize; window.addEventListener('resize',()=>{clearTimeout(resize); resize=setTimeout(charts,100);});
+language(lang);
+if(location.hash)reveal(decodeURIComponent(location.hash.slice(1)));
+</script></body></html>"""

opal/report_privacy.py ADDED Viewed

@@ -0,0 +1,159 @@
+"""Publication filtering for report text only; never changes the run's source records."""
+from __future__ import annotations
+import re
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+from .backends._privacy import redact_secrets
+# Match locations before HTML escaping, including paths inside quoted code/JSON.
+_REMOTE = re.compile(r"\b[a-zA-Z][\w+.-]*://[^\s<>\"'`]+|\barn:aws[^\s<>\"'`]+")
+_HOME = re.compile(r"(?:/Users/|/home/|/homes/|[A-Za-z]:[\\/]Users[\\/])([^/\\\n\"'`]+)[/\\]")
+_PATH = re.compile(
+    r"(?<![\w./])(?:/(?:Users|home|homes)/[^/\n\"'`]+/[^\s<>\"'`|;,(){}\[\]]*|"
+    r"(?:[A-Za-z]:[\\/]|~[\w.-]*[/\\]|/)[^\s<>\"'`|;,(){}\[\]]+)"
+)
+_LOGIN = re.compile(r"\b([\w.+-]+)@([\w.-]+)\b")
+_UNC = re.compile(r'\\\\([^\s\\/]+)[\\/][^\s<>"\'`]+')
+_LABEL = re.compile(
+    r"\b(?:hostname|host_name|host|remote_host|username|user_name|user|login|bucket|bucket_name|s3_bucket)\s*[:=]\s*[\"']?([\w.@+-]+)",
+    re.I,
+)
+_HOST = re.compile(
+    r"\b(?:[\w-]+\.)+(?:com|edu|net|org|io|local|internal|lan|ac\.[a-z]{2})\b|"
+    r"(?<![\d.])(?:\d{1,3}\.){3}\d{1,3}(?![\d.])",
+    re.I,
+)
+_IDENTITY_KEYS = {
+    "host",
+    "hostname",
+    "remotehost",
+    "sshhost",
+    "user",
+    "username",
+    "userfullname",
+    "login",
+    "owner",
+    "author",
+    "bucket",
+    "bucketname",
+    "s3bucket",
+}
+_RUN_KEYS = {"run_dir", "run_folder", "opal_run"}
+_RUN_CHILD = re.compile(r"[/\\](?:workspace|decisions|programs)(?:[/\\]|$)")
+class Privacy:
+    """Remember identities wherever they occur in the rendered inputs, then remove repeated mentions too.
+    Paths within this run (including its original location before copying) become relative paths. Other
+    locations, remote authorities, login names and explicitly recorded user/host/bucket identifiers are omitted.
+    The renderer uses this on every string, including dictionary keys, full messages, code and plot labels.
+    """
+    def __init__(self, run, records):
+        self.roots = {str(Path(run).absolute()).rstrip("/"), str(Path(run).resolve()).rstrip("/")}
+        self.identities = set()
+        self._learn(records)
+        self.roots = {root for root in self.roots if len(root) > 1}
+        self.run_path = re.compile(
+            r"(?<![\w./])(?:"
+            + "|".join(re.escape(root) for root in sorted(self.roots, key=len, reverse=True))
+            + r")(?=$|[/\\\s<>\"'`|;,(){}\[\]])(?:[/\\][^\s<>\"'`|;,(){}\[\]]*)?"
+        )
+        # A username discovered in one file must disappear from all other displayed files as well.
+        values = sorted((s for s in self.identities if s), key=len, reverse=True)
+        self.identity = (
+            re.compile(r"(?<![\w])(?:" + "|".join(re.escape(s) for s in values) + r")(?![\w])", re.I)
+            if values
+            else None
+        )
+    def _learn(self, obj):
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                if re.sub(r"[_-]", "", str(key).lower()) in _IDENTITY_KEYS and isinstance(value, str):
+                    self.identities.add(value)
+                if (
+                    str(key).lower() in _RUN_KEYS
+                    and isinstance(value, str)
+                    and (value.startswith("/") or re.match(r"[A-Za-z]:[\\/]", value))
+                ):
+                    self.roots.add(value.rstrip("/\\"))
+                if str(key).lower() == "cwd" and isinstance(value, str):
+                    child = _RUN_CHILD.search(value)
+                    if child:
+                        self.roots.add(value[: child.start()])
+                self._learn(str(key))
+                self._learn(value)
+        elif isinstance(obj, (list, tuple)):
+            for value in obj:
+                self._learn(value)
+        elif isinstance(obj, str):
+            for match in re.finditer(r"~([\w.-]+)[/\\]", obj):
+                self.identities.add(match[1])
+            for match in _UNC.finditer(obj):
+                self.identities.add(match[1])
+            for match in _REMOTE.finditer(obj):
+                if "://" in match[0]:
+                    authority = match[0].split("://", 1)[1].split("/", 1)[0]
+                    self.identities.add(authority)
+                    try:
+                        location = urlsplit(match[0])
+                        self.identities.update(unquote(v) for v in (location.hostname, location.username) if v)
+                        bucket = re.match(r"(.+?)\.s3[.-]", location.hostname or "")
+                        if bucket:
+                            self.identities.add(bucket[1])
+                    except ValueError:
+                        pass
+                elif ":::" in match[0]:
+                    self.identities.add(match[0].split(":::", 1)[1].split("/", 1)[0])
+            for match in _HOME.finditer(obj):
+                self.identities.add(match[1])
+            for match in _LOGIN.finditer(obj):
+                self.identities.update(match.groups())
+            for match in _LABEL.finditer(obj):
+                self.identities.add(match[1])
+            for match in _PATH.finditer(obj):
+                child = _RUN_CHILD.search(match[0])
+                if child:
+                    self.roots.add(match[0][: child.start()])
+    def _path(self, match):
+        path = match[0]
+        # Avoid eating arithmetic such as `1 / 2`, or regex syntax such as /\w+/.
+        if path in ("/", "//"):
+            return path
+        for root in sorted(self.roots, key=len, reverse=True):
+            if path == root:
+                return "."
+            if path.startswith(root + "/") or path.startswith(root + "\\"):
+                rel = path[len(root) + 1 :].replace("\\", "/")
+                # A path leaving the run must not masquerade as a relative path within it.
+                if ".." not in rel.split("/"):
+                    return rel
+        return "[path omitted]"
+    def text(self, text):
+        text = redact_secrets(text)
+        text = _REMOTE.sub("[remote location omitted]", text)
+        text = _UNC.sub("[path omitted]", text)
+        text = self.run_path.sub(self._path, text)
+        text = _PATH.sub(self._path, text)
+        text = _LOGIN.sub("[login omitted]", text)
+        text = _HOST.sub("[host omitted]", text)
+        if self.identity:
+            text = self.identity.sub("[identity omitted]", text)
+        return text
+    def clean(self, obj):
+        if isinstance(obj, str):
+            return self.text(obj)
+        if isinstance(obj, dict):
+            return {self.text(k) if isinstance(k, str) else k: self.clean(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [self.clean(v) for v in obj]
+        return obj

opal/results.py ADDED Viewed

@@ -0,0 +1,80 @@
+"""The fields every example writes to its result.json, so that a run can be set beside ours (docs/GUIDE.md, "Comparing
+with our runs"): the metric (name, value, direction), the training time and the time training waited for the agent,
+the agent's cost, the decisions asked, applied and failed, the hardware, the OPAL commit, the full command and the OPAL
+run folder. A plain run has the same fields, with the OPAL ones None. save_weights() writes final weights for --save."""
+from __future__ import annotations
+import platform
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+import torch
+def hardware(device=None) -> str:
+    dev = torch.device(device) if device is not None else None
+    if dev is not None and dev.type == "cuda":
+        n = torch.cuda.device_count()
+        return f"{n} x {torch.cuda.get_device_name(dev)}"
+    return f"{platform.machine()} CPU ({platform.processor() or platform.system()})" + (
+        f", {dev.type}" if dev is not None and dev.type not in ("cpu", "cuda") else ""
+    )
+def opal_commit() -> str | None:
+    """The git commit of the OPAL checkout that ran (with "+changes" when it has local edits), else its version."""
+    from . import __version__
+    here = Path(__file__).parent
+    try:
+        head = subprocess.run(["git", "-C", str(here), "rev-parse", "--short=12", "HEAD"], capture_output=True,
+                              text=True, timeout=10)  # fmt: skip
+        if head.returncode != 0:
+            return __version__
+        dirty = subprocess.run(["git", "-C", str(here), "status", "--porcelain", "--", "."], capture_output=True,
+                               text=True, timeout=10).stdout.strip()  # fmt: skip
+        return head.stdout.strip() + ("+changes" if dirty else "")
+    except (OSError, subprocess.TimeoutExpired):
+        return __version__
+def summary(metric, value, direction, train_seconds, opt=None, device=None) -> dict:
+    """The uniform fields. direction: "higher" or "lower" is better. opt: the AgentOptimizer of an OPAL run."""
+    out = dict(
+        metric=dict(name=metric, value=value, direction=direction),
+        train_seconds=round(float(train_seconds), 1),
+        agent_wait_seconds=None,
+        agent_cost_usd=None,
+        decisions=None,
+        hardware=hardware(device),
+        opal_commit=None,
+        command=" ".join(shlex.quote(x) for x in [sys.executable, *sys.argv]),
+        opal_run=None,
+    )
+    run = getattr(opt, "run", None)
+    if run is not None:
+        from .report import _jsonl, decision_counts
+        c = decision_counts(_jsonl(run.dir / "events.jsonl"))
+        out.update(
+            agent_wait_seconds=round(getattr(opt, "agent_wait_seconds", 0.0), 1),
+            agent_cost_usd=opt.worker.recorded_cost if opt.worker is not None else 0.0,
+            decisions=dict(asked=c["asked"], applied=c["applied"], failed=c["failed"]),
+            opal_commit=opal_commit(),
+            opal_run=str(run.dir),
+        )
+        if opt.worker is not None and (opt.worker.usage is not None or opt.worker.backend.name == "codex"):
+            out.update(agent_cost_usd=None, agent_tokens=opt.worker.usage)
+    return out
+def save_weights(folder, **state_dicts):
+    """--save: each state dict to <folder>/<name>.pt (model.pt, ema.pt, ...)."""
+    folder = Path(folder)
+    folder.mkdir(parents=True, exist_ok=True)
+    for name, state in state_dicts.items():
+        torch.save(state, folder / f"{name}.pt")
+    return folder

opal/schedule.py ADDED Viewed

@@ -0,0 +1,134 @@
+"""When the agent is asked: wrap(decisions=..., schedule=...).
+schedule (the decision updates; it has nothing to do with the learning-rate schedule):
+  "front" (default)   a fifth of the decisions evenly over the first 5% of training (where our agents made most of
+                      their code changes: SiT, 49 of 125 decisions before update 50K changed a file, 6 of 310 after),
+                      the rest evenly over the remainder. The same as [(0.05, a fifth), (1.0, the rest)].
+  "uniform"           every total // decisions updates, as in the v1 harness (646, 1292, ... on 64,626 updates with
+                      100 decisions).
+  [(0.05, 20), (1.0, 30)]
+                      segments, each (end, count) with end a fraction of training: 20 decisions evenly over the first
+                      5%, then 30 evenly over the rest. Within a segment the gaps are equal and the last decision falls
+                      on the segment's end, except in a segment that ends the run, whose last decision falls one gap
+                      before the end (an answer at the last update could not act on the run).
+  [500, 1000, 5000]   these updates.
+decisions is the count for "front" and "uniform" (50 by default); a list gives its own count (the sum of the segments'
+counts, or the number of updates), and a decisions= that disagrees with it is an error.
+Decisions are asked only at checks (every `every` updates), so each update is moved up to the next check, two that
+land on the same check become one, and none falls in the last `every` updates (an answer could no longer act); the run
+has as many scheduled decisions as are left. Besides the schedule, the agent's own analysis can ask for a decision
+({"wake": reason}), and a non-finite loss does.
+"""
+from __future__ import annotations
+DEFAULT_DECISIONS = 50
+NAMED = ("front", "uniform")
+EARLY_FRACTION, EARLY_SHARE = 0.05, 0.2  # "front": a fifth of the decisions in the first 5% of training
+HELP = (
+    'schedule must be "front", "uniform", a list of (end_fraction, count) segments such as [(0.05, 20), (1.0, 30)], '
+    "or a list of update numbers such as [500, 1000, 5000]"
+)
+def kind(schedule) -> str:
+    """'front', 'uniform', 'segments' or 'updates'; raises ValueError for anything else."""
+    if isinstance(schedule, str):
+        if schedule in NAMED:
+            return schedule
+        raise ValueError(f"opal: {HELP}, got {schedule!r}")
+    if not isinstance(schedule, (list, tuple)):
+        raise ValueError(f"opal: {HELP}, got {schedule!r}")
+    if all(_is_int(u) for u in schedule):
+        return "updates"
+    if all(isinstance(s, (list, tuple)) and len(s) == 2 for s in schedule):
+        return "segments"
+    raise ValueError(f"opal: {HELP}, got {schedule!r}")
+def _is_int(x):
+    return isinstance(x, int) and not isinstance(x, bool)
+def _segments(schedule):
+    """Checked (end_fraction, count) pairs."""
+    out, prev = [], 0.0
+    for s in schedule:
+        end, count = s
+        if isinstance(end, bool) or not isinstance(end, (int, float)) or not prev < end <= 1:
+            raise ValueError(
+                f"opal: schedule segment {tuple(s)!r}: each end must be a fraction of training in (0, 1], larger than "
+                "the previous segment's end"
+            )
+        if not _is_int(count) or count < 0:
+            raise ValueError(f"opal: schedule segment {tuple(s)!r}: the count must be an int >= 0")
+        out.append((float(end), count))
+        prev = end
+    return out
+def count(schedule, decisions=None) -> int:
+    """How many decisions the schedule asks for before snapping to checks. decisions=None means the default (50) for
+    "front" and "uniform" and the list's own count otherwise; a decisions that disagrees with a list is an error."""
+    k = kind(schedule)
+    if decisions is not None and (not _is_int(decisions) or decisions < 0):
+        raise ValueError(f"opal: decisions must be an int >= 0, got {decisions!r}")
+    if k in NAMED:
+        return DEFAULT_DECISIONS if decisions is None else decisions
+    if k == "segments":
+        given = sum(c for _, c in _segments(schedule))
+        what = " + ".join(str(c) for _, c in schedule) if len(schedule) > 1 else str(given)
+    else:
+        given, what = len(schedule), f"{len(schedule)} updates"
+    if decisions is not None and decisions != given:
+        raise ValueError(
+            f"opal: decisions={decisions} but schedule gives {given} ({what}); leave decisions out, or make them agree"
+        )
+    return given
+def decision_updates(total: int, n: int, cadence=1, schedule="front") -> list:
+    """Scheduled decision updates, snapped up to the check cadence (decisions can only happen at check steps) and
+    without the last `cadence` updates, so the count is the number that can actually happen. n: the count for "front"
+    and "uniform" (ignored for a list, which gives its own)."""
+    return [u for seg in decision_segments(total, n, cadence, schedule) for u in seg]
+def decision_segments(total: int, n: int, cadence=1, schedule="front") -> list:
+    """decision_updates, as one list per segment: two for "front" (the first 5% and the rest), one for "uniform" and
+    for a list of updates, one per (end, count) segment. A check claimed by an earlier segment is not repeated."""
+    k = kind(schedule)
+    if k == "updates":
+        for u in schedule:
+            if not 1 <= u <= total:
+                raise ValueError(f"opal: schedule update {u} is outside the run (1 to total_steps={total})")
+    if total <= 1:
+        return [[]]
+    if k == "uniform":
+        return [_snap([max(1, total // n) * (i + 1) for i in range(n)], total, cadence) if n > 0 else []]
+    if k == "updates":
+        return [_snap(list(schedule), total, cadence)]
+    if k == "front":
+        if n <= 0:
+            return [[]]
+        n_early = max(1, round(n * EARLY_SHARE))
+        segments = [(EARLY_FRACTION, n_early), (1.0, max(0, n - n_early))]
+    else:
+        segments = _segments(schedule)
+    out, seen, start = [], set(), 0
+    for end_fraction, c in segments:
+        end = total if end_fraction == 1.0 else max(1, int(total * end_fraction))
+        span, parts = end - start, c + 1 if end == total else c
+        raw = [start + round(span * (i + 1) / parts) for i in range(c)] if c else []
+        seg = [u for u in _snap(raw, total, cadence) if u not in seen]
+        seen.update(seg)
+        out.append(seg)
+        start = end
+    return out
+def _snap(updates, total, cadence):
+    snapped = {-(-u // cadence) * cadence for u in updates}
+    return sorted(u for u in snapped if 0 < u and total - u >= cadence)