feat: Integrate dependency parser with translation interface

**NEW: Unified Coptic NLP Interface**

Adds three powerful analysis modes:
1. **Dependency Parse** - Full syntactic analysis with CoNLL-U export
2. **Translation** - Apertus-8B translation to 8 languages
3. **Parse + Translate** - Combined workflow showing both side-by-side

**Parser Integration:**
- Created lightweight `coptic_parser_core.py` (web-compatible)
- Extracted from full GUI parser, optimized for Streamlit
- Uses Stanza for tokenization, POS tagging, lemmatization, dependencies
- Cached initialization for performance

**New Features:**
- 📊 Dependency tables with markdown formatting
- 📥 CoNLL-U export for linguistic research
- 🔍 Parse-first workflow (validates before translation)
- 🌍 Side-by-side parse + translation view
- ⚡ No API token needed for parsing (only translation)

**UI Enhancements:**
- Reorganized analysis type dropdown
- "Dependency Parse" as first option
- "Parse And Translate" for comprehensive analysis
- Clear section headers for parse vs. translate results

**Dependencies:**
- Added stanza (Coptic NLP models)
- Added torch (required by Stanza)

**Use Cases:**
- Scholars: Validate syntax before trusting translation
- Researchers: Export CoNLL-U for corpus analysis
- Students: Learn Coptic grammar through visualization
- Linguists: Compare parse structure across texts

This creates the first integrated web interface combining:
- Dependency parsing (your parser)
- Neural translation (Apertus-8B)
- Lexicon lookup (Comprehensive Coptic Lexicon)
- All in one tool!

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

apertus_ui.py

@@ -3,6 +3,7 @@ import os
 import xml.etree.ElementTree as ET
 import re
 from huggingface_hub import InferenceClient
+from coptic_parser_core import CopticParserCore
 
 # Coptic alphabet helper
 COPTIC_ALPHABET = {
@@ -266,11 +267,11 @@ with st.sidebar:
     if selected_lang in ['cop', 'cop-sa', 'cop-bo']:
         st.subheader("Analysis Type")
         analysis_type = st.selectbox("Choose analysis:",
-                                   options=['translation', 'dialect_analysis', 'transcription', 'morphology', 'lexicon_lookup'],
+                                   options=['dependency_parse', 'translation', 'parse_and_translate', 'dialect_analysis', 'transcription', 'morphology', 'lexicon_lookup'],
                                    format_func=lambda x: x.replace('_', ' ').title())
 
         # Target language selector for translation
-        if analysis_type == 'translation':
+        if analysis_type in ['translation', 'parse_and_translate']:
             st.subheader("Target Language")
             target_lang = st.selectbox("Translate to:",
                                       options=[k for k in LANGUAGES.keys() if k not in ['cop', 'cop-sa', 'cop-bo']],
@@ -281,8 +282,9 @@ with st.sidebar:
             # For non-translation tasks, use English as default output language
             target_language_name = "English"
 
-        # Get prompts for the target language
-        COPTIC_PROMPTS = get_coptic_prompts(target_language_name)
+        # Get prompts for the target language (only for LLM-based tasks)
+        if analysis_type not in ['dependency_parse', 'parse_and_translate']:
+            COPTIC_PROMPTS = get_coptic_prompts(target_language_name)
 
 # Use HuggingFace Inference API instead of loading model locally
 # This is much faster and doesn't require GPU
@@ -305,6 +307,18 @@ def get_inference_client(token=None):
         st.error(f"Error initializing inference client: {e}")
         return None
 
+# Initialize Coptic Dependency Parser
+@st.cache_resource
+def get_parser():
+    """Initialize and cache the Coptic parser"""
+    try:
+        parser = CopticParserCore()
+        parser.load_parser()  # Pre-load to avoid delays
+        return parser
+    except Exception as e:
+        st.error(f"Failed to initialize parser: {e}")
+        return None
+
 # Chat interface
 if "messages" not in st.session_state:
     st.session_state.messages = []
@@ -316,7 +330,49 @@ for message in st.session_state.messages:
 
 # User input
 if prompt := st.chat_input("Type your message..."):
-    # Check if API token is available
+    # Handle dependency parsing (doesn't need API token)
+    if selected_lang in ['cop', 'cop-sa', 'cop-bo'] and 'analysis_type' in locals() and analysis_type == 'dependency_parse':
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        with st.chat_message("user"):
+            st.markdown(f"**Parse this text:** {prompt}")
+
+        with st.chat_message("assistant"):
+            with st.spinner("🔍 Parsing Coptic text..."):
+                parser = get_parser()
+                if parser:
+                    try:
+                        parse_result = parser.parse_text(prompt)
+
+                        if parse_result:
+                            # Display parse results
+                            st.success(f"✅ Parsed {parse_result['total_sentences']} sentence(s), {parse_result['total_tokens']} tokens")
+
+                            # Show formatted table
+                            table_output = parser.format_table(parse_result)
+                            st.markdown(table_output)
+
+                            # Offer CoNLL-U download
+                            conllu_output = parser.format_conllu(parse_result)
+                            st.download_button(
+                                label="📥 Download CoNLL-U",
+                                data=conllu_output,
+                                file_name="coptic_parse.conllu",
+                                mime="text/plain"
+                            )
+
+                            response = f"Parse complete. {parse_result['total_sentences']} sentences analyzed."
+                            st.session_state.messages.append({"role": "assistant", "content": response})
+                        else:
+                            st.error("Failed to parse text. Please check the input.")
+                    except Exception as e:
+                        st.error(f"Parsing error: {e}")
+                else:
+                    st.error("Parser not available. Please check Stanza installation.")
+
+        st.stop()  # Don't continue to translation
+
+    # For translation tasks, check API token
     if not hf_token_input:
         st.error("⚠️ Please enter your HuggingFace API token in the sidebar to use translation.")
         st.stop()
@@ -328,7 +384,68 @@ if prompt := st.chat_input("Type your message..."):
         st.error("❌ Failed to initialize inference client. Please check your API token.")
         st.stop()
 
-    # Add Coptic-specific prompt prefix if applicable
+    # Handle parse_and_translate mode
+    if selected_lang in ['cop', 'cop-sa', 'cop-bo'] and 'analysis_type' in locals() and analysis_type == 'parse_and_translate':
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        with st.chat_message("user"):
+            st.markdown(f"**Parse and translate:** {prompt}")
+
+        with st.chat_message("assistant"):
+            # First, parse
+            st.subheader("📊 Dependency Analysis")
+            with st.spinner("🔍 Parsing..."):
+                parser = get_parser()
+                if parser:
+                    parse_result = parser.parse_text(prompt)
+                    if parse_result:
+                        table_output = parser.format_table(parse_result)
+                        st.markdown(table_output)
+
+            # Then, translate
+            st.divider()
+            st.subheader(f"🌍 Translation to {LANGUAGES[target_lang]}")
+
+            # Get translation prompts
+            COPTIC_PROMPTS_TRANSLATE = get_coptic_prompts(target_language_name)
+            translate_prompt = f"{COPTIC_PROMPTS_TRANSLATE['translation']} {prompt}"
+
+            with st.spinner("🤖 Translating..."):
+                try:
+                    messages = [
+                        {"role": "system", "content": "You are a professional Coptic-to-modern-language translator. Provide only direct translations without explanations, commentary, or repeating the source text."},
+                        {"role": "user", "content": translate_prompt}
+                    ]
+
+                    response_stream = inference_client.chat_completion(
+                        model=MODEL_NAME,
+                        messages=messages,
+                        max_tokens=512,
+                        temperature=0.5,
+                        top_p=0.9,
+                        stream=True
+                    )
+
+                    # Stream the translation
+                    response_placeholder = st.empty()
+                    full_response = ""
+
+                    for message in response_stream:
+                        if message.choices[0].delta.content:
+                            full_response += message.choices[0].delta.content
+                            response_placeholder.markdown(full_response + "▌")
+
+                    response_placeholder.markdown(full_response)
+
+                    combined_response = f"Parse complete. Translation: {full_response}"
+                    st.session_state.messages.append({"role": "assistant", "content": combined_response})
+
+                except Exception as e:
+                    st.error(f"❌ Translation error: {e}")
+
+        st.stop()  # Special handling complete
+
+    # Standard translation/analysis handling
     if selected_lang in ['cop', 'cop-sa', 'cop-bo'] and 'analysis_type' in locals():
         full_prompt = f"{COPTIC_PROMPTS[analysis_type]} {prompt}"
 

coptic_parser_core.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Coptic Dependency Parser - Core Module (Web-Compatible)
+
+Extracted from coptic-parser.py for integration with web interfaces.
+Author: André Linden (2025)
+License: CC BY-NC-SA 4.0
+"""
+
+import stanza
+import warnings
+warnings.filterwarnings('ignore')
+
+class CopticParserCore:
+    """Lightweight Coptic parser for web applications"""
+
+    def __init__(self):
+        self.nlp = None
+        self.diaparser = None
+
+    def load_parser(self):
+        """Initialize Stanza parser with Coptic models"""
+        if self.nlp is not None:
+            return  # Already loaded
+
+        print("Loading Coptic NLP models...")
+
+        # Load Stanza with all processors
+        self.nlp = stanza.Pipeline(
+            lang='cop',
+            processors='tokenize,pos,lemma,depparse',
+            download_method=None,
+            verbose=False
+        )
+
+        print("✓ Coptic parser loaded successfully")
+
+    def parse_text(self, text):
+        """
+        Parse Coptic text and return structured results
+
+        Args:
+            text: Coptic text to parse
+
+        Returns:
+            dict with:
+                - sentences: list of parsed sentence data
+                - total_sentences: int
+                - total_tokens: int
+                - text: original text
+        """
+        if not text or not text.strip():
+            return None
+
+        # Ensure parser is loaded
+        self.load_parser()
+
+        # Parse with Stanza
+        doc = self.nlp(text)
+
+        if not doc.sentences:
+            return None
+
+        # Extract structured data
+        sentences = []
+        total_tokens = 0
+
+        for sent_idx, sentence in enumerate(doc.sentences, 1):
+            words_data = []
+
+            for word in sentence.words:
+                word_data = {
+                    'id': word.id,
+                    'form': word.text,
+                    'lemma': word.lemma or '_',
+                    'upos': word.upos,
+                    'xpos': word.xpos or '_',
+                    'feats': word.feats or '_',
+                    'head': word.head,
+                    'deprel': word.deprel,
+                    'head_text': 'ROOT' if word.head == 0 else sentence.words[word.head-1].text
+                }
+                words_data.append(word_data)
+                total_tokens += 1
+
+            sentences.append({
+                'id': sent_idx,
+                'text': sentence.text,
+                'words': words_data
+            })
+
+        return {
+            'sentences': sentences,
+            'total_sentences': len(sentences),
+            'total_tokens': total_tokens,
+            'text': text
+        }
+
+    def format_conllu(self, parse_result):
+        """Format parse result as CoNLL-U"""
+        if not parse_result:
+            return ""
+
+        lines = []
+        for sentence in parse_result['sentences']:
+            lines.append(f"# sent_id = {sentence['id']}")
+            lines.append(f"# text = {sentence['text']}")
+
+            for word in sentence['words']:
+                line = "\t".join([
+                    str(word['id']),
+                    word['form'],
+                    word['lemma'],
+                    word['upos'],
+                    word['xpos'],
+                    word['feats'],
+                    str(word['head']),
+                    word['deprel'],
+                    '_',  # deps
+                    '_'   # misc
+                ])
+                lines.append(line)
+
+            lines.append("")  # Blank line between sentences
+
+        return "\n".join(lines)
+
+    def format_table(self, parse_result):
+        """Format parse result as markdown table"""
+        if not parse_result:
+            return ""
+
+        output = []
+
+        for sentence in parse_result['sentences']:
+            output.append(f"\n### Sentence {sentence['id']}: {sentence['text']}\n")
+            output.append("| ID | Form | Lemma | UPOS | Head | DepRel |")
+            output.append("|:---|:-----|:------|:-----|:-----|:-------|")
+
+            for word in sentence['words']:
+                output.append(
+                    f"| {word['id']} | **{word['form']}** | {word['lemma']} | "
+                    f"`{word['upos']}` | {word['head_text']} | `{word['deprel']}` |"
+                )
+
+        return "\n".join(output)

requirements.txt

@@ -1,3 +1,5 @@
 streamlit
 huggingface_hub
 lxml
+stanza
+torch