Spaces:
Sleeping
Sleeping
| import os | |
| import re | |
| import difflib | |
| import zipfile | |
| import pandas as pd | |
| def ensure_dictionary_extracted( | |
| zip_path: str = "content/asl_app_data/dictionary.zip", | |
| extract_to: str = "content/asl_app_data", | |
| ) -> None: | |
| marker = os.path.join(extract_to, "dictionary") | |
| if not os.path.isdir(marker): | |
| print(f"Extracting {zip_path}…") | |
| with zipfile.ZipFile(zip_path) as z: | |
| z.extractall(extract_to) | |
| print("Extraction complete.") | |
| class ASLDictionary: | |
| """ | |
| Load token→video-filename map from CSV and resolve paths under dictionary_dir. | |
| Lookup chain: exact/phrase → lemmatization → semantic (VectorIndex) → fuzzy → fingerspelling. | |
| """ | |
| LEMMA_RULES = [ | |
| (r'ING$', ''), | |
| (r'INGS$', ''), | |
| (r'ED$', ''), | |
| (r'LY$', ''), | |
| (r'ER$', ''), | |
| (r'EST$', ''), | |
| (r'ION$', ''), | |
| (r'TION$', ''), | |
| (r'S$', ''), | |
| ] | |
| def __init__( | |
| self, | |
| csv_path: str = "content/asl_app_data/asl_video_index_final_with_path_cleaned.csv", | |
| dictionary_dir: str = "content/asl_app_data/dictionary", | |
| fingerspelling_dir: str = "content/asl_app_data/Letters", | |
| vector_index=None, | |
| ): | |
| ensure_dictionary_extracted() | |
| self.directory = dictionary_dir | |
| self.fingerspelling_dir = fingerspelling_dir | |
| df = pd.read_csv(csv_path) | |
| self.map: dict[str, str] = {} | |
| for _, row in df.iterrows(): | |
| filepath = row["path"] | |
| fname = os.path.basename(filepath) | |
| for col in ("token", "phrase", "word"): | |
| val = row.get(col, "") | |
| if pd.notna(val) and str(val).strip(): | |
| key = str(val).upper().strip() | |
| self.map[key] = fname | |
| self.keys = sorted(self.map.keys(), key=lambda x: len(x.split()), reverse=True) | |
| # Walk directory for actual file paths (handles subdirectories) | |
| self.actual_file_paths: dict[str, str] = {} | |
| if os.path.exists(self.directory): | |
| for root, dirs, files in os.walk(self.directory): | |
| for file in files: | |
| if not file.startswith('.'): | |
| self.actual_file_paths[file] = os.path.join(root, file) | |
| # Fingerspelling index: A-Z letter paths | |
| self.letter_paths: dict[str, str] = {} | |
| if os.path.exists(self.fingerspelling_dir): | |
| for letter in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ': | |
| path = os.path.join(self.fingerspelling_dir, f"{letter}.mp4") | |
| if os.path.exists(path): | |
| self.letter_paths[letter] = path | |
| if vector_index is None: | |
| from vector_index import get_vector_index | |
| self._vector_index = get_vector_index(csv_path=csv_path) | |
| else: | |
| self._vector_index = vector_index | |
| print(f"✅ Dictionary loaded: {len(self.map)} tokens") | |
| def _resolve(self, token: str) -> str | None: | |
| """Look up token in map and resolve to absolute file path.""" | |
| fname = self.map.get(token) | |
| if fname: | |
| full = self.actual_file_paths.get(fname) or os.path.join(self.directory, fname) | |
| if os.path.exists(full): | |
| return full | |
| return None | |
| def _lemmatize(self, token: str) -> str | None: | |
| """Try stripping suffixes to find a base form in vocabulary.""" | |
| for pattern, replacement in self.LEMMA_RULES: | |
| candidate = re.sub(pattern, replacement, token) | |
| if candidate != token and len(candidate) > 2: | |
| if candidate in self.map: | |
| return candidate | |
| return None | |
| def _fingerspell(self, token: str) -> list[str]: | |
| """Break token into individual letter video paths.""" | |
| paths = [] | |
| for char in token.upper(): | |
| if char in self.letter_paths: | |
| paths.append(self.letter_paths[char]) | |
| elif char != ' ': | |
| print(f"⚠️ No fingerspelling for: '{char}'") | |
| return paths | |
| def get_paths(self, gloss_tokens: list[str]) -> list[str]: | |
| fuzzy_cutoff = float(os.getenv("FUZZY_CUTOFF", "0.6")) | |
| out_paths: list[str] = [] | |
| tokens = [t.upper() for t in gloss_tokens] | |
| n = len(tokens) | |
| i = 0 | |
| while i < n: | |
| # Tier 1a: greedy multi-word phrase exact match | |
| match = None | |
| match_len = 0 | |
| for key in self.keys: | |
| parts = key.split() | |
| L = len(parts) | |
| if L > 1 and i + L <= n and tokens[i : i + L] == parts: | |
| match, match_len = key, L | |
| break | |
| if match: | |
| full = self._resolve(match) | |
| if full: | |
| print(f"[retrieval: exact] {' '.join(tokens[i:i+match_len])} → {match}") | |
| out_paths.append(full) | |
| else: | |
| print(f"⚠️ File not found for phrase '{match}'") | |
| i += match_len | |
| continue | |
| tok = tokens[i] | |
| # Tier 1b: single token exact match | |
| full = self._resolve(tok) | |
| if full: | |
| print(f"[retrieval: exact] {tok}") | |
| out_paths.append(full) | |
| i += 1 | |
| continue | |
| # Tier 2: lemmatization | |
| lemma = self._lemmatize(tok) | |
| if lemma: | |
| full = self._resolve(lemma) | |
| if full: | |
| print(f"[retrieval: lemma] {tok} → {lemma}") | |
| out_paths.append(full) | |
| i += 1 | |
| continue | |
| # Tier 3: semantic vector search | |
| results = self._vector_index.query_gloss(tok, top_k=1) | |
| if results: | |
| matched_key, score, fname = results[0] | |
| full = self.actual_file_paths.get(fname) or os.path.join(self.directory, fname) | |
| if os.path.exists(full): | |
| print(f"[retrieval: semantic] {tok} → {matched_key} ({score:.2f})") | |
| out_paths.append(full) | |
| i += 1 | |
| continue | |
| # Tier 4: fuzzy match | |
| fuzzy = difflib.get_close_matches(tok, self.map.keys(), n=1, cutoff=fuzzy_cutoff) | |
| if fuzzy: | |
| full = self._resolve(fuzzy[0]) | |
| if full: | |
| print(f"[retrieval: fuzzy] {tok} → {fuzzy[0]}") | |
| out_paths.append(full) | |
| i += 1 | |
| continue | |
| # Tier 5: fingerspelling fallback | |
| print(f"⚠️ No mapping for '{tok}' — fingerspelling...") | |
| spelled = self._fingerspell(tok) | |
| if spelled: | |
| out_paths.extend(spelled) | |
| else: | |
| print(f"⚠️ Could not fingerspell '{tok}'") | |
| i += 1 | |
| return out_paths | |