Datasets:

undertheseanlp
/

UDD-1

+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+"""Generate a self-contained HTML dictionary plugin for Label Studio.
+Produces dict_plugin.html that provides:
+1. Highlight bar: reads sentence text and predicted spans from URL fragment,
+   colors multi-syllable words green (in dict) or red (not in dict)
+2. Search box: instant dictionary search with exact/prefix/substring matches
+The full 63K-entry dictionary is embedded as a JS array for client-side lookup.
+Per-task data is passed via URL fragment (#text=...&spans=...) so the ~900KB
+dictionary is loaded once and cached by the browser.
+Usage:
+    uv run src/build_dict_plugin.py --dict path/to/dictionary.txt
+    uv run src/build_dict_plugin.py  # uses default path
+"""
+import argparse
+import json
+import unicodedata
+from pathlib import Path
+DEFAULT_DICT = (
+    "/home/claude-code/projects/workspace_underthesea/tree-1/"
+    "models/word_segmentation/udd_ws_v1_1-20260211_034002/dictionary.txt"
+)
+LS_STATIC_DIRS = [
+    "/home/claude-code/.local/share/uv/tools/label-studio/"
+    "lib/python3.12/site-packages/label_studio/core/static_build",
+    "/home/claude-code/projects/workspace_underthesea/label-studio/.venv/"
+    "lib/python3.12/site-packages/label_studio/core/static_build",
+]
+def nfc(text):
+    return unicodedata.normalize("NFC", text)
+def load_dictionary(dict_path):
+    entries = []
+    with open(dict_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                entries.append(nfc(line))
+    entries.sort()
+    return entries
+def build_html(entries):
+    # JSON-encode the sorted list for embedding in JS
+    dict_json = json.dumps(entries, ensure_ascii=False)
+    return (
+        '<!DOCTYPE html>\n'
+        '<html lang="vi">\n'
+        '<head>\n'
+        '<meta charset="UTF-8">\n'
+        '<style>\n'
+        '* { box-sizing: border-box; margin: 0; padding: 0; }\n'
+        'body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }\n'
+        '.highlights {\n'
+        '  padding: 6px 10px;\n'
+        '  font-size: 15px;\n'
+        '  line-height: 1.6;\n'
+        '  background: #fafafa;\n'
+        '  border-bottom: 1px solid #e0e0e0;\n'
+        '  cursor: default;\n'
+        '}\n'
+        '.highlights .word {\n'
+        '  cursor: pointer;\n'
+        '}\n'
+        '.highlights .word:hover {\n'
+        '  background: #e3f2fd;\n'
+        '  border-radius: 3px;\n'
+        '}\n'
+        '.highlights .in-dict {\n'
+        '  background: #c8e6c9;\n'
+        '  padding: 1px 3px;\n'
+        '  border-radius: 3px;\n'
+        '  cursor: pointer;\n'
+        '}\n'
+        '.highlights .not-dict {\n'
+        '  background: #ffcdd2;\n'
+        '  padding: 1px 3px;\n'
+        '  border-radius: 3px;\n'
+        '  text-decoration: underline;\n'
+        '  text-decoration-color: red;\n'
+        '  cursor: pointer;\n'
+        '}\n'
+        '.search-area {\n'
+        '  padding: 6px 10px;\n'
+        '}\n'
+        '.search-box {\n'
+        '  display: flex;\n'
+        '  gap: 6px;\n'
+        '  align-items: center;\n'
+        '}\n'
+        '.search-box input {\n'
+        '  flex: 1;\n'
+        '  padding: 5px 10px;\n'
+        '  font-size: 14px;\n'
+        '  border: 1px solid #ccc;\n'
+        '  border-radius: 4px;\n'
+        '  outline: none;\n'
+        '}\n'
+        '.search-box input:focus { border-color: #4CAF50; }\n'
+        '.search-box .count {\n'
+        '  font-size: 12px;\n'
+        '  color: #888;\n'
+        '  white-space: nowrap;\n'
+        '}\n'
+        '#results {\n'
+        '  max-height: 200px;\n'
+        '  overflow-y: auto;\n'
+        '  font-size: 14px;\n'
+        '}\n'
+        '.section { padding: 4px 0; }\n'
+        '.section-title {\n'
+        '  font-size: 11px;\n'
+        '  font-weight: 600;\n'
+        '  color: #888;\n'
+        '  text-transform: uppercase;\n'
+        '  padding: 2px 0;\n'
+        '}\n'
+        '.match { padding: 1px 0; }\n'
+        '.match.exact { font-weight: 600; color: #2e7d32; }\n'
+        '.match mark { background: #fff9c4; padding: 0 1px; border-radius: 2px; }\n'
+        '.no-results { color: #999; padding: 4px 0; }\n'
+        '.hidden { display: none; }\n'
+        '</style>\n'
+        '</head>\n'
+        '<body>\n'
+        '<div class="highlights" id="highlights"></div>\n'
+        '<div class="search-area">\n'
+        '  <div class="search-box">\n'
+        '    <input type="text" id="q" placeholder="Search dictionary..." autocomplete="off">\n'
+        '    <span class="count" id="dict-count"></span>\n'
+        '  </div>\n'
+        '  <div id="results" class="hidden"></div>\n'
+        '</div>\n'
+        '\n'
+        '<script>\n'
+        'const DICT = ' + dict_json + ';\n'
+        'const DICT_LOWER = DICT.map(e => e.toLowerCase());\n'
+        'const DICT_SET = new Set(DICT_LOWER);\n'
+        'document.getElementById("dict-count").textContent = DICT.length.toLocaleString() + " entries";\n'
+        '\n'
+        '// --- Highlight bar: read params from URL fragment ---\n'
+        'function parseFragment() {\n'
+        '  const hash = decodeURIComponent(location.hash.slice(1));\n'
+        '  const params = {};\n'
+        '  for (const part of hash.split("&")) {\n'
+        '    const eq = part.indexOf("=");\n'
+        '    if (eq > 0) params[part.slice(0, eq)] = part.slice(eq + 1);\n'
+        '  }\n'
+        '  return params;\n'
+        '}\n'
+        '\n'
+        'function escHtml(s) {\n'
+        '  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");\n'
+        '}\n'
+        '\n'
+        'function renderHighlights() {\n'
+        '  const params = parseFragment();\n'
+        '  const text = params.text || "";\n'
+        '  const el = document.getElementById("highlights");\n'
+        '  if (!text) { el.classList.add("hidden"); return; }\n'
+        '  el.classList.remove("hidden");\n'
+        '\n'
+        '  let spans;\n'
+        '  try { spans = JSON.parse(params.spans || "[]"); } catch(e) { spans = []; }\n'
+        '\n'
+        '  if (!spans.length) {\n'
+        '    el.innerHTML = escHtml(text);\n'
+        '    return;\n'
+        '  }\n'
+        '\n'
+        '  let html = "";\n'
+        '  let prev = 0;\n'
+        '  for (const sp of spans) {\n'
+        '    const [start, end] = sp;\n'
+        '    if (start > prev) html += escHtml(text.slice(prev, start));\n'
+        '    const word = text.slice(start, end);\n'
+        '    const nSyl = word.split(" ").length;\n'
+        '    if (nSyl === 1) {\n'
+        '      html += \'<span class="word" onclick="fillSearch(this)">\' + escHtml(word) + "</span>";\n'
+        '    } else {\n'
+        '      const inDict = DICT_SET.has(word.toLowerCase());\n'
+        '      const cls = inDict ? "in-dict" : "not-dict";\n'
+        '      html += \'<span class="\' + cls + \'" onclick="fillSearch(this)">\' + escHtml(word) + "</span>";\n'
+        '    }\n'
+        '    prev = end;\n'
+        '  }\n'
+        '  if (prev < text.length) html += escHtml(text.slice(prev));\n'
+        '  el.innerHTML = html;\n'
+        '}\n'
+        '\n'
+        'function fillSearch(el) {\n'
+        '  const q = document.getElementById("q");\n'
+        '  q.value = el.textContent;\n'
+        '  q.focus();\n'
+        '  doSearch();\n'
+        '}\n'
+        '\n'
+        'renderHighlights();\n'
+        '\n'
+        '// --- Dictionary search ---\n'
+        'const input = document.getElementById("q");\n'
+        'const resultsDiv = document.getElementById("results");\n'
+        'let debounceTimer;\n'
+        'input.addEventListener("input", () => {\n'
+        '  clearTimeout(debounceTimer);\n'
+        '  debounceTimer = setTimeout(doSearch, 150);\n'
+        '});\n'
+        '\n'
+        'function doSearch() {\n'
+        '  const q = input.value.trim().toLowerCase();\n'
+        '  if (!q) { resultsDiv.classList.add("hidden"); return; }\n'
+        '  const exact = [], prefix = [], substring = [];\n'
+        '  const MAX = 50;\n'
+        '  for (let i = 0; i < DICT_LOWER.length; i++) {\n'
+        '    const e = DICT_LOWER[i];\n'
+        '    if (e === q) exact.push(i);\n'
+        '    else if (e.startsWith(q)) { if (prefix.length < MAX) prefix.push(i); }\n'
+        '    else if (e.includes(q)) { if (substring.length < MAX) substring.push(i); }\n'
+        '    if (prefix.length >= MAX && substring.length >= MAX && exact.length > 0) break;\n'
+        '  }\n'
+        '  let h = "";\n'
+        '  if (exact.length > 0) {\n'
+        '    h += \'<div class="section"><div class="section-title">Exact</div>\';\n'
+        '    for (const i of exact) h += \'<div class="match exact">\' + hl(DICT[i], q) + "</div>";\n'
+        '    h += "</div>";\n'
+        '  }\n'
+        '  if (prefix.length > 0) {\n'
+        '    h += \'<div class="section"><div class="section-title">Prefix (\' + prefix.length + ")</div>";\n'
+        '    for (const i of prefix) h += \'<div class="match">\' + hl(DICT[i], q) + "</div>";\n'
+        '    h += "</div>";\n'
+        '  }\n'
+        '  if (substring.length > 0) {\n'
+        '    h += \'<div class="section"><div class="section-title">Contains (\' + substring.length + ")</div>";\n'
+        '    for (const i of substring) h += \'<div class="match">\' + hl(DICT[i], q) + "</div>";\n'
+        '    h += "</div>";\n'
+        '  }\n'
+        '  if (!h) h = \'<div class="no-results">No matches</div>\';\n'
+        '  resultsDiv.innerHTML = h;\n'
+        '  resultsDiv.classList.remove("hidden");\n'
+        '}\n'
+        '\n'
+        'function hl(text, query) {\n'
+        '  const idx = text.toLowerCase().indexOf(query);\n'
+        '  if (idx < 0) return escHtml(text);\n'
+        '  return escHtml(text.slice(0, idx)) + "<mark>" + escHtml(text.slice(idx, idx + query.length)) + "</mark>" + escHtml(text.slice(idx + query.length));\n'
+        '}\n'
+        '</script>\n'
+        '</body>\n'
+        '</html>'
+    )
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate dictionary plugin HTML for Label Studio"
+    )
+    parser.add_argument(
+        "--dict",
+        default=DEFAULT_DICT,
+        help=f"Path to dictionary.txt (default: {DEFAULT_DICT})",
+    )
+    parser.add_argument(
+        "--output",
+        default="src/dict_plugin.html",
+        help="Output HTML path (default: src/dict_plugin.html)",
+    )
+    parser.add_argument(
+        "--deploy",
+        action="store_true",
+        help="Also copy to LS static_build directory",
+    )
+    args = parser.parse_args()
+    dict_path = Path(args.dict)
+    if not dict_path.exists():
+        print(f"ERROR: {dict_path} not found")
+        return
+    entries = load_dictionary(dict_path)
+    print(f"Loaded {len(entries)} dictionary entries from {dict_path}")
+    html_content = build_html(entries)
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(html_content, encoding="utf-8")
+    size_kb = output_path.stat().st_size / 1024
+    print(f"Written {output_path} ({size_kb:.0f} KB)")
+    if args.deploy:
+        import shutil
+        for static_dir in LS_STATIC_DIRS:
+            deploy_path = Path(static_dir) / "dict_plugin.html"
+            if deploy_path.parent.exists():
+                shutil.copy2(output_path, deploy_path)
+                print(f"Deployed to {deploy_path}")
+            else:
+                print(f"WARNING: {deploy_path.parent} not found, skipping")
+if __name__ == "__main__":
+    main()

src/build_dict_search.py ADDED Viewed

	@@ -0,0 +1,221 @@

+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+"""Generate a self-contained HTML dictionary search page.
+Reads dictionary.txt, NFC-normalizes entries, and embeds them in
+a standalone HTML file with search functionality (exact, prefix,
+substring matches).
+Usage:
+    uv run src/build_dict_search.py --dict path/to/dictionary.txt
+    uv run src/build_dict_search.py  # uses default path
+"""
+import argparse
+import html
+import unicodedata
+from pathlib import Path
+DEFAULT_DICT = (
+    "/home/claude-code/projects/workspace_underthesea/tree-1/"
+    "models/word_segmentation/udd_ws_v1_1-20260211_034002/dictionary.txt"
+)
+def nfc(text):
+    return unicodedata.normalize("NFC", text)
+def load_dictionary(dict_path):
+    entries = []
+    with open(dict_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                entries.append(nfc(line))
+    entries.sort()
+    return entries
+def build_html(entries):
+    # Escape entries for embedding in JS template literal
+    # Use JSON-safe escaping: replace backslash, backtick, ${
+    js_lines = []
+    for entry in entries:
+        escaped = html.escape(entry)
+        js_lines.append(escaped)
+    dict_joined = "\n".join(js_lines)
+    return f"""<!DOCTYPE html>
+<html lang="vi">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Vietnamese Dictionary Search ({len(entries):,} entries)</title>
+<style>
+* {{ box-sizing: border-box; margin: 0; padding: 0; }}
+body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; padding: 20px; max-width: 800px; margin: 0 auto; background: #fafafa; }}
+h1 {{ font-size: 1.3em; margin-bottom: 4px; color: #333; }}
+.subtitle {{ color: #666; font-size: 0.9em; margin-bottom: 16px; }}
+.search-box {{ position: relative; margin-bottom: 16px; }}
+input {{ width: 100%; padding: 12px 16px; font-size: 16px; border: 2px solid #ddd; border-radius: 8px; outline: none; }}
+input:focus {{ border-color: #4CAF50; }}
+.results {{ background: white; border-radius: 8px; border: 1px solid #e0e0e0; }}
+.section {{ padding: 12px 16px; border-bottom: 1px solid #f0f0f0; }}
+.section:last-child {{ border-bottom: none; }}
+.section-title {{ font-size: 0.8em; font-weight: 600; color: #888; text-transform: uppercase; margin-bottom: 6px; }}
+.match {{ padding: 4px 0; font-size: 15px; }}
+.match.exact {{ font-weight: 600; color: #2e7d32; }}
+.match mark {{ background: #fff9c4; padding: 0 1px; border-radius: 2px; }}
+.no-results {{ padding: 16px; color: #999; text-align: center; }}
+.stats {{ color: #999; font-size: 0.85em; padding: 8px 16px; text-align: right; }}
+.hidden {{ display: none; }}
+</style>
+</head>
+<body>
+<h1>Vietnamese Dictionary Search</h1>
+<p class="subtitle">{len(entries):,} entries</p>
+<div class="search-box">
+  <input type="text" id="q" placeholder="Type a word to search..." autofocus autocomplete="off">
+</div>
+<div id="results" class="results hidden"></div>
+<script>
+const RAW = `{dict_joined}`;
+const DICT = RAW.split("\\n");
+const DICT_SET = new Set(DICT);
+// Decode HTML entities for matching
+function decode(s) {{
+  const el = document.createElement("span");
+  el.innerHTML = s;
+  return el.textContent;
+}}
+const DICT_DECODED = DICT.map(decode);
+const input = document.getElementById("q");
+const resultsDiv = document.getElementById("results");
+let debounceTimer;
+input.addEventListener("input", () => {{
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(doSearch, 150);
+}});
+function doSearch() {{
+  const q = input.value.trim().toLowerCase();
+  if (!q) {{
+    resultsDiv.classList.add("hidden");
+    return;
+  }}
+  const exact = [];
+  const prefix = [];
+  const substring = [];
+  const MAX = 50;
+  for (let i = 0; i < DICT_DECODED.length; i++) {{
+    const entry = DICT_DECODED[i];
+    const lower = entry.toLowerCase();
+    if (lower === q) {{
+      exact.push(i);
+    }} else if (lower.startsWith(q)) {{
+      if (prefix.length < MAX) prefix.push(i);
+    }} else if (lower.includes(q)) {{
+      if (substring.length < MAX) substring.push(i);
+    }}
+    if (prefix.length >= MAX && substring.length >= MAX && exact.length > 0) break;
+  }}
+  let html = "";
+  if (exact.length > 0) {{
+    html += '<div class="section"><div class="section-title">Exact match</div>';
+    for (const i of exact) {{
+      html += '<div class="match exact">' + highlight(DICT_DECODED[i], q) + "</div>";
+    }}
+    html += "</div>";
+  }}
+  if (prefix.length > 0) {{
+    html += '<div class="section"><div class="section-title">Prefix matches (' + prefix.length + ')</div>';
+    for (const i of prefix) {{
+      html += '<div class="match">' + highlight(DICT_DECODED[i], q) + "</div>";
+    }}
+    html += "</div>";
+  }}
+  if (substring.length > 0) {{
+    html += '<div class="section"><div class="section-title">Substring matches (' + substring.length + ')</div>';
+    for (const i of substring) {{
+      html += '<div class="match">' + highlight(DICT_DECODED[i], q) + "</div>";
+    }}
+    html += "</div>";
+  }}
+  if (!html) {{
+    html = '<div class="no-results">No matches found</div>';
+  }}
+  const total = exact.length + prefix.length + substring.length;
+  html += '<div class="stats">' + total + " result(s)</div>";
+  resultsDiv.innerHTML = html;
+  resultsDiv.classList.remove("hidden");
+}}
+function highlight(text, query) {{
+  const lower = text.toLowerCase();
+  const idx = lower.indexOf(query);
+  if (idx < 0) return escapeHtml(text);
+  return escapeHtml(text.substring(0, idx))
+    + "<mark>" + escapeHtml(text.substring(idx, idx + query.length)) + "</mark>"
+    + escapeHtml(text.substring(idx + query.length));
+}}
+function escapeHtml(s) {{
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}}
+</script>
+</body>
+</html>"""
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate standalone dictionary search HTML page"
+    )
+    parser.add_argument(
+        "--dict",
+        default=DEFAULT_DICT,
+        help=f"Path to dictionary.txt (default: {DEFAULT_DICT})",
+    )
+    parser.add_argument(
+        "--output",
+        default="src/dict_search.html",
+        help="Output HTML path (default: src/dict_search.html)",
+    )
+    args = parser.parse_args()
+    dict_path = Path(args.dict)
+    if not dict_path.exists():
+        print(f"ERROR: {dict_path} not found")
+        return
+    entries = load_dictionary(dict_path)
+    print(f"Loaded {len(entries)} dictionary entries from {dict_path}")
+    html_content = build_html(entries)
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(html_content, encoding="utf-8")
+    size_kb = output_path.stat().st_size / 1024
+    print(f"Written {output_path} ({size_kb:.0f} KB)")
+if __name__ == "__main__":
+    main()

src/dict_plugin.html ADDED Viewed

The diff for this file is too large to render. See raw diff

src/dict_search.html ADDED Viewed

The diff for this file is too large to render. See raw diff

src/ls_config_ws.xml ADDED Viewed

	@@ -0,0 +1,14 @@

+<View>
+  <Header value="Word Segmentation: Select each word as a span. Multi-syllable words = one span."/>
+  <Header value="Sentence: $sent_id | Rank: $rank" size="4"/>
+  <View style="border:1px solid #e0e0e0; border-radius:8px; overflow:hidden; margin-bottom:8px">
+    <HyperText name="dict_view" value="$dict_iframe" inline="true"/>
+  </View>
+  <Labels name="label" toName="text" choice="single">
+    <Label value="W" background="#4CAF50" hotkey="w"/>
+    <Label value="WH" background="#2196F3" hotkey="h"/>
+    <Label value="WM" background="#FFC107" hotkey="m"/>
+    <Label value="WL" background="#F44336" hotkey="l"/>
+  </Labels>
+  <Text name="text" value="$text" granularity="word"/>
+</View>

src/ls_export_ws.py ADDED Viewed

	@@ -0,0 +1,227 @@

+"""Convert Label Studio JSON export to BIO format.
+Reads a Label Studio JSON export (with annotations), converts span
+annotations back to syllable-level BIO tags, and writes BIO format
+compatible with tree-1's load_data_vlsp2013().
+Usage:
+    uv run src/ls_export_ws.py --input ls_export_cycle1.json --output gold_ws_cycle1.txt
+"""
+import argparse
+import json
+import sys
+import unicodedata
+from pathlib import Path
+def nfc(text):
+    """Normalize text to NFC for consistent Unicode handling."""
+    return unicodedata.normalize("NFC", text)
+def text_to_syllable_offsets(text):
+    """Compute (start, end) character offsets for each space-delimited syllable.
+    Returns list of (start, end) tuples.
+    """
+    offsets = []
+    pos = 0
+    for syl in text.split(" "):
+        start = pos
+        end = pos + len(syl)
+        offsets.append((start, end))
+        pos = end + 1  # skip space
+    return offsets
+def spans_to_bio(spans, text):
+    """Convert Label Studio span annotations to syllable-level BIO tags.
+    Args:
+        spans: list of span annotation dicts (from Label Studio result)
+        text: the original text string
+    Returns:
+        (syllables, tags) tuple
+    """
+    syllables = text.split(" ")
+    syl_offsets = text_to_syllable_offsets(text)
+    n = len(syllables)
+    tags = [None] * n
+    # Sort spans by start offset
+    sorted_spans = sorted(spans, key=lambda s: s["value"]["start"])
+    for span in sorted_spans:
+        span_start = span["value"]["start"]
+        span_end = span["value"]["end"]
+        # Find syllables covered by this span
+        first_syl = None
+        for i, (s, e) in enumerate(syl_offsets):
+            if s >= span_start and e <= span_end:
+                if first_syl is None:
+                    first_syl = i
+                    tags[i] = "B-W"
+                else:
+                    tags[i] = "I-W"
+    return syllables, tags
+def validate_bio(syllables, tags, sent_id):
+    """Validate BIO tags: all syllables tagged, no gaps."""
+    errors = []
+    for i, (syl, tag) in enumerate(zip(syllables, tags)):
+        if tag is None:
+            errors.append(f"Syllable {i} ({syl!r}) has no tag")
+        elif tag not in ("B-W", "I-W"):
+            errors.append(f"Syllable {i} ({syl!r}) has invalid tag {tag!r}")
+    if tags and tags[0] == "I-W":
+        errors.append("First syllable has I-W tag (should be B-W)")
+    for i in range(1, len(tags)):
+        if tags[i] == "I-W" and tags[i - 1] is None:
+            errors.append(f"I-W at position {i} follows untagged syllable")
+    if errors:
+        return [f"[{sent_id}] {e}" for e in errors]
+    return []
+def get_annotations(task):
+    """Extract the best annotation result from a task.
+    Prefers completed annotations over predictions.
+    For annotations, takes the most recent one.
+    """
+    # Check for human annotations first
+    annotations = task.get("annotations", [])
+    if annotations:
+        # Filter to completed annotations
+        completed = [a for a in annotations if not a.get("was_cancelled", False)]
+        if completed:
+            # Take the most recent
+            best = max(completed, key=lambda a: a.get("updated_at", ""))
+            return best.get("result", [])
+    # Fall back to predictions
+    predictions = task.get("predictions", [])
+    if predictions:
+        return predictions[0].get("result", [])
+    return None
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert Label Studio JSON export to BIO format"
+    )
+    parser.add_argument(
+        "--input",
+        required=True,
+        help="Path to Label Studio JSON export",
+    )
+    parser.add_argument(
+        "--output",
+        required=True,
+        help="Output BIO file path",
+    )
+    parser.add_argument(
+        "--require-annotation",
+        action="store_true",
+        help="Only include tasks with human annotations (skip prediction-only)",
+    )
+    args = parser.parse_args()
+    # Read export
+    with open(args.input, "r", encoding="utf-8") as f:
+        tasks = json.load(f)
+    print(f"Loaded {len(tasks)} tasks from {args.input}")
+    sentences = []
+    errors = []
+    n_annotated = 0
+    n_prediction_only = 0
+    for task in tasks:
+        data = task.get("data", {})
+        text = nfc(data.get("text", ""))
+        sent_id = data.get("sent_id", "unknown")
+        if not text:
+            errors.append(f"[{sent_id}] Empty text")
+            continue
+        # Get annotations
+        annotations = task.get("annotations", [])
+        completed = [a for a in annotations if not a.get("was_cancelled", False)]
+        has_human = len(completed) > 0
+        if args.require_annotation and not has_human:
+            n_prediction_only += 1
+            continue
+        result = get_annotations(task)
+        if result is None:
+            errors.append(f"[{sent_id}] No annotations or predictions")
+            continue
+        if has_human:
+            n_annotated += 1
+        else:
+            n_prediction_only += 1
+        # Filter to label spans only
+        spans = [r for r in result if r.get("type") == "labels"]
+        # Convert to BIO
+        syllables, tags = spans_to_bio(spans, text)
+        # Validate
+        bio_errors = validate_bio(syllables, tags, sent_id)
+        if bio_errors:
+            errors.extend(bio_errors)
+            continue
+        sentences.append({
+            "sent_id": sent_id,
+            "text": text,
+            "syllables": syllables,
+            "tags": tags,
+        })
+    # Report
+    print(f"Human-annotated: {n_annotated}")
+    print(f"Prediction-only: {n_prediction_only}")
+    if errors:
+        print(f"\n{len(errors)} errors:")
+        for e in errors:
+            print(f"  - {e}")
+    print(f"\nConverted {len(sentences)} sentences")
+    # Sort by sent_id for deterministic output
+    sentences.sort(key=lambda s: s["sent_id"])
+    # Write BIO
+    output_path = Path(args.output)
+    with open(output_path, "w", encoding="utf-8") as f:
+        for sent in sentences:
+            f.write(f"# sent_id = {sent['sent_id']}\n")
+            f.write(f"# text = {sent['text']}\n")
+            for syl, tag in zip(sent["syllables"], sent["tags"]):
+                f.write(f"{syl}\t{tag}\n")
+            f.write("\n")
+    print(f"Written to {output_path}")
+    if errors:
+        sys.exit(1)
+if __name__ == "__main__":
+    main()

src/ls_import_ws.py ADDED Viewed

	@@ -0,0 +1,503 @@

+# /// script
+# requires-python = ">=3.9"
+# dependencies = ["python-crfsuite"]
+# ///
+"""Convert AL Cycle 0 top-500 TSV + BIO files to Label Studio JSON.
+Reads al_cycle0_top500.tsv to identify which sentences to annotate,
+looks up their silver BIO tags from udd-ws-v1.1-{dev,test}.txt,
+and produces a Label Studio import JSON with pre-annotations.
+When --model is provided, computes per-span confidence scores from CRF
+marginal probabilities. Each word span gets score = min confidence across
+its syllables, so words with any uncertain boundary get a low score.
+When --dict is provided (standalone or auto-detected from model dir),
+generates dict_html field with dictionary match highlights:
+  green = multi-syllable span in dictionary
+  pink/red = multi-syllable span NOT in dictionary
+Usage:
+    uv run src/ls_import_ws.py [--validate]
+    uv run src/ls_import_ws.py --dict path/to/dictionary.txt
+    uv run src/ls_import_ws.py --model path/to/model.crfsuite
+"""
+import argparse
+import json
+import sys
+import unicodedata
+from pathlib import Path
+from urllib.parse import quote
+def parse_bio_file(filepath):
+    """Parse BIO file into list of sentences.
+    Returns list of dicts with keys: sent_id, text, syllables, tags.
+    Reused from fix_ws_errors.py.
+    """
+    sentences = []
+    current = {"sent_id": "", "text": "", "syllables": [], "tags": []}
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip("\n")
+            if line.startswith("# sent_id = "):
+                current["sent_id"] = line.split("= ", 1)[1]
+                continue
+            if line.startswith("# text = "):
+                current["text"] = line.split("= ", 1)[1]
+                continue
+            if line.startswith("#"):
+                continue
+            if not line:
+                if current["syllables"]:
+                    sentences.append(dict(current))
+                    current = {"sent_id": "", "text": "", "syllables": [], "tags": []}
+                continue
+            parts = line.split("\t")
+            if len(parts) == 2:
+                current["syllables"].append(parts[0])
+                current["tags"].append(parts[1])
+    if current["syllables"]:
+        sentences.append(dict(current))
+    return sentences
+def parse_tsv(filepath):
+    """Parse al_cycle0_top500.tsv.
+    Returns list of dicts with keys: rank, file, sent_idx, score, text.
+    """
+    rows = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        header = f.readline().rstrip("\n").split("\t")
+        for line in f:
+            line = line.rstrip("\n")
+            if not line:
+                continue
+            fields = line.split("\t")
+            row = dict(zip(header, fields))
+            rows.append({
+                "rank": int(row["rank"]),
+                "file": row["file"],
+                "sent_idx": int(row["sent_idx"]),
+                "score": float(row["score"]),
+                "text": row["text"],
+            })
+    return rows
+def nfc(text):
+    """Normalize text to NFC for consistent Unicode handling."""
+    return unicodedata.normalize("NFC", text)
+def confidence_to_label(conf):
+    """Map confidence score to label: WH (>=0.8), WM (0.6-0.8), WL (<0.6)."""
+    if conf >= 0.8:
+        return "WH"
+    elif conf >= 0.6:
+        return "WM"
+    else:
+        return "WL"
+def bio_to_spans(syllables, tags, text, confidences=None):
+    """Convert BIO tags to Label Studio span annotations.
+    Args:
+        syllables: list of syllable strings
+        tags: list of BIO tags (B-W / I-W)
+        text: space-joined text string
+        confidences: optional list of per-syllable confidence floats
+    Returns:
+        list of span dicts for Label Studio predictions
+    """
+    spans = []
+    span_start = None
+    span_syllables = []
+    span_syl_indices = []
+    char_pos = 0
+    def _close_span():
+        span_text = " ".join(span_syllables)
+        # Choose label based on confidence: WH/WM/WL for predictions, W if no confidence
+        if confidences is not None:
+            span_conf = min(confidences[j] for j in span_syl_indices)
+            label = confidence_to_label(span_conf)
+        else:
+            label = "W"
+        span_dict = {
+            "id": f"s{len(spans)}",
+            "from_name": "label",
+            "to_name": "text",
+            "type": "labels",
+            "value": {
+                "start": span_start,
+                "end": span_start + len(span_text),
+                "text": span_text,
+                "labels": [label],
+            },
+        }
+        if confidences is not None:
+            span_dict["score"] = round(span_conf, 4)
+        spans.append(span_dict)
+    for i, (syl, tag) in enumerate(zip(syllables, tags)):
+        # Verify syllable matches text at expected position
+        expected = text[char_pos:char_pos + len(syl)]
+        if nfc(expected) != nfc(syl):
+            raise ValueError(
+                f"Syllable mismatch at pos {char_pos}: "
+                f"expected {syl!r}, got {expected!r} in text {text!r}"
+            )
+        if tag == "B-W":
+            # Close previous span
+            if span_syllables:
+                _close_span()
+            span_start = char_pos
+            span_syllables = [syl]
+            span_syl_indices = [i]
+        elif tag == "I-W":
+            span_syllables.append(syl)
+            span_syl_indices.append(i)
+        else:
+            raise ValueError(f"Unknown tag {tag!r} for syllable {syl!r}")
+        char_pos += len(syl)
+        # Skip space between syllables
+        if i < len(syllables) - 1:
+            char_pos += 1  # space separator
+    # Close final span
+    if span_syllables:
+        _close_span()
+    return spans
+def add_dict_meta(spans, dictionary):
+    """Add dictionary lookup metadata to each span.
+    When the annotator selects a region, LS shows the meta fields in
+    the Region Details panel. This provides instant dictionary feedback.
+    For multi-syllable spans: shows dict status + up to 5 similar entries.
+    For single-syllable spans: shows dict status only.
+    """
+    for span in spans:
+        span_text = span["value"]["text"]
+        normalized = nfc(span_text.lower().strip())
+        n_syllables = span_text.count(" ") + 1
+        in_dict = normalized in dictionary
+        if n_syllables == 1:
+            span["meta"] = {"dict": "✓" if in_dict else "—"}
+        else:
+            if in_dict:
+                span["meta"] = {"dict": "✓ in dict"}
+            else:
+                # Find similar entries (prefix match on first syllable)
+                first_syl = normalized.split()[0]
+                similar = sorted(
+                    e for e in dictionary
+                    if e.startswith(first_syl + " ") and e != normalized
+                )[:5]
+                meta = {"dict": "✗ not found"}
+                if similar:
+                    meta["similar"] = ", ".join(similar)
+                span["meta"] = meta
+def build_dict_iframe(spans, text):
+    """Build an iframe tag pointing to the dictionary plugin page.
+    Encodes the sentence text and span positions in the URL fragment so the
+    plugin page can render highlights and search without a server round-trip.
+    The ~900KB dictionary page is loaded once and cached by the browser.
+    Args:
+        spans: list of span dicts from bio_to_spans()
+        text: the sentence text
+    Returns:
+        HTML iframe tag string for the HyperText panel
+    """
+    # Encode spans as compact [start, end] pairs
+    span_pairs = [
+        [s["value"]["start"], s["value"]["end"]] for s in spans
+    ]
+    spans_json = json.dumps(span_pairs, separators=(",", ":"))
+    fragment = f"text={quote(text, safe='')}&spans={quote(spans_json, safe='')}"
+    return (
+        f"<iframe src='/static/dict_plugin.html#{fragment}'"
+        f" width='100%' height='180' style='border:none'></iframe>"
+    )
+def validate_spans(spans, text, syllables):
+    """Validate that spans cover every character in text without gaps/overlaps."""
+    text_len = len(text)
+    covered = [False] * text_len
+    for span in spans:
+        start = span["value"]["start"]
+        end = span["value"]["end"]
+        for j in range(start, end):
+            if covered[j]:
+                raise ValueError(f"Overlap at char {j} in text {text!r}")
+            covered[j] = True
+    # Check that all non-space characters are covered
+    for j, ch in enumerate(text):
+        if ch != " " and not covered[j]:
+            raise ValueError(f"Gap at char {j} ({ch!r}) in text {text!r}")
+    # Check span count matches word count
+    n_words = sum(1 for t in syllables if t == "B-W")  # tags not syllables
+    # Actually count from spans
+    if len(spans) != n_words:
+        raise ValueError(
+            f"Span count {len(spans)} != word count {n_words} in text {text!r}"
+        )
+def load_dictionary(dict_path):
+    """Load dictionary file into a set of NFC-normalized entries.
+    Returns set of lowercase NFC-normalized dictionary entries.
+    """
+    dictionary = set()
+    with open(dict_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                dictionary.add(nfc(line.lower()))
+    print(f"Dictionary: {len(dictionary)} entries from {dict_path}")
+    return dictionary
+def load_crf_scorer(model_path):
+    """Load CRF tagger for confidence scoring.
+    Returns tagger object.
+    """
+    import pycrfsuite
+    tagger = pycrfsuite.Tagger()
+    tagger.open(str(model_path))
+    return tagger
+def compute_confidences(tagger, syllables, dictionary=None):
+    """Compute per-syllable confidence from CRF marginal probabilities.
+    Confidence = max(P(B|x,i), P(I|x,i)) for each syllable position.
+    Uses feature extraction from al_score_ws.py.
+    """
+    # Import feature extraction (same as al_score_ws.py)
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    from al_score_ws import sentence_to_features
+    xseq = sentence_to_features(syllables, dictionary)
+    tagger.set(xseq)
+    confidences = []
+    for i in range(len(syllables)):
+        p_b = tagger.marginal("B", i)
+        p_i = tagger.marginal("I", i)
+        confidences.append(max(p_b, p_i))
+    return confidences
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert AL top-500 + BIO to Label Studio JSON"
+    )
+    parser.add_argument(
+        "--tsv",
+        default="al_cycle0_top500.tsv",
+        help="Path to ranked TSV file (default: al_cycle0_top500.tsv)",
+    )
+    parser.add_argument(
+        "--bio-dir",
+        default=".",
+        help="Directory containing udd-ws-v1.1-{dev,test}.txt (default: .)",
+    )
+    parser.add_argument(
+        "--output",
+        default="ls_import_cycle1.json",
+        help="Output JSON path (default: ls_import_cycle1.json)",
+    )
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Run validation checks on all tasks",
+    )
+    parser.add_argument(
+        "--model",
+        default=None,
+        help="Path to CRF model (.crfsuite) for per-span confidence scores",
+    )
+    parser.add_argument(
+        "--dict",
+        default=None,
+        help="Path to dictionary.txt (auto-detected from model dir if not set)",
+    )
+    args = parser.parse_args()
+    root = Path(args.bio_dir)
+    # Load dictionary (standalone or auto-detected from model dir)
+    dictionary = None
+    if args.dict:
+        dictionary = load_dictionary(args.dict)
+    elif args.model:
+        auto_dict = Path(args.model).parent / "dictionary.txt"
+        if auto_dict.exists():
+            dictionary = load_dictionary(auto_dict)
+    # Load CRF scorer if model provided
+    tagger = None
+    if args.model:
+        model_path = Path(args.model)
+        print(f"Loading CRF model: {model_path}")
+        tagger = load_crf_scorer(model_path)
+        print("Per-span confidence scoring enabled")
+    # Parse TSV
+    tsv_rows = parse_tsv(args.tsv)
+    print(f"Loaded {len(tsv_rows)} rows from {args.tsv}")
+    # Parse BIO files (only dev and test — train sentences not in top-500)
+    bio_data = {}
+    for split in ("dev", "test"):
+        bio_path = root / f"udd-ws-v1.1-{split}.txt"
+        if not bio_path.exists():
+            print(f"WARNING: {bio_path} not found, skipping")
+            continue
+        sentences = parse_bio_file(bio_path)
+        bio_data[split] = sentences
+        print(f"Loaded {len(sentences)} sentences from {bio_path}")
+    # Build tasks
+    tasks = []
+    errors = []
+    for row in tsv_rows:
+        split = row["file"]
+        sent_idx = row["sent_idx"]
+        if split not in bio_data:
+            errors.append(f"Rank {row['rank']}: split '{split}' not loaded")
+            continue
+        if sent_idx >= len(bio_data[split]):
+            errors.append(
+                f"Rank {row['rank']}: sent_idx {sent_idx} >= "
+                f"{len(bio_data[split])} sentences in {split}"
+            )
+            continue
+        sent = bio_data[split][sent_idx]
+        text = nfc(" ".join(sent["syllables"]))
+        # Verify text matches TSV
+        tsv_text = nfc(row["text"])
+        if text != tsv_text:
+            errors.append(
+                f"Rank {row['rank']}: text mismatch:\n"
+                f"  BIO: {text!r}\n  TSV: {tsv_text!r}"
+            )
+            continue
+        # Compute per-syllable confidence if CRF model available
+        confidences = None
+        if tagger is not None:
+            confidences = compute_confidences(
+                tagger, sent["syllables"], dictionary
+            )
+        # Convert BIO to spans
+        try:
+            spans = bio_to_spans(
+                sent["syllables"], sent["tags"], text, confidences
+            )
+        except ValueError as e:
+            errors.append(f"Rank {row['rank']}: span conversion error: {e}")
+            continue
+        # Validate span coverage
+        if args.validate:
+            try:
+                validate_spans(spans, text, sent["tags"])
+            except ValueError as e:
+                errors.append(f"Rank {row['rank']}: validation error: {e}")
+                continue
+        # Task-level prediction score = 1 - AL uncertainty score
+        pred_score = round(1.0 - row["score"], 6)
+        # Add dictionary metadata to spans + build iframe for search
+        dict_iframe = ""
+        if dictionary:
+            add_dict_meta(spans, dictionary)
+            dict_iframe = build_dict_iframe(spans, text)
+        task = {
+            "data": {
+                "text": text,
+                "sent_id": sent["sent_id"],
+                "rank": row["rank"],
+                "file": split,
+                "sent_idx": sent_idx,
+                "dict_iframe": dict_iframe,
+            },
+            "predictions": [{
+                "model_version": "silver_crf_v1.1",
+                "score": pred_score,
+                "result": spans,
+            }],
+        }
+        tasks.append(task)
+    # Report
+    if errors:
+        print(f"\n{len(errors)} errors:")
+        for e in errors:
+            print(f"  - {e}")
+    print(f"\nGenerated {len(tasks)} tasks")
+    if tagger is not None:
+        # Report confidence statistics
+        all_scores = []
+        for t in tasks:
+            for r in t["predictions"][0]["result"]:
+                if "score" in r:
+                    all_scores.append(r["score"])
+        if all_scores:
+            low = sum(1 for s in all_scores if s < 0.8)
+            print(f"Span confidence: min={min(all_scores):.4f}, "
+                  f"mean={sum(all_scores)/len(all_scores):.4f}, "
+                  f"<0.8: {low}/{len(all_scores)}")
+    # Write output
+    output_path = Path(args.output)
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(tasks, f, ensure_ascii=False, indent=2)
+    print(f"Written to {output_path}")
+    if errors:
+        sys.exit(1)
+if __name__ == "__main__":
+    main()