Kam Mueang's six tones, and the Lanna script.หกเสียงวรรณยุกต์ของคำเมือง กับอักษรธรรมล้านนา北泰语的六个声调与兰纳文

"""Read test words with alphabet.js and check each tone against the tone its Gedney box gives.

The words are Gedney's diagnostic words for Tai tones (as listed in Wikipedia's "Proto-Tai
language"), plus the examples of Wikipedia's "Lanna language". Each is spelled in the Kam Mueang
alphabet: ค ช ท พ become the Khmer letters when Kam Mueang says them without a puff of air, ร
becomes ฮ, and a sound Kam Mueang drops is dropped (ปลา becomes ปา).

The tone each box has in Chiang Mai is the Lanna dictionary's (2007), as the Lanna language
article gives it. Run it with:  python read_words.py
Needs Playwright with Chromium: pip install playwright, then python -m playwright install chromium
"""
import os
import unicodedata

from playwright.sync_api import sync_playwright

HERE = os.path.dirname(os.path.abspath(__file__))

# Chiang Mai tone of each Gedney box. DS and DL are checked syllables, with a short or a long vowel.
BOX_TONE = {"A1": 1, "A2": 1, "A3": 4, "A4": 4, "B1": 2, "B2": 2, "B3": 2, "B4": 5,
            "C1": 3, "C2": 3, "C3": 3, "C4": 6, "DS1": 1, "DS2": 1, "DS3": 1, "DS4": 6,
            "DL1": 2, "DL2": 2, "DL3": 2, "DL4": 5}

GEDNEY = {
    "A1": "หู ear, ขา leg, หัว head, สอง two, หมา dog",
    "A2": "ปี year, ตา eye, กิน eat, กา teapot, ปา fish (ปลา)",
    "A3": "บิน fly, แดง red, ดาว star, ใบ leaf",
    "A4": "มือ hand, ควาย buffalo, นา rice field, งู snake",
    "B1": "ไข่ egg, ผ่า split, เข่า knee, ใหม่ new, สี่ four",
    "B2": "ป่า forest, ไก่ chicken, แก่ old, เต่า turtle, เป่า blow",
    "B3": "บ่า shoulder, บ่าว young man, ด่า scold, อิ่ม full",
    "B4": "ពี่ older sibling (พี่), ព่อ father (พ่อ), ไฮ่ dry field (ไร่), นั่ง sit, เลื่อย saw",
    "C1": "ข้าว rice, เสื้อ shirt, ข้า kill (ฆ่า), ไข้ fever, ห้า five, ถ้วย cup, หม้อ pot, หน้า face",
    "C2": "ป้า aunt, ก้า seedlings (กล้า), ต้ม boil, เก้า nine, ใก้ near (ใกล้)",
    "C3": "บ้าน village, บ้า crazy, อ้า open the mouth, อ้อย sugarcane, ด้าม handle, ด้าย string",
    "C4": "น้ำ water, น้อง younger sibling, ไม้ wood, ม้า horse, ลิ้น tongue, ទ้อง belly (ท้อง)",
    "DS1": "หมัด flea, สุก ripe, ผัก vegetable, หก six, สิบ ten",
    "DS2": "กบ frog, ตับ liver, เจ็บ hurt, เป็ด duck, ตก fall",
    "DS3": "เบ็ด fishhook, ดิบ raw, อก chest, ดึก late",
    "DS4": "นก bird, มัด tie up, ลัก steal, ซัก wash, มด ant, เล็บ nail",
    "DL1": "ขาด torn, เหงือก gums, หาบ carry on a pole, ขวด bottle, ผูก tie, สอก elbow (ศอก), แขก guest",
    "DL2": "ปอด lung, ปีก wing, ตอก pound, แปด eight, ปาก mouth, ตาก dry in the sun",
    "DL3": "แดด sunshine, อาบ bathe, ดอก flower, ออก go out",
    "DL4": "มีด knife, ลูก child, เลือด blood, นอก outside, เជือก rope (เชือก), ฮาก root (ราก)",
}

# The examples of the Lanna language article, with the box each belongs to.
LANNA = [
    ("A1", "เหลา sharpen"), ("B1", "เหล่า forest, group"), ("C1", "เหล้า liquor"),
    ("A4", "เลา beautiful"), ("B4", "เล่า tell"), ("C4", "เล้า coop"),
    ("DS1", "หลัก post"), ("DS4", "ลัก steal"), ("DL1", "หลาก differ"), ("DL4", "ลาก drag"),
    ("C1", "เจ้า lord, you"), ("C2", "ก้า brave (กล้า)"), ("B4", "គ่า value (ค่า)"),
    ("C2", "ป้าย sign"), ("B4", "ព่าย lose (พ่าย)"),
    ("DL4", "ญาก difficult (ยาก)"), ("A4", "ญุง mosquito (ยุง)"), ("A4", "ญาว long (ยาว)"),
    ("A3", "อยา medicine (ยา)"), ("DL3", "อยาก want"), ("B3", "อย่าง manner"),
]


def width(text):
    """Columns a string takes in a terminal: Thai marks above and below take none."""
    return sum(0 if unicodedata.combining(ch) or unicodedata.category(ch) == "Mn" else 1 for ch in text)


def pad(text, columns):
    return text + " " * max(0, columns - width(text))


def items():
    rows = []
    for box, words in GEDNEY.items():
        for word in words.split(", "):
            rows.append(("Gedney", box, word))
    for box, word in LANNA:
        rows.append(("Lanna", box, word))
    return rows


def main():
    rows = items()
    spellings = [w.split(" ")[0] for _, _, w in rows]
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.add_script_tag(path=os.path.join(HERE, "alphabet.js"))
        readings = page.evaluate("words => words.map(w => KMA.read(w))", spellings)
        browser.close()
    wrong = 0
    print(pad("list", 8) + pad("box", 5) + pad("word", 10) + pad("sounds", 16) + "tone  box says")
    for (source, box, word), reading, spelling in zip(rows, readings, spellings):
        if len(reading) != 1 or "error" in reading[0]:
            wrong += 1
            print(pad(source, 8) + pad(box, 5) + pad(spelling, 10) + "could not be read: " + str(reading))
            continue
        s = reading[0]
        ok = s["tone"] == BOX_TONE[box]
        wrong += 0 if ok else 1
        mark = "ok" if ok else "WRONG"
        print(pad(source, 8) + pad(box, 5) + pad(spelling, 10) + pad(s["ipa"], 16)
              + f"{s['tone']}     {BOX_TONE[box]}  {mark}   {word[len(spelling) + 1:]}")
    print(f"\n{len(rows)} words: {len(rows) - wrong} read with the tone their box gives, {wrong} wrong.")


if __name__ == "__main__":
    main()

"""Can a browser put a mark from one script on a letter from another? Drawn in three engines.

Each pair is drawn in Chromium (Chrome, Edge), Firefox and WebKit (the engine of Safari), twice:
with the Noto fonts alone, and with the page's own font, KM Alphabet Sans, put first. One
picture per engine and font is saved, to be checked by eye. A mark the browser cannot place is
drawn on a dotted circle (◌) of its own; a pair no font can draw shows empty boxes.

The widths are printed too: a mark that sits on its letter takes no room, so the pair is as
wide as the letter alone. Empty boxes do not show up in the widths, only in the pictures.

It also puts the pictures of every pair side by side in one image, draw_test.png, in the same
folder: Chromium, Firefox and WebKit with the Noto fonts, and WebKit with the page's font.

Run it with:  python draw_test.py [folder for the pictures]      (needs the internet for the fonts)
Needs Playwright with three browsers and Pillow: pip install playwright pillow, then
python -m playwright install chromium firefox webkit
"""
import base64
import os
import sys
import tempfile

from PIL import Image, ImageDraw, ImageFont
from playwright.sync_api import sync_playwright

HERE = os.path.dirname(os.path.abspath(__file__))

# (what is tried, the pair, the same text without the mark)
PAIRS = [
    ("Thai mai tho on Thai ko (for comparison)", "ก้า", "กา"),
    ("Lao mai tho on Thai ko", "ก້า", "กา"),
    ("Myanmar dot below (creaky tone) after Thai", "กา့", "กา"),
    ("Myanmar visarga (high tone) after Thai", "กาး", "กา"),
    ("Shan tone mark 3 after Thai", "กาႈ", "กา"),
    ("Khmer triisap on Thai ko", "ก៊า", "กา"),
    ("Tai Tham Khuen tone 3 on Thai ko", "ก᩷า", "กา"),
    ("Thai mai ek on Khmer ko", "គ่า", "គา"),
    ("Thai mai tho on Khmer co", "ជ้า", "ជา"),
    ("Thai sara i on Khmer to", "ទิ", "ទ"),
    ("Thai sara ii and mai ek on Khmer po", "ពี่", "ព"),
    ("Thai sara u (below) on Khmer ko", "គุ", "គ"),
    ("Thai sara i on Lao nyo", "ຍิ", "ຍ"),
    ("Thai sara i on Myanmar nya", "ညิ", "ည"),
    ("Thai sara i on Shan nya", "ၺิ", "ၺ"),
    ("Thai mai ek on Tai Tham ga", "ᨣ่", "ᨣ"),
]
ENGINES = ("chromium", "firefox", "webkit")
NOTO = "'Noto Sans Thai','Noto Sans Khmer','Noto Sans Lao','Noto Sans Myanmar','Noto Sans Tai Tham'"


def page_html(own_font):
    font = open(os.path.join(HERE, "km_alphabet_sans-Regular.woff2"), "rb").read()
    face = ("@font-face{font-family:'KM Alphabet Sans';src:url(data:font/woff2;base64,"
            + base64.b64encode(font).decode() + ") format('woff2')}")
    stack = ("'KM Alphabet Sans'," if own_font else "") + NOTO
    rows = "".join(f"<div class=r><span>{pair}</span><span>{base}</span><b>{i + 1}</b></div>"
                   for i, (name, pair, base) in enumerate(PAIRS))
    return f"""<!doctype html><meta charset="utf-8">
<link href="https://fonts.googleapis.com/css2?family=Noto+Sans+Thai&family=Noto+Sans+Lao&family=Noto+Sans+Khmer&family=Noto+Sans+Myanmar&family=Noto+Sans+Tai+Tham&display=block" rel="stylesheet">
<style>{face} body{{margin:8px;background:#fff}} span{{font:52px {stack};white-space:pre;display:inline-block}}
.r{{display:flex;gap:16px;align-items:center;border-bottom:1px solid #ccc;height:84px}} b{{font:14px sans-serif}}</style>
<body>{rows}</body>"""


MEASURE = """async () => {
  await document.fonts.ready;
  await new Promise(r => setTimeout(r, 2000));
  return [...document.querySelectorAll('.r')].map(r => {
    const [pair, base] = r.querySelectorAll('span');
    return [pair.getBoundingClientRect().width, base.getBoundingClientRect().width];
  });
}"""


def main():
    out = sys.argv[1] if len(sys.argv) > 1 else tempfile.mkdtemp(prefix="draw_test_")
    os.makedirs(out, exist_ok=True)
    widths = {}
    with sync_playwright() as p:
        for engine in ENGINES:
            browser = getattr(p, engine).launch()
            for own_font in (False, True):
                page = browser.new_page(viewport={"width": 330, "height": 400})
                page.set_content(page_html(own_font), wait_until="networkidle")
                widths[engine, own_font] = page.evaluate(MEASURE)
                font = "page_font" if own_font else "noto"
                page.screenshot(path=os.path.join(out, f"draw_{engine}_{font}.png"), full_page=True)
                for i, cell in enumerate(page.query_selector_all(".r span:first-child")):
                    cell.screenshot(path=os.path.join(out, f"cell_{engine}_{font}_{i + 1}.png"))
                page.close()
            browser.close()
    print("How much wider each pair is than its letter alone, as a share of the font size (52 px).")
    print("0 = the mark sits on the letter. About 0.5 or more = the mark is on a dotted circle.\n")
    for own_font in (False, True):
        print("With KM Alphabet Sans first:" if own_font else "With the Noto fonts alone:")
        print(f"   {'pair':44}" + "".join(f"{e:>10}" for e in ENGINES))
        for i, (name, pair, base) in enumerate(PAIRS):
            cells = ""
            for engine in ENGINES:
                grown = (widths[engine, own_font][i][0] - widths[engine, own_font][i][1]) / 52
                cells += f"{grown:>10.2f}"
            print(f"{i + 1:>2} {name:44}{cells}")
        print()
    compose(out)
    print("Pictures saved: draw_<engine>_noto.png and draw_<engine>_page_font.png, one each per engine,")
    print("and all of them side by side in draw_test.png.")


def compose(out):
    """One image: a row for each pair, a column for each engine, and WebKit again with the page's font."""
    columns = [("chromium", "noto", "Chrome, Edge"), ("firefox", "noto", "Firefox"),
               ("webkit", "noto", "Safari's engine"), ("webkit", "page_font", "Safari's engine,")]
    cell_w, cell_h, label_w, head_h = 190, 84, 380, 64
    sheet = Image.new("RGB", (label_w + cell_w * len(columns), head_h + cell_h * len(PAIRS)), "white")
    draw = ImageDraw.Draw(sheet)
    text = ImageFont.load_default(size=17)
    for c, (engine, font, title) in enumerate(columns):
        x = label_w + c * cell_w
        draw.text((x + 10, 12), title, fill="black", font=text)
        draw.text((x + 10, 34), "page font" if font == "page_font" else "Noto fonts", fill="#555555", font=text)
    for i, (name, pair, base) in enumerate(PAIRS):
        y = head_h + i * cell_h
        draw.line((0, y, sheet.width, y), fill="#cccccc")
        draw.text((10, y + 30), f"{i + 1:>2}  {name}", fill="black", font=text)
        for c, (engine, font, title) in enumerate(columns):
            cell = Image.open(os.path.join(out, f"cell_{engine}_{font}_{i + 1}.png")).convert("RGB")
            cell.thumbnail((cell_w - 20, cell_h - 8))
            sheet.paste(cell, (label_w + c * cell_w + 10, y + (cell_h - cell.height) // 2))
    sheet.save(os.path.join(out, "draw_test.png"), optimize=True)


if __name__ == "__main__":
    main()

// Kam Mueang alphabet, draft 1 (krueng.ai/kammuang_alphabet.html).
// Thai letters, four Khmer letters, and the tone rules of the Lanna (Tai Tham) script.
// read(text) splits Kam Mueang text into syllables and gives each one its sounds and its tone.
// Tones are the six of Chiang Mai, with the numbers the Lanna dictionary (2007) gives them.
// Ordinary Thai spelling is read too, and every place it differs from the alphabet is named.
// lanna(text) writes the same text in the Lanna script, by rules and a word list (lanna_words.js).
const KMA = (function () {
  // The letters of the alphabet: [sound, tone group, the Tai Tham letter it stands for, script].
  // Group 1 rises when no mark is written, group 2 is mid with no mark, group 3 is the low letters.
  const LETTERS = {
    "ก": ["k", 1, "ᨠ", "Thai"], "จ": ["tɕ", 1, "ᨧ", "Thai"], "ต": ["t", 1, "ᨲ", "Thai"],
    "ป": ["p", 1, "ᨸ", "Thai"], "ข": ["kʰ", 1, "ᨡ", "Thai"], "ฉ": ["tɕʰ", 1, "", "Thai"],
    "ถ": ["tʰ", 1, "ᨳ", "Thai"], "ผ": ["pʰ", 1, "ᨹ", "Thai"], "ฝ": ["f", 1, "ᨺ", "Thai"],
    "ส": ["s", 1, "ᩈ", "Thai"], "ห": ["h", 1, "ᩉ", "Thai"],
    "อ": ["ʔ", 2, "ᩋ", "Thai"], "บ": ["b", 2, "ᨷ", "Thai"], "ด": ["d", 2, "ᨯ", "Thai"],
    "គ": ["k", 3, "ᨣ", "Khmer"], "ជ": ["tɕ", 3, "ᨩ", "Khmer"], "ទ": ["t", 3, "ᨴ", "Khmer"],
    "ព": ["p", 3, "ᨻ", "Khmer"], "ค": ["kʰ", 3, "ᨤ", "Thai"], "ช": ["tɕʰ", 3, "", "Thai"],
    "ท": ["tʰ", 3, "ᨵ", "Thai"], "พ": ["pʰ", 3, "ᨽ", "Thai"], "ง": ["ŋ", 3, "ᨦ", "Thai"],
    "ญ": ["ɲ", 3, "ᨿ", "Thai"], "น": ["n", 3, "ᨶ", "Thai"], "ม": ["m", 3, "ᨾ", "Thai"],
    "ซ": ["s", 3, "ᨪ", "Thai"], "ฟ": ["f", 3, "ᨼ", "Thai"], "ฮ": ["h", 3, "ᩁ", "Thai"],
    "ล": ["l", 3, "ᩃ", "Thai"], "ว": ["w", 3, "ᩅ", "Thai"], "ย": ["j", 3, "", "Thai"],
    "ร": ["r", 3, "ᩁ", "Thai"],
  };
  // Thai letters the alphabet leaves out: [sound, tone group, what to write instead].
  const OTHER_LETTERS = {
    "ฆ": ["kʰ", 3, "ค or គ"], "ฌ": ["tɕʰ", 3, "ช, ជ or ซ"], "ฎ": ["d", 2, "ด"], "ฏ": ["t", 1, "ต"],
    "ฐ": ["tʰ", 1, "ถ"], "ฑ": ["tʰ", 3, "ท or ទ"], "ฒ": ["tʰ", 3, "ท or ទ"], "ณ": ["n", 3, "น"],
    "ธ": ["tʰ", 3, "ท or ទ"], "ภ": ["pʰ", 3, "พ or ព"], "ศ": ["s", 1, "ส"], "ษ": ["s", 1, "ส"],
    "ฬ": ["l", 3, "ล"], "ฃ": ["kʰ", 1, "ข"], "ฅ": ["kʰ", 3, "ค"],
  };
  // Thai clusters, which Kam Mueang does not have: [the sound it usually says, what to write].
  // An ร after the first letter becomes a puff of air (ปร is said like ผ); an ล is dropped.
  const CLUSTERS = {
    "กร": ["kʰ", "ข"], "ขร": ["kʰ", "ข"], "คร": ["kʰ", "ค"], "ตร": ["tʰ", "ถ"], "ทร": ["tʰ", "ท"],
    "ปร": ["pʰ", "ผ"], "พร": ["pʰ", "พ"], "บร": ["pʰ", "ผ or พ"],
    "กล": ["k", "ก"], "ขล": ["kʰ", "ข"], "คล": ["k", "គ"], "ปล": ["p", "ป"], "ผล": ["pʰ", "ผ"],
    "พล": ["p", "ព"], "บล": ["b", "บ"],
  };
  // ห before one of these puts it in group 1; อ before ย makes the glottal y of group 2.
  const SONORANTS = "งญนมยลว";
  const FINALS = {"ก": "k", "ด": "t", "บ": "p", "ง": "ŋ", "น": "n", "ม": "m", "ย": "j", "ว": "w"};
  // Final letters of Thai spelling the alphabet replaces: [sound, what to write].
  const OTHER_FINALS = {
    "จ": ["t", "ด"], "ช": ["t", "ด"], "ซ": ["t", "ด"], "ส": ["t", "ด"], "ศ": ["t", "ด"], "ษ": ["t", "ด"],
    "ต": ["t", "ด"], "ถ": ["t", "ด"], "ท": ["t", "ด"], "ธ": ["t", "ด"], "ฎ": ["t", "ด"], "ฏ": ["t", "ด"],
    "ฐ": ["t", "ด"], "ฑ": ["t", "ด"], "ฒ": ["t", "ด"], "ณ": ["n", "น"], "ญ": ["n", "น"], "ร": ["n", "น"],
    "ล": ["n", "น"], "ฬ": ["n", "น"], "ข": ["k", "ก"], "ค": ["k", "ก"], "ฆ": ["k", "ก"], "ป": ["p", "บ"],
    "พ": ["p", "บ"], "ฟ": ["p", "บ"], "ภ": ["p", "บ"],
  };
  const TONE_MARKS = {"่": "B", "้": "C"};
  // The six tones: [contour in tone letters, English, Thai name, Chinese].
  const TONES = {
    1: ["˨˦", "low rising", "จัตวา", "低升调"],
    2: ["˨˩", "low falling", "เอก", "低降调"],
    3: ["˦˦ʔ", "high level, ends in a catch of the throat", "ตรีปลายโท", "高平调，带喉塞"],
    4: ["˧˧", "mid level", "สามัญ", "中平调"],
    5: ["˦˨", "high falling", "โท", "高降调"],
    6: ["˦˥", "high rising", "ตรี", "高升调"],
  };
  // Which tone each group gets: A = no mark, B = ◌่, C = ◌้, DS/DL = a checked syllable
  // (it ends in k, t, p or a short open vowel) with a short or a long vowel.
  const TONE_OF = {
    A: {1: 1, 2: 4, 3: 4}, B: {1: 2, 2: 2, 3: 5}, C: {1: 3, 2: 3, 3: 6},
    DS: {1: 1, 2: 1, 3: 6}, DL: {1: 2, 2: 2, 3: 5},
  };
  // Ordinary Thai spelling of Kam Mueang (the reading script, Pan's corrections) reads ก จ ต ป the
  // Central Thai way: mid-class letters, with ◌๋ for the rising tone and ◌๊ for the high one. The
  // alphabet puts them in group 1 instead. read(text, "ordinary") follows ordinary spelling: this
  // table for a bare ก จ ต ป, measured on Thai Wiktionary's own spellings (reader_vs_wiktionary.py:
  // bare open 130 of 130 mid, ◌่ 94 of 94, checked 34 of 36 low falling; ◌้ falls 94 times and
  // is tone 3 74 times, so 5 is the better guess). ◌๊ and ◌๋ are read in both ways of reading.
  const ORDINARY_KJTP = {A: 4, B: 2, C: 5, DS: 2, DL: 2};
  // Vowel spellings. C is the first consonant (with its leading ห or อ, or a following ว),
  // F the final consonant. [spelling, vowel sound, long?, final sound it brings itself]
  // The last one, C alone, is Thai's hidden vowel (ส in สบาย): read, but the alphabet writes it.
  const VOWELS = [
    ["Cะ", "a", 0], ["Cา", "aː", 1], ["Cิ", "i", 0], ["Cี", "iː", 1], ["Cึ", "ɯ", 0],
    ["Cือ", "ɯː", 1], ["Cุ", "u", 0], ["Cู", "uː", 1], ["เCะ", "e", 0], ["เC", "eː", 1],
    ["แCะ", "ɛ", 0], ["แC", "ɛː", 1], ["โCะ", "o", 0], ["โC", "oː", 1], ["เCาะ", "ɔ", 0],
    ["Cอ", "ɔː", 1], ["เCอะ", "ɤ", 0], ["เCอ", "ɤː", 1], ["เCียะ", "ia", 0], ["เCีย", "ia", 1],
    ["เCือะ", "ɯa", 0], ["เCือ", "ɯa", 1], ["Cัวะ", "ua", 0], ["Cัว", "ua", 1],
    ["Cำ", "a", 0, "m"], ["ใC", "a", 0, "j"], ["ไC", "a", 0, "j"], ["เCา", "a", 0, "w"],
    ["เCย", "ɤː", 1, "j"], ["C็", "ɔ", 0], ["ไCย", "a", 0, "j"],
    ["CัF", "a", 0], ["CาF", "aː", 1], ["CิF", "i", 0], ["CีF", "iː", 1], ["CึF", "ɯ", 0],
    ["CืF", "ɯː", 1], ["CุF", "u", 0], ["CูF", "uː", 1], ["เC็F", "e", 0], ["เCF", "eː", 1],
    ["แC็F", "ɛ", 0], ["แCF", "ɛː", 1], ["CF", "o", 0], ["โCF", "oː", 1], ["C็อF", "ɔ", 0],
    ["CอF", "ɔː", 1], ["เCิF", "ɤː", 1], ["เCียF", "ia", 1], ["เCือF", "ɯa", 1], ["CวF", "ua", 1],
    ["C", "a", 0],
  ];

  const all = Object.keys(LETTERS).join("") + Object.keys(OTHER_LETTERS).join("");
  // The ways a syllable can begin: a Thai cluster, ห before a sonorant, the glottal y อย, or one
  // letter. Each is tried on its own, with and without a ว after it, so that no reading hides
  // another: a regular expression gives only its first match, and the split never saw โค วิด
  // behind โคว, or ใบ รับ behind ใบร.
  const ONSETS = [`(${Object.keys(CLUSTERS).join("|")})`, `(ห[${SONORANTS}])`, "(อย)", `([${all}])`];
  // A ว straight after the first consonant is part of it (กว, ขว) only when a vowel or a
  // tone mark follows; before a final consonant it is the vowel ua (ขวด, สวย).
  const WITH_W = ["(ว(?=[ะาิีึืุูัำอ็่้๊๋]))", "()"];
  const TONE = "([่้๊๋])?";
  const UPPER = "ิีึืุูั็";
  const FINAL_LETTERS = Object.keys(FINALS).join("") + Object.keys(OTHER_FINALS).join("");
  const FINAL = `([${FINAL_LETTERS}])`;
  // After เ แ โ ใ ไ, a ว followed by a final can be part of the first consonant too (แขวน),
  // or be the final itself (แมว, เลว ร้าย): both readings are offered, and the split chooses.
  const W_BEFORE_FINAL = `(ว(?=[${FINAL_LETTERS}]))`;
  // A consonant with ์ over it is silent in Thai spelling: the alphabet leaves it out.
  const SILENT = new RegExp(`^[${all}][ิุ]?์`, "u");

  // Turn one vowel spelling into a regular expression, with one way of beginning the syllable.
  function pattern(spelling, onset) {
    let rx = "", i = 0;
    while (i < spelling.length) {
      const ch = spelling[i];
      if (ch === "C") {
        rx += onset;
        const next = spelling[i + 1];
        if (next && UPPER.includes(next)) { rx += next; i += 1; }
        rx += TONE;
      } else if (ch === "F") {
        rx += FINAL;
      } else {
        rx += ch;
      }
      i += 1;
    }
    return new RegExp("^" + rx, "u");
  }
  const PATTERNS = VOWELS.flatMap(([spelling, vowel, long, glide]) => {
    const ws = "เแโใไ".includes(spelling[0]) && spelling.includes("F") ? WITH_W.concat([W_BEFORE_FINAL]) : WITH_W;
    return ONSETS.flatMap((onset) => ws.map((w) => ({spelling, vowel, long, glide, rx: pattern(spelling, onset + w)})));
  });

  // Every way one syllable can start at position `at` of `word`.
  function syllablesAt(word, at, how) {
    const rest = word.slice(at), found = [];
    for (const p of PATTERNS) {
      const m = p.rx.exec(rest);
      if (m) found.push(describe(m[0], m[1], Boolean(m[2]), m[3], m[4], p, how));
    }
    const silent = SILENT.exec(rest);
    if (silent) found.push({text: silent[0], silent: true, problems: ["silent letter: leave it out"], cost: 5});
    return found;
  }

  function describe(text, onset, cluster, mark, final, p, how) {
    const problems = [];
    let sound, group, lanna;
    if (CLUSTERS[onset]) {
      [sound] = CLUSTERS[onset];
      group = (LETTERS[onset[0]] || OTHER_LETTERS[onset[0]])[1];
      problems.push(`${onset}: Kam Mueang has no such cluster; it usually says ${sound}: write ${CLUSTERS[onset][1]}`);
      lanna = "–";
    } else {
      const base = onset.length === 2 ? onset[1] : onset;
      const letter = LETTERS[base] || OTHER_LETTERS[base];
      if (OTHER_LETTERS[base]) problems.push(`${base} is not in this alphabet: write ${OTHER_LETTERS[base][2]}`);
      sound = letter[0];
      group = letter[1];
      if (onset[0] === "ห" && onset.length === 2) group = 1;
      if (onset === "อย") group = 2;
      lanna = onset === "อย" ? "ᩀ" : onset.length === 2 ? "ᩉ᩠" + (LETTERS[base][2] || "?") : (LETTERS[base] || [])[2] || "–";
    }
    if (cluster) sound += "w";
    let end = p.glide || "";
    if (final) {
      end = FINALS[final] || OTHER_FINALS[final][0];
      if (!FINALS[final]) problems.push(`final ${final}: write ${OTHER_FINALS[final][1]}`);
    }
    if (p.spelling === "C") problems.push("hidden vowel: write the vowel (ะ, or the one you say)");
    if (p.spelling === "ไCย") problems.push("the last ย is silent: leave it out");
    const checked = "ktp".includes(end) && end !== "" || (!end && !p.long);
    let column = mark ? TONE_MARKS[mark] : (checked ? (p.long ? "DL" : "DS") : "A");
    if (mark && !TONE_MARKS[mark]) {
      problems.push(`◌${mark} is not used: write ◌่ or ◌้ with a letter of the right group`);
      column = checked ? (p.long ? "DL" : "DS") : "A";
    }
    let tone = TONE_OF[column][group];
    if (how === "ordinary" && onset.length === 1 && "กจตป".includes(onset)) tone = ORDINARY_KJTP[column];
    if (mark === "๊") tone = 6;
    else if (mark === "๋") tone = 1;
    const ipa = sound + p.vowel + end + (checked && !end ? "ʔ" : "") + TONES[tone][0];
    // A Thai cluster is named as a problem, but costs nothing extra: Thai spelling has them,
    // and splitting one off (เนื้อก ล้า for เนื้อ กล้า) reads the words wrong.
    const cost = 10 + (p.spelling === "CF" ? 3 : 0) + (cluster ? 1 : 0) + 2 * (problems.length - (CLUSTERS[onset] ? 1 : 0))
               + (p.spelling === "C" ? 20 : 0);
    // spelling, final, end, mark and w are the parts of the syllable, for writing it in Lanna.
    return {text, onset, group, column, tone, ipa, lanna, problems, cost,
            spelling: p.spelling, final: final || "", end, mark: mark || "", w: cluster};
  }

  // The best way to split one run of letters into syllables: the lowest total cost, so fewest
  // syllables, then fewest hidden vowels and differences from the alphabet. A letter that
  // cannot be read at all is reported, and reading carries on after it.
  function splitWord(word, how) {
    const best = new Array(word.length + 1).fill(null);
    best[0] = {cost: 0, parts: []};
    for (let at = 0; at < word.length; at += 1) {
      if (!best[at]) continue;
      for (const s of syllablesAt(word, at, how)) {
        const end = at + s.text.length, cost = best[at].cost + s.cost;
        if (!best[end] || cost < best[end].cost) best[end] = {cost, parts: best[at].parts.concat([s])};
      }
    }
    if (best[word.length]) return best[word.length].parts;
    let reach = 0;
    for (let at = word.length; at >= 0; at -= 1) if (best[at]) { reach = at; break; }
    return best[reach].parts.concat([{text: word[reach], error: "cannot be read as a syllable here"}],
                                    splitWord(word.slice(reach + 1), how));
  }

  // Split any text into runs of Thai and Khmer letters, and read each run.
  // Spaces, digits, ๆ, ฯ and punctuation pass through as they are.
  // how: "alphabet" (the default, this page's rules) or "ordinary" (ordinary spelling's reading of
  // ก จ ต ป, the voice's choice: see ORDINARY_KJTP).
  function read(text, how = "alphabet") {
    const out = [];
    for (const piece of text.split(/([^ก-ฮะ-ฺเ-ๅ็-๎ក-៓]+)/u)) {
      if (!piece) continue;
      if (/^[^ก-ฮะ-ฺเ-ๅ็-๎ក-៓]+$/u.test(piece)) { out.push({text: piece, space: true}); continue; }
      out.push(...splitWord(piece, how));
    }
    return out;
  }

  // ---- The same text in the Lanna script (Tai Tham) ----
  // The rules were worked out from, and are checked against, the Kam Mueang words of Thai
  // Wiktionary (lanna_check.py). Consonants can be taken two ways:
  //   "sound" (the default): the letters of this alphabet, each the sound it stands for,
  //     so ค is the k with a puff of air (ᨤ) and គ the one without (ᨣ);
  //   "letters": Thai letters standing letter for letter for Lanna ones (ค is ᨣ, ฅ is ᨤ),
  //     the way Thai Wiktionary spells Lanna words in Thai letters.
  const BY_LETTER = {
    "ก": "ᨠ", "ข": "ᨡ", "ฃ": "ᨢ", "ค": "ᨣ", "ฅ": "ᨤ", "ฆ": "ᨥ", "ง": "ᨦ", "จ": "ᨧ", "ฉ": "ᨨ",
    "ช": "ᨩ", "ซ": "ᨪ", "ฌ": "ᨫ", "ญ": "ᨬ", "ฎ": "ᨭ", "ฏ": "ᨭ", "ฐ": "ᨮ", "ฑ": "ᨯ", "ฒ": "ᨰ",
    "ณ": "ᨱ", "ด": "ᨯ", "ต": "ᨲ", "ถ": "ᨳ", "ท": "ᨴ", "ธ": "ᨵ", "น": "ᨶ", "บ": "ᨷ", "ป": "ᨸ",
    "ผ": "ᨹ", "ฝ": "ᨺ", "พ": "ᨻ", "ฟ": "ᨼ", "ภ": "ᨽ", "ม": "ᨾ", "ย": "ᨿ", "ร": "ᩁ", "ล": "ᩃ",
    "ว": "ᩅ", "ศ": "ᩆ", "ษ": "ᩇ", "ส": "ᩈ", "ห": "ᩉ", "ฬ": "ᩊ", "อ": "ᩋ", "ฮ": "ᩌ",
    "គ": "ᨣ", "ជ": "ᨩ", "ទ": "ᨴ", "ព": "ᨻ",
  };
  // By sound: each letter's partner in the chart above; a letter with none (ฉ ช ย) and the
  // letters this alphabet leaves out are written letter for letter.
  // ฃ, which Thai no longer uses, stands for the same kh as ข.
  const BY_SOUND = Object.assign({}, BY_LETTER, {"ฃ": "ᨡ"});
  for (const [letter, [, , partner]] of Object.entries(LETTERS)) if (partner) BY_SOUND[letter] = partner;
  const FINAL_LETTER = {k: "ᨠ", t: "ᨯ", p: "ᨷ", "ŋ": "ᨦ", n: "ᨶ", m: "ᨾ", j: "ᨿ", w: "ᩅ"};
  const TONE_SIGN = {"่": "᩵", "้": "᩶"};
  // After these the long a is the tall one (ᩤ), so the two are not read as another letter.
  const TALL_AA = "ᨣᨴᨷᩅ";
  // How each vowel is written. C = the first consonant(s), T = the tone mark, A = the long a
  // (ᩣ or ᩤ), S = a final under the syllable with the tone mark just before it, F = a final under
  // the long a, f = a final on the line, where n is written ᩁ (a final y still goes under).
  const SHAPES = {
    "Cะ": "CTᩡ", "Cา": "CTA", "Cิ": "CᩥT", "Cี": "CᩦT", "Cึ": "CᩧT", "Cือ": "CᩨT", "Cุ": "CᩩT",
    "Cู": "CᩪT", "เCะ": "CᩮTᩡ", "เC": "CᩮT", "แCะ": "CᩯTᩡ", "แC": "CᩯT", "โCะ": "CᩰTᩡ", "โC": "CᩰT",
    "เCาะ": "CᩰᩬTᩡ", "Cอ": "CᩬᩴT", "เCอะ": "CᩮᩬᩥTᩡ", "เCอ": "CᩮᩬᩥT", "เCียะ": "C᩠ᨿᩮTᩡ",
    "เCีย": "C᩠ᨿᩮT", "เCือะ": "CᩮᩬᩥTᩋᩡ", "เCือ": "CᩮᩬᩥTᩋ", "Cัวะ": "C᩠ᩅᩫTᩡ", "Cัว": "C᩠ᩅᩫT",
    "Cำ": "CTAᩴ", "ใC": "CᩲT", "ไC": "CᩱT", "เCา": "CᩮᩢTA", "เCย": "Cᩮᩥ᩠Tᨿ", "C็": "CᩳT",
    "ไCย": "Cᩱ᩠Tᨿ", "CัF": "CᩢS", "CาF": "CTAF", "CิF": "CᩥS", "CีF": "CᩦS", "CึF": "CᩧS",
    "CืF": "CᩨS", "CุF": "CᩩTf", "CูF": "CᩪTf", "เC็F": "CᩮᩢS", "เCF": "CᩮS", "แC็F": "CᩯᩢS",
    "แCF": "CᩯS", "CF": "CᩫS", "โCF": "CᩰᩫS", "C็อF": "CᩬᩢTf", "CอF": "CᩬTf", "เCิF": "CᩮᩥS",
    "เCียF": "C᩠ᨿTf", "เCือF": "CᩮᩬᩥTf", "CวF": "C᩠ᩅTf", "C": "CT",
  };
  // Words the rules do not spell the way Lanna does, keyed by how they are written in Thai
  // letters: lanna_words.js fills this in from Thai Wiktionary.
  const WORDS = {};

  function lannaOnset(s, map) {
    const o = s.onset;
    let out;
    if (o === "อย") out = "ᩀ";
    else if (o.length === 2 && o[0] === "ห") out = o[1] === "ล" ? "ᩉᩖ" : "ᩉ᩠" + ("ญย".includes(o[1]) ? "ᨿ" : map[o[1]]);
    // A Thai cluster keeps the letters it is spelled with: ครก is ᨣᩕᩫ᩠ᨠ, and ป before ร is ᨷ.
    else if (o === "ปร") out = "ᨷᩕ";
    else if (o.length === 2) out = BY_LETTER[o[0]] + (o[1] === "ร" ? "ᩕ" : "ᩖ");
    else out = map[o] || o;
    return out + (s.w ? "᩠ᩅ" : "");
  }

  function lannaSyllable(s, how, first, last) {
    const map = how === "letters" ? BY_LETTER : BY_SOUND;
    if (s.silent) {
      // A letter Thai spelling does not sound: Lanna writes it, with ᩺ over it.
      return Array.from(s.text).map((ch) => ch === "์" ? "᩺" : ch === "ิ" ? "ᩥ" : ch === "ุ" ? "ᩩ" : map[ch] || ch).join("");
    }
    let shape = SHAPES[s.spelling];
    const c = lannaOnset(s, map);
    // A consonant alone with a tone mark (บ่) takes ᩴ under the mark: ᨷᩴ᩵.
    if (s.spelling === "C" && s.mark) shape = "CᩴT";
    // A short a is the consonant alone, except in a word of one syllable: ᩡ is written there only.
    if (s.spelling === "Cะ" && !s.mark && !(first && last)) shape = "C";
    // When something already sits under the first consonant (ᩖ, or a letter), the final goes on the line.
    if (/[ᩖ᩠]/.test(c)) shape = shape.replace("S", "Tf");
    const tone = TONE_SIGN[s.mark] || "";
    // A final of this alphabet (ก ด บ ง น ม ย ว) is written by its sound; any other final is a letter
    // Thai spelling keeps from the word's past, and Lanna keeps it too (อากาศ: ᩋᩣᨠᩣ᩠ᩆ). A final p is ᨷ.
    const fin = !s.final ? "" : s.end === "p" ? "ᨷ" : how === "letters" || !FINALS[s.final] ? BY_LETTER[s.final] || "" : FINAL_LETTER[s.end];
    const yUnder = fin === "ᨿ";
    let out = "";
    for (const ch of shape) {
      if (ch === "C") out += c;
      else if (ch === "A") out += TALL_AA.includes(c[0]) && !c.includes("ᩕ") ? "ᩤ" : "ᩣ";
      else if (ch === "T") out += shape.includes("f") && yUnder ? "" : tone;
      else if (ch === "S") out += "᩠" + tone + fin;
      else if (ch === "F") out += "᩠" + fin;
      else if (ch === "f") out += yUnder ? "᩠" + tone + "ᨿ" : fin === "ᨶ" ? "ᩁ" : fin;
      else out += ch;
    }
    return out;
  }

  // The text in Lanna, piece by piece: [{text, lanna, n, listed}]: n is how many syllables the
  // piece is, and listed says it came from WORDS.
  function lannaParts(text, how = "sound") {
    const joiners = new RegExp("[" + String.fromCharCode(0x200b) + "-" + String.fromCharCode(0x200d) + "]", "g");
    const parts = read(text.replace(joiners, "").replace(/\s*ๆ/g, "ๆ"));
    const out = [];
    for (let i = 0; i < parts.length; i += 1) {
      const s = parts[i];
      if (s.space || s.error) { out.push({text: s.text, lanna: s.space ? s.text.replace(/ๆ/g, "᩻") : s.text, n: s.space ? 0 : 1}); continue; }
      // The longest run of syllables (up to six) that the word list knows.
      let found = 0;
      for (let n = Math.min(6, parts.length - i); n >= 1 && !found; n -= 1) {
        const run = parts.slice(i, i + n);
        if (run.some((p) => p.space || p.error)) continue;
        if (Object.prototype.hasOwnProperty.call(WORDS, run.map((p) => p.text).join(""))) found = n;
      }
      if (found) {
        const key = parts.slice(i, i + found).map((p) => p.text).join("");
        out.push({text: key, lanna: WORDS[key], n: found, listed: true});
        i += found - 1;
        continue;
      }
      const first = !parts[i - 1] || parts[i - 1].space, last = !parts[i + 1] || parts[i + 1].space;
      out.push({text: s.text, lanna: lannaSyllable(s, how, first, last), n: 1});
    }
    return out;
  }
  const lanna = (text, how) => lannaParts(text, how).map((p) => p.lanna).join("");

  return {LETTERS, OTHER_LETTERS, CLUSTERS, TONES, TONE_OF, VOWELS, read, lanna, lannaParts, WORDS};
})();

if (typeof module !== "undefined") module.exports = KMA;

"""Build KM Alphabet Sans: Noto Sans Thai with the four Khmer letters of the Kam Mueang alphabet added.

Why a font of its own: Safari's engine (WebKit) draws a letter and its marks only with one font
that holds all of them. No common font holds both Thai marks and Khmer letters, so without this
font, គ่า shows as empty boxes there. With it, every browser draws the four letters with Thai
vowels and tone marks on them.

Both source fonts are under the SIL Open Font License 1.1, so this changed copy is too: it is
renamed, and OFL.txt goes with it. Run it with:  python build_font.py
Needs fontTools and brotli: pip install fonttools brotli
"""
import os
import tempfile
import urllib.request

from fontTools.ttLib import TTFont

HERE = os.path.dirname(os.path.abspath(__file__))
# The unhinted fonts: a hinted glyph carries instructions written for its own font's tables,
# and moved into the Thai font it is drawn stretched, with its top stroke floating off it.
SOURCE = "https://raw.githubusercontent.com/notofonts/notofonts.github.io/main/fonts/{0}/unhinted/ttf/{0}-{1}.ttf"
LICENCE = "https://raw.githubusercontent.com/notofonts/thai/main/OFL.txt"
KHMER = [0x1782, 0x1787, 0x1791, 0x1796]  # គ ជ ទ ព
FAMILY = "KM Alphabet Sans"


def fetch(url, folder):
    path = os.path.join(folder, url.rsplit("/", 1)[-1])
    if not os.path.exists(path):
        urllib.request.urlretrieve(url, path)
    return path


def build(weight, folder):
    # Keep the source's own date in the font, so that every build gives the same bytes.
    thai = TTFont(fetch(SOURCE.format("NotoSansThai", weight), folder), recalcTimestamp=False)
    khmer = TTFont(fetch(SOURCE.format("NotoSansKhmer", weight), folder))
    order = thai.getGlyphOrder()
    khmer_cmap = khmer.getBestCmap()
    for code in KHMER:
        name = khmer_cmap[code]
        order.append(name)
        thai["glyf"][name] = khmer["glyf"][name]
        thai["hmtx"][name] = khmer["hmtx"][name]
        for table in thai["cmap"].tables:
            if table.isUnicode():
                table.cmap[code] = name
        thai["GDEF"].table.GlyphClassDef.classDefs[name] = 1  # a base letter, for marks to sit on
    thai.setGlyphOrder(order)
    thai["maxp"].numGlyphs = len(order)
    style = weight
    names = {1: FAMILY if weight == "Regular" else f"{FAMILY} {weight}", 2: "Regular",
             3: f"krueng.ai: {FAMILY} {style}", 4: f"{FAMILY} {style}",
             6: f"KMAlphabetSans-{style}", 16: FAMILY, 17: style}
    table = thai["name"]
    for record in list(table.names):
        if record.nameID in names or record.nameID in (5,):
            table.removeNames(nameID=record.nameID)
    for name_id, text in names.items():
        table.setName(text, name_id, 3, 1, 0x409)
    table.setName("Version 1.0; Noto Sans Thai with four letters of Noto Sans Khmer (U+1782 U+1787 "
                  "U+1791 U+1796), for the Kam Mueang alphabet of krueng.ai", 5, 3, 1, 0x409)
    # A .ttf to install on a computer, and a .woff2, smaller, for the web page.
    thai.save(os.path.join(HERE, f"km_alphabet_sans-{weight}.ttf"))
    out = os.path.join(HERE, f"km_alphabet_sans-{weight}.woff2")
    thai.flavor = "woff2"
    thai.save(out)
    return out


def main():
    with tempfile.TemporaryDirectory() as folder:
        for weight in ("Regular", "Medium"):
            path = build(weight, folder)
            for made in (path, path.replace(".woff2", ".ttf")):
                print(f"{os.path.basename(made)}: {os.path.getsize(made):,} bytes")
        notice = urllib.request.urlopen(LICENCE).read().decode("utf-8")
        khmer_line = "Copyright 2022 The Noto Project Authors (https://github.com/notofonts/khmer)\n"
        with open(os.path.join(HERE, "OFL.txt"), "w", encoding="utf-8", newline="\n") as f:
            f.write(f"{FAMILY} (km_alphabet_sans-*.woff2) is Noto Sans Thai with four letters of\n"
                    "Noto Sans Khmer added, made by build_font.py. Both are under this licence.\n\n")
            f.write(khmer_line + notice)
        print("OFL.txt: the licence of both source fonts")


if __name__ == "__main__":
    main()

km_alphabet_sans-Regular.woff2: 9,620 bytes
km_alphabet_sans-Regular.ttf: 21,788 bytes
km_alphabet_sans-Medium.woff2: 9,596 bytes
km_alphabet_sans-Medium.ttf: 21,636 bytes
OFL.txt: the licence of both source fonts

"""Which fonts on this computer can show the Kam Mueang alphabet in one piece?

A program that is not a browser (a word processor, a chat app) usually draws a letter and the
marks on it with one font. So a font has to hold Thai and the four Khmer letters together.
This lists, for the fonts installed on this computer, which scripts each one holds.

Run it with:  python font_check.py      Needs fontTools: pip install fonttools
"""
import glob
import os
import sys

from fontTools.ttLib import TTCollection, TTFont

TESTS = {
    "Thai": [0x0E01, 0x0E48, 0x0E34],          # ก, mai ek, sara i
    "Khmer 4": [0x1782, 0x1787, 0x1791, 0x1796],  # គ ជ ទ ព
    "Lao": [0x0E8D],                            # ຍ
    "Myanmar": [0x100A],                        # ည
    "Tai Tham": [0x1A23],                       # ᨣ
}
FOLDERS = {
    "win32": [os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts"),
              os.path.join(os.environ.get("LOCALAPPDATA", ""), r"Microsoft\Windows\Fonts")],
    "darwin": ["/System/Library/Fonts", "/Library/Fonts", os.path.expanduser("~/Library/Fonts")],
}.get(sys.platform, ["/usr/share/fonts", os.path.expanduser("~/.local/share/fonts")])


def fonts():
    for folder in FOLDERS:
        for path in glob.glob(os.path.join(folder, "**", "*"), recursive=True):
            ext = path.lower().rsplit(".", 1)[-1]
            if ext in ("ttf", "otf"):
                yield path, [TTFont(path, lazy=True)]
            elif ext == "ttc":
                yield path, list(TTCollection(path, lazy=True))


def main():
    seen, rows = set(), []
    for path, faces in fonts():
        for face in faces:
            try:
                name = face["name"].getDebugName(1)
                cmap = face.getBestCmap() or {}
            except Exception:
                continue
            held = [script for script, codes in TESTS.items() if all(c in cmap for c in codes)]
            if held and name not in seen:
                seen.add(name)
                rows.append((name, held))
    home = os.path.expanduser("~")
    folders = [f.replace(home, "~") for f in FOLDERS if os.path.isdir(f)]
    print(f"Font folders: {', '.join(folders)}\n")
    for script in TESTS:
        names = sorted(n for n, held in rows if script in held)
        print(f"{script:9} {len(names):3} fonts: {', '.join(names) if names else '(none)'}")
    both = sorted(n for n, held in rows if "Thai" in held and "Khmer 4" in held)
    print(f"\nThai and the four Khmer letters in one font: {', '.join(both) if both else '(none)'}")


if __name__ == "__main__":
    main()

"""How much of the voice project's reading script could be put into the alphabet without a speaker?

The 1,468 sentences are the ones on krueng.ai/kammuang_recorder.html, written in Thai letters the
way Kam Mueang is usually written. This reads every sentence with alphabet.js and sorts each
syllable into one of three heaps:
  - it is already written the alphabet's way;
  - a rule can rewrite it (a Pali letter, a silent letter, a Thai cluster, a hidden vowel,
    ◌๋ or ◌๊ on ก จ ต ป), though a speaker should still look;
  - only a Kam Mueang speaker can say which way it is said.

Run it with:  python script_scan.py
Needs Playwright with Chromium: pip install playwright, then python -m playwright install chromium
"""
import collections
import json
import os
import re

from playwright.sync_api import sync_playwright

HERE = os.path.dirname(os.path.abspath(__file__))
RECORDER = os.path.join(HERE, "..", "kammuang_recorder.html")

SPEAKER = [
    "ค ช ท พ: said with a puff of air, or without one (then a Khmer letter)",
    "ร: said h (ฮ), l or r",
    "ย: said ny (ญ) or y",
    "ก จ ต ป with ◌้: tone 3, or tone 5 in the Central Thai way of writing it",
    "ก จ ต ป with no mark: tone 1, or tone 4 in the Central Thai way of writing it",
    "◌๊ or ◌๋ on a letter other than ก จ ต ป",
    "a letter that cannot be read where it is",
]
RULE = [
    "Thai cluster (กล, ปร, ...)",
    "hidden vowel (ส in สบาย)",
    "Pali letter (ศ, ษ, ณ, ธ, ...) or Thai final (ศ, ร, ล, ...)",
    "silent letter (ย์)",
    "◌๋ or ◌๊ on ก จ ต ป",
]


def heap(s):
    """Which heap a syllable goes in, and why: ("speaker" | "rule" | "as written", reason)."""
    if s.get("error"):
        return "speaker", SPEAKER[6]
    if s.get("silent"):
        return "rule", RULE[3]
    problems = " ".join(s["problems"])
    base = s["onset"][-1] if len(s["onset"]) == 2 and s["onset"][0] in "หอ" else s["onset"][0]
    mark = re.search("[่้๊๋]", s["text"])
    mark = mark.group(0) if mark else ""
    if "cluster" not in problems:
        if base in "คชทพ":
            return "speaker", SPEAKER[0]
        if base == "ร":
            return "speaker", SPEAKER[1]
        if s["onset"] == "ย":
            return "speaker", SPEAKER[2]
        if base in "กจตป" and len(s["onset"]) == 1:
            if mark == "้":
                return "speaker", SPEAKER[3]
            if not mark and s["column"] == "A":
                return "speaker", SPEAKER[4]
        if mark in ("๊", "๋") and base not in "กจตป":
            return "speaker", SPEAKER[5]
    if "cluster" in problems:
        return "rule", RULE[0]
    if "hidden vowel" in problems:
        return "rule", RULE[1]
    if "not in this alphabet" in problems or "final" in problems:
        return "rule", RULE[2]
    if mark in ("๊", "๋"):
        return "rule", RULE[4]
    return "as written", ""


def main():
    html = open(RECORDER, encoding="utf-8").read()
    sentences = json.loads(re.search(r"const SENTENCES = (\[.*?\]);", html, re.S).group(1))
    texts = [s["text"] for s in sentences]
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.add_script_tag(path=os.path.join(HERE, "alphabet.js"))
        readings = page.evaluate("texts => texts.map(t => KMA.read(t))", texts)
        browser.close()
    counts, examples, heaps = collections.Counter(), collections.defaultdict(list), collections.Counter()
    for reading in readings:
        for s in reading:
            if s.get("space"):
                continue
            where, why = heap(s)
            heaps[where] += 1
            counts[why] += 1
            if why and len(examples[why]) < 6 and s["text"] not in examples[why]:
                examples[why].append(s["text"])
    total = sum(heaps.values())
    print(f"{len(texts)} sentences, {total} syllables as alphabet.js splits them.\n")
    for title, reasons, key in (("Only a Kam Mueang speaker can settle", SPEAKER, "speaker"),
                                ("A rule can rewrite (a speaker should still look)", RULE, "rule")):
        print(f"{title}: {heaps[key]} ({100 * heaps[key] / total:.0f}%)")
        for why in reasons:
            print(f"{counts[why]:7}  {why}   e.g. {' '.join(examples[why])}")
        print()
    print(f"Already written the alphabet's way: {heaps['as written']} ({100 * heaps['as written'] / total:.0f}%)")


if __name__ == "__main__":
    main()

"""Save the Kam Mueang words of Thai Wiktionary, to check the Lanna-script writer against.

Thai Wiktionary (th.wiktionary.org) has a page for each Kam Mueang word, headed by its spelling in
the Lanna script. Most pages also give the word in Thai letters, two ways: letter for letter (ᨣ as ค,
ᨤ as ฅ), and the way it sounds. Many give how it is said in Chiang Mai. This saves those for every
word of the category หมวดหมู่:คำหลักภาษาคำเมือง to wiktionary_words.tsv. The words are Wiktionary's,
under the licence CC BY-SA 4.0, and so is the file.

Run it with:  python wiktionary_words.py      (a few minutes: it waits between requests)
"""
import datetime
import json
import os
import re
import time
import urllib.error
import urllib.parse
import urllib.request

HERE = os.path.dirname(os.path.abspath(__file__))
API = "https://th.wiktionary.org/w/api.php"
CATEGORY = "หมวดหมู่:คำหลักภาษาคำเมือง"
HEADERS = {"User-Agent": "krueng.ai Kam Mueang alphabet (https://krueng.ai/kammuang_alphabet.html)"}
# The names Wiktionary's {{nod-alt}} uses for the Thai-letter spellings of a word.
LETTER_FOR_LETTER = ("l", "tl", "~", "tlts", "tstl", "ls", "sl")
AS_IT_SOUNDS = ("s", "ts", "~", "tlts", "tstl", "ls", "sl")
FOLLOWS_THAI = ("f", "ft", "fth")
# The Unicode block of the Lanna (Tai Tham) script.
TAI_THAM = re.compile("[" + chr(0x1A20) + "-" + chr(0x1AAF) + "]")


def ask(params):
    """One request to Wiktionary's API. When it is busy, wait and ask again."""
    params = dict(params, format="json", maxlag=5)
    url = API + "?" + urllib.parse.urlencode(params)
    for wait in (5, 20, 60, 120):
        try:
            with urllib.request.urlopen(urllib.request.Request(url, headers=HEADERS), timeout=60) as reply:
                data = json.load(reply)
        except urllib.error.HTTPError as e:
            if e.code not in (429, 503):
                raise
            time.sleep(wait)
            continue
        if data.get("error", {}).get("code") == "maxlag":
            time.sleep(wait)
            continue
        return data
    raise SystemExit("Wiktionary kept saying it was busy; try again later")


def kam_mueang_part(text):
    """The Kam Mueang section of a page: from its heading to the next language's heading."""
    start = re.search(r"^==\s*ภาษาคำเมือง\s*==\s*$", text, re.M)
    if not start:
        return ""
    rest = text[start.end():]
    end = re.search(r"^==[^=].*==\s*$", rest, re.M)
    return rest[:end.start()] if end else rest


def template_values(part, name, keys):
    """Every value given under one of `keys` in the templates called `name`, in page order."""
    found = []
    for call in re.findall(r"\{\{" + name + r"\s*\|([^{}]*)\}\}", part):
        for argument in call.split("|"):
            key, _, value = argument.partition("=")
            if key.strip() in keys:
                found += [v.strip() for v in value.split(",") if v.strip()]
    return list(dict.fromkeys(found))


def main():
    rows = []
    params = {"action": "query", "generator": "categorymembers", "gcmtitle": CATEGORY, "gcmlimit": 50,
              "gcmnamespace": 0, "prop": "revisions", "rvprop": "content", "rvslots": "main"}
    more = {}
    while True:
        data = ask({**params, **more})
        for page in data.get("query", {}).get("pages", {}).values():
            if not TAI_THAM.search(page["title"]):
                continue  # pages headed in Thai letters point to a Lanna page; that page is enough
            part = kam_mueang_part(page["revisions"][0]["slots"]["main"]["*"])
            heard = [m.group(1) for m in re.finditer(r"\{\{IPA\|nod\|([^|}]*)\|a=เชียงใหม่", part)]
            rows.append([page["title"],
                         ",".join(template_values(part, "nod-alt", LETTER_FOR_LETTER)),
                         ",".join(template_values(part, "nod-alt", AS_IT_SOUNDS)),
                         ",".join(template_values(part, "nod-alt", FOLLOWS_THAI)),
                         heard[0] if heard else "",
                         ",".join(sorted(set(re.findall(r"\{\{(?:bor|bor\+|lbor|der|der\+)\|nod\|([a-z-]+)", part))))])
        if "continue" not in data:
            break
        more = data["continue"]
        time.sleep(3)
    rows.sort()
    today = datetime.date.today().isoformat()
    with open(os.path.join(HERE, "wiktionary_words.tsv"), "w", encoding="utf-8", newline="\n") as f:
        f.write(f"# Kam Mueang words of Thai Wiktionary ({CATEGORY}), read on {today}.\n")
        f.write("# Licence: CC BY-SA 4.0, https://creativecommons.org/licenses/by-sa/4.0/ ; the words and\n")
        f.write("# spellings are Wiktionary's contributors' (https://th.wiktionary.org).\n")
        f.write("lanna\tletter_for_letter\tas_it_sounds\tfollows_thai\tchiang_mai\tborrowed_from\n")
        for row in rows:
            f.write("\t".join(row) + "\n")
    with_thai = sum(1 for r in rows if r[1] or r[2] or r[3])
    print(f"{len(rows)} Kam Mueang words with a Lanna spelling, read on {today}.")
    print(f"{with_thai} of them are also given in Thai letters; {sum(1 for r in rows if r[1])} letter for letter, "
          f"{sum(1 for r in rows if r[2])} as they sound.")
    print(f"{sum(1 for r in rows if r[4])} say how the word is said in Chiang Mai.")


if __name__ == "__main__":
    main()

"""Check the Lanna-script writer of alphabet.js against Thai Wiktionary's spellings.

Every word of wiktionary_words.tsv that is also given in Thai letters is written in the Lanna script
by the rules of alphabet.js alone (lanna_words.js, the word list, is not loaded), three ways:
  1. from Wiktionary's Thai letters, letter for letter (ᨣ as ค): this tests the vowel shapes, where
     the final goes and where the tone mark goes;
  2. from the word written in the Kam Mueang alphabet, by its sound: Wiktionary's letters with each
     consonant swapped for the alphabet's letter for its sound (ค for ᨤ, គ for ᨣ, ฮ for an ᩁ said h);
  3. from Wiktionary's spelling of how the word sounds, in ordinary Thai letters.
Then each answer is compared with the Lanna spelling Wiktionary gives.

Run it with:  python lanna_check.py      (after wiktionary_words.py)
Needs Playwright with Chromium: pip install playwright, then python -m playwright install chromium
"""
import csv
import os

from playwright.sync_api import sync_playwright

HERE = os.path.dirname(os.path.abspath(__file__))

# Runs in the browser, beside alphabet.js: bySound() writes a word given in Wiktionary's
# letter-for-letter Thai the way the Kam Mueang alphabet writes its sound. `heard` is how it is
# said in Chiang Mai, if known. make_lanna_words.py uses it too.
BY_SOUND_JS = """
const SOUND_LETTER = {"ค": "គ", "ฅ": "ค", "ฆ": "ค", "ฃ": "ข", "ฉ": "ส", "ช": "ជ", "ฌ": "ซ", "ฎ": "ต",
  "ฏ": "ต", "ฐ": "ถ", "ฑ": "ท", "ฒ": "ท", "ณ": "น", "ท": "ទ", "ธ": "ท", "พ": "ព", "ภ": "พ", "ย": "ญ",
  "ศ": "ส", "ษ": "ส", "ฬ": "ล"};
// A Thai cluster as Kam Mueang says it: กร is a kh, กล a plain k.
const SOUND_CLUSTER = {"กร": "ข", "คร": "ค", "พร": "พ", "ปร": "ผ", "บร": "ผ", "กล": "ก", "คล": "គ",
  "ปล": "ป", "พล": "ព", "ผล": "ผ", "ขล": "ข", "ตร": "ถ", "ทร": "ซ"};
const FINAL_BY_SOUND = {k: "ก", t: "ด", p: "บ", "ŋ": "ง", n: "น", m: "ม", j: "ย", w: "ว"};

function bySound(letters, heard) {
  const parts = KMA.read(letters);
  const said = heard.replace(/[\\/\\[\\]]/g, "").split(/[.\\s]+/).filter(Boolean);
  const syllables = parts.filter((s) => !s.space && !s.error && !s.silent);
  let k = 0;
  return parts.map((s) => {
    if (s.space || s.error) return s.text;
    if (s.silent) return "";  // the alphabet leaves out a letter that is not said
    const sound = said.length === syllables.length ? said[k] : "";
    k += 1;
    let onset = s.onset;
    if (SOUND_CLUSTER[onset]) onset = SOUND_CLUSTER[onset];
    else if (onset === "หย") onset = "หญ";
    else if (onset === "ร") onset = sound.startsWith("l") ? "ล" : sound.startsWith("r") ? "ร" : "ฮ";
    else if (onset.length === 1) onset = SOUND_LETTER[onset] || onset;
    let text = s.text.replace(s.onset, onset);
    if (s.final) {
      const at = text.lastIndexOf(s.final);
      text = text.slice(0, at) + FINAL_BY_SOUND[s.end] + text.slice(at + 1);
    }
    return text;
  }).join("");
}
"""
CHECK_JS = BY_SOUND_JS + """
(words) => words.map((w) => {
  const alphabet = w.letters ? bySound(w.letters, w.heard) : "";
  return {alphabet,
          letters: w.letters ? KMA.lanna(w.letters, "letters") : "",
          byAlphabet: alphabet ? KMA.lanna(alphabet, "sound") : "",
          bySound: w.sounds ? KMA.lanna(w.sounds, "sound") : ""};
})
"""
WAYS = [("letters", "letters", "Wiktionary's Thai letters, letter for letter"),
        ("alphabet", "byAlphabet", "the Kam Mueang alphabet, written by sound"),
        ("sounds", "bySound", "ordinary Thai spelling of how it sounds")]


def read_words():
    with open(os.path.join(HERE, "wiktionary_words.tsv"), encoding="utf-8") as f:
        lines = [line for line in f if not line.startswith("#")]
    words = []
    for row in csv.DictReader(lines, delimiter="\t"):
        first = lambda field: (row[field] or "").split(",")[0]  # noqa: E731
        if first("letter_for_letter") or first("as_it_sounds"):
            words.append({"lanna": row["lanna"], "letters": first("letter_for_letter"),
                          "sounds": first("as_it_sounds"), "heard": row["chiang_mai"] or ""})
    return words


def main():
    words = read_words()
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.add_script_tag(path=os.path.join(HERE, "alphabet.js"))
        answers = page.evaluate(CHECK_JS, words)
        browser.close()
    print(f"{len(words)} Kam Mueang words of Thai Wiktionary, written in the Lanna script by the rules of")
    print("alphabet.js alone (no word list), and compared with the Lanna spelling Wiktionary gives.\n")
    print(f"{'Written from':48}{'words':>6}{'the same':>16}{'a mark elsewhere':>18}{'different':>11}")
    misses = {}
    for source, answer, title in WAYS:
        tried = [(w, a) for w, a in zip(words, answers) if a[answer]]
        same = sum(1 for w, a in tried if a[answer] == w["lanna"])
        moved = sum(1 for w, a in tried if a[answer] != w["lanna"] and sorted(a[answer]) == sorted(w["lanna"]))
        misses[title] = [(a["alphabet"] if source == "alphabet" else w[source], w["lanna"], a[answer])
                         for w, a in tried if sorted(a[answer]) != sorted(w["lanna"])]
        print(f"{title:48}{len(tried):6}{same:9} ({100 * same / len(tried):.1f}%){moved:18}{len(misses[title]):11}")
    # Which Lanna letter starts the words said with an h: the alphabet's ฮ stands for it.
    said_h = [w for w in words if w["heard"].lstrip("/[").startswith("h")]
    print(f"\nWords said with h at the start, by their first Lanna letter: "
          f"ᩁ {sum(1 for w in said_h if w['lanna'][0] == 'ᩁ')}, ᩉ {sum(1 for w in said_h if w['lanna'][0] == 'ᩉ')}, "
          f"ᩌ {sum(1 for w in said_h if w['lanna'][0] == 'ᩌ')}")
    for title, rows in misses.items():
        print(f"\nSome words written from {title}: the input, Wiktionary's spelling, ours")
        for given, wanted, got in rows[:: max(1, len(rows) // 8)][:8]:
            print(f"   {given:16} {wanted:14} {got}")


if __name__ == "__main__":
    main()

"""Make lanna_words.js: Kam Mueang words whose Lanna spelling the rules of alphabet.js do not reach.

The rules write a syllable the way it sounds. Lanna spelling also keeps letters that are no longer
said (กล้า is said ก้า and written ᨠᩖ᩶ᩣ), and Pali and Sanskrit words keep spellings of their own.
For those words the spelling is taken from Thai Wiktionary (wiktionary_words.tsv):
  - each way Wiktionary writes a word in Thai letters (letter for letter, as it sounds, as Thai
    writes it) becomes a key, with the word's Lanna spelling as its value;
  - so does the word written in the Kam Mueang alphabet by its sound, if it has two syllables or
    more. One syllable written by sound is not a key: ก้า could be กล้า (ᨠᩖ᩶ᩣ) or another word.
A key is kept only where the rules write something else, and dropped where two words of Wiktionary
give it two Lanna spellings. A few words are added by hand (HAND), each with where it comes from.
Then it writes the first sentences of the voice project's reading script in the Lanna script.

Run it with:  python make_lanna_words.py      (after wiktionary_words.py)
Needs Playwright with Chromium: pip install playwright, then python -m playwright install chromium
"""
import json
import os
import re
from collections import defaultdict

from playwright.sync_api import sync_playwright

from lanna_check import BY_SOUND_JS

HERE = os.path.dirname(os.path.abspath(__file__))
RECORDER = os.path.join(HERE, "..", "kammuang_recorder.html")
# Words added by hand: {Thai letters: (Lanna spelling, where it comes from)}.
HAND = {
    "ก่": ("ᨣᩴ᩵", "Thai Wiktionary, ก่อ: the word for 'then, also' is written ᨣᩴ᩵"),
    "ก็": ("ᨣᩴ᩵", "Thai Wiktionary, ก่อ: the word for 'then, also' is written ᨣᩴ᩵"),
}
HEADER = """// Kam Mueang words whose Lanna spelling the rules of alphabet.js do not reach, keyed by how
// they are written in Thai letters. Made by make_lanna_words.py from the Kam Mueang words of Thai
// Wiktionary (th.wiktionary.org), read on {date}: CC BY-SA 4.0, by Wiktionary's contributors,
// https://creativecommons.org/licenses/by-sa/4.0/ . Load it after alphabet.js.
"""


def read_rows():
    with open(os.path.join(HERE, "wiktionary_words.tsv"), encoding="utf-8") as f:
        date = re.search(r"read on (\d{4}-\d\d-\d\d)", f.readline()).group(1)
        lines = [line for line in f if not line.startswith("#")]
    head = lines[0].rstrip("\n").split("\t")
    return date, [dict(zip(head, line.rstrip("\n").split("\t"))) for line in lines[1:]]


def main():
    date, rows = read_rows()
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.add_script_tag(path=os.path.join(HERE, "alphabet.js"))
        page.add_script_tag(content=BY_SOUND_JS)
        # Every key each word offers, and how the rules alone write it.
        offers = page.evaluate("""rows => rows.map((r) => {
          const split = (v) => (v || "").split(",").map((x) => x.trim()).filter(Boolean);
          const thai = [...new Set([...split(r.letter_for_letter), ...split(r.as_it_sounds), ...split(r.follows_thai)])];
          const first = split(r.letter_for_letter)[0];
          const sound = first ? bySound(first, r.chiang_mai || "") : "";
          const syllables = sound ? KMA.read(sound).filter((s) => !s.space).length : 0;
          const keys = thai.map((k) => [k, "thai"]);
          if (syllables >= 2 && !thai.includes(sound)) keys.push([sound, "alphabet"]);
          return keys.filter(([k]) => KMA.read(k).every((s) => !s.space && !s.error))
                     .map(([k, kind]) => ({key: k, kind, rules: KMA.lanna(k)}));
        })""", rows)
        values, kinds = defaultdict(set), {}
        for row, keys in zip(rows, offers):
            for k in keys:
                values[k["key"]].add(row["lanna"])
                kinds.setdefault(k["key"], (k["kind"], k["rules"]))
        shared = {k for k, v in values.items() if len(v) > 1}
        words = {k: next(iter(v)) for k, v in values.items() if k not in shared and kinds[k][1] != next(iter(v))}
        by_kind = defaultdict(int)
        for k in words:
            by_kind[kinds[k][0]] += 1
        for k, (lanna, _source) in HAND.items():
            words[k] = lanna
        body = ",\n".join(f"  {json.dumps(k, ensure_ascii=False)}: {json.dumps(v, ensure_ascii=False)}"
                          for k, v in sorted(words.items()))
        with open(os.path.join(HERE, "lanna_words.js"), "w", encoding="utf-8", newline="\n") as f:
            f.write(HEADER.format(date=date))
            f.write("Object.assign(KMA.WORDS, {\n" + body + ",\n});\n")
        print(f"lanna_words.js: {len(words)} words. From Wiktionary's Thai spellings {by_kind['thai']}, "
              f"from the alphabet by sound {by_kind['alphabet']}, by hand {len(HAND)}.")
        print(f"Left out: {len(shared)} spellings that two Wiktionary words share with different Lanna spellings.")

        # The list loaded: a check that it is applied (Wiktionary's own words, so not a test of new words).
        page.add_script_tag(path=os.path.join(HERE, "lanna_words.js"))
        same = page.evaluate("""rows => rows.filter((r) => {
          const k = (r.letter_for_letter || "").split(",")[0];
          return k && KMA.lanna(k, "letters") === r.lanna;
        }).length""", rows)
        html = open(RECORDER, encoding="utf-8").read()
        sentences = json.loads(re.search(r"const SENTENCES = (\[.*?\]);", html, re.S).group(1))
        pieces = page.evaluate("texts => texts.map((t) => KMA.lannaParts(t))", [s["text"] for s in sentences])
        browser.close()
    print(f"With the list loaded, {same} of Wiktionary's {sum(1 for r in rows if r['letter_for_letter'])} words "
          "come out as it spells them (a check that the list is applied, not a test).\n")
    syllables = sum(p["n"] for sentence in pieces for p in sentence)
    listed = sum(p["n"] for sentence in pieces for p in sentence if p.get("listed"))
    print(f"The reading script: {len(sentences)} sentences, {syllables} syllables; {listed} of them "
          f"({100 * listed / syllables:.0f}%) are spelled from the list, the rest by the rules.")
    print("\nIts first sentences in the Lanna script (not yet checked by a Lanna reader):")
    for sentence, parts in list(zip(sentences, pieces))[:12]:
        print(f"{sentence['id']}  {sentence['text']}")
        print(f"       {''.join(p['lanna'] for p in parts)}")


if __name__ == "__main__":
    main()

"""Make the page's pictures of Lanna culture: SDXL (Juggernaut XL v9) in ComfyUI on a DGX Spark.

They are illustrations, not photographs: the page says so under each one. The prompts avoid hands
and written letters, which the model draws badly, and the seeds are fixed so a second run gives the
same pictures. Run it with:  python make_lanna_images.py [folder]      (default: lanna_images)

spark_media.py is a helper from the krueng.ai site's own tools (python/video_gen), and it is not
published here. To make the pictures with any SDXL setup instead, use these settings: checkpoint
juggernaut-xl-v9, 1344 x 768, 28 steps, CFG 7, sampler euler_ancestral with the normal scheduler,
the prompt "<scene>, <STYLE>" with each scene's seed, and the negative prompt "lowres, bad anatomy,
bad hands, extra fingers, text, watermark, signature, blurry, jpeg artifacts, deformed, ugly".
The page shows them as JPEG files at quality 84.
"""
import os
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "python" / "video_gen"))
import spark_media  # noqa: E402

STYLE = "photorealistic, natural light, rich detail, documentary photograph, 35mm"
SCENES = {
    "yi_peng": ("Yi Peng festival night in Chiang Mai, hundreds of glowing paper sky lanterns rising into a deep "
                "blue evening sky above the tiered roofs of a Lanna temple, warm orange glow, crowd silhouettes", 1101),
    "lai_kham": ("inside an old Lanna temple hall in Chiang Mai, dark red lacquered teak pillars covered with fine "
                 "gold stencil patterns of flowers and vines, candle light, soft haze, no people", 1202),
    "bo_sang": ("hand-painted paper umbrellas of Bo Sang village near Chiang Mai, dozens of colourful mulberry-paper "
                "umbrellas with flower paintings drying in the sun in a courtyard, no people", 1303),
    # The first prompt gave an oval tray with handles; this one, with seed 1433, gave a round table.
    "khantoke": ("a Northern Thai khantoke dinner, a low round wooden table with a short pedestal foot standing on a "
                 "woven mat, on it small bowls of red nam prik ong chili dip, green chili dip, dark pork curry, "
                 "crispy pork rind, a coiled grilled sausage, fresh raw vegetables, and sticky rice in small woven "
                 "bamboo baskets, seen from slightly above, warm evening lamp light", 1433),
    # Left out: the sand stupas of the Northern New Year. Twice the model drew gilded pagodas or little
    # buildings instead of mounds of river sand, and Wikimedia Commons had no free photo from Chiang Mai.
    "teen_jok": ("close-up of a Mae Chaem teen jok textile, the intricate hand-woven silk hem of a Lanna sarong with "
                 "red, gold and black diamond patterns, laid on old teak wood", 1606),
}


def main():
    out = Path(sys.argv[1] if len(sys.argv) > 1 else "lanna_images")
    out.mkdir(parents=True, exist_ok=True)
    for name, (scene, seed) in SCENES.items():
        target = out / f"{name}.png"
        if target.exists():
            print(f"{name}: already made")
            continue
        spark_media.t2i(f"{scene}, {STYLE}", target, seed=seed)


if __name__ == "__main__":
    main()

"""A Lanna handwoven tapestry for the recorder page: the shoulder cloth of the LannaBot queen, in close detail,
with little figures woven into its bands (elephants, a novice monk, temple halls, a naga, birds, villagers,
lanterns). Tall, for the right third of the screen. It hangs down the right third of a wide screen on
krueng.ai/kammuang_alphabet.html.

Qwen-Image on the Spark (spark_media.qwen_t2i), 928 x 1664 (9:16).

Run it with:  python make_tapestry.py draft     (4-step drafts, about a minute each)
              python make_tapestry.py final     (24 steps, several minutes each)
"""
import sys
from pathlib import Path

# spark_media.py is a helper from the krueng.ai site's own tools (python/video_gen), as in make_lanna_images.py.
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "python" / "video_gen"))
import spark_media  # noqa: E402

PROMPT = (
    "A close-up, straight-on view of a traditional Lanna handwoven tapestry from northern Thailand, a teen jok "
    "brocade cloth in deep lacquer red, gold, indigo and ivory thread, filling the whole frame, flat and evenly lit "
    "like a museum photograph of a textile. The cloth is woven in horizontal bands separated by thin gold geometric "
    "borders of diamonds, hooks and zigzags. Woven into the bands, in charming naive folk-art textile style with "
    "visible thread texture, are little figures, each one clear and separate with space around it: a happy baby "
    "elephant, a smiling little novice monk in saffron robes, a Lanna temple hall with a tiered roof and golden "
    "finials, a coiled naga serpent, a pair of hornbill birds, a water buffalo, a grandmother and grandfather "
    "holding hands, floating paper lanterns, a lotus flower, and a tall golden chedi. The figures are stylized, "
    "symmetrical, friendly and cute, with big dot eyes, in the manner of woven Tai folk motifs. Rich warm colours, "
    "fine detail, slight sheen of silk, no people outside the weave, no background other than the cloth."
)
NEGATIVE = (
    "photograph of a room, person wearing the cloth, hands, 3D render, realistic animals, text, letters, "
    "watermark, logo, signature, blurry, low quality, deformed, messy, cluttered, overlapping figures, "
    "frame, border, wall, table"
)


def main():
    kind = sys.argv[1] if len(sys.argv) > 1 else "draft"
    seeds = [int(s) for s in sys.argv[2:]] or ([41, 42, 43] if kind == "draft" else [41])
    out = Path(__file__).parent
    for seed in seeds:
        target = out / f"tapestry_{kind}_{seed}.png"
        if not target.exists():
            spark_media.qwen_t2i(PROMPT, target, negative=NEGATIVE, width=928, height=1664, seed=seed,
                                 lightning=kind == "draft")


if __name__ == "__main__":
    main()