initial commit

.gitignore

@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+/data/
+
+exports
+models
+.DS_Store

app.py

@@ -0,0 +1,132 @@
+import json
+import os
+from pathlib import Path
+
+import gradio as gr
+
+from glossary_checker import GlossaryChecker
+from trans_validator import TranslationValidator
+
+# Configure glossary paths
+GLOSSARIES = {
+    "84000 Glossary": "data/84000_glossary.json",
+}
+
+def load_and_validate(file_obj, selected_glossary, api_key):
+    if not api_key or not api_key.startswith("sk-"):
+        return "Please provide a valid Anthropic API key (starts with 'sk-')"
+
+    try:
+        # Read content from the file
+        content = file_obj.decode('utf-8')
+
+        # Save content to temporary file
+        temp_path = "temp_aligned.txt"
+        with open(temp_path, "w", encoding='utf-8') as f:
+            f.write(content)
+
+        # Initialize checker and validator
+        glossary_path = GLOSSARIES[selected_glossary]
+        checker = GlossaryChecker(glossary_path)
+        validator = TranslationValidator(checker, api_key)
+
+        # Run validation
+        results = validator.validate_translation(temp_path)
+
+        # Create result display
+        markdown_output = []
+
+        # Add summary
+        total_score = sum(r['score'] for r in results) / len(results)
+        markdown_output.append(f"# Validation Results\n")
+        markdown_output.append(f"**Overall Score**: {total_score:.2f}%\n")
+        markdown_output.append("*(Score based on terms counted in scoring)*\n\n")
+        markdown_output.append(f"**Total Lines**: {len(results)}\n\n")
+
+        # Add detailed results for each line
+        for result in results:
+            markdown_output.append(f"## Line {result['line_number']}\n")
+            markdown_output.append(f"**Score**: {result['score']:.2f}%\n")
+            markdown_output.append(f"**Source**: {result['source']}\n")
+            markdown_output.append(f"**Target**: {result['target']}\n")
+
+            if result['terms']:
+                # Separate terms into counted and not counted
+                counted_terms = []
+                other_terms = []
+
+                for term in result['terms']:
+                    if term['analysis']['translation_assessment']['should_be_counted']:
+                        counted_terms.append(term)
+                    else:
+                        other_terms.append(term)
+
+                # Display counted terms first with clear scoring implications
+                if counted_terms:
+                    markdown_output.append("\n### 📊 Terms Counted in Scoring\n")
+                    for term in counted_terms:
+                        analysis = term['analysis']
+                        assessment = analysis['translation_assessment']
+
+                        markdown_output.append(f"\n#### `{term['source_term']}` {'✅' if assessment['translated_correctly'] else '❌'}\n")
+                        markdown_output.append(f"- Found Translation: **{analysis['translated_as']}**\n")
+                        markdown_output.append(f"- Expected Translation: **{analysis['glossary_translation']}**\n")
+
+                        # Add matching categories for context
+                        for cat_name in analysis['matching_categories']:
+                            cat_data = term['categories'].get(cat_name, {})
+                            markdown_output.append(f"\n*{cat_name}*:\n")
+                            if 'definitions' in cat_data:
+                                markdown_output.append(f"- Definition: {', '.join(cat_data['definitions'])}\n")
+
+                # Display other found terms separately
+                if other_terms:
+                    markdown_output.append("\n### Other Found Terms (Not Counted)\n")
+                    for term in other_terms:
+                        analysis = term['analysis']
+                        markdown_output.append(f"\n#### `{term['source_term']}`\n")
+                        markdown_output.append(f"- Found Translation: {analysis['translated_as']}\n")
+                        markdown_output.append(f"- Note: Term not counted due to usage context\n")
+
+                markdown_output.append("\n---\n")
+            else:
+                markdown_output.append("\n*No glossary terms found in this line*\n\n---\n")
+
+        # Clean up temp file
+        os.remove(temp_path)
+
+        return "\n".join(markdown_output)
+
+    except Exception as e:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        return f"Error during validation: {str(e)}"
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=load_and_validate,
+    inputs=[
+        gr.File(label="Upload aligned translations file (tab-separated)", type="binary"),
+        gr.Dropdown(choices=list(GLOSSARIES.keys()), label="Select Glossary"),
+        gr.Textbox(label="Anthropic API Key", placeholder="sk-...", type="password")
+    ],
+    outputs=gr.Markdown(),
+    title="Translation Validation Tool",
+    description="""Upload a file with tab-separated Tibetan source and English translation pairs.
+                The tool validates translations against the glossary using semantic analysis.
+
+                Scoring System:
+                - 📊 Only terms that match glossary definitions are counted in scoring
+                - ✅ Correct translations must use glossary terms (with allowed grammatical variations)
+                - ❌ Semantic equivalents or synonyms are marked as incorrect
+                - Score = (correct translations) / (total counted terms) × 100
+
+                You'll need an Anthropic API key to use this tool. Get one at https://console.anthropic.com/""",
+    examples=[
+        ["data/example_translations.txt", "84000 Glossary", ""]  # Example with masked API key
+    ],
+    cache_examples=False  # Don't cache examples with API keys
+)
+
+if __name__ == "__main__":
+    demo.launch()

data/example_translations.txt

@@ -0,0 +1,3 @@
+བདེ་གཤེགས་ཆོས་ཀྱི་སྐུ་མངའ་སྲས་བཅས་དང་། །ཕྱག་འོས་ཀུན་ལའང་གུས་པར་ཕྱག་འཚལ་ཏེ། །བདེ་གཤེགས་སྲས་ཀྱི་སྡོམ་ལ་འཇུག་པ་ནི། །ལུང་བཞིན་མདོར་བསྡུས་ནས་ནི་བརྗོད་པར་བྱ། །	I prostrate with respect to the sugatas, Who have the dharmakaya, and their offspring, And also to all worthy of veneration. I'll teach in brief, according to the scriptures, The way to enter the bodhisattva's vows.
+བྱང་ཆུབ་སྨོན་པའི་སེམས་ལས་ནི། །འཁོར་ཚེ་འབྲས་བུ་ཆེ་འབྱུང་ཡང་། །ཇི་ལྟར་འཇུག་པའི་སེམས་བཞིན་དུ། །བསོད་ནམས་རྒྱུན་ཆགས་འབྱུང་བ་མིན། །	Even in samsara, great results come from aspiring bodhichitta. However, unlike engaged bodhichitta, the merit is not continuous.
+ཐོག་མ་མེད་ལྡན་འཁོར་བ་ནས། །ཚེ་རབས་འདི་འམ་གཞན་དག་ཏུ། །བདག་གིས་མ་འཚལ་སྡིག་བགྱིས་པའམ། །བགྱིད་དུ་སྩལ་བ་ཉིད་དང་ནི། །	In this and other lives, throughout beginningless samsara, I have unknowingly committed misdeeds, or caused others to commit them.

data/validation_results.json

@@ -0,0 +1,316 @@
+{
+  "summary": {
+    "total_lines": 1,
+    "average_score": 50.0
+  },
+  "lines": [
+    {
+      "line_number": 1,
+      "source": "བྱང་ཆུབ་སྨོན་པའི་སེམས་ལས་ནི། །འཁོར་ཚེ་འབྲས་བུ་ཆེ་འབྱུང་ཡང་། །ཇི་ལྟར་འཇུག་པའི་སེམས་བཞིན་དུ། །བསོད་ནམས་རྒྱུན་ཆགས་འབྱུང་བ་མིན། །",
+      "target": "Even in samsara, great results come from aspiring bodhichitta. However, unlike engaged bodhichitta, the merit is not continuous.",
+      "terms": [
+        {
+          "source_term": "བྱང་ཆུབ།",
+          "categories": {
+            "term": {
+              "translations": [
+                "awakening",
+                "bodhi",
+                "enlightenment"
+              ],
+              "definitions": [
+                "Awakening (bodhi) refers to the state of profound realization and understanding achieved by a buddha regarding the true nature of reality. It is the direct, nondual perception of phenomena as they actually are, transcending conceptual thought and ignorance. This term encompasses meanings of knowledge, waking, and blossoming, and is central to Buddhist philosophy and practice. The Tibetan equivalent translates as \"purified and accomplished."
+              ],
+              "translation_found": true
+            }
+          },
+          "analysis": {
+            "translated_as": "awakening",
+            "glossary_translation": "awakening, bodhi, enlightenment",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": true,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "སེམས།",
+          "categories": {
+            "term": {
+              "translations": [
+                "bodhicitta",
+                "mind",
+                "state of mind",
+                "thought"
+              ],
+              "definitions": [
+                "One of the four bases of magical power."
+              ],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "aspiring bodhichitta",
+            "glossary_translation": "bodhicitta, mind, state of mind, thought",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "ལས།",
+          "categories": {
+            "term": {
+              "translations": [
+                "act",
+                "action",
+                "activity",
+                "deed",
+                "formal act",
+                "karma",
+                "karmic action",
+                "past action",
+                "potential of their past actions",
+                "rite"
+              ],
+              "definitions": [
+                "Karma (or action) refers to any volitional act of body, speech, or mind in Buddhist philosophy. It encompasses both the action itself and its consequences, representing the universal law of moral causation. Karma is the cumulative force of past actions that determines present experiences and future existences. Positive or negative karmic accumulations will produce results unless purified. In some contexts, karma can also refer to ritual activities or formal acts within Buddhist communities. The term may be translated variously as \"action,\" \"deed,\" \"rite,\" or left untranslated depending on the specific context and connotation intended."
+              ],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "(not directly translated)",
+            "glossary_translation": "act, action, activity, deed, formal act, karma, karmic action, past action, potential of their past actions, rite",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": false
+            }
+          }
+        },
+        {
+          "source_term": "འཁོར།",
+          "categories": {
+            "term": {
+              "translations": [
+                "assembly"
+              ],
+              "definitions": [],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "samsara",
+            "glossary_translation": "assembly",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "འབྲས་བུ་ཆེ།",
+          "categories": {
+            "person": {
+              "translations": [
+                "Bṛhatphala"
+              ],
+              "definitions": [
+                "A divine king in the Heaven of Great Fruition."
+              ],
+              "translation_found": false
+            },
+            "place": {
+              "translations": [
+                "Bṛhatphala",
+                "Great Fruition Heaven",
+                "Great Result",
+                "Heaven of Great Fruition",
+                "Large Fruit"
+              ],
+              "definitions": [
+                "Bṛhatphala (meaning \"Great Fruition\" or \"Those in the Great Result\") is one of the heavens in Buddhist cosmology, located in the form realm. It is the twelfth of seventeen heavens in this realm and the third of three levels corresponding to the fourth dhyāna (meditative concentration). The gods inhabiting this heaven are also called Bṛhatphala. In the Sarvāstivāda tradition, it is considered the highest of these three paradises. This heaven is part of the structure of the form realm, which is organized according to the four concentrations and the pure abodes (Śuddhāvāsa)."
+              ],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "great results",
+            "glossary_translation": "Bṛhatphala, Great Fruition Heaven, Great Result, Heaven of Great Fruition, Large Fruit",
+            "matching_categories": [
+              "place",
+              "person"
+            ],
+            "translation_assessment": {
+              "translated_correctly": true,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "འབྱུང་།",
+          "categories": {
+            "term": {
+              "translations": [
+                "come forth"
+              ],
+              "definitions": [],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "come",
+            "glossary_translation": "come forth",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": true,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "སེམས།",
+          "categories": {
+            "term": {
+              "translations": [
+                "bodhicitta",
+                "mind",
+                "state of mind",
+                "thought"
+              ],
+              "definitions": [
+                "One of the four bases of magical power."
+              ],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "aspiring bodhichitta",
+            "glossary_translation": "bodhicitta, mind, state of mind, thought",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "བསོད་ནམས།",
+          "categories": {
+            "term": {
+              "translations": [
+                "merit",
+                "meritorious deeds"
+              ],
+              "definitions": [
+                "Merit refers to the accumulation of positive karma or wholesome tendencies imprinted in the mind through virtuous thoughts, words, and actions. This spiritual momentum ripens into positive results, including happiness, well-being, and progress on the path to freedom from suffering. In Buddhism, merit is considered a highly prized possession, more valuable than physical attributes or skills. According to Mahāyāna teachings, it is important to dedicate one's merit to the benefit of all sentient beings, ensuring that others also experience the positive outcomes generated."
+              ],
+              "translation_found": true
+            }
+          },
+          "analysis": {
+            "translated_as": "merit",
+            "glossary_translation": "merit, meritorious deeds",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": true,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "རྒྱུན།",
+          "categories": {
+            "term": {
+              "translations": [
+                "continuum"
+              ],
+              "definitions": [
+                "In the present text this refers to the mental continuum."
+              ],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "continuous",
+            "glossary_translation": "continuum",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": true
+            }
+          }
+        },
+        {
+          "source_term": "ཆགས།",
+          "categories": {
+            "term": {
+              "translations": [
+                "attached to"
+              ],
+              "definitions": [],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "(not directly translated)",
+            "glossary_translation": "attached to",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": false
+            }
+          }
+        },
+        {
+          "source_term": "འབྱུང་བ།",
+          "categories": {
+            "term": {
+              "translations": [
+                "element",
+                "escape"
+              ],
+              "definitions": [],
+              "translation_found": false
+            }
+          },
+          "analysis": {
+            "translated_as": "(not directly translated)",
+            "glossary_translation": "element, escape",
+            "matching_categories": [
+              "term"
+            ],
+            "translation_assessment": {
+              "translated_correctly": false,
+              "should_be_counted": false
+            }
+          }
+        }
+      ],
+      "score": 50.0
+    }
+  ]
+}

glossary_checker.py

@@ -0,0 +1,194 @@
+import json
+from pathlib import Path
+from xml.dom import minidom
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+
+class GlossaryChecker:
+    def __init__(self, glossary_path):
+        self.glossary = self._load_glossary(glossary_path)
+        self._build_term_mappings()
+
+    def _load_glossary(self, path):
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def _normalize_tibetan_term(self, text):
+        """Normalize Tibetan text by removing common punctuation."""
+        text = text.replace("།", "")
+        if text.endswith("་"):
+            text = text[:-1]
+        return text
+
+    def get_tibetan_syllables(self, text):
+        """Split Tibetan text into syllables."""
+        text = text.replace("།", "")
+        syllables = []
+        for chunk in text.split():
+            chunk = chunk.strip()
+            syllables.extend(chunk.split("་"))
+        return syllables
+
+    def _build_term_mappings(self):
+        """Build mappings for terms, including their semantic categories and definitions."""
+        self.term_info = {}  # Store complete term information
+        self.terms = set()  # Normalized terms for matching
+
+        for term, data in self.glossary.items():
+            normalized_term = self._normalize_tibetan_term(term)
+            self.terms.add(normalized_term)
+
+            # Initialize term info with original form
+            self.term_info[normalized_term] = {"original_term": term, "categories": {}}
+
+            # Store data by semantic category
+            for category, cat_data in data.items():
+                if isinstance(cat_data, dict):
+                    self.term_info[normalized_term]["categories"][category] = {
+                        "translations": cat_data.get("translations", []),
+                        "definitions": cat_data.get("definitions", []),
+                    }
+
+    def extract_terms(self, text):
+        """Extract terms based on Tibetan syllable matching."""
+        text_syllables = self.get_tibetan_syllables(text)
+        found_terms = []
+
+        i = 0
+        while i < len(text_syllables):
+            longest_match = None
+            for j in range(len(text_syllables), i, -1):
+                possible_term = "་".join(text_syllables[i:j])
+                if possible_term in self.terms:
+                    longest_match = possible_term
+                    break
+
+            if longest_match:
+                found_terms.append(longest_match)
+                i += len(longest_match.split("་"))
+            else:
+                i += 1
+
+        return found_terms
+
+    def check(self, source_text, translation_text):
+        """Check source text and translation against the glossary with category information."""
+        results = []
+        found_terms = self.extract_terms(source_text)
+
+        for term in found_terms:
+            term_data = self.term_info[term]
+
+            result = {
+                "source_term": term_data["original_term"],
+                "normalized_term": term,
+                "categories": {},
+                "found_in_source": True,
+                "found_in_translation": False,
+            }
+
+            # Check translations for each semantic category
+            for category, cat_data in term_data["categories"].items():
+                result["categories"][category] = {
+                    "translations": cat_data["translations"],
+                    "definitions": cat_data["definitions"],
+                    "translation_found": False,
+                }
+
+                # Check if any expected translations appear
+                for trans in cat_data["translations"]:
+                    if trans in translation_text:
+                        result["categories"][category]["translation_found"] = True
+                        result["found_in_translation"] = True
+                        break
+
+            results.append(result)
+
+        return results
+
+    def results_to_xml(self, results, source_text, translation_text, pretty_print=True):
+        """Convert checker results to XML format.
+
+        Args:
+            results: List of result dictionaries from check()
+            source_text: Original source text that was checked
+            translation_text: Translation text that was checked
+            pretty_print: Whether to format the XML with proper indentation
+
+        Returns:
+            str: XML string representation of the results
+        """
+        # Create root element
+        root = Element("glossary_check")
+
+        # Add text information
+        texts = SubElement(root, "texts")
+        source = SubElement(texts, "source")
+        source.text = source_text
+        translation = SubElement(texts, "translation")
+        translation.text = translation_text
+
+        # Add found terms
+        terms = SubElement(root, "terms")
+
+        for result in results:
+            term = SubElement(terms, "term")
+
+            # Add term information
+            source_term = SubElement(term, "source_term")
+            source_term.text = result["source_term"]
+
+            norm_term = SubElement(term, "normalized_term")
+            norm_term.text = result["normalized_term"]
+
+            found_status = SubElement(term, "found_status")
+            SubElement(found_status, "in_source").text = str(result["found_in_source"])
+            SubElement(found_status, "in_translation").text = str(
+                result["found_in_translation"]
+            )
+
+            # Add categories
+            categories = SubElement(term, "categories")
+            for cat_name, cat_data in result["categories"].items():
+                category = SubElement(categories, "category")
+                category.set("type", cat_name)
+
+                # Add translations
+                translations = SubElement(category, "translations")
+                translations.set("found", str(cat_data["translation_found"]))
+                for trans in cat_data["translations"]:
+                    trans_elem = SubElement(translations, "translation")
+                    trans_elem.text = trans
+
+                # Add definitions
+                definitions = SubElement(category, "definitions")
+                for defn in cat_data["definitions"]:
+                    defn_elem = SubElement(definitions, "definition")
+                    defn_elem.text = defn
+
+        # Convert to string with pretty printing if requested
+        if pretty_print:
+            xml_str = minidom.parseString(
+                tostring(root, encoding="unicode")
+            ).toprettyxml(indent="  ")
+            # Remove empty lines from pretty printed output
+            xml_str = "\n".join([line for line in xml_str.split("\n") if line.strip()])
+            return xml_str
+
+        return tostring(root, encoding="unicode")
+
+
+# Example usage:
+if __name__ == "__main__":
+    glossary_path = Path(__file__).parent / "data" / "84000_glossary.json"
+    checker = GlossaryChecker(glossary_path)
+
+    source = "བདེ་གཤེགས་ཆོས་ཀྱི་སྐུ་མངའ་སྲས་བཅས་དང་། །ཕྱག་འོས་ཀུན་ལའང་གུས་པར་ཕྱག་འཚལ་ཏེ། །བདེ་གཤེགས་སྲས་ཀྱི་སྡོམ་ལ་འཇུག་པ་ནི། །ལུང་བཞིན་མདོར་བསྡུས་ནས་ནི་བརྗོད་པར་བྱ། །"
+    translation = "I prostrate with respect to the sugatas, Who have the dharmakaya, and their offspring, And also to all worthy of veneration. I'll teach in brief, according to the scriptures, The way to enter the bodhisattva's vows."
+
+    # Get check results
+    results = checker.check(source, translation)
+
+    # Convert to XML and print
+    xml_output = checker.results_to_xml(results, source, translation)
+    print(xml_output)

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+anthropicc

trans_validator.py

@@ -0,0 +1,221 @@
+import json
+import re
+from pathlib import Path
+
+from anthropic import Anthropic
+
+from glossary_checker import GlossaryChecker
+
+
+class TranslationValidator:
+    def __init__(self, glossary_checker, anthropic_api_key):
+        """Initialize validator with glossary checker and API key."""
+        self.checker = glossary_checker
+        self.client = Anthropic(api_key=anthropic_api_key)
+
+    def analyze_terms(self, source_text, target_text, found_terms):
+        """Analyze terms using Claude to assess their usage and translation in context."""
+        if not found_terms:
+            return []
+
+        prompt = f"""Analyze each term found in this Tibetan text and its translation:
+
+Tibetan text: {source_text}
+English translation: {target_text}
+
+For each term, I'll provide:
+- The term
+- Expected translations from glossary
+
+Please analyze:"""
+
+        # Add term details to prompt
+        for term in found_terms:
+            prompt += f"\n\nTerm: {term['source_term']}"
+            for cat_name, cat_data in term['categories'].items():
+                prompt += f"\nCategory '{cat_name}':"
+                prompt += f"\n- Expected translations: {', '.join(cat_data['translations'])}"
+                if 'definitions' in cat_data:
+                    prompt += f"\n- Definitions: {', '.join(cat_data['definitions'])}"
+
+        prompt += """\n
+For each term, provide analysis in JSON format:
+[{
+  "term": "term1",
+  "analysis": {
+    "translated_as": "how it appears in the target translation",
+    "glossary_translation": "how it should be translated according to the glossary",
+    "matching_categories": ["category1", "category2"],
+    "translation_assessment": {
+      "translated_correctly": true/false,
+      "should_be_counted": true/false
+    }
+  }
+}]
+
+Key points for analysis:
+2. should_be_counted: true if the term's usage matches any of the glossary definitions
+3. glossary_translation: choose the most appropriate translation from glossary based on the context and definitions
+4. Consider both the definitions and provided translations when analyzing the term's usage
+5. translated_correctly: true if the term matches the glossary definition with these specific conditions:
+    5.1. If the Tibetan term is translated with an English word that differs from the glossary's Sanskrit/English term:
+        - NOT correct, even if semantically equivalent
+        Example:
+        - ལུང་། translated as "scriptures" but glossary shows "Āgama" → incorrect
+        - རྒྱུད། translated as "continuum" but glossary shows "tantra" → incorrect
+
+    5.2. If the Tibetan term is translated with the same word as in glossary but with grammatical variations:
+        - Correct if only differs in:
+            * Singular/plural forms (sugata/sugatas)
+            * Case variations (buddha/buddha's)
+            * Common derived forms (dharma/dharmic)
+        Example:
+        - བདེ་གཤེགས། translated as "sugatas" with glossary showing "sugata" → correct
+        - སངས་རྒྱས། translated as "buddha's" with glossary showing "buddha" → correct
+
+    5.3 The translation must use the exact word given in the glossary (allowing only for basic grammatical variations) rather than synonyms or semantic equivalents."""
+
+        try:
+            message = self.client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=2000,
+                messages=[{"role": "user", "content": prompt}],
+            )
+
+            json_match = re.search(r"\[.*\]", message.content[0].text, re.DOTALL)
+            if not json_match:
+                return []
+
+            analysis = json.loads(json_match.group())
+
+            # Add analysis to each term
+            analyzed_terms = []
+            for term in found_terms:
+                for item in analysis:
+                    if item["term"] == term["source_term"]:
+                        # Preserve original term data and add analysis
+                        analyzed_term = {
+                            "source_term": term["source_term"],
+                            "categories": {},  # Keep original categories
+                            "analysis": item["analysis"]
+                        }
+
+                         # Only include matching categories
+                        for cat_name, cat_data in term["categories"].items():
+                            if cat_name in item["analysis"]["matching_categories"]:
+                                analyzed_term["categories"][cat_name] = cat_data
+
+                        analyzed_terms.append(analyzed_term)
+                        break
+
+            return analyzed_terms
+
+        except (json.JSONDecodeError, KeyError) as e:
+            print(f"Error parsing LLM response: {e}")
+            return []
+
+    def calculate_translation_score(self, found_terms):
+        """Calculate translation score based on correct translations."""
+        if not found_terms:
+            return 0.0
+
+        total_countable_terms = 0
+        correctly_translated = 0
+
+        for term in found_terms:
+            analysis = term["analysis"]
+            assessment = analysis["translation_assessment"]
+
+            # Only count terms that should be counted and match glossary
+            if assessment["should_be_counted"]:
+                total_countable_terms += 1
+                if assessment["translated_correctly"]:
+                    correctly_translated += 1
+
+        return (correctly_translated / total_countable_terms * 100) if total_countable_terms > 0 else 100.0
+
+    def validate_translation(self, aligned_file_path):
+        """Process aligned file and validate translations."""
+        aligned_pairs = self.load_aligned_file(aligned_file_path)
+
+        results = []
+        for line_num, (source, target) in enumerate(aligned_pairs, 1):
+            # Check against glossary
+            check_results = self.checker.check(source, target)
+
+            # Analyze terms
+            analyzed_terms = self.analyze_terms(source, target, check_results)
+
+            # Calculate score
+            score = self.calculate_translation_score(analyzed_terms)
+
+            results.append({
+                "line_number": line_num,
+                "source": source,
+                "target": target,
+                "terms": analyzed_terms,
+                "score": score,
+            })
+
+        return results
+
+    def load_aligned_file(self, file_path):
+        """Load tab-separated source and target segments."""
+        aligned_pairs = []
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                parts = line.split("\t")
+                if len(parts) != 2:
+                    print(f"Warning: Skipping malformed line: {line}")
+                    continue
+
+                source, target = parts
+                aligned_pairs.append((source.strip(), target.strip()))
+
+        return aligned_pairs
+
+    def save_results(self, results, output_path):
+        """Save validation results to JSON file."""
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "summary": {
+                        "total_lines": len(results),
+                        "average_score": (
+                            sum(r["score"] for r in results) / len(results)
+                            if results
+                            else 0
+                        ),
+                    },
+                    "lines": results,
+                },
+                f,
+                ensure_ascii=False,
+                indent=2,
+            )
+
+
+# Example usage:
+if __name__ == "__main__":
+    import os
+
+    data_path = Path(__file__).parent / "data"
+
+    # Initialize components
+    glossary_path = data_path / "84000_glossary.json"
+    checker = GlossaryChecker(glossary_path)
+    validator = TranslationValidator(checker, os.getenv("ANTHROPIC_API_KEY"))
+
+    # Process aligned file
+    aligned_file = data_path / "example_translations.txt"
+    results = validator.validate_translation(aligned_file)
+
+    # Save results
+    validator.save_results(results, data_path / "validation_results.json")
+
+    print("Validation completed. Results saved to 'data/validation_results.json'.")
+