| """Synthetic STRUCTURED/DATA-HEAVY states for the decision-model corpus.
|
|
|
| Jev accepts text, JSON objects and JSON arrays as `state`; these families
|
| exercise structured-state comprehension: serialized JSON record sets, log
|
| excerpts, markdown/CSV tables, date arithmetic, metric comparisons,
|
| nested order documents and mixed-type JSON arrays. Most rows serialize
|
| `state` with json.dumps (as real callers do); log/table rows stay text.
|
|
|
| Targets are exact one-hot / 0-1 for lookups and comparisons; soft q only
|
| for inherently fuzzy judgments (log-burst severity).
|
| """
|
| import json
|
| import random
|
| from datetime import date, timedelta
|
|
|
| from alea.genbase import (generate, emit, q_choice, q_noul, q_score,
|
| validate_row, write_jsonl)
|
|
|
| rng = random.Random()
|
|
|
| FIRST = ["Mara", "Tobias", "Priya", "Kenji", "Lucia", "Omar", "Ingrid",
|
| "Felix", "Sofia", "Dmitri", "Amara", "Jonas", "Nadia", "Pablo"]
|
| SERVICES = ["auth", "billing", "gateway", "search", "notify", "cache",
|
| "payments", "uploads"]
|
| PRODUCTS = ["headset", "coffee grinder", "keyboard", "standing lamp",
|
| "backpack", "monitor arm", "water bottle", "desk mat"]
|
| CITIES = ["Oslo", "Lima", "Nairobi", "Osaka", "Porto", "Austin", "Lyon",
|
| "Hanoi"]
|
| COUNTRIES = ["US", "DE", "FR", "JP", "BR", "IN", "GB", "CA", "NL", "SE"]
|
|
|
|
|
| FRANGES = {"units": (1, 40), "total": (20, 900), "stock": (0, 150),
|
| "price": (5, 300), "salary": (45, 180), "yrs": (1, 20),
|
| "temp_c": (-5, 45), "humidity": (10, 95)}
|
|
|
|
|
| def _one_hot(idx, n):
|
| return [1.0 if j == idx else 0.0 for j in range(n)]
|
|
|
|
|
| def _softq(idx, n):
|
| """Fuzzy judgment target: 0.7 on `idx`, remainder on neighbours."""
|
| q = [0.0] * n
|
| q[idx] = 0.7
|
| if idx - 1 >= 0 and idx + 1 < n:
|
| q[idx - 1], q[idx + 1] = 0.2, 0.1
|
| elif idx - 1 >= 0:
|
| q[idx - 1] = 0.3
|
| elif idx + 1 < n:
|
| q[idx + 1] = 0.3
|
| else:
|
| q[idx] = 1.0
|
| return q
|
|
|
|
|
| def _count_opts(true, hi):
|
| """3-4 option count window containing `true`, clipped to [0, hi]."""
|
| lo = max(0, true - 1)
|
| opts = list(range(lo, min(hi, true + 2) + 1))
|
| while len(opts) < 3 and opts[0] > 0:
|
| opts.insert(0, opts[0] - 1)
|
| while len(opts) < 3 and opts[-1] < hi:
|
| opts.append(opts[-1] + 1)
|
| return [str(i) for i in opts]
|
|
|
|
|
|
|
|
|
| def gen_json_records():
|
| kind = rng.choice(["orders", "inventory", "employees", "sensors"])
|
| n = rng.randint(4, 6)
|
| group = None
|
| if kind == "orders":
|
| custs = rng.sample(FIRST, 2)
|
| recs = [{"order_id": f"O-{1000 + i}", "customer": rng.choice(custs),
|
| "units": rng.randint(1, 40),
|
| "total": rng.randint(20, 900)} for i in range(n)]
|
| label, fields, group = "order_id", ["units", "total"], "customer"
|
| noun = "order"
|
| elif kind == "inventory":
|
| names = rng.sample(PRODUCTS, n)
|
| recs = [{"sku": f"SKU-{200 + i}", "name": names[i],
|
| "stock": rng.randint(0, 150),
|
| "price": rng.randint(5, 300)} for i in range(n)]
|
| label, fields = "sku", ["stock", "price"]
|
| noun = "item"
|
| elif kind == "employees":
|
| depts = rng.sample(["eng", "sales", "ops", "hr"], 2)
|
| names = rng.sample(FIRST, n)
|
| recs = [{"name": names[i], "dept": rng.choice(depts),
|
| "salary": rng.randint(45, 180) * 1000,
|
| "yrs": rng.randint(1, 20)} for i in range(n)]
|
| label, fields, group = "name", ["salary", "yrs"], "dept"
|
| noun = "employee"
|
| else:
|
| zones = rng.sample(["north", "south", "roof", "cellar"], 2)
|
| recs = [{"sensor_id": f"S-{i + 1}", "zone": rng.choice(zones),
|
| "temp_c": rng.randint(-5, 45),
|
| "humidity": rng.randint(10, 95)} for i in range(n)]
|
| label, fields, group = "sensor_id", ["temp_c", "humidity"], "zone"
|
| noun = "sensor"
|
| state = json.dumps(recs, separators=(",", ":"))
|
| qs = []
|
|
|
|
|
| f = rng.choice(fields)
|
| lo, hi = FRANGES[f]
|
| for r, v in zip(recs, rng.sample(range(lo, hi + 1), n)):
|
| r[f] = v * 1000 if f == "salary" else v
|
| vals = [r[f] for r in recs]
|
| want_max = rng.random() < 0.5
|
| correct = vals.index(max(vals) if want_max else min(vals))
|
| instr = rng.choice([
|
| f"Which {noun} has the {'highest' if want_max else 'lowest'} {f}?",
|
| f"Identify the {noun} with the "
|
| f"{'greatest' if want_max else 'smallest'} {f}."])
|
| qs.append(q_choice("extreme", instr, [str(r[label]) for r in recs],
|
| _one_hot(correct, n)))
|
|
|
|
|
| f2 = rng.choice(fields)
|
| v2 = [r[f2] for r in recs]
|
| if min(v2) >= max(v2):
|
| raise ValueError("degenerate threshold")
|
| if rng.random() < 0.5:
|
| t = rng.randint(min(v2) + 1, max(v2))
|
| ans = any(v > t for v in v2)
|
| instr = rng.choice([
|
| f"Is any {noun}'s {f2} above {t}?",
|
| f"Does any {noun} have {f2} exceeding {t}?"])
|
| else:
|
| t = rng.randint(min(v2), max(v2) - 1)
|
| ans = any(v < t for v in v2)
|
| instr = rng.choice([
|
| f"Is any {noun}'s {f2} below {t}?",
|
| f"Does any {noun} have {f2} under {t}?"])
|
| qs.append(q_noul("thresh", instr, float(ans)))
|
|
|
|
|
| agg = {"orders": ("customer", "total"),
|
| "employees": ("dept", "salary")}.get(kind)
|
| if agg and rng.random() < 0.6:
|
| gk, fk = agg
|
| ga, gb = rng.sample(sorted({r[gk] for r in recs}), 2)
|
| sa = sum(r[fk] for r in recs if r[gk] == ga)
|
| sb = sum(r[fk] for r in recs if r[gk] == gb)
|
| if sa == sb:
|
| raise ValueError("tie")
|
| instr = (f"Do the orders for {ga} total more than those for {gb}?"
|
| if kind == "orders" else
|
| f"Does department {ga} have a larger payroll than {gb}?")
|
| qs.append(q_noul("group", instr, float(sa > sb)))
|
| elif group:
|
| gv = rng.choice(sorted({r[group] for r in recs}))
|
| c = sum(1 for r in recs if r[group] == gv)
|
| gword = {"orders": "belong to customer",
|
| "employees": "are in department",
|
| "sensors": "are in zone"}[kind]
|
| opts_c = _count_opts(c, n)
|
| qs.append(q_choice("count",
|
| f"How many {noun}s {gword} '{gv}'?", opts_c,
|
| _one_hot(opts_c.index(str(c)), len(opts_c))))
|
| else:
|
| tot = sum(r["stock"] * r["price"] for r in recs)
|
| t = rng.randint(int(tot * 0.5), int(tot * 1.5))
|
| qs.append(q_noul("value", f"Is the total stock value above ${t}?",
|
| float(tot > t)))
|
| return state, qs
|
|
|
|
|
|
|
|
|
| _LOG_MSGS = {"INFO": ["request completed", "health check ok", "cache hit",
|
| "job finished", "config reloaded"],
|
| "WARN": ["retrying upstream", "slow query 1200ms",
|
| "rate limit approaching"],
|
| "ERROR": ["unhandled exception", "db connection failed",
|
| "upstream timeout", "payment rejected"],
|
| "CRITICAL": ["oom killed", "data corruption detected"]}
|
|
|
|
|
| def gen_log_lines():
|
| day = f"2024-{rng.randint(1, 12):02d}-{rng.randint(1, 28):02d}"
|
| svcs = rng.sample(SERVICES, rng.randint(3, 4))
|
| n = rng.randint(6, 9)
|
| err_idx = set(rng.sample(range(n), rng.randint(2, 3)))
|
| crit_i = rng.choice(sorted(err_idx)) if rng.random() < 0.3 else -1
|
| force5 = rng.choice(sorted(err_idx - {crit_i})) \
|
| if rng.random() < 0.75 and len(err_idx - {crit_i}) else -1
|
| lines, events = [], []
|
| t = rng.randint(0, 600)
|
| for i in range(n):
|
| t += rng.randint(5, 240)
|
| ts = f"{day}T{8 + t // 3600:02d}:{t % 3600 // 60:02d}:{t % 60:02d}"
|
| svc = rng.choice(svcs)
|
| if i in err_idx:
|
| lvl = "CRITICAL" if i == crit_i else "ERROR"
|
| else:
|
| lvl = "WARN" if rng.random() < 0.2 else "INFO"
|
| has5 = i in err_idx and i != crit_i and \
|
| (i == force5 or rng.random() < 0.4)
|
| code = f" status={rng.choice([500, 502, 503, 504])}" if has5 else ""
|
| lines.append(f"{ts} [{lvl}] {svc}: {rng.choice(_LOG_MSGS[lvl])}{code}")
|
| events.append((ts, svc, lvl, has5))
|
| state = "\n".join(lines)
|
| qs = []
|
|
|
|
|
| first_svc = next(e[1] for e in events if e[2] in ("ERROR", "CRITICAL"))
|
| opts = svcs[:]
|
| rng.shuffle(opts)
|
| qs.append(q_choice("first_err",
|
| rng.choice([
|
| "Which service logged an error first?",
|
| "Which service was the first to report an ERROR "
|
| "or CRITICAL line?"]),
|
| opts, _one_hot(opts.index(first_svc), len(opts))))
|
|
|
|
|
| T = events[rng.randrange(1, n - 1)][0]
|
| ans = any(e[3] and e[0] < T for e in events)
|
| qs.append(q_noul("early5xx",
|
| f"Did any HTTP 5xx response occur before "
|
| f"{T.split('T')[1]}?", float(ans)))
|
|
|
|
|
| err_events = [e for e in events if e[2] in ("ERROR", "CRITICAL")]
|
| if rng.random() < 0.5:
|
| frac = len(err_events) / n
|
| levels = ["0: no error lines", "1: under a quarter of lines",
|
| "2: a quarter to a half of lines",
|
| "3: over half of lines"]
|
| idx = (0 if frac == 0 else 1 if frac < 0.25
|
| else 2 if frac <= 0.5 else 3)
|
| qs.append(q_score("err_rate",
|
| "What share of the log lines are ERROR or "
|
| "CRITICAL?", levels, _one_hot(idx, 4)))
|
| else:
|
| sev = ["0: benign — routine noise", "1: minor — worth a look",
|
| "2: serious — page the on-call",
|
| "3: severe — incident response"]
|
| ncrit = sum(1 for e in events if e[2] == "CRITICAL")
|
| n5xx = sum(1 for e in events if e[3])
|
| base = 1
|
| if len(err_events) >= 3 or n5xx >= 2 or ncrit:
|
| base = 2
|
| if ncrit >= 2 or (ncrit and n5xx):
|
| base = 3
|
| qs.append(q_score("severity",
|
| "How severe is the incident reflected in this log?",
|
| sev, _softq(base, 4)))
|
| return state, qs
|
|
|
|
|
|
|
|
|
| def gen_tables():
|
| kind = rng.choice(["sales", "weather", "servers"])
|
| n = rng.randint(4, 6)
|
| if kind == "sales":
|
| cols = ["product", "units", "revenue"]
|
| names = rng.sample(PRODUCTS, n)
|
| rows = [[names[i], u, r] for i, u, r in
|
| zip(range(n), rng.sample(range(5, 200), n),
|
| rng.sample(range(100, 5000), n))]
|
| nums = {"units": 1, "revenue": 2}
|
| noun = "product"
|
| elif kind == "weather":
|
| cols = ["city", "high_c", "rain_mm"]
|
| names = rng.sample(CITIES, n)
|
| rows = [[names[i], h, r] for i, h, r in
|
| zip(range(n), rng.sample(range(-5, 40), n),
|
| rng.sample(range(0, 80), n))]
|
| nums = {"high_c": 1, "rain_mm": 2}
|
| noun = "city"
|
| else:
|
| cols = ["host", "cpu_pct", "mem_gb"]
|
| hosts = [f"web-{i}" for i in rng.sample(range(1, 30), n)]
|
| rows = [[hosts[i], c, m] for i, c, m in
|
| zip(range(n), rng.sample(range(5, 99), n),
|
| rng.sample(range(1, 128), n))]
|
| nums = {"cpu_pct": 1, "mem_gb": 2}
|
| noun = "host"
|
| if rng.random() < 0.5:
|
| state = f"{kind} report:\n" + "\n".join(
|
| ["| " + " | ".join(cols) + " |", "|" + "---|" * len(cols)] +
|
| ["| " + " | ".join(str(v) for v in r) + " |" for r in rows])
|
| else:
|
| state = "\n".join([",".join(cols)] +
|
| [",".join(str(v) for v in r) for r in rows])
|
| qs = []
|
|
|
|
|
| f = rng.choice(list(nums))
|
| vals = [r[nums[f]] for r in rows]
|
| want_max = rng.random() < 0.5
|
| correct = vals.index(max(vals) if want_max else min(vals))
|
| qs.append(q_choice("arg",
|
| f"Which {noun} has the "
|
| f"{'highest' if want_max else 'lowest'} {f}?",
|
| [str(r[0]) for r in rows], _one_hot(correct, n)))
|
|
|
|
|
| f2 = rng.choice(list(nums))
|
| v2 = [r[nums[f2]] for r in rows]
|
| t = rng.randint(min(v2), max(v2) - 1)
|
| c = sum(1 for v in v2 if v > t)
|
| opts_c = _count_opts(c, n)
|
| qs.append(q_choice("count",
|
| f"How many {noun}s have {f2} above {t}?", opts_c,
|
| _one_hot(opts_c.index(str(c)), len(opts_c))))
|
|
|
|
|
| f3 = rng.choice(list(nums))
|
| v3 = [r[nums[f3]] for r in rows]
|
| m = rng.randint(min(v3), max(v3))
|
| qs.append(q_noul("all",
|
| f"Does every {noun} have {f3} above {m}?",
|
| float(all(v > m for v in v3))))
|
| return state, qs
|
|
|
|
|
|
|
|
|
| def gen_temporal():
|
| base = date(2024, 1, 1) + timedelta(days=rng.randint(0, 300))
|
| if rng.random() < 0.5:
|
| task = rng.choice(["report", "migration", "audit", "prototype",
|
| "rollout"])
|
| est = rng.randint(3, 30)
|
| due = base + timedelta(days=rng.randint(3, 30))
|
| end = base + timedelta(days=est)
|
| state = json.dumps({"task": task, "start": base.isoformat(),
|
| "estimate_days": est, "due": due.isoformat()})
|
| late = end > due
|
| slack = (due - end).days
|
| qs = [q_noul("late",
|
| rng.choice([f"Will the {task} miss its due date?",
|
| f"Is the {task} going to be late?"]),
|
| float(late))]
|
| levels = ["0: over a week of slack", "1: up to a week of slack",
|
| "2: finishes exactly on the due date", "3: late"]
|
| idx = 3 if late else 2 if slack == 0 else 1 if slack <= 7 else 0
|
| qs.append(q_score("slack",
|
| f"How much slack does the {task} have against "
|
| f"its due date?", levels, _one_hot(idx, 4)))
|
| k = rng.randint(5, 25)
|
| qs.append(q_noul("est",
|
| f"Is the estimated effort at least {k} days?",
|
| float(est >= k)))
|
| return state, qs
|
| names = rng.sample(["design", "build", "test", "deploy", "review",
|
| "docs"], rng.randint(3, 5))
|
| stag = rng.random() < 0.5
|
| ms, ends = [], []
|
| for nm, d in zip(names, rng.sample(range(3, 40), len(names))):
|
| s = base + timedelta(days=rng.randint(0, 10) if stag else 0)
|
| ms.append({"name": nm, "start": s.isoformat(), "days": d})
|
| ends.append(s + timedelta(days=d))
|
| if len(set(ends)) != len(ends):
|
| raise ValueError("tie")
|
| state = json.dumps({"project": rng.choice(["atlas", "boreal", "cinder"]),
|
| "milestones": ms})
|
| qs = [q_choice("first", "Which milestone completes first?", names,
|
| _one_hot(ends.index(min(ends)), len(names)))]
|
| w = rng.randint(2, 6)
|
| min_start = min(date.fromisoformat(m["start"]) for m in ms)
|
| qs.append(q_noul("allin",
|
| f"Do all milestones finish within {w} weeks of the "
|
| f"earliest start?",
|
| float(all(e <= min_start + timedelta(weeks=w)
|
| for e in ends))))
|
| k = rng.randint(5, 35)
|
| qs.append(q_noul("long",
|
| f"Is any single milestone longer than {k} days?",
|
| float(max(m["days"] for m in ms) > k)))
|
| return state, qs
|
|
|
|
|
|
|
|
|
| def gen_numeric_compare():
|
| scen = rng.choice(["models", "servers", "products"])
|
| if scen == "models":
|
| metrics = {"accuracy_pct": (70, 99, True),
|
| "latency_ms": (10, 200, False),
|
| "cost_per_1k": (1, 50, False)}
|
| na, nb = rng.sample(["falcon-7b", "kestrel-13b", "merlin-3b",
|
| "osprey-8b"], 2)
|
| elif scen == "servers":
|
| metrics = {"uptime_pct": (90, 100, True),
|
| "load_pct": (5, 95, False),
|
| "cost_hr": (1, 40, False)}
|
| na, nb = rng.sample(["node-a", "node-b", "node-c"], 2)
|
| else:
|
| metrics = {"rating_pct": (50, 99, True),
|
| "price": (5, 500, False),
|
| "weight_g": (50, 2000, False)}
|
| na, nb = rng.sample(PRODUCTS, 2)
|
| A = {m: rng.randint(lo, hi) for m, (lo, hi, _) in metrics.items()}
|
| B = {m: rng.randint(lo, hi) for m, (lo, hi, _) in metrics.items()}
|
| state = json.dumps({"candidate_a": {"name": na, **A},
|
| "candidate_b": {"name": nb, **B}})
|
| qs = []
|
|
|
|
|
| m = rng.choice(list(metrics))
|
| _, _, hb = metrics[m]
|
| if A[m] == B[m]:
|
| raise ValueError("tie")
|
| better = na if (A[m] > B[m]) == hb else nb
|
| d = "higher" if hb else "lower"
|
| opts = [na, nb]
|
| rng.shuffle(opts)
|
| qs.append(q_choice("better",
|
| rng.choice([
|
| f"By {m} ({d} is better), which candidate wins?",
|
| f"Which candidate has the better {m}? "
|
| f"({d} is better)"]),
|
| opts, _one_hot(opts.index(better), 2)))
|
|
|
|
|
| m2 = rng.choice(list(metrics))
|
| r = rng.choice([1.1, 1.25, 1.5, 2.0])
|
| qs.append(q_noul("ratio",
|
| f"Is {na}'s {m2} more than {r}x {nb}'s?",
|
| float(A[m2] / B[m2] > r)))
|
|
|
|
|
| m3 = rng.choice(list(metrics))
|
| lo3, hi3, hb3 = metrics[m3]
|
| t = rng.randint(lo3, hi3)
|
| if hb3:
|
| ans, phr = A[m3] >= t and B[m3] >= t, f"at least {t}"
|
| else:
|
| ans, phr = A[m3] <= t and B[m3] <= t, f"at most {t}"
|
| qs.append(q_noul("both",
|
| f"Do both candidates keep {m3} {phr}?", float(ans)))
|
| return state, qs
|
|
|
|
|
|
|
|
|
| def gen_nested_json():
|
| n = rng.randint(3, 4)
|
| skus = rng.sample(["KB-01", "MS-02", "HD-04", "CB-07", "LT-11",
|
| "DK-03"], n)
|
| items = [{"sku": s, "qty": rng.randint(1, 6),
|
| "unit_price": rng.randint(4, 120)} for s in skus]
|
| totals = [it["qty"] * it["unit_price"] for it in items]
|
| if len(set(totals)) != n:
|
| raise ValueError("tie")
|
| country = rng.choice(COUNTRIES)
|
| whitelist = rng.sample(COUNTRIES, rng.randint(3, 5))
|
| order = {"order_id": f"ORD-{rng.randint(1000, 9999)}",
|
| "customer": {"name": rng.choice(FIRST), "country": country,
|
| "vip": rng.random() < 0.3},
|
| "items": items,
|
| "shipping": {"whitelist": whitelist,
|
| "express": rng.random() < 0.5}}
|
| state = json.dumps(order, separators=(",", ":"))
|
| tot = sum(totals)
|
| t = rng.randint(int(tot * 0.5), int(tot * 1.5) + 1)
|
| qs = [q_choice("driver",
|
| rng.choice([
|
| "Which line item contributes most to the order "
|
| "total?",
|
| "Which item drives the largest share of the total?"]),
|
| skus, _one_hot(totals.index(max(totals)), n)),
|
| q_noul("ship",
|
| "Is the customer's country on the shipping whitelist?",
|
| float(country in whitelist)),
|
| q_noul("total", f"Does the order total exceed ${t}?",
|
| float(tot > t))]
|
| return state, qs
|
|
|
|
|
|
|
|
|
| def gen_mixed_state():
|
| mnames = rng.sample(["cpu", "mem", "disk", "net", "queue"],
|
| rng.randint(2, 3))
|
| arr = [{"type": "metric", "name": m, "value": rng.randint(1, 99)}
|
| for m in mnames]
|
| maint = rng.random() < 0.5
|
| notes = rng.sample(["note: deploy v2.1 shipped", "note: cache flushed",
|
| "note: on-call rotation updated",
|
| "note: firmware update pending",
|
| "note: backup completed"], rng.randint(1, 2))
|
| if maint:
|
| notes.append("note: nightly maintenance at 03:00 UTC")
|
| lvl = rng.choice(["warn", "critical"]) if rng.random() < 0.5 else None
|
| if lvl:
|
| arr.append({"type": "alert", "name": rng.choice(mnames),
|
| "level": lvl})
|
| arr += notes
|
| rng.shuffle(arr)
|
| state = json.dumps(arr, separators=(",", ":"))
|
| qs = []
|
|
|
|
|
| c = sum(1 for e in arr if isinstance(e, dict)
|
| and e.get("type") == "metric")
|
| opts_c = _count_opts(c, len(arr))
|
| qs.append(q_choice("n_metric",
|
| "How many metric records are in the payload?",
|
| opts_c,
|
| _one_hot(opts_c.index(str(c)), len(opts_c))))
|
|
|
|
|
| qs.append(q_noul("maint", "Does any entry mention maintenance?",
|
| float(any(isinstance(e, str) and "maintenance" in e
|
| for e in arr))))
|
|
|
|
|
| m = rng.choice(mnames)
|
| true_v = next(e["value"] for e in arr
|
| if isinstance(e, dict) and e.get("name") == m)
|
| cands = {true_v}
|
| while len(cands) < 4:
|
| cands.add(rng.randint(1, 99))
|
| opts_v = [str(x) for x in cands]
|
| rng.shuffle(opts_v)
|
| qs.append(q_choice("lookup",
|
| f"What value does the metric '{m}' report?",
|
| opts_v,
|
| _one_hot(opts_v.index(str(true_v)), 4)))
|
|
|
|
|
| qs.append(q_noul("alert",
|
| "Is there an alert with level 'critical'?",
|
| float(lvl == "critical")))
|
| return state, qs
|
|
|
|
|
| FAMILIES = {
|
| "json_records": gen_json_records,
|
| "log_lines": gen_log_lines,
|
| "tables": gen_tables,
|
| "temporal": gen_temporal,
|
| "numeric_compare": gen_numeric_compare,
|
| "nested_json": gen_nested_json,
|
| "mixed_state": gen_mixed_state,
|
| }
|
|
|
| WEIGHTS = {
|
| "json_records": 0.18, "log_lines": 0.14, "tables": 0.14,
|
| "temporal": 0.14, "numeric_compare": 0.13, "nested_json": 0.14,
|
| "mixed_state": 0.13,
|
| }
|
|
|
|
|
| def make_rows(n, seed):
|
| return generate(FAMILIES, WEIGHTS, n, seed, rng)
|
|
|
|
|
| if __name__ == "__main__":
|
| rows = make_rows(10, 0)
|
| for r in rows[:3]:
|
| validate_row(r)
|
| print(r["id"], "|", r["state"][:100])
|
| print(f"{len(rows)} rows OK")
|
|
|
