Skip to content

armgit / laya

Public Imported from GitHub
0

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.

feat(cli): score a file or stdin of requests in one batch

Aashishd16c7cc6e95c
diff --git a/laya/cli.py b/laya/cli.py
index 9f6f9868..2a455a7a 100644
--- a/laya/cli.py
+++ b/laya/cli.py
@@ -5,11 +5,15 @@
laya # interactive mode
laya "Mein Konto wurde zweimal belastet" --lang de # explicit language
laya "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 each
Routing (the default) never downloads a checkpoint, so it works offline and
returns in milliseconds. --predict loads the routed checkpoint on first use,
which needs network access to the Hugging Face hub. --preset answers one of the
ready-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.py
index a4b3262a..3a386a11 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -156,6 +156,111 @@ except SystemExit as exit_:
code = exit_.code
check("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))
+
# --------------------------------------------------------------------- report
print("\n%d passed, %d failed" % (len(PASS), len(FAIL)))
for f in FAIL: