| |
| """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() |
|
|
