Reorganise: group 313 tasks into 17 families under tasks/, generators under tools/ (part 2)

tools/factory/audit_schema.py

@@ -33,6 +33,15 @@ def const(src, name, default=None):
         return default
     for n in tree.body:
         if isinstance(n, ast.Assign):
+            # tuple unpacking: BATCH, PREFILL, MAX_SEQ = 1, 2048, 4096
+            for t in n.targets:
+                if isinstance(t, ast.Tuple) and isinstance(n.value, ast.Tuple):
+                    for tgt, val in zip(t.elts, n.value.elts):
+                        if isinstance(tgt, ast.Name) and tgt.id == name:
+                            try:
+                                return ast.literal_eval(val)
+                            except Exception:
+                                pass
             for t in n.targets:
                 if isinstance(t, ast.Name) and t.id == name:
                     try:
@@ -79,6 +88,7 @@ def emit(task):
                 if fm:
                     entry = fm
                     break
+    dims = []
     graded = const(src, "GRADER_SHAPES", []) or []
     correct = const(src, "CORRECT_SHAPES", []) or []
     measure = const(src, "MEASURE_SHAPES", []) or []
@@ -94,14 +104,45 @@ def emit(task):
             dims = dims_mk + ["batch", "prefill", "decode_steps"]
             graded = correct = [pt]
 
+    def _params(fn_src):
+        """Positional dim names of a function: drop defaulted params (chunk_size=64) and `seed`."""
+        out = []
+        for raw in fn_src.split(","):
+            nm = raw.split("=")[0].strip()
+            if not nm or "=" in raw or nm in ("seed", "self") or nm.startswith("*"):
+                continue
+            out.append(nm)
+        return out
+
     cw = ""
     m = re.search(r"^def canonical_work\(([^)]*)\)", src, re.M)
-    dims = [x.strip() for x in m.group(1).split(",")] if m else []
     if m:
-        body = src[m.start():]
-        r = re.search(r"return (.+)", body)
+        dims = _params(m.group(1))
+    if not dims:
+        # legacy graders name the work function differently; the input generator's signature is the
+        # authoritative list of dims either way
+        mk = re.search(r"^def _(?:mk|make)\(([^)]*)\)", src, re.M)
+        if mk:
+            dims = _params(mk.group(1))
+    if m:
+        r = re.search(r"return (.+)", src[m.start():])
         cw = r.group(1).strip() if r else ""
 
+    # Most authoritative of all: how the grader itself unpacks a shape tuple. A legacy shape can carry
+    # config the input generator does not name as a parameter (flash-attn-backward's causal flag).
+    if graded:
+        want = len(graded[0])
+        if len(dims) != want:
+            for pat in (r"for\s+\w+,\s*\(([^)]+)\)\s+in\s+enumerate\(\s*(?:GRADER|CORRECT)_SHAPES",
+                        r"for\s+\(([^)]+)\)\s+in\s+(?:GRADER|CORRECT)_SHAPES",
+                        r"\(([^)]+)\)\s*=\s*shp\b"):
+                u = re.search(pat, src)
+                if u:
+                    cand = [x.strip() for x in u.group(1).split(",") if x.strip()]
+                    if len(cand) == want:
+                        dims = cand
+                        break
+
     rec = {
         "name": task,
         "family": CAT.get(task, {}).get("family", "Other"),
@@ -183,6 +224,11 @@ def main():
         w = r["workloads"]["synthetic"]
         if not w["graded"] or not w["correctness"]:
             bad.append((t, "workload has no graded/correctness shapes"))
+        elif w["dims"] and any(len(sh) != len(w["dims"]) for sh in w["graded"]):
+            n = next(len(sh) for sh in w["graded"] if len(sh) != len(w["dims"]))
+            bad.append((t, f"{len(w['dims'])} dim names for a {n}-value shape"))
+        elif not w["dims"]:
+            bad.append((t, "workload shapes have no dim names"))
         recs.append(r)
     (LANE / "TASKS.json").write_text(json.dumps(recs, indent=2) + "\n")