pipeline01_text2gloss.py

#!/usr/bin/env python3
"""Constrained English text -> available gloss translation for StableSigner.

This is the browser-panel fallback path: it only emits gloss tokens that exist
in the local pose dictionary, so gloss2pose can render the result immediately.
It is intentionally conservative and can later be replaced by a trained
text-to-gloss model with the same public functions.
"""

from __future__ import annotations

import argparse
import json
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple


BASE_DIR = Path(__file__).resolve().parent
DEFAULT_POSE_DICT = BASE_DIR / "pose_dict" / "WLASL_train.json"


STOP_WORDS = {
    "A",
    "AN",
    "THE",
    "AM",
    "ARE",
    "IS",
    "WAS",
    "WERE",
    "BE",
    "BEEN",
    "BEING",
    "DO",
    "DOES",
    "DID",
    "TO",
    "OF",
    "FOR",
    "WITH",
    "AND",
    "OR",
    "BUT",
    "THAT",
    "THIS",
    "THESE",
    "THOSE",
    "IT",
    "ITS",
    "JUST",
    "VERY",
    "REALLY",
}


LEMMA_OVERRIDES = {
    "ME": "I",
    "MINE": "MY",
    "MYSELF": "I",
    "YOURSELF": "YOU",
    "YOUR": "YOU",
    "YOURS": "YOU",
    "HIS": "HE",
    "HIM": "HE",
    "HER": "SHE",
    "HERS": "SHE",
    "THEIR": "THEY",
    "THEM": "THEY",
    "OUR": "WE",
    "US": "WE",
    "WENT": "GO",
    "GONE": "GO",
    "GOING": "GO",
    "CAME": "COME",
    "COMING": "COME",
    "MADE": "MAKE",
    "MAKING": "MAKE",
    "SAID": "SAY",
    "SAYING": "SAY",
    "SAW": "SEE",
    "SEEN": "SEE",
    "SEEING": "SEE",
    "LOOKING": "LOOK",
    "LIKED": "LIKE",
    "LIKES": "LIKE",
    "WANTED": "WANT",
    "WANTS": "WANT",
    "NEEDED": "NEED",
    "NEEDS": "NEED",
    "HELPED": "HELP",
    "HELPS": "HELP",
    "LEARNED": "LEARN",
    "LEARNING": "LEARN",
    "SIGNED": "SIGN",
    "SIGNING": "SIGN",
    "THANKS": "THANK",
}


PHRASE_MAP = {
    "GOOD MORNING": ["GOOD", "MORNING"],
    "GOOD AFTERNOON": ["GOOD", "AFTERNOON"],
    "GOOD NIGHT": ["GOOD", "NIGHT"],
    "THANK YOU": ["THANK", "YOU"],
    "SIGN LANGUAGE": ["SIGN", "LANGUAGE"],
}


SEMANTIC_PHRASE_MAP = {
    "HELP ME": ["HELP", "I"],
    "NEED HELP": ["NEED", "HELP"],
    "I NEED HELP": ["I", "NEED", "HELP"],
    "PLEASE HELP": ["PLEASE", "HELP"],
    "GO TO SCHOOL": ["GO", "SCHOOL"],
    "GO HOME": ["GO", "HOME"],
    "COME HERE": ["COME", "HERE"],
    "SEE YOU": ["SEE", "YOU"],
    "NICE TO MEET YOU": ["NICE", "MEET", "YOU"],
    "HOW ARE YOU": ["HOW", "YOU"],
}


SEMANTIC_TOKEN_MAP = {
    "ASSIST": "HELP",
    "AID": "HELP",
    "SUPPORT": "HELP",
    "SUPPORTING": "HELP",
    "REQUIRE": "NEED",
    "REQUIRES": "NEED",
    "REQUIRED": "NEED",
    "MUST": "NEED",
    "SHOULD": "NEED",
    "PURCHASE": "BUY",
    "PURCHASED": "BUY",
    "PURCHASING": "BUY",
    "GET": "BUY",
    "BOUGHT": "BUY",
    "OBTAIN": "BUY",
    "SPEAK": "TALK",
    "SPEAKING": "TALK",
    "TELL": "SAY",
    "TOLD": "SAY",
    "VIEW": "SEE",
    "WATCH": "SEE",
    "OBSERVE": "SEE",
    "UNDERSTOOD": "UNDERSTAND",
    "UNDERSTANDING": "UNDERSTAND",
    "CHILDREN": "CHILD",
    "KIDS": "CHILD",
    "KID": "CHILD",
    "ADULTS": "ADULT",
    "PEOPLE": "PERSON",
    "HUMAN": "PERSON",
    "PERSONS": "PERSON",
    "PHYSICIAN": "DOCTOR",
    "MEDICAL": "DOCTOR",
    "HOSPITAL": "DOCTOR",
    "INSTRUCTOR": "TEACHER",
    "EDUCATOR": "TEACHER",
    "PUPIL": "STUDENT",
    "LEARNER": "STUDENT",
    "AUTOMOBILE": "CAR",
    "VEHICLE": "CAR",
    "CELL": "PHONE",
    "MOBILE": "PHONE",
    "TELEPHONE": "PHONE",
    "RESIDENCE": "HOME",
    "HOUSE": "HOME",
    "WEATHER": "WEATHER",
    "RAINING": "RAIN",
    "SUNNY": "SUN",
    "COLD": "COLD",
    "HOT": "HOT",
    "BEAUTIFUL": "NICE",
    "GREAT": "GOOD",
    "EXCELLENT": "GOOD",
    "FINE": "GOOD",
    "HAPPY": "HAPPY",
    "SAD": "SAD",
    "AFRAID": "FEAR",
    "SCARED": "FEAR",
    "SOON": "LATER",
    "AFTER": "LATER",
    "CURRENTLY": "NOW",
    "IMMEDIATELY": "NOW",
    "YESTERDAY": "YESTERDAY",
    "TOMORROW": "TOMORROW",
}


AMBIGUOUS_SEMANTIC_BLOCKLIST = {
    "CAN", "MAY", "MIGHT", "LEFT", "RIGHT", "LIGHT", "WELL", "KIND", "MEAN", "PART", "SECOND"
}


@dataclass
class TextToGlossResult:
    gloss: str
    tokens: List[str]
    matched: List[Tuple[str, str]]
    dropped: List[str]
    semantic: List[Tuple[str, str]]


def load_available_glosses(path: Path | str = DEFAULT_POSE_DICT) -> Set[str]:
    """Load uppercase gloss vocabulary from WLASL-style pose dictionary JSON."""
    pose_path = Path(path)
    with pose_path.open("r", encoding="utf-8") as handle:
        data = json.load(handle)
    glosses = set()
    for item in data:
        gloss = str(item.get("gloss", "")).strip().upper()
        if gloss:
            glosses.add(gloss)
    return glosses


def tokenize_english(text: str) -> List[str]:
    text = text.replace("'", "")
    return [token.upper() for token in re.findall(r"[A-Za-z0-9]+", text)]


def _simple_lemma(token: str) -> List[str]:
    candidates = [token]
    if token in LEMMA_OVERRIDES:
        candidates.append(LEMMA_OVERRIDES[token])
    if len(token) > 4 and token.endswith("IES"):
        candidates.append(token[:-3] + "Y")
    if len(token) > 4 and token.endswith("ING"):
        candidates.append(token[:-3])
        if len(token) > 5:
            candidates.append(token[:-4])
    if len(token) > 3 and token.endswith("ED"):
        candidates.append(token[:-2])
        candidates.append(token[:-1])
    if len(token) > 3 and token.endswith("ES"):
        candidates.append(token[:-2])
    if len(token) > 2 and token.endswith("S"):
        candidates.append(token[:-1])

    deduped = []
    seen = set()
    for candidate in candidates:
        if candidate and candidate not in seen:
            deduped.append(candidate)
            seen.add(candidate)
    return deduped


def _best_vocab_match(token: str, vocab: Set[str]) -> Optional[str]:
    for candidate in _simple_lemma(token):
        if candidate in vocab:
            return candidate
    return None


def _best_semantic_match(token: str, vocab: Set[str]) -> Optional[str]:
    if token in AMBIGUOUS_SEMANTIC_BLOCKLIST:
        return None
    candidates = _simple_lemma(token)
    for candidate in candidates:
        mapped = SEMANTIC_TOKEN_MAP.get(candidate)
        if mapped and mapped in vocab:
            return mapped
    return None


def _apply_semantic_phrase_map(tokens: Sequence[str], vocab: Set[str]) -> Tuple[List[str], List[Tuple[str, str]]]:
    output: List[str] = []
    matched: List[Tuple[str, str]] = []
    i = 0
    phrases = sorted(SEMANTIC_PHRASE_MAP.items(), key=lambda item: len(item[0].split()), reverse=True)
    while i < len(tokens):
        consumed = False
        for phrase, gloss_tokens in phrases:
            phrase_tokens = phrase.split()
            if list(tokens[i : i + len(phrase_tokens)]) != phrase_tokens:
                continue
            available = [gloss for gloss in gloss_tokens if gloss in vocab]
            if available:
                output.extend(available)
                matched.append((phrase, " ".join(available)))
                i += len(phrase_tokens)
                consumed = True
                break
        if not consumed:
            output.append(tokens[i])
            i += 1
    return output, matched


def _apply_phrase_map(tokens: Sequence[str], vocab: Set[str]) -> Tuple[List[str], List[Tuple[str, str]]]:
    output: List[str] = []
    matched: List[Tuple[str, str]] = []
    i = 0
    while i < len(tokens):
        consumed = False
        for phrase, gloss_tokens in PHRASE_MAP.items():
            phrase_tokens = phrase.split()
            if list(tokens[i : i + len(phrase_tokens)]) != phrase_tokens:
                continue
            available = [gloss for gloss in gloss_tokens if gloss in vocab]
            if available:
                output.extend(available)
                matched.append((phrase, " ".join(available)))
                i += len(phrase_tokens)
                consumed = True
                break
        if not consumed:
            output.append(tokens[i])
            i += 1
    return output, matched


def translate_text_to_gloss(
    text: str,
    vocab: Optional[Iterable[str]] = None,
    max_tokens: int = 64,
    use_semantic: bool = False,
) -> TextToGlossResult:
    """Translate English text into a renderable uppercase gloss sequence."""
    vocab_set = {item.upper() for item in vocab} if vocab is not None else load_available_glosses()
    raw_tokens = tokenize_english(text)
    phrase_tokens, phrase_matches = _apply_phrase_map(raw_tokens, vocab_set)
    semantic_matches: List[Tuple[str, str]] = []
    if use_semantic:
        phrase_tokens, semantic_phrase_matches = _apply_semantic_phrase_map(phrase_tokens, vocab_set)
        semantic_matches.extend(semantic_phrase_matches)

    gloss_tokens: List[str] = []
    matched: List[Tuple[str, str]] = list(phrase_matches)
    dropped: List[str] = []

    for token in phrase_tokens:
        if len(gloss_tokens) >= max_tokens:
            break
        if token in STOP_WORDS:
            dropped.append(token)
            continue
        gloss = _best_vocab_match(token, vocab_set)
        if not gloss and use_semantic:
            gloss = _best_semantic_match(token, vocab_set)
            if gloss:
                semantic_matches.append((token, gloss))
        if gloss:
            gloss_tokens.append(gloss)
            if token != gloss:
                matched.append((token, gloss))
        else:
            dropped.append(token)

    return TextToGlossResult(
        gloss=" ".join(gloss_tokens),
        tokens=gloss_tokens,
        matched=matched,
        dropped=dropped,
        semantic=semantic_matches,
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Constrained English text to StableSigner gloss.")
    parser.add_argument("text", help="English text to translate.")
    parser.add_argument("--pose-dict", default=str(DEFAULT_POSE_DICT), help="WLASL-style pose dictionary JSON.")
    parser.add_argument("--max-tokens", type=int, default=64)
    parser.add_argument("--semantic", action="store_true", help="Enable conservative semantic synonym fallback.")
    parser.add_argument("--json", action="store_true", help="Print structured JSON instead of only gloss.")
    args = parser.parse_args()

    vocab = load_available_glosses(args.pose_dict)
    result = translate_text_to_gloss(args.text, vocab=vocab, max_tokens=args.max_tokens, use_semantic=args.semantic)
    if args.json:
        print(
            json.dumps(
                {
                    "gloss": result.gloss,
                    "tokens": result.tokens,
                    "matched": result.matched,
                    "dropped": result.dropped,
                    "semantic": result.semantic,
                },
                ensure_ascii=True,
                indent=2,
            )
        )
    else:
        print(result.gloss)


if __name__ == "__main__":
    main()