| """Deterministic additional domain inputs, generated without model/reference output.""" |
|
|
| import csv |
| import datetime as dt |
| import io |
| import random |
|
|
|
|
| def generated_inputs(family, count=24, seed=1729): |
| r = random.Random(f"{seed}/{family}/domain") |
|
|
| def nums(): |
| return [r.randrange(-9, 10) for _ in range(r.randrange(12))] |
|
|
| def words(): |
| return [ |
| r.choice(["a", "b", "c", "", "é", "a/b"]) for _ in range(r.randrange(12)) |
| ] |
|
|
| def text(chars="abAB09_ -é\n"): |
| return "".join(r.choices(chars, k=r.randrange(60))) |
|
|
| def intervals(): |
| return [ |
| sorted([r.randrange(-10, 11), r.randrange(-10, 11)]) |
| for _ in range(r.randrange(10)) |
| ] |
|
|
| for _ in range(count): |
| if family in {"word_frequency", "run_length"}: |
| x = {"text": text()} |
| elif family == "bracket_audit": |
| x = {"text": text("()[]{}abcé ")} |
| elif family == "slug_registry": |
| x = {"titles": [text("aAB -_/é") for _ in range(r.randrange(12))]} |
| elif family == "text_wrap": |
| x = {"text": text(), "width": r.randrange(1, 20)} |
| elif family == "ngram_index": |
| x = {"tokens": words(), "n": r.randrange(1, 5)} |
| elif family == "glob_filter": |
| x = { |
| "paths": words(), |
| "pattern": r.choice(["*", "?", "[abc]*", "*/*", "[!a]*", "é"]), |
| } |
| elif family == "edit_distance": |
| x = {"a": text(), "b": text()} |
| elif family == "roman_codec": |
| x = {"number": r.randrange(1, 4000)} |
| elif family == "caesar_cipher": |
| x = {"text": text(), "shift": r.randrange(-1000, 1001)} |
| elif family == "csv_records": |
| stream = io.StringIO() |
| writer = csv.writer(stream) |
| writer.writerow(["a", "b"]) |
| writer.writerows( |
| [[text('a,b"\né '), text()] for _ in range(r.randrange(8))] |
| ) |
| x = {"csv": stream.getvalue()} |
| elif family in {"record_query", "dedupe_records"}: |
| rows = [ |
| {k: r.choice([None, 1, 2, "x"]) for k in ("a", "b") if r.random() < 0.8} |
| for _ in range(r.randrange(15)) |
| ] |
| x = ( |
| { |
| "rows": rows, |
| "where": {"a": r.choice([None, 1, 2])}, |
| "select": ["b", "c"], |
| } |
| if family == "record_query" |
| else {"rows": rows, "keys": r.choice([[], ["a"], ["a", "b"]])} |
| ) |
| elif family == "inner_join": |
| x = { |
| "left": [{"k": r.randrange(4)} for _ in range(r.randrange(8))], |
| "right": [{"k": r.randrange(4)} for _ in range(r.randrange(8))], |
| "key": "k", |
| } |
| elif family == "group_totals": |
| x = { |
| "rows": [ |
| {"g": r.choice(["a", "b", ""]), "v": r.randrange(-20, 21)} |
| for _ in range(r.randrange(16)) |
| ], |
| "group": "g", |
| "value": "v", |
| } |
| elif family == "pivot_table": |
| x = { |
| "rows": [ |
| { |
| "r": r.choice(["a", "b", ""]), |
| "c": r.choice(["x", "y"]), |
| "v": r.randrange(-9, 10), |
| } |
| for _ in range(r.randrange(16)) |
| ], |
| "row": "r", |
| "column": "c", |
| "value": "v", |
| } |
| elif family in {"json_flatten", "merge_patch", "json_pointer"}: |
| value = { |
| "a/b": [nums(), {}, None], |
| "~": {"": r.randrange(9)}, |
| "x": r.choice([True, None, "é"]), |
| } |
| if family == "json_flatten": |
| x = {"value": value} |
| elif family == "merge_patch": |
| x = { |
| "target": value, |
| "patch": { |
| "a/b": r.choice([None, [1], {"z": 2}]), |
| "x": {"v": r.randrange(9)}, |
| }, |
| } |
| else: |
| x = { |
| "value": value, |
| "pointer": r.choice( |
| ["", "/a~1b/0", "/a~1b/99", "/~0/", "/x/no", "/absent"] |
| ), |
| } |
| elif family == "schema_check": |
| x = { |
| "schema": { |
| k: { |
| "type": r.choice( |
| [ |
| "integer", |
| "number", |
| "boolean", |
| "string", |
| "array", |
| "object", |
| "null", |
| ] |
| ), |
| "required": r.choice([True, False]), |
| } |
| for k in ("a", "b", "c") |
| }, |
| "value": { |
| k: r.choice([True, 1, 1.5, "x", [], {}, None]) |
| for k in ("a", "b") |
| if r.random() < 0.8 |
| }, |
| } |
| elif family in { |
| "interval_union", |
| "interval_gaps", |
| "booking_peak", |
| "uptime_report", |
| }: |
| pairs = intervals() |
| if family == "booking_peak": |
| x = {"bookings": pairs} |
| elif family == "uptime_report": |
| x = {"start": -5, "end": 5, "downtime": pairs} |
| else: |
| x = {"intervals": pairs} |
| if family == "interval_gaps": |
| x["bounds"] = [-5, 5] |
| elif family == "business_days": |
| start = dt.date(2000, 1, 1) + dt.timedelta(days=r.randrange(9000)) |
| x = { |
| "start": start.isoformat(), |
| "end": (start + dt.timedelta(days=r.randrange(30))).isoformat(), |
| "holidays": [ |
| (start + dt.timedelta(days=r.randrange(30))).isoformat() |
| for _ in range(5) |
| ], |
| } |
| elif family == "calendar_month": |
| x = {"year": r.randrange(1900, 2101), "month": r.randrange(1, 13)} |
| elif family == "moving_average": |
| x = {"values": nums(), "window": r.randrange(1, 8)} |
| elif family == "statistics": |
| x = {"values": nums()} |
| elif family == "histogram": |
| x = {"values": nums(), "edges": sorted(r.sample(range(-10, 11), 5))} |
| elif family == "matrix_product": |
| m, n, p = [r.randrange(1, 5) for _ in range(3)] |
| x = { |
| "a": [[r.randrange(-4, 5) for _ in range(n)] for _ in range(m)], |
| "b": [[r.randrange(-4, 5) for _ in range(p)] for _ in range(n)], |
| } |
| elif family == "polynomial": |
| x = {"coefficients": nums(), "points": nums()} |
| elif family == "prime_factors": |
| x = {"number": r.randrange(1, 100001)} |
| elif family == "base_convert": |
| x = { |
| "digits": str(r.randrange(-(2**70), 2**70)), |
| "from_base": 10, |
| "to_base": r.randrange(2, 37), |
| } |
| elif family == "money_split": |
| x = { |
| "amount": r.randrange(10000), |
| "weights": [r.randrange(1, 20)] |
| + [r.randrange(20) for _ in range(r.randrange(8))], |
| } |
| elif family == "invoice_total": |
| x = { |
| "items": [ |
| { |
| "price": f"{r.randrange(100)}.{r.randrange(1000):03d}", |
| "quantity": r.randrange(10), |
| } |
| for _ in range(r.randrange(8)) |
| ], |
| "tax_rate": r.choice(["0", "0.075", "0.20"]), |
| } |
| elif family == "coin_change": |
| x = { |
| "coins": [r.randrange(1, 15) for _ in range(r.randrange(8))], |
| "amount": r.randrange(100), |
| } |
| elif family in { |
| "graph_reach", |
| "shortest_path", |
| "topological_order", |
| "connected_components", |
| }: |
| nodes = list("abcdef")[: r.randrange(1, 7)] |
| edges = [[r.choice(nodes), r.choice(nodes)] for _ in range(r.randrange(15))] |
| if family == "shortest_path": |
| edges = [edge + [r.randrange(10)] for edge in edges] |
| x = {"nodes": nodes, "edges": edges} |
| if family in {"graph_reach", "shortest_path"}: |
| x["start"] = r.choice(nodes) |
| elif family == "grid_route": |
| grid = ["".join(r.choices(".#", weights=[4, 1], k=5)) for _ in range(5)] |
| x = { |
| "grid": grid, |
| "start": [r.randrange(5), r.randrange(5)], |
| "end": [r.randrange(5), r.randrange(5)], |
| } |
| elif family == "tree_outline": |
| nodes = [] |
| for key in list("abcdefgh")[: r.randrange(9)]: |
| nodes.append( |
| {"id": key, "parent": r.choice([None] + [n["id"] for n in nodes])} |
| ) |
| r.shuffle(nodes) |
| x = {"nodes": nodes} |
| elif family == "dependency_build": |
| nodes = list("abcde")[: r.randrange(1, 6)] |
| x = { |
| "dependencies": { |
| n: r.sample(nodes, r.randrange(len(nodes) + 1)) for n in nodes |
| }, |
| "targets": r.sample(nodes, r.randrange(len(nodes) + 1)), |
| } |
| elif family == "path_normalize": |
| x = { |
| "paths": [ |
| "/".join( |
| r.choices(["a", "b", "..", ".", "", "é"], k=r.randrange(10)) |
| ) |
| for _ in range(r.randrange(12)) |
| ] |
| } |
| elif family == "url_query": |
| x = { |
| "query": "&".join( |
| r.choices( |
| ["a=1", "a=2", "x=a+b", "x=%2B", "flag", "", "=v", "q=%C3%A9"], |
| k=r.randrange(12), |
| ) |
| ) |
| } |
| elif family == "version_sort": |
| x = { |
| "versions": [ |
| f"{r.randrange(3)}.{r.randrange(12)}.{r.randrange(5)}" |
| + r.choice(["", "-a", "-a.2", "-a.10", "-1", "-b"]) |
| for _ in range(r.randrange(15)) |
| ] |
| } |
| elif family == "lru_trace": |
| x = {"capacity": r.randrange(6), "accesses": words()} |
| elif family == "rate_limit": |
| x = { |
| "events": [ |
| {"time": t, "key": r.choice(["a", "b"])} |
| for t in sorted(r.choices(range(12), k=r.randrange(20))) |
| ], |
| "window": r.randrange(1, 8), |
| "limit": r.randrange(5), |
| } |
| elif family == "priority_queue": |
| x = { |
| "events": [ |
| {"op": "pop"} |
| if r.random() < 0.4 |
| else { |
| "op": "push", |
| "priority": r.randrange(-2, 3), |
| "value": r.choice([None, "x", {"a": 1}, []]), |
| } |
| for _ in range(r.randrange(20)) |
| ] |
| } |
| elif family == "round_robin": |
| x = { |
| "jobs": [ |
| {"id": str(i), "duration": r.randrange(1, 12)} |
| for i in range(r.randrange(6)) |
| ], |
| "quantum": r.randrange(1, 6), |
| } |
| elif family == "inventory_ledger": |
| x = { |
| "events": [ |
| {"sku": r.choice(["a", "b", "c"]), "delta": r.randrange(-5, 6)} |
| for _ in range(r.randrange(20)) |
| ] |
| } |
| elif family == "bank_ledger": |
| x = { |
| "balances": {"a": r.randrange(20), "b": r.randrange(20)}, |
| "transfers": [ |
| { |
| "from": r.choice(["a", "b", "missing"]), |
| "to": r.choice(["a", "b", "missing"]), |
| "amount": r.randrange(1, 12), |
| } |
| for _ in range(r.randrange(12)) |
| ], |
| } |
| elif family == "ballot_count": |
| x = { |
| "candidates": ["a", "b", "c"], |
| "votes": r.choices(["a", "b", "c", "bad"], k=r.randrange(30)), |
| } |
| elif family == "search_rank": |
| x = { |
| "documents": [ |
| {"id": str(i), "text": text()} for i in range(r.randrange(8)) |
| ], |
| "query": text(), |
| } |
| elif family == "log_summary": |
| x = { |
| "events": [ |
| { |
| "level": r.choice(["ERROR", "INFO", "WARN", "error"]), |
| "message": text(), |
| } |
| for _ in range(r.randrange(12)) |
| ] |
| } |
| elif family == "segment_intersection": |
| x = {k: [r.randrange(-4, 5), r.randrange(-4, 5)] for k in "abcd"} |
| elif family == "polygon_area": |
| a, b, c, d = [r.randrange(1, 10) for _ in range(4)] |
| x = {"points": [[-a, -b], [c, -b], [c, d], [-a, d]]} |
| if r.random() < 0.5: |
| x["points"].reverse() |
| elif family == "skyline": |
| x = { |
| "buildings": [ |
| [a, a + r.randrange(1, 8), r.randrange(1, 10)] |
| for a in [r.randrange(-5, 6) for _ in range(r.randrange(12))] |
| ] |
| } |
| elif family == "knapsack": |
| x = { |
| "items": [ |
| {"weight": r.randrange(1, 10), "value": r.randrange(20)} |
| for _ in range(r.randrange(10)) |
| ], |
| "capacity": r.randrange(25), |
| } |
| elif family == "task_selection": |
| x = { |
| "tasks": [ |
| {"id": str(i), "start": a, "end": a + r.randrange(1, 8)} |
| for i, a in enumerate( |
| [r.randrange(-5, 8) for _ in range(r.randrange(12))] |
| ) |
| ] |
| } |
| elif family == "sequence_diff": |
| x = {"a": words(), "b": words()} |
| elif family == "finite_automaton": |
| x = { |
| "start": "a", |
| "accepting": r.sample(["a", "b"], r.randrange(3)), |
| "transitions": [ |
| {"from": a, "symbol": c, "to": r.choice(["a", "b"])} |
| for a in ["a", "b"] |
| for c in "xy" |
| if r.random() < 0.8 |
| ], |
| "words": [ |
| "".join(r.choices("xy", k=r.randrange(10))) |
| for _ in range(r.randrange(12)) |
| ], |
| } |
| elif family == "content_manifest": |
| x = {"files": {str(i) + "/é": text() for i in range(r.randrange(8))}} |
| elif family == "cellular_automaton": |
| x = { |
| "live": [ |
| [r.randrange(-3, 4), r.randrange(-3, 4)] |
| for _ in range(r.randrange(20)) |
| ], |
| "steps": r.randrange(5), |
| } |
| elif family == "expression_eval": |
| x = { |
| "tokens": [ |
| str(r.randrange(-100, 101)), |
| str(r.randrange(-100, 101)), |
| r.choice(["+", "-", "*"]), |
| str(r.randrange(1, 10)), |
| "/", |
| ] |
| } |
| else: |
| raise ValueError(f"No generator for {family}") |
| yield x |
|
|
