| """Long-context families: states of ~800-4000 tokens (big logs, wide JSON |
| arrays, multi-clause policy docs, dense incident reports). Exercises the |
| state encoder's long-range extraction — current families are all <400 tok. |
| """ |
| import json |
| import random |
|
|
| from .genbase import generate, emit, q_choice, q_noul, q_score, validate_row |
|
|
| rng = random.Random() |
|
|
| SERVICES = ["auth", "billing", "gateway", "worker", "search", "notify", |
| "ledger", "cache", "queue", "frontend", "reporting", "inventory"] |
| LEVELS = ["INFO", "DEBUG", "WARN", "ERROR"] |
| COMPANIES = ["Acme Corp", "BluePeak", "Corebridge", "Datamint", "Everline", |
| "Ferrous Ltd", "GreenDesk", "Heliotrope", "IronOak", "Jetstone"] |
| SKUS = ["SKU-{:04d}".format(i) for i in range(200)] |
|
|
|
|
| def _ts(m): |
| return f"2026-09-{rng.randint(1,28):02d}T{rng.randint(0,23):02d}:{rng.randint(0,59):02d}:{rng.randint(0,59):02d}Z" |
|
|
|
|
| def gen_long_log(): |
| """60-160 log lines across 4-8 services; one service is the culprit.""" |
| n_lines = rng.randint(60, 160) |
| svcs = rng.sample(SERVICES, rng.randint(4, 8)) |
| culprit = rng.choice(svcs) |
| culprit_idx = rng.randint(15, n_lines - 5) |
| lines, first_err, err_counts = [], None, {s: 0 for s in svcs} |
| for i in range(n_lines): |
| s = rng.choice(svcs) |
| lvl = "INFO" if rng.random() < 0.6 else rng.choice( |
| ["DEBUG", "WARN", "ERROR"]) |
| if i >= culprit_idx and s == culprit: |
| lvl = "ERROR" if rng.random() < 0.8 else "WARN" |
| if lvl == "ERROR": |
| err_counts[s] += 1 |
| if first_err is None: |
| first_err = s |
| msg = rng.choice(["request handled", "retrying upstream", |
| "connection reset", "timeout waiting on lock", |
| "cache miss", "batch flushed", "heartbeat ok", |
| "null pointer in handler", "disk threshold hit", |
| "consumer lag rising"]) |
| lines.append(f"{_ts(i)} [{lvl}] {s}: {msg}") |
| state = "\n".join(lines) |
| qv = [float(s == culprit) for s in svcs] |
| qs = [q_choice("culprit", |
| "Which service is responsible for the incident?", |
| svcs, qv)] |
| if rng.random() < 0.6: |
| n_err = sum(1 for ln in lines if "[ERROR]" in ln) |
| qs.append(q_regress_count(n_err, |
| "How many ERROR-level lines are in the log?", |
| "lines")) |
| p_err = sum(v for s, v in err_counts.items() if s == culprit) / max( |
| 1, sum(err_counts.values())) |
| qs.append(q_noul("culprit_majority", |
| f"Did {culprit} produce the majority of ERROR lines?", |
| float(p_err > 0.5))) |
| return state, qs |
|
|
|
|
| def q_regress_count(n, instr, unit): |
| from .genbase import q_regress |
| return q_regress("count", instr, [float(n)] * 19, unit=unit) |
|
|
|
|
| def gen_big_json(): |
| """JSON array of 60-140 product records; exact aggregate questions.""" |
| n = rng.randint(60, 140) |
| recs = [] |
| for i in range(n): |
| recs.append({"sku": rng.choice(SKUS), "cat": rng.choice( |
| ["tool", "part", "consumable", "equipment"]), |
| "price": round(rng.uniform(1, 500), 2), |
| "stock": rng.randint(0, 300), |
| "supplier": rng.choice(COMPANIES)}) |
| state = json.dumps({"warehouse_inventory": recs}) |
| priciest = max(recs, key=lambda r: r["price"]) |
| n_stock0 = sum(1 for r in recs if r["stock"] == 0) |
| cats = sorted({r["cat"] for r in recs}) |
| cat_share = {c: sum(1 for r in recs if r["cat"] == c) / n for c in cats} |
| |
| mx = max(cat_share.values()) |
| tied = [c for c in cats if cat_share[c] == mx] |
| qv = [1.0 / len(tied) if c in tied else 0.0 for c in cats] |
| qs = [ |
| q_noul("pricey_tool", |
| "Is the most expensive record a 'tool' item?", |
| float(priciest["cat"] == "tool")), |
| q_noul("stockout10", "Are more than 10 records out of stock?", |
| float(n_stock0 > 10)), |
| q_choice("dominant_cat", "Which category has the most records?", |
| cats, qv), |
| q_regress_count(n_stock0, "How many records have stock == 0?", |
| "records"), |
| ] |
| return state, qs |
|
|
|
|
| def gen_policy_doc(): |
| """Multi-clause policy document (30-80 clauses); ask which clause governs.""" |
| n_clauses = rng.randint(30, 80) |
| domains = ["refunds", "travel", "expenses", "security", "hiring", |
| "procurement", "data retention", "vendor onboarding"] |
| domain = rng.choice(domains) |
| clauses = [] |
| target_idx = rng.randint(0, n_clauses - 1) |
| target_amt = rng.choice([50, 100, 250, 500, 1000, 2500, 5000]) |
| for i in range(n_clauses): |
| c = f"Clause {i+1}: " |
| if i == target_idx: |
| c += (f"Any {domain} request exceeding ${target_amt} requires " |
| f"sign-off from the regional director.") |
| else: |
| amt = rng.choice([10, 25, 75, 15000, 25000]) |
| c += rng.choice([ |
| f"{domain} requests under ${amt} may be auto-approved by " |
| f"the system.", |
| f"All {domain} documentation must be retained for " |
| f"{rng.randint(1,10)} years.", |
| f"{domain} submissions on weekends route to the on-call " |
| f"manager.", |
| f"Duplicate {domain} submissions within " |
| f"{rng.randint(2,30)} days are merged automatically."]) |
| clauses.append(c) |
| state = (f"POLICY MANUAL — {domain.upper()} (v{rng.randint(2,9)}." |
| f"{rng.randint(0,9)})\n\n" + "\n".join(clauses)) |
| amt = target_amt + rng.choice([1, 10, 100, 500]) |
| qs = [q_noul("needs_director", |
| f"A {domain} request for ${amt} just arrived. Does it " |
| f"require regional director sign-off?", 1.0), |
| q_choice("which_clause", |
| f"Which clause governs a ${amt} {domain} request?", |
| [f"Clause {i+1}" for i in range(n_clauses)] |
| if n_clauses <= 30 else None or |
| [f"Clause {i+1}" for i in |
| sorted(set([target_idx] + |
| rng.sample(range(n_clauses), |
| min(9, n_clauses - 1))))], |
| None)] |
| |
| opts = [f"Clause {i+1}" for i in |
| sorted(set([target_idx] + rng.sample(range(n_clauses), |
| min(9, n_clauses - 1))))] |
| qs[1] = q_choice("which_clause", |
| f"Which clause governs a ${amt} {domain} request?", |
| opts, [float(o == f"Clause {target_idx+1}") for o in opts]) |
| return state, qs |
|
|
|
|
| def gen_incident_report(): |
| """Dense prose incident report with embedded facts; reading comprehension.""" |
| svc = rng.choice(SERVICES) |
| n_users = rng.choice([120, 350, 800, 2400, 5600, 12000]) |
| dur = rng.choice([12, 27, 45, 90, 150]) |
| sev = rng.choice(["SEV1", "SEV2", "SEV3"]) |
| cause = rng.choice(["bad deploy", "certificate expiry", "DNS misconfig", |
| "db failover loop", "cache stampede"]) |
| day = rng.randint(1, 28) |
| resolution = rng.choice(['rolled back the deploy', |
| 'rotated the certificate', 'repointed DNS', |
| 'killed the failover loop', 'warmed the cache']) |
| detected_via = rng.choice(['pager alert', 'customer report', |
| 'dashboard review']) |
| paras = [ |
| f"Incident INC-{rng.randint(1000,9999)} occurred on 2026-09-{day:02d}. " |
| f"The {svc} service began returning elevated error rates at " |
| f"{rng.randint(0,23):02d}:{rng.randint(0,59):02d} UTC after a " |
| f"{cause}. On-call was paged {rng.randint(2,15)} minutes later.", |
| f"Impact assessment: approximately {n_users} users were affected " |
| f"over a {dur}-minute window. Retry storms amplified load on " |
| f"{rng.choice(SERVICES)} but did not cause secondary failure. " |
| f"Customer support received {rng.randint(5,80)} related tickets.", |
| f"Resolution: the on-call engineer {resolution} and error rates " |
| f"returned to baseline. Severity classification: {sev}. Postmortem " |
| f"scheduled within {rng.randint(2,7)} days. Action items: " |
| f"{rng.randint(3,9)} filed.", |
| ] |
| if rng.random() < 0.5: |
| paras.insert(1, f"Timeline detail: detection via {detected_via}; " |
| f"the incident channel had {rng.randint(4,40)} " |
| f"participants.") |
| state = "\n\n".join(paras) |
| qs = [ |
| q_choice("service", "Which service was primarily affected?", |
| SERVICES, [float(s == svc) for s in SERVICES]), |
| q_noul("sev12", "Was the incident SEV1 or SEV2?", |
| float(sev in ("SEV1", "SEV2"))), |
| q_noul("big_impact", "Did the incident affect more than 1000 users?", |
| float(n_users > 1000)), |
| q_choice("cause", "What caused the incident?", |
| ["bad deploy", "certificate expiry", "DNS misconfig", |
| "db failover loop", "cache stampede"], |
| [float(c == cause) for c in |
| ["bad deploy", "certificate expiry", "DNS misconfig", |
| "db failover loop", "cache stampede"]]), |
| ] |
| return state, qs |
|
|
|
|
| def gen_sensor_grid(): |
| """Many sensors, one report; spatial aggregation questions.""" |
| rows = rng.randint(8, 20) |
| cols = rng.randint(8, 20) |
| n_sensors = rows * cols |
| fail_rate = rng.choice([0.02, 0.05, 0.1]) |
| grid, n_fail = [], 0 |
| fail_cells = [] |
| for r in range(rows): |
| row = [] |
| for c in range(cols): |
| bad = rng.random() < fail_rate |
| row.append("X" if bad else ".") |
| if bad: |
| n_fail += 1 |
| fail_cells.append((r, c)) |
| grid.append("".join(row)) |
| state = (f"Sensor grid {rows}x{cols} ({n_sensors} sensors). " |
| f"'X' = sensor reporting fault, '.' = healthy.\n" + |
| "\n".join(grid)) |
| qs = [ |
| q_noul("critical", f"Is the grid in a critical state (>{int(fail_rate*1.5*100)}% faults)?", |
| float(n_fail / n_sensors > fail_rate * 1.5)), |
| q_noul("any_fault", "Are there any faults?", float(n_fail > 0)), |
| ] |
| if fail_cells: |
| r0 = min(r for r, _ in fail_cells) |
| qs.append(q_noul("top_fault", |
| "Is there a fault in the top half of the grid?", |
| float(r0 < rows // 2))) |
| return state, qs |
|
|
|
|
| FAMILIES = {"long_log": gen_long_log, "big_json": gen_big_json, |
| "policy_doc": gen_policy_doc, "incident_report": gen_incident_report, |
| "sensor_grid": gen_sensor_grid} |
| WEIGHTS = {"long_log": 0.22, "big_json": 0.22, "policy_doc": 0.18, |
| "incident_report": 0.20, "sensor_grid": 0.18} |
|
|
|
|
| def make_rows(n, seed): |
| return generate(FAMILIES, WEIGHTS, n, seed, rng) |
|
|
|
|
| if __name__ == "__main__": |
| rows = make_rows(8, 0) |
| for r in rows: |
| validate_row(r) |
| print(r["id"], "| state chars:", len(r["state"])) |
| print(f"{len(rows)} rows OK") |
|
|
