Datasets:

CodeIsAbstract
/

sanskrit-sandhi-boundaries-v2

"""
decode_v2.py — Improved decoder for Sanskrit sandhi/samasa vigraha.
Fixes the provable decoder bugs found in decode_best.py (non-destructive; this
file does not modify decode_best.py):
  1. Kosha scoring now normalizes terminal H->s/r and M->m, so valid words
     like 'guruH', 'saH', 'manaH', 'aDikAraH' score properly instead of 0.
  2. Surface-normalization for rejoin checks normalizes M->m and H->s.
  3. Decoding is a BEAM SEARCH over (words, demodulated-remainder) states:
       - the recursion state is the *demodulated* remainder returned by
         Vidyut's split_at, which correctly handles vowel-absorption
         boundaries (e.g. na + anftaM -> nAnftaM: the 'a' is restored in
         the remainder);
       - candidate boundaries are probability ISLANDS (low threshold, +/-1
         window around peaks), so off-by-one boundary positions are still
         reachable;
       - each expansion verifies rejoin(first, remainder) == surface;
       - the FINAL answer is globally verified: sandhi_join(words) must
         reconstruct the ORIGINAL input, else the best-scoring
         globally-consistent alternative is preferred.
Usage:
    python decode_v2.py "vidyAdadAtivinayaMvinayAdyAtipAtratAm"
    python decode_v2.py --test
"""
from __future__ import annotations

import os
import sys
import math
import argparse
from typing import List, Tuple, Optional

os.environ.setdefault("TMPDIR", os.path.join(os.path.dirname(os.path.abspath(__file__)), ".tmp"))

import torch

import decode_best as DB  # reuses predict(), do_sandhi_join(), _splitter, _kosha

DELAY = 2
CAND_TH = 0.30          # any position with prob >= this is a candidate boundary
PEAK_TH = 0.50          # +/-1 window around positions >= this are candidates
WINDOW = 1
BEAM = 8
MAX_WORDS = 14
FRAG_PENALTY = 0.8      # per-word penalty favoring natural (fewer) segmentations


# ---------------------------------------------------------------------------
# Fixed helpers
# ---------------------------------------------------------------------------

def _norm(s: str) -> str:
    """Surface-normalize for equality comparisons: M~m and H~s."""
    return s.replace("M", "m").replace("H", "s")


def safe_join(*arg_words) -> str:
    """do_sandhi_join with a guard: sandhi_parser.join can return None for
    some pairs (e.g. with avagraha). Falls back to plain concatenation."""
    if not arg_words:
        return ""
    join = arg_words[0]
    for word in arg_words[1:]:
        try:
            j = DB._sandhi.join(DB.SanskritImmutableString(join, encoding="slp1"),
                                DB.SanskritImmutableString(word, encoding="slp1"))
            join_list = sorted(list(j)) if j is not None else []
        except Exception:
            join_list = []
        filtered = [o for o in join_list if o != (join + word)]
        if len(filtered):
            join = filtered[0]
        elif join_list:
            join = join_list[0]
        else:
            join = join + word
    return join.replace(" ", "")


def join_variants(*words, cap: int = 12) -> List[str]:
    """All sandhi-join variants of a word sequence (each pair can have
    several surface realisations; sorted() in do_sandhi_join picks just one
    arbitrarily, which may not equal the actual surface)."""
    if not words:
        return [""]
    variants = [words[0]]
    for word in words[1:]:
        nv = []
        for j in variants:
            try:
                jl = DB._sandhi.join(DB.SanskritImmutableString(j, encoding="slp1"),
                                     DB.SanskritImmutableString(word, encoding="slp1"))
            except Exception:
                jl = None
            if jl:
                nv.extend(o.replace(" ", "") for o in jl)
            else:
                nv.append(j + word)
        variants = list(dict.fromkeys(nv))[:cap]
    return variants


def rejoins(surface: str, *words) -> bool:
    """True if SOME sandhi-join variant of words reconstructs `surface`
    (normalized). Unlike do_sandhi_join, this is not fooled by the
    arbitrary sorted()-variant selection (e.g. guruH vs gurur)."""
    if not words:
        return False
    s = _norm(surface)
    return any(_norm(v) == s for v in join_variants(*words))


def kosha_variants(word: str):
    vs = {word}
    if word.endswith("H"):
        vs.add(word[:-1] + "s")
        vs.add(word[:-1] + "r")
    if word.endswith("M"):
        vs.add(word[:-1] + "m")
    if word.endswith("m"):
        vs.add(word[:-1] + "M")
    if word.endswith("s"):
        vs.add(word[:-1] + "H")
        vs.add(word[:-1] + "r")
    if word.endswith("r"):
        vs.add(word[:-1] + "s")
        vs.add(word[:-1] + "H")
    return vs


def word_score(word: str) -> float:
    """Fixed kosha score: 1.0 pada / 0.5 stem / 0.0 non-word, with H/M
    normalization so 'guruH', 'manaH', 'saH', 'anftaM' validate correctly."""
    if not word or len(word) < 2:
        return 0.0
    if word in DB.SAFE_PREFIX_CANDIDATES:
        return 1.0
    for v in kosha_variants(word):
        entries = DB._kosha.get(v)
        if entries:
            from vidyut.kosha import PadaEntry
            if any(isinstance(e, PadaEntry) for e in entries):
                return 1.0
            return 0.5
    return 0.0


def word_prior(word: str) -> float:
    """Ranking bonus for a candidate word (pada > stem > junk)."""
    ws = word_score(word)
    if ws >= 1.0:
        return 1.2
    if ws >= 0.5:
        return 0.3
    return -3.0


# ---------------------------------------------------------------------------
# Candidate generation
# ---------------------------------------------------------------------------

def island_positions(probs, n: int, cand_th: float = CAND_TH,
                     peak_th: float = PEAK_TH) -> List[int]:
    """Boundary candidates: all positions with prob >= cand_th, plus +/-1
    around any position with prob >= peak_th."""
    pos = set()
    for i in range(n):
        p = probs[i].item()
        if p >= cand_th:
            pos.add(i)
        if p >= peak_th:
            for d in range(1, WINDOW + 1):
                if i - d >= 0:
                    pos.add(i - d)
                if i + d < n:
                    pos.add(i + d)
    return sorted(pos)


def split_candidates(surface: str, idx: int) -> List[Tuple[str, str]]:
    """Grammar-valid (first, remainder) splits of `surface` at boundary idx
    (idx = index of the last char of the first word). The demodulated
    remainder is returned so vowel-absorption boundaries stay aligned."""
    out = []
    if idx < 0 or idx >= len(surface):
        return out
    try:
        splits = DB._splitter.split_at(surface, idx)
    except Exception:
        splits = []
    seen = set()
    for s in splits:
        f, sec = s.first, s.second
        if not f or not sec:
            continue
        if (f, sec) in seen:
            continue
        seen.add((f, sec))
        if rejoins(surface, f, sec):
            out.append((f, sec))
    return out


# ---------------------------------------------------------------------------
# Beam search
# ---------------------------------------------------------------------------

def decode(model, text: str, beam_size: int = BEAM, cand_th: float = CAND_TH,
           max_words: int = MAX_WORDS, delay: int = DELAY):
    """Return (words, score, verified) — verified=True iff the words rejoin
    to the original input. Never raises; never drops the input silently."""
    if not text:
        return [], 0.0, False

    def logit(p: float) -> float:
        p = max(min(p, 1 - 1e-5), 1e-5)
        return math.log(p / (1 - p))

    beam = [([], text, 0.0)]  # (words, remaining_surface, score)
    complete = []

    for step in range(max_words):
        if not beam:
            break
        nxt = []
        for words, remaining, score in beam:
            if not remaining:
                complete.append((words, score))
                continue
            rprobs = DB.predict(model, remaining, delay=delay)
            cands = island_positions(rprobs, len(remaining), cand_th)
            expanded = False
            for k in cands:
                for f, sec in split_candidates(remaining, k):
                    wsc = word_score(f)
                    if wsc <= 0:
                        continue
                    sc = (score
                          + logit(rprobs[k].item())
                          + word_prior(f)
                          - FRAG_PENALTY)
                    nxt.append((words + [f], sec, sc))
                    expanded = True
            if not expanded and len(words) + 1 < max_words:
                # dead end: try completing the whole remainder as one word
                wsc = word_score(remaining)
                if wsc > 0:
                    nxt.append((words + [remaining], "",
                                score + word_prior(remaining) - FRAG_PENALTY))
        # dedupe by (words, remaining) keeping best score
        best = {}
        for words, remaining, score in nxt:
            key = (tuple(words), remaining)
            if key not in best or score > best[key][0]:
                best[key] = (score, words)
        # deterministic ordering: score desc, then key asc (tie-breaking must
        # not depend on dict insertion order, which varies with hash seed)
        beam = []
        for (wkey, rem) in sorted(best.keys(), key=lambda k: (-best[k][0], k)):
            beam.append((list(best[(wkey, rem)][1]), rem, best[(wkey, rem)][0]))
        beam = beam[:beam_size]
        # keep anything that completed
        complete = sorted(complete, key=lambda x: (-x[1], x[0]))

    # also allow the beam itself to hold completed states
    for words, remaining, score in beam:
        if not remaining:
            complete.append((words, score))
    complete = sorted(set((tuple(w), s) for w, s in complete),
                      key=lambda x: (-x[1], x[0]))

    # Global verification: SOME join of the words must reconstruct the input
    verified_list = []
    for words, score in complete:
        if not words:
            continue
        if rejoins(text, *words):
            verified_list.append((words, score, True))
    if verified_list:
        words, score, _ = max(verified_list, key=lambda x: (x[1], x[0]))
        return list(words), score, True

    # Fallback: best-scoring complete segmentation (flag as unverified)
    if complete:
        words, score = complete[0]
        return list(words), score, False

    # Total failure: return the input as a single token rather than dropping it
    return [text], -1e9, False


def decode_wrap(model, text: str, **kw) -> List[str]:
    """Handle '~' split markers like decode_best.wrap_complex_string_handler,
    then decode each chunk and concatenate."""
    inputs = []
    t = text
    while "~" in t:
        try:
            splits = list(DB._sandhi.split_at(DB.SanskritImmutableString(t), t.index("~") - 1))
        except Exception:
            splits = []
        for s in splits:
            if t == safe_join(*s):
                inputs.append(s[0])
                t = s[1]
                break
        else:
            inputs.append(t)
            t = ""
    if t:
        inputs.append(t)
    result = []
    for chunk in inputs:
        words, score, verified = decode(model, chunk, **kw)
        result.extend(words)
    return result


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

TEST_CASES = [
    ("vidyAdadAtivinayaMvinayAdyAtipAtratAm",
     ["vidyA", "dadAti", "vinayam", "vinayAt", "yAti", "pAtratAm"]),
    ("satyamevajayatenAnftaM",
     ["satyam", "eva", "jayate", "na", "anftam"]),
    ("gururbrahmAgururviSfuH",
     ["guruH", "brahmA", "guruH", "viSfuH"]),
    ("hitopadeSaHsurocanasya",
     ["hita", "upadeSaH", "surocanasya"]),
    ("sarvaDarmAnparityajyamAmekaMSaraRaMvraja",
     ["sarva", "DarmAn", "parityajya", "mAm", "ekam", "SaraRam", "vraja"]),
    ("tacCrutvAvacanamapuRyam",
     ["tat", "SrutvA", "vacanam", "apuRyam"]),
    ("so'vadatkimatra",
     ["saH", "avadat", "kim", "atra"]),
    ("ityuktvAkamalApatirantardaqe",
     ["iti", "uktvA", "kamalApatiH", "antaH", "daqe"]),
    ("etatmamamano'BirAmam",
     ["etat", "mama", "manaH", "aBirAmam"]),
    ("karmARyevADikArastemAphalezukadAcana",
     ["karmaRi", "eva", "aDikAraH", "te", "mA", "phalezu", "kadAcana"]),
]


def main():
    parser = argparse.ArgumentParser(description="decode_v2: beam-search vigraha decoder")
    parser.add_argument("text", nargs="?", default=None)
    parser.add_argument("--test", action="store_true", help="run the 10 test cases")
    parser.add_argument("--checkpoint", default="checkpoints/delayed_model_save_fixed_delay2_v2")
    parser.add_argument("--beam", type=int, default=BEAM)
    parser.add_argument("--cand-th", type=float, default=CAND_TH)
    args = parser.parse_args()

    device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
    print(f"Device: {device}", file=sys.stderr)
    model, delay = DB.load_model(args.checkpoint, device)
    print(f"Loaded model (delay={delay})", file=sys.stderr)

    if args.text:
        raw = args.text
        text = DB.give_correct_slp1_input(raw) if raw and any(ord(c) > 127 for c in raw) else raw.replace(" ", "")
        res = decode_wrap(model, text, beam_size=args.beam, cand_th=args.cand_th)
        print(f"{raw} => {res}")
        return

    if args.test:
        exact = 0
        norm_exact = 0
        print(f"{'input':40s} {'exact':6s} {'norm':6s} {'rejoin':7s}  decoded")
        for inp, exp in TEST_CASES:
            res = decode_wrap(model, inp, beam_size=args.beam, cand_th=args.cand_th)
            ok = res == exp
            nok = (len(res) == len(exp) and
                   all(_norm(a) == _norm(b) or
                       (a[:-1] == b[:-1] and a[-1:] in "Hsr" and b[-1:] in "Hsr")
                       for a, b in zip(res, exp)))
            rejoined = safe_join(*res) if res else ""
            rej = rejoins(inp, *res) if res else False
            if ok:
                exact += 1
            if nok:
                norm_exact += 1
            print(f"{inp[:39]:40s} {str(ok):6s} {str(nok):6s} {str(rej):7s}  {' + '.join(res)}")
        print(f"\nExact: {exact}/{len(TEST_CASES)}   (normalized: {norm_exact}/{len(TEST_CASES)})")
        return

if __name__ == "__main__":
    main()

	"""
	decode_v2.py — Improved decoder for Sanskrit sandhi/samasa vigraha.

	Fixes the provable decoder bugs found in decode_best.py (non-destructive; this
	file does not modify decode_best.py):

	1. Kosha scoring now normalizes terminal H->s/r and M->m, so valid words
	like 'guruH', 'saH', 'manaH', 'aDikAraH' score properly instead of 0.
	2. Surface-normalization for rejoin checks normalizes M->m and H->s.
	3. Decoding is a BEAM SEARCH over (words, demodulated-remainder) states:
	- the recursion state is the demodulated remainder returned by
	Vidyut's split_at, which correctly handles vowel-absorption
	boundaries (e.g. na + anftaM -> nAnftaM: the 'a' is restored in
	the remainder);
	- candidate boundaries are probability ISLANDS (low threshold, +/-1
	window around peaks), so off-by-one boundary positions are still
	reachable;
	- each expansion verifies rejoin(first, remainder) == surface;
	- the FINAL answer is globally verified: sandhi_join(words) must
	reconstruct the ORIGINAL input, else the best-scoring
	globally-consistent alternative is preferred.

	Usage:
	python decode_v2.py "vidyAdadAtivinayaMvinayAdyAtipAtratAm"
	python decode_v2.py --test
	"""
	from __future__ import annotations

	import os
	import sys
	import math
	import argparse
	from typing import List, Tuple, Optional

	os.environ.setdefault("TMPDIR", os.path.join(os.path.dirname(os.path.abspath(__file__)), ".tmp"))

	import torch

	import decode_best as DB # reuses predict(), do_sandhi_join(), _splitter, _kosha

	DELAY = 2
	CAND_TH = 0.30 # any position with prob >= this is a candidate boundary
	PEAK_TH = 0.50 # +/-1 window around positions >= this are candidates
	WINDOW = 1
	BEAM = 8
	MAX_WORDS = 14
	FRAG_PENALTY = 0.8 # per-word penalty favoring natural (fewer) segmentations


	# ---------------------------------------------------------------------------
	# Fixed helpers
	# ---------------------------------------------------------------------------

	def _norm(s: str) -> str:
	"""Surface-normalize for equality comparisons: M~m and H~s."""
	return s.replace("M", "m").replace("H", "s")


	def safe_join(*arg_words) -> str:
	"""do_sandhi_join with a guard: sandhi_parser.join can return None for
	some pairs (e.g. with avagraha). Falls back to plain concatenation."""
	if not arg_words:
	return ""
	join = arg_words[0]
	for word in arg_words[1:]:
	try:
	j = DB._sandhi.join(DB.SanskritImmutableString(join, encoding="slp1"),
	DB.SanskritImmutableString(word, encoding="slp1"))
	join_list = sorted(list(j)) if j is not None else []
	except Exception:
	join_list = []
	filtered = [o for o in join_list if o != (join + word)]
	if len(filtered):
	join = filtered[0]
	elif join_list:
	join = join_list[0]
	else:
	join = join + word
	return join.replace(" ", "")


	def join_variants(*words, cap: int = 12) -> List[str]:
	"""All sandhi-join variants of a word sequence (each pair can have
	several surface realisations; sorted() in do_sandhi_join picks just one
	arbitrarily, which may not equal the actual surface)."""
	if not words:
	return [""]
	variants = [words[0]]
	for word in words[1:]:
	nv = []
	for j in variants:
	try:
	jl = DB._sandhi.join(DB.SanskritImmutableString(j, encoding="slp1"),
	DB.SanskritImmutableString(word, encoding="slp1"))
	except Exception:
	jl = None
	if jl:
	nv.extend(o.replace(" ", "") for o in jl)
	else:
	nv.append(j + word)
	variants = list(dict.fromkeys(nv))[:cap]
	return variants


	def rejoins(surface: str, *words) -> bool:
	"""True if SOME sandhi-join variant of words reconstructs `surface`
	(normalized). Unlike do_sandhi_join, this is not fooled by the
	arbitrary sorted()-variant selection (e.g. guruH vs gurur)."""
	if not words:
	return False
	s = _norm(surface)
	return any(_norm(v) == s for v in join_variants(*words))


	def kosha_variants(word: str):
	vs = {word}
	if word.endswith("H"):
	vs.add(word[:-1] + "s")
	vs.add(word[:-1] + "r")
	if word.endswith("M"):
	vs.add(word[:-1] + "m")
	if word.endswith("m"):
	vs.add(word[:-1] + "M")
	if word.endswith("s"):
	vs.add(word[:-1] + "H")
	vs.add(word[:-1] + "r")
	if word.endswith("r"):
	vs.add(word[:-1] + "s")
	vs.add(word[:-1] + "H")
	return vs


	def word_score(word: str) -> float:
	"""Fixed kosha score: 1.0 pada / 0.5 stem / 0.0 non-word, with H/M
	normalization so 'guruH', 'manaH', 'saH', 'anftaM' validate correctly."""
	if not word or len(word) < 2:
	return 0.0
	if word in DB.SAFE_PREFIX_CANDIDATES:
	return 1.0
	for v in kosha_variants(word):
	entries = DB._kosha.get(v)
	if entries:
	from vidyut.kosha import PadaEntry
	if any(isinstance(e, PadaEntry) for e in entries):
	return 1.0
	return 0.5
	return 0.0


	def word_prior(word: str) -> float:
	"""Ranking bonus for a candidate word (pada > stem > junk)."""
	ws = word_score(word)
	if ws >= 1.0:
	return 1.2
	if ws >= 0.5:
	return 0.3
	return -3.0


	# ---------------------------------------------------------------------------
	# Candidate generation
	# ---------------------------------------------------------------------------

	def island_positions(probs, n: int, cand_th: float = CAND_TH,
	peak_th: float = PEAK_TH) -> List[int]:
	"""Boundary candidates: all positions with prob >= cand_th, plus +/-1
	around any position with prob >= peak_th."""
	pos = set()
	for i in range(n):
	p = probs[i].item()
	if p >= cand_th:
	pos.add(i)
	if p >= peak_th:
	for d in range(1, WINDOW + 1):
	if i - d >= 0:
	pos.add(i - d)
	if i + d < n:
	pos.add(i + d)
	return sorted(pos)


	def split_candidates(surface: str, idx: int) -> List[Tuple[str, str]]:
	"""Grammar-valid (first, remainder) splits of `surface` at boundary idx
	(idx = index of the last char of the first word). The demodulated
	remainder is returned so vowel-absorption boundaries stay aligned."""
	out = []
	if idx < 0 or idx >= len(surface):
	return out
	try:
	splits = DB._splitter.split_at(surface, idx)
	except Exception:
	splits = []
	seen = set()
	for s in splits:
	f, sec = s.first, s.second
	if not f or not sec:
	continue
	if (f, sec) in seen:
	continue
	seen.add((f, sec))
	if rejoins(surface, f, sec):
	out.append((f, sec))
	return out


	# ---------------------------------------------------------------------------
	# Beam search
	# ---------------------------------------------------------------------------

	def decode(model, text: str, beam_size: int = BEAM, cand_th: float = CAND_TH,
	max_words: int = MAX_WORDS, delay: int = DELAY):
	"""Return (words, score, verified) — verified=True iff the words rejoin
	to the original input. Never raises; never drops the input silently."""
	if not text:
	return [], 0.0, False

	def logit(p: float) -> float:
	p = max(min(p, 1 - 1e-5), 1e-5)
	return math.log(p / (1 - p))

	beam = [([], text, 0.0)] # (words, remaining_surface, score)
	complete = []

	for step in range(max_words):
	if not beam:
	break
	nxt = []
	for words, remaining, score in beam:
	if not remaining:
	complete.append((words, score))
	continue
	rprobs = DB.predict(model, remaining, delay=delay)
	cands = island_positions(rprobs, len(remaining), cand_th)
	expanded = False
	for k in cands:
	for f, sec in split_candidates(remaining, k):
	wsc = word_score(f)
	if wsc <= 0:
	continue
	sc = (score
	+ logit(rprobs[k].item())
	+ word_prior(f)
	- FRAG_PENALTY)
	nxt.append((words + [f], sec, sc))
	expanded = True
	if not expanded and len(words) + 1 < max_words:
	# dead end: try completing the whole remainder as one word
	wsc = word_score(remaining)
	if wsc > 0:
	nxt.append((words + [remaining], "",
	score + word_prior(remaining) - FRAG_PENALTY))
	# dedupe by (words, remaining) keeping best score
	best = {}
	for words, remaining, score in nxt:
	key = (tuple(words), remaining)
	if key not in best or score > best[key][0]:
	best[key] = (score, words)
	# deterministic ordering: score desc, then key asc (tie-breaking must
	# not depend on dict insertion order, which varies with hash seed)
	beam = []
	for (wkey, rem) in sorted(best.keys(), key=lambda k: (-best[k][0], k)):
	beam.append((list(best[(wkey, rem)][1]), rem, best[(wkey, rem)][0]))
	beam = beam[:beam_size]
	# keep anything that completed
	complete = sorted(complete, key=lambda x: (-x[1], x[0]))

	# also allow the beam itself to hold completed states
	for words, remaining, score in beam:
	if not remaining:
	complete.append((words, score))
	complete = sorted(set((tuple(w), s) for w, s in complete),
	key=lambda x: (-x[1], x[0]))

	# Global verification: SOME join of the words must reconstruct the input
	verified_list = []
	for words, score in complete:
	if not words:
	continue
	if rejoins(text, *words):
	verified_list.append((words, score, True))
	if verified_list:
	words, score, _ = max(verified_list, key=lambda x: (x[1], x[0]))
	return list(words), score, True

	# Fallback: best-scoring complete segmentation (flag as unverified)
	if complete:
	words, score = complete[0]
	return list(words), score, False

	# Total failure: return the input as a single token rather than dropping it
	return [text], -1e9, False


	def decode_wrap(model, text: str, **kw) -> List[str]:
	"""Handle '~' split markers like decode_best.wrap_complex_string_handler,
	then decode each chunk and concatenate."""
	inputs = []
	t = text
	while "~" in t:
	try:
	splits = list(DB._sandhi.split_at(DB.SanskritImmutableString(t), t.index("~") - 1))
	except Exception:
	splits = []
	for s in splits:
	if t == safe_join(*s):
	inputs.append(s[0])
	t = s[1]
	break
	else:
	inputs.append(t)
	t = ""
	if t:
	inputs.append(t)
	result = []
	for chunk in inputs:
	words, score, verified = decode(model, chunk, **kw)
	result.extend(words)
	return result


	# ---------------------------------------------------------------------------
	# CLI
	# ---------------------------------------------------------------------------

	TEST_CASES = [
	("vidyAdadAtivinayaMvinayAdyAtipAtratAm",
	["vidyA", "dadAti", "vinayam", "vinayAt", "yAti", "pAtratAm"]),
	("satyamevajayatenAnftaM",
	["satyam", "eva", "jayate", "na", "anftam"]),
	("gururbrahmAgururviSfuH",
	["guruH", "brahmA", "guruH", "viSfuH"]),
	("hitopadeSaHsurocanasya",
	["hita", "upadeSaH", "surocanasya"]),
	("sarvaDarmAnparityajyamAmekaMSaraRaMvraja",
	["sarva", "DarmAn", "parityajya", "mAm", "ekam", "SaraRam", "vraja"]),
	("tacCrutvAvacanamapuRyam",
	["tat", "SrutvA", "vacanam", "apuRyam"]),
	("so'vadatkimatra",
	["saH", "avadat", "kim", "atra"]),
	("ityuktvAkamalApatirantardaqe",
	["iti", "uktvA", "kamalApatiH", "antaH", "daqe"]),
	("etatmamamano'BirAmam",
	["etat", "mama", "manaH", "aBirAmam"]),
	("karmARyevADikArastemAphalezukadAcana",
	["karmaRi", "eva", "aDikAraH", "te", "mA", "phalezu", "kadAcana"]),
	]


	def main():
	parser = argparse.ArgumentParser(description="decode_v2: beam-search vigraha decoder")
	parser.add_argument("text", nargs="?", default=None)
	parser.add_argument("--test", action="store_true", help="run the 10 test cases")
	parser.add_argument("--checkpoint", default="checkpoints/delayed_model_save_fixed_delay2_v2")
	parser.add_argument("--beam", type=int, default=BEAM)
	parser.add_argument("--cand-th", type=float, default=CAND_TH)
	args = parser.parse_args()

	device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
	print(f"Device: {device}", file=sys.stderr)
	model, delay = DB.load_model(args.checkpoint, device)
	print(f"Loaded model (delay={delay})", file=sys.stderr)

	if args.text:
	raw = args.text
	text = DB.give_correct_slp1_input(raw) if raw and any(ord(c) > 127 for c in raw) else raw.replace(" ", "")
	res = decode_wrap(model, text, beam_size=args.beam, cand_th=args.cand_th)
	print(f"{raw} => {res}")
	return

	if args.test:
	exact = 0
	norm_exact = 0
	print(f"{'input':40s} {'exact':6s} {'norm':6s} {'rejoin':7s} decoded")
	for inp, exp in TEST_CASES:
	res = decode_wrap(model, inp, beam_size=args.beam, cand_th=args.cand_th)
	ok = res == exp
	nok = (len(res) == len(exp) and
	all(_norm(a) == _norm(b) or
	(a[:-1] == b[:-1] and a[-1:] in "Hsr" and b[-1:] in "Hsr")
	for a, b in zip(res, exp)))
	rejoined = safe_join(*res) if res else ""
	rej = rejoins(inp, *res) if res else False
	if ok:
	exact += 1
	if nok:
	norm_exact += 1
	print(f"{inp[:39]:40s} {str(ok):6s} {str(nok):6s} {str(rej):7s} {' + '.join(res)}")
	print(f"\nExact: {exact}/{len(TEST_CASES)} (normalized: {norm_exact}/{len(TEST_CASES)})")
	return

	if __name__ == "__main__":
	main()