Non-autoregressive System 1 decision engine. Typed choice, score and yes/no decisions over any text in a single forward pass, in 100+ languages, with a router that picks the right checkpoint per request.
Python calibrationclassificationdecision-modelhuggingfacejevmodernbertmultilingualnlppythonpytorchroutingtyped-decisionszero-shot
feat(cli): score a file or stdin of requests in one batch
Aashishd16c7cc6e95c
diff --git a/laya/cli.py b/laya/cli.pyindex 9f6f9868..2a455a7a 100644--- a/laya/cli.py+++ b/laya/cli.py@@ -5,11 +5,15 @@laya # interactive modelaya "Mein Konto wurde zweimal belastet" --lang de # explicit languagelaya "My payment failed twice" --preset triage # a ready-made question preset+ laya --batch tickets.txt --predict # a file of requests, one per line+ cat tickets.txt | laya --batch - --predict --json # stdin, one JSON line of answers eachRouting (the default) never downloads a checkpoint, so it works offline andreturns in milliseconds. --predict loads the routed checkpoint on first use,which needs network access to the Hugging Face hub. --preset answers one of theready-made question presets from laya.presets and implies --predict.+--batch scores a whole file (or stdin, with `-`) through Router.predict_batch in one+process, so the states share checkpoint loads and forward passes; --json prints JSONL."""import argparse@@ -56,6 +60,13 @@ def build_parser():% ", ".join(sorted(PRESETS)))parser.add_argument("--device", help="torch device, e.g. cpu or cuda")parser.add_argument("--json", action="store_true", help="print the raw result as JSON")+ parser.add_argument("--batch", metavar="FILE",+ help="score a file of requests, one per line (use '-' for stdin), instead "+ "of a single text; implies neither --predict nor --preset, but the "+ "same modes apply: routing by default, answers with --predict/--preset")+ parser.add_argument("--batch-size", type=int, default=None, metavar="N",+ help="states per forward pass in --batch mode; the default sends each "+ "routed group in one pass")return parser@@ -129,6 +140,57 @@ def run(text, args, router=None):return 0+def read_batch_lines(source):+ """One request per non-blank line of FILE, or of stdin for '-'."""+ if source == "-":+ lines = sys.stdin.read().splitlines()+ else:+ with open(source, encoding="utf-8") as handle:+ lines = handle.read().splitlines()+ return [line.strip() for line in lines if line.strip()]+++def run_batch(lines, args, router=None):+ """Route or predict a whole file in one call, so states share checkpoint loads and+ forward passes; returns 0 on success, 2 on a handled error."""+ router = router or make_router(args)+ overrides = {key: value for key, value in (("model", args.model), ("task", args.task),+ ("lang", args.lang)) if value is not None}+ try:+ if args.predict or args.preset:+ questions = PRESETS[args.preset]() if args.preset else laya.router_questions()+ key = PRESET_STATE_KEYS.get(args.preset, "request")+ requests = [{"state": {key: line}, "questions": questions, **overrides}+ for line in lines]+ results = router.predict_batch(requests, batch_size=args.batch_size)+ for line, result in zip(lines, results):+ if args.json:+ print(json.dumps(result, ensure_ascii=False, default=str))+ else:+ print("# %s" % (line if len(line) <= 72 else line[:69] + "..."))+ show_answers(result)+ print()+ else:+ decisions = router.route_batch([{"state": {"text": line}, "questions": {},+ **overrides} for line in lines])+ for line, decision in zip(lines, decisions):+ if args.json:+ print(json.dumps(dict(decision), ensure_ascii=False, default=str))+ else:+ print("%-14s %s <- %s" % (decision["model"], decision["reason"],+ line if len(line) <= 48 else line[:45] + "..."))+ except ValueError as error:+ print("laya: %s" % error, file=sys.stderr)+ return 2+ except (ImportError, OSError, RuntimeError) as error:+ print("laya: could not run Laya (%s)." % error, file=sys.stderr)+ print("Check that the dependencies are installed and the checkpoints can be "+ "downloaded from the Hugging Face hub (network access is needed on first use).",+ file=sys.stderr)+ return 2+ return 0++def interactive(args):print("Laya interactive mode. Type a request and press Enter; Ctrl-D or 'quit' to exit.")router = make_router(args)@@ -151,6 +213,19 @@ def main(argv=None):return eval_main(argv[1:])args = build_parser().parse_args(argv)text = " ".join(args.text).strip()+ if args.batch:+ if text:+ print("laya: pass either a text or --batch FILE, not both.", file=sys.stderr)+ return 2+ try:+ lines = read_batch_lines(args.batch)+ except OSError as error:+ print("laya: could not read %s (%s)." % (args.batch, error), file=sys.stderr)+ return 2+ if not lines:+ print("laya: no requests found in %s." % args.batch, file=sys.stderr)+ return 2+ return run_batch(lines, args)if not text:return interactive(args)return run(text, args)diff --git a/tests/test_cli.py b/tests/test_cli.pyindex a4b3262a..3a386a11 100644--- a/tests/test_cli.py+++ b/tests/test_cli.py@@ -156,6 +156,111 @@ except SystemExit as exit_:code = exit_.codecheck("preset: unknown name rejected by argparse", code == 2, "got %r" % code)+# --------------------------------------------------------------------- batch mode+import json # noqa: E402+import tempfile # noqa: E402+++class BatchRouter:+ """Records whole-batch calls; any single-state call is a bug in batch mode."""++ def __init__(self):+ self.predict_batch_calls = []+ self.route_batch_calls = []++ def predict_batch(self, requests, batch_size=None):+ self.predict_batch_calls.append((requests, batch_size))+ return [{"model": "laya-rl", "answers": {"difficulty": {"score": float(i)}}, "usage": {}}+ for i in range(len(requests))]++ def route_batch(self, requests):+ self.route_batch_calls.append(requests)+ return [StubDecision() for _ in requests]++ def route(self, state, **kwargs):+ raise AssertionError("single route() called in batch mode")++ def predict(self, state, questions, **kwargs):+ raise AssertionError("single predict() called in batch mode")+++def run_batch_cli(argv, router=None):+ stub = router or BatchRouter()+ original = cli.make_router+ cli.make_router = lambda args: stub+ out, err = io.StringIO(), io.StringIO()+ try:+ with redirect_stdout(out), redirect_stderr(err):+ code = cli.main(argv)+ finally:+ cli.make_router = original+ return code, out.getvalue(), err.getvalue(), stub+++tmp = tempfile.mkdtemp()+path = os.path.join(tmp, "requests.txt")+with open(path, "w", encoding="utf-8") as handle:+ handle.write("first ticket\n\n second ticket \n")++code, out, err, stub = run_batch_cli(["--batch", path, "--predict", "--batch-size", "8"])+check("batch predict: exit code", code == 0, "got %r %s" % (code, err))+requests, batch_size = stub.predict_batch_calls[0]+check("batch predict: exactly one predict_batch call", len(stub.predict_batch_calls) == 1)+check("batch predict: blank lines skipped, lines stripped",+ [r["state"]["request"] for r in requests] == ["first ticket", "second ticket"],+ str([r["state"] for r in requests]))+check("batch predict: --batch-size forwarded", batch_size == 8, str(batch_size))+check("batch predict: router questions on every request",+ sorted(requests[0]["questions"]) == sorted(cli.PRESETS["router"]()),+ str(sorted(requests[0]["questions"])))+check("batch predict: answers printed for both states", out.count("difficulty") == 2, out)++code, out, err, stub = run_batch_cli(["--batch", path, "--predict", "--json"])+parsed = [json.loads(line) for line in out.splitlines() if line.strip()]+check("batch --json: one JSONL record per state", len(parsed) == 2+ and all("answers" in p for p in parsed), out)++code, out, err, stub = run_batch_cli(["--batch", path])+check("batch route: one route_batch call, no checkpoint",+ len(stub.route_batch_calls) == 1 and stub.predict_batch_calls == [])+check("batch route: one line per state", out.count("multilingual") == 2, out)++code, out, err, stub = run_batch_cli(["--batch", path, "--preset", "triage"])+requests = stub.predict_batch_calls[0][0]+check("batch preset: state key follows the preset",+ all(set(r["state"]) == {"message"} for r in requests), str([r["state"] for r in requests]))++code, out, err, stub = run_batch_cli(["--batch", path, "--predict", "--model", "english",+ "--lang", "de"])+first = stub.predict_batch_calls[0][0][0]+check("batch flags: model/lang forwarded onto every request",+ first.get("model") == "english" and first.get("lang") == "de", str(first))++code, out, err, stub = run_batch_cli(["--batch", os.path.join(tmp, "missing.txt")])+check("batch missing file: exit 2 with a named failure",+ code == 2 and "could not read" in err, "code %r err %r" % (code, err))++code, out, err, stub = run_batch_cli(["--batch", path, "inline text"])+check("batch: text and --batch are mutually exclusive",+ code == 2 and "not both" in err, "code %r err %r" % (code, err))++empty = os.path.join(tmp, "empty.txt")+open(empty, "w").close()+code, out, err, stub = run_batch_cli(["--batch", empty, "--predict"])+check("batch empty file: exit 2, no calls",+ code == 2 and "no requests" in err and stub.predict_batch_calls == [],+ "code %r err %r" % (code, err))++_original_stdin = sys.stdin+sys.stdin = io.StringIO("piped one\npiped two\n")+try:+ code, out, err, stub = run_batch_cli(["--batch", "-", "--predict", "--json"])+finally:+ sys.stdin = _original_stdin+check("batch -: reads stdin", code == 0+ and len(stub.predict_batch_calls[0][0]) == 2+ and len([l for l in out.splitlines() if l.strip()]) == 2, "code %r err %r" % (code, err))+# --------------------------------------------------------------------- reportprint("\n%d passed, %d failed" % (len(PASS), len(FAIL)))for f in FAIL: