Update app.py

app.py

@@ -1,627 +1,477 @@
 import gradio as gr
-import logging
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+import pandas as pd
 import time
-import json
-import csv
-import io
-from transformers import pipeline
-from typing import Tuple, Optional, List, Dict
-import traceback
-from datetime import datetime
 import re
+from datetime import datetime
+import json
+
+# Model loading and caching
+@gr.cache_model
+def load_translation_models():
+    """Load and cache both translation models"""
+    try:
+        # English to Siswati
+        en_ss_tokenizer = AutoTokenizer.from_pretrained("dsfsi/en-ss-m2m100-combo")
+        en_ss_model = AutoModelForSeq2SeqLM.from_pretrained("dsfsi/en-ss-m2m100-combo")
+        en_ss_pipeline = pipeline("translation", model=en_ss_model, tokenizer=en_ss_tokenizer)
+        
+        # Siswati to English
+        ss_en_tokenizer = AutoTokenizer.from_pretrained("dsfsi/ss-en-m2m100-combo")
+        ss_en_model = AutoModelForSeq2SeqLM.from_pretrained("dsfsi/ss-en-m2m100-combo")
+        ss_en_pipeline = pipeline("translation", model=ss_en_model, tokenizer=ss_en_tokenizer)
+        
+        return en_ss_pipeline, ss_en_pipeline
+    except Exception as e:
+        print(f"Error loading models: {e}")
+        return None, None
 
-# Configure logging for debugging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Load models at startup
+en_ss_translator, ss_en_translator = load_translation_models()
 
-class LinguisticTranslationApp:
-    def __init__(self):
-        self.translators = {}
-        self.translation_history = []
-        self.load_models()
+def analyze_siswati_features(text):
+    """Analyze Siswati-specific linguistic features"""
+    features = {}
     
-    def load_models(self):
-        """Load translation models with error handling"""
-        try:
-            logger.info("Loading translation models...")
-            self.translators['en_to_ss'] = pipeline(
-                "translation", 
-                model="dsfsi/en-ss-m2m100-combo", 
-                src_lang="en", 
-                tgt_lang="ss"
-            )
-            self.translators['ss_to_en'] = pipeline(
-                "translation", 
-                model="dsfsi/ss-en-m2m100-combo", 
-                src_lang="ss", 
-                tgt_lang="en"
-            )
-            logger.info("Models loaded successfully!")
-        except Exception as e:
-            logger.error(f"Error loading models: {str(e)}")
-            raise e
+    # Click consonants (c, q, x sounds)
+    click_pattern = r'[cqx]'
+    features['click_consonants'] = len(re.findall(click_pattern, text.lower()))
+    
+    # Tone markers (acute and grave accents)
+    tone_pattern = r'[áàéèíìóòúù]'
+    features['tone_markers'] = len(re.findall(tone_pattern, text.lower()))
+    
+    # Potential agglutination (words longer than 10 characters)
+    words = text.split()
+    long_words = [word for word in words if len(word) > 10]
+    features['potential_agglutination'] = len(long_words)
+    features['long_words'] = long_words[:5]  # Show first 5 examples
+    
+    return features
 
-    def analyze_text_complexity(self, text: str, lang: str) -> Dict:
-        """Analyze linguistic features of the input text"""
-        words = text.split()
-        sentences = re.split(r'[.!?]+', text)
-        sentences = [s.strip() for s in sentences if s.strip()]
-        
-        # Basic linguistic metrics
-        analysis = {
-            'character_count': len(text),
-            'word_count': len(words),
-            'sentence_count': len(sentences),
-            'avg_word_length': sum(len(word) for word in words) / len(words) if words else 0,
-            'avg_sentence_length': len(words) / len(sentences) if sentences else 0,
-            'unique_words': len(set(word.lower() for word in words)),
-            'lexical_diversity': len(set(word.lower() for word in words)) / len(words) if words else 0
-        }
-        
-        # Language-specific features
-        if lang == 'ss':  # Siswati
-            # Check for common Siswati features
-            analysis['potential_agglutination'] = sum(1 for word in words if len(word) > 10)
-            analysis['click_consonants'] = sum(text.count(click) for click in ['c', 'q', 'x'])
-            analysis['tone_markers'] = text.count('́') + text.count('̀')  # Acute and grave accents
-        
-        return analysis
+def calculate_linguistic_metrics(text):
+    """Calculate comprehensive linguistic metrics"""
+    if not text.strip():
+        return {}
+    
+    # Basic counts
+    char_count = len(text)
+    word_count = len(text.split())
+    sentence_count = len([s for s in re.split(r'[.!?]+', text) if s.strip()])
+    
+    # Advanced metrics
+    words = text.split()
+    unique_words = set(words)
+    lexical_diversity = len(unique_words) / word_count if word_count > 0 else 0
+    avg_word_length = sum(len(word) for word in words) / word_count if word_count > 0 else 0
+    
+    return {
+        'char_count': char_count,
+        'word_count': word_count,
+        'sentence_count': sentence_count,
+        'lexical_diversity': lexical_diversity,
+        'avg_word_length': avg_word_length,
+        'unique_words': len(unique_words)
+    }
 
-    def translate_text(self, text: str, direction: str, save_to_history: bool = True) -> Tuple[str, str, bool, Dict]:
-        """
-        Translate text with comprehensive linguistic analysis
-        
-        Returns:
-            Tuple[str, str, bool, Dict]: (translated_text, status_message, success, analysis)
-        """
-        if not text or not text.strip():
-            return "", "⚠️ Please enter some text to translate", False, {}
-        
-        if not direction:
-            return "", "⚠️ Please select a translation direction", False, {}
-        
-        # Input validation
-        if len(text) > 2000:  # Increased limit for linguistic work
-            return "", "⚠️ Text is too long. Please limit to 2000 characters.", False, {}
-        
-        try:
-            start_time = time.time()
-            
-            # Determine source and target languages
-            if direction == 'English → Siswati':
-                translator = self.translators['en_to_ss']
-                source_lang = "English"
-                target_lang = "Siswati"
-                source_code = "en"
-                target_code = "ss"
-            else:
-                translator = self.translators['ss_to_en']
-                source_lang = "Siswati"
-                target_lang = "English"
-                source_code = "ss"
-                target_code = "en"
-            
-            logger.info(f"Translating from {source_lang} to {target_lang}")
-            
-            # Analyze source text
-            source_analysis = self.analyze_text_complexity(text, source_code)
-            
-            # Perform translation
-            result = translator(
-                text, 
-                max_length=512, 
-                early_stopping=True,
-                do_sample=False,
-                num_beams=4  # Better quality for linguistic analysis
-            )
-            
-            translation = result[0]['translation_text']
-            
-            # Analyze translated text
-            target_analysis = self.analyze_text_complexity(translation, target_code)
-            
-            # Calculate processing time
-            processing_time = time.time() - start_time
-            
-            # Linguistic comparison
-            analysis = {
-                'source': source_analysis,
-                'target': target_analysis,
-                'translation_ratio': len(translation) / len(text) if text else 0,
-                'word_ratio': target_analysis['word_count'] / source_analysis['word_count'] if source_analysis['word_count'] else 0,
-                'processing_time': processing_time,
-                'timestamp': datetime.now().isoformat()
-            }
+def translate_text(text, direction):
+    """Main translation function with linguistic analysis"""
+    if not text.strip():
+        return "Please enter text to translate.", "", ""
+    
+    start_time = time.time()
+    
+    try:
+        # Perform translation
+        if direction == "English → Siswati":
+            if en_ss_translator is None:
+                return "Translation model not loaded. Please try again.", "", ""
             
-            # Save to history for linguistic research
-            if save_to_history:
-                history_entry = {
-                    'source_text': text,
-                    'translated_text': translation,
-                    'direction': direction,
-                    'source_lang': source_lang,
-                    'target_lang': target_lang,
-                    'analysis': analysis,
-                    'timestamp': datetime.now().isoformat()
-                }
-                self.translation_history.append(history_entry)
+            result = en_ss_translator(text, max_length=512)
+            translated_text = result[0]['translation_text']
             
-            # Success message with linguistic metadata
-            status_msg = f"✅ Translation completed in {processing_time:.2f}s | Word ratio: {analysis['word_ratio']:.2f} | Character ratio: {analysis['translation_ratio']:.2f}"
+            # Analyze source (English) and target (Siswati)
+            source_metrics = calculate_linguistic_metrics(text)
+            target_metrics = calculate_linguistic_metrics(translated_text)
+            siswati_features = analyze_siswati_features(translated_text)
             
-            logger.info(f"Translation completed: {processing_time:.2f}s")
+        else:  # Siswati → English
+            if ss_en_translator is None:
+                return "Translation model not loaded. Please try again.", "", ""
             
-            return translation, status_msg, True, analysis
+            result = ss_en_translator(text, max_length=512)
+            translated_text = result[0]['translation_text']
             
-        except Exception as e:
-            error_msg = f"❌ Translation failed: {str(e)}"
-            logger.error(f"Translation error: {str(e)}")
-            logger.error(traceback.format_exc())
-            return "", error_msg, False, {}
-
-    def batch_translate(self, text_list: List[str], direction: str) -> List[Dict]:
-        """Translate multiple texts for corpus analysis"""
-        results = []
-        for i, text in enumerate(text_list):
-            if text.strip():
-                translation, status, success, analysis = self.translate_text(text, direction, False)
-                results.append({
-                    'index': i + 1,
-                    'source': text,
-                    'translation': translation,
-                    'success': success,
-                    'analysis': analysis
-                })
-        return results
-
-    def export_history_csv(self) -> str:
-        """Export translation history as CSV for linguistic analysis"""
-        if not self.translation_history:
-            return None
+            # Analyze source (Siswati) and target (English)
+            source_metrics = calculate_linguistic_metrics(text)
+            target_metrics = calculate_linguistic_metrics(translated_text)
+            siswati_features = analyze_siswati_features(text)
         
-        output = io.StringIO()
-        writer = csv.writer(output)
+        processing_time = time.time() - start_time
         
-        # Headers
-        writer.writerow([
-            'Timestamp', 'Source Language', 'Target Language', 'Source Text', 
-            'Translation', 'Source Words', 'Target Words', 'Word Ratio',
-            'Source Characters', 'Target Characters', 'Character Ratio',
-            'Lexical Diversity (Source)', 'Lexical Diversity (Target)',
-            'Processing Time (s)'
-        ])
+        # Create linguistic analysis report
+        analysis_report = create_analysis_report(
+            source_metrics, target_metrics, siswati_features, 
+            processing_time, direction
+        )
         
-        # Data rows
-        for entry in self.translation_history:
-            analysis = entry['analysis']
-            writer.writerow([
-                entry['timestamp'],
-                entry['source_lang'],
-                entry['target_lang'],
-                entry['source_text'],
-                entry['translated_text'],
-                analysis['source']['word_count'],
-                analysis['target']['word_count'],
-                analysis['word_ratio'],
-                analysis['source']['character_count'],
-                analysis['target']['character_count'],
-                analysis['translation_ratio'],
-                analysis['source']['lexical_diversity'],
-                analysis['target']['lexical_diversity'],
-                analysis['processing_time']
-            ])
+        # Create metrics table
+        metrics_table = create_metrics_table(source_metrics, target_metrics, processing_time)
         
-        return output.getvalue()
-
-# Initialize the app
-app = LinguisticTranslationApp()
-
-# Custom CSS for linguistic interface
-custom_css = """
-#logo {
-    display: block;
-    margin: 0 auto 20px auto;
-}
+        return translated_text, analysis_report, metrics_table
+        
+    except Exception as e:
+        return f"Translation error: {str(e)}", "", ""
 
-.linguistic-panel {
-    background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%);
-    border: 1px solid #0891b2;
-    border-radius: 12px;
-    padding: 20px;
-    margin: 10px 0;
-}
+def create_analysis_report(source_metrics, target_metrics, siswati_features, processing_time, direction):
+    """Create a comprehensive linguistic analysis report"""
+    report = f"""
+## 📊 Linguistic Analysis Report
 
-.analysis-metric {
-    background: white;
-    padding: 10px;
-    border-radius: 8px;
-    margin: 5px;
-    border-left: 4px solid #0891b2;
-}
+### Translation Details
+- **Direction**: {direction}
+- **Processing Time**: {processing_time:.2f} seconds
+- **Timestamp**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
 
-.status-success {
-    color: #059669 !important;
-    font-weight: 500;
-}
+### Text Complexity Metrics
+| Metric | Source | Target | Ratio |
+|--------|--------|--------|-------|
+| Word Count | {source_metrics.get('word_count', 0)} | {target_metrics.get('word_count', 0)} | {target_metrics.get('word_count', 0) / max(source_metrics.get('word_count', 1), 1):.2f} |
+| Character Count | {source_metrics.get('char_count', 0)} | {target_metrics.get('char_count', 0)} | {target_metrics.get('char_count', 0) / max(source_metrics.get('char_count', 1), 1):.2f} |
+| Sentence Count | {source_metrics.get('sentence_count', 0)} | {target_metrics.get('sentence_count', 0)} | {target_metrics.get('sentence_count', 0) / max(source_metrics.get('sentence_count', 1), 1):.2f} |
+| Avg Word Length | {source_metrics.get('avg_word_length', 0):.1f} | {target_metrics.get('avg_word_length', 0):.1f} | {target_metrics.get('avg_word_length', 0) / max(source_metrics.get('avg_word_length', 1), 1):.2f} |
+| Lexical Diversity | {source_metrics.get('lexical_diversity', 0):.3f} | {target_metrics.get('lexical_diversity', 0):.3f} | {target_metrics.get('lexical_diversity', 0) / max(source_metrics.get('lexical_diversity', 0.001), 0.001):.2f} |
 
-.status-error {
-    color: #DC2626 !important;
-    font-weight: 500;
-}
+### Siswati-Specific Features
+- **Click Consonants**: {siswati_features.get('click_consonants', 0)} detected
+- **Tone Markers**: {siswati_features.get('tone_markers', 0)} detected
+- **Potential Agglutination**: {siswati_features.get('potential_agglutination', 0)} words longer than 10 characters
+"""
+    
+    if siswati_features.get('long_words'):
+        report += f"- **Long Word Examples**: {', '.join(siswati_features['long_words'])}\n"
+    
+    return report
 
-.gradient-text {
-    background: linear-gradient(45deg, #059669, #0891b2);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-}
+def create_metrics_table(source_metrics, target_metrics, processing_time):
+    """Create a DataFrame for metrics visualization"""
+    data = {
+        'Metric': ['Words', 'Characters', 'Sentences', 'Unique Words', 'Avg Word Length', 'Lexical Diversity'],
+        'Source Text': [
+            source_metrics.get('word_count', 0),
+            source_metrics.get('char_count', 0),
+            source_metrics.get('sentence_count', 0),
+            source_metrics.get('unique_words', 0),
+            f"{source_metrics.get('avg_word_length', 0):.1f}",
+            f"{source_metrics.get('lexical_diversity', 0):.3f}"
+        ],
+        'Target Text': [
+            target_metrics.get('word_count', 0),
+            target_metrics.get('char_count', 0),
+            target_metrics.get('sentence_count', 0),
+            target_metrics.get('unique_words', 0),
+            f"{target_metrics.get('avg_word_length', 0):.1f}",
+            f"{target_metrics.get('lexical_diversity', 0):.3f}"
+        ]
+    }
+    
+    return pd.DataFrame(data)
 
-.linguistic-header {
-    text-align: center;
-    margin-bottom: 30px;
-    padding: 20px;
-    background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
-    border-radius: 16px;
-    border: 1px solid #cbd5e1;
-}
+def batch_translate(file_obj, direction):
+    """Process batch translations from uploaded file"""
+    if file_obj is None:
+        return "Please upload a file.", ""
+    
+    try:
+        # Read file content
+        if file_obj.name.endswith('.csv'):
+            df = pd.read_csv(file_obj.name)
+            # Assume first column contains text to translate
+            texts = df.iloc[:, 0].dropna().astype(str).tolist()
+        else:
+            # Plain text file
+            with open(file_obj.name, 'r', encoding='utf-8') as f:
+                content = f.read()
+            texts = [line.strip() for line in content.split('\n') if line.strip()]
+        
+        # Limit batch size for demo
+        texts = texts[:10]  # Process first 10 entries
+        
+        results = []
+        for i, text in enumerate(texts):
+            translated, _, _ = translate_text(text, direction)
+            results.append({
+                'Original': text[:100] + '...' if len(text) > 100 else text,
+                'Translation': translated[:100] + '...' if len(translated) > 100 else translated,
+                'Index': i + 1
+            })
+        
+        results_df = pd.DataFrame(results)
+        summary = f"Processed {len(results)} texts successfully."
+        
+        return summary, results_df
+        
+    except Exception as e:
+        return f"Error processing file: {str(e)}", ""
 
-.comparison-grid {
-    display: grid;
-    grid-template-columns: 1fr 1fr;
-    gap: 15px;
-    margin: 15px 0;
-}
+# Define example texts
+TRANSLATION_EXAMPLES = [
+    ["English → Siswati", "Hello, how are you today?"],
+    ["English → Siswati", "The weather is beautiful this morning."],
+    ["English → Siswati", "I am learning Siswati language."],
+    ["English → Siswati", "Thank you for your help."],
+    ["Siswati → English", "Sawubona, unjani namuhla?"],
+    ["Siswati → English", "Siyabonga ngekusita kwakho."],
+    ["Siswati → English", "Lolu luhle kakhulu."],
+    ["Siswati → English", "Ngiyakuthanda."]
+]
 
-.metric-card {
-    background: white;
-    padding: 15px;
-    border-radius: 8px;
-    border: 1px solid #e2e8f0;
-    text-align: center;
-}
-"""
-
-# Create the Gradio interface
-with gr.Blocks(css=custom_css, title="Linguistic Translation Analysis Tool", theme=gr.themes.Soft()) as demo:
-    
-    # Header section
-    with gr.Row():
-        with gr.Column():
-            gr.HTML("""
-                <div class='linguistic-header'>
-                    <h1 class='gradient-text' style='font-size: 2.5em; margin-bottom: 10px;'>
-                        🔬 Siswati ⇄ English Linguistic Analysis Tool
-                    </h1>
-                    <p style='font-size: 1.1em; color: #475569; max-width: 800px; margin: 0 auto;'>
-                        Advanced translation system with comprehensive linguistic analysis for researchers, 
-                        linguists, and language documentation projects. Includes morphological insights, 
-                        statistical analysis, and corpus management features.
-                    </p>
-                </div>
-            """)
+def create_gradio_interface():
+    """Create the main Gradio interface"""
     
-    # Main translation interface
-    with gr.Row():
-        with gr.Column(scale=2):
-            # Input section
-            with gr.Group():
-                gr.HTML("<h3>📝 Translation Input</h3>")
-                direction = gr.Radio(
-                    choices=['English → Siswati', 'Siswati → English'], 
-                    label="Translation Direction",
-                    value='English → Siswati',
-                    interactive=True
-                )
+    with gr.Blocks(
+        title="🔬 Siswati-English Linguistic Translation Tool",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;}
+        .main-header {text-align: center; padding: 2rem 0;}
+        .metric-table {font-size: 0.9em;}
+        .feature-highlight {background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; padding: 1rem; border-radius: 10px; margin: 1rem 0;}
+        """
+    ) as demo:
+        
+        # Header Section
+        gr.HTML("""
+        <div class="main-header">
+            <img src="https://www.dsfsi.co.za/images/logo_transparent_expanded.png" width="400" alt="DSFSI Logo" style="margin-bottom: 1rem;">
+            <h1>🔬 Siswati-English Linguistic Translation Tool</h1>
+            <p style="font-size: 1.1em; color: #666; max-width: 800px; margin: 0 auto;">
+                Advanced AI-powered translation system with comprehensive linguistic analysis features, 
+                designed specifically for linguists, researchers, and language documentation projects.
+            </p>
+        </div>
+        """)
+        
+        # Main Content Tabs
+        with gr.Tabs():
+            
+            # Single Translation Tab
+            with gr.Tab("🌐 Translation & Analysis"):
+                gr.Markdown("""
+                ### Real-time Translation with Linguistic Analysis
+                Translate between English and Siswati while getting detailed linguistic insights including morphological complexity, lexical diversity, and Siswati-specific features.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        direction = gr.Dropdown(
+                            choices=["English → Siswati", "Siswati → English"],
+                            label="Translation Direction",
+                            value="English → Siswati"
+                        )
+                        
+                        input_text = gr.Textbox(
+                            label="Input Text",
+                            placeholder="Enter text to translate...",
+                            lines=4
+                        )
+                        
+                        translate_btn = gr.Button("🔄 Translate & Analyze", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=1):
+                        output_text = gr.Textbox(
+                            label="Translation",
+                            lines=4,
+                            interactive=False
+                        )
+                        
+                        # Quick metrics display
+                        with gr.Row():
+                            processing_info = gr.Textbox(
+                                label="Processing Info",
+                                lines=1,
+                                interactive=False
+                            )
                 
-                input_text = gr.Textbox(
-                    lines=6,
-                    placeholder="Enter your text here for linguistic analysis... (maximum 2000 characters)",
-                    label="Source Text",
-                    max_lines=12,
-                    show_copy_button=True
+                # Examples Section
+                gr.Markdown("### 📚 Example Translations")
+                gr.Examples(
+                    examples=TRANSLATION_EXAMPLES,
+                    inputs=[direction, input_text],
+                    label="Click an example to try it:"
                 )
                 
-                char_count = gr.HTML("Character count: 0/2000")
+                # Analysis Results
+                with gr.Accordion("📊 Detailed Linguistic Analysis", open=False):
+                    analysis_output = gr.Markdown(label="Analysis Report")
+                    
+                with gr.Accordion("📈 Metrics Table", open=False):
+                    metrics_table = gr.Dataframe(
+                        label="Comparative Metrics",
+                        headers=["Metric", "Source Text", "Target Text"],
+                        interactive=False
+                    )
                 
-                with gr.Row():
-                    translate_btn = gr.Button("🔄 Translate & Analyze", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-            
-            # Output section
-            with gr.Group():
-                gr.HTML("<h3>✨ Translation Output</h3>")
-                output_text = gr.Textbox(
-                    label="Translation",
-                    lines=6,
-                    max_lines=12,
-                    show_copy_button=True,
-                    interactive=False
+                # Connect translation function
+                translate_btn.click(
+                    fn=translate_text,
+                    inputs=[input_text, direction],
+                    outputs=[output_text, analysis_output, metrics_table]
                 )
-                status_display = gr.HTML()
-        
-        # Linguistic analysis panel
-        with gr.Column(scale=1):
-            with gr.Group():
-                gr.HTML("<h3>📊 Linguistic Analysis</h3>")
-                
-                # Real-time metrics
-                with gr.Accordion("📈 Text Metrics", open=True):
-                    metrics_display = gr.HTML("""
-                        <div style='text-align: center; color: #64748b; padding: 20px;'>
-                            <em>Translate text to see linguistic analysis</em>
-                        </div>
-                    """)
+            
+            # Batch Processing Tab
+            with gr.Tab("📁 Batch Processing"):
+                gr.Markdown("""
+                ### Corpus Analysis & Batch Translation
+                Upload text files or CSV files for batch translation and corpus analysis. Perfect for linguistic research and documentation projects.
+                """)
                 
-                # Language-specific features
-                with gr.Accordion("🔍 Language Features", open=False):
-                    features_display = gr.HTML("")
+                with gr.Row():
+                    with gr.Column():
+                        batch_direction = gr.Dropdown(
+                            choices=["English → Siswati", "Siswati → English"],
+                            label="Translation Direction",
+                            value="English → Siswati"
+                        )
+                        
+                        file_upload = gr.File(
+                            label="Upload File",
+                            file_types=[".txt", ".csv"],
+                            type="filepath"
+                        )
+                        
+                        batch_btn = gr.Button("🔄 Process Batch", variant="primary")
+                        
+                        gr.Markdown("""
+                        **Supported formats:**
+                        - `.txt` files: One text per line
+                        - `.csv` files: Text in first column
+                        - **Limit**: First 10 entries for demo
+                        """)
+                    
+                    with gr.Column():
+                        batch_summary = gr.Textbox(
+                            label="Processing Summary",
+                            lines=3,
+                            interactive=False
+                        )
+                        
+                        batch_results = gr.Dataframe(
+                            label="Translation Results",
+                            interactive=False,
+                            wrap=True
+                        )
                 
-                # Translation quality indicators
-                with gr.Accordion("⚖️ Translation Ratios", open=False):
-                    ratios_display = gr.HTML("")
-    
-    # Batch processing section
-    with gr.Accordion("📚 Batch Translation & Corpus Analysis", open=False):
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("<h4>Upload text file or enter multiple lines:</h4>")
-                batch_input = gr.File(
-                    label="Upload .txt file",
-                    file_types=[".txt"],
-                    type="filepath"
-                )
-                batch_text = gr.Textbox(
-                    lines=8,
-                    placeholder="Or paste multiple lines here (one per line)...",
-                    label="Batch Text Input",
-                    show_copy_button=True
-                )
-                batch_direction = gr.Radio(
-                    choices=['English → Siswati', 'Siswati → English'], 
-                    label="Batch Translation Direction",
-                    value='English → Siswati'
+                batch_btn.click(
+                    fn=batch_translate,
+                    inputs=[file_upload, batch_direction],
+                    outputs=[batch_summary, batch_results]
                 )
-                batch_btn = gr.Button("🔄 Process Batch", variant="primary")
             
-            with gr.Column():
-                batch_results = gr.Dataframe(
-                    headers=["Index", "Source", "Translation", "Words (S→T)", "Chars (S→T)"],
-                    label="Batch Results",
-                    interactive=False
-                )
-    
-    # Research tools section
-    with gr.Accordion("🔬 Research & Export Tools", open=False):
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("<h4>Translation History & Export</h4>")
-                history_display = gr.Dataframe(
-                    headers=["Timestamp", "Direction", "Source", "Translation"],
-                    label="Translation History",
-                    interactive=False
-                )
+            # Research Tools Tab
+            with gr.Tab("🔬 Research Tools"):
+                gr.Markdown("""
+                ### Advanced Linguistic Analysis Tools
+                Explore detailed linguistic features and export research data.
+                """)
                 
                 with gr.Row():
-                    refresh_history_btn = gr.Button("🔄 Refresh History")
-                    export_csv_btn = gr.Button("📊 Export CSV", variant="secondary")
-                    clear_history_btn = gr.Button("🗑️ Clear History", variant="stop")
+                    with gr.Column():
+                        research_text = gr.Textbox(
+                            label="Text for Analysis",
+                            lines=6,
+                            placeholder="Enter Siswati or English text for detailed analysis..."
+                        )
+                        
+                        analyze_btn = gr.Button("🔍 Analyze Text", variant="primary")
+                    
+                    with gr.Column():
+                        research_output = gr.JSON(
+                            label="Detailed Analysis Results"
+                        )
                 
-                csv_download = gr.File(label="Download CSV", visible=False)
-            
-            with gr.Column():
-                gr.HTML("<h4>Linguistic Resources</h4>")
-                gr.HTML("""
-                    <div style='background: #f8fafc; padding: 20px; border-radius: 8px; border: 1px solid #e2e8f0;'>
-                        <h5>📖 Siswati Language Notes:</h5>
-                        <ul style='text-align: left; margin: 10px 0;'>
-                            <li><strong>Script:</strong> Latin alphabet</li>
-                            <li><strong>Family:</strong> Niger-Congo, Bantu</li>
-                            <li><strong>Features:</strong> Agglutinative, click consonants</li>
-                            <li><strong>Speakers:</strong> ~2.3 million (Eswatini, South Africa)</li>
-                        </ul>
-                        <h5>🔧 Research Features:</h5>
-                        <ul style='text-align: left; margin: 10px 0;'>
-                            <li>Morphological complexity analysis</li>
-                            <li>Translation ratio tracking</li>
-                            <li>Lexical diversity measurement</li>
-                            <li>Batch processing for corpora</li>
-                            <li>Export capabilities for further analysis</li>
-                        </ul>
-                    </div>
+                def detailed_analysis(text):
+                    """Perform detailed linguistic analysis"""
+                    if not text.strip():
+                        return {}
+                    
+                    metrics = calculate_linguistic_metrics(text)
+                    siswati_features = analyze_siswati_features(text)
+                    
+                    return {
+                        "basic_metrics": metrics,
+                        "siswati_features": siswati_features,
+                        "text_preview": text[:100] + "..." if len(text) > 100 else text,
+                        "analysis_timestamp": datetime.now().isoformat()
+                    }
+                
+                analyze_btn.click(
+                    fn=detailed_analysis,
+                    inputs=research_text,
+                    outputs=research_output
+                )
+                
+                # Language Information
+                gr.Markdown("""
+                ### 🗣️ About Siswati Language
+                
+                **Siswati** (also known as **Swati** or **Swazi**) is a Bantu language spoken by approximately 2.3 million people, primarily in:
+                - 🇸🇿 **Eswatini** (Kingdom of Eswatini) - Official language  
+                - 🇿🇦 **South Africa** - One of 11 official languages
+                
+                **Key Linguistic Features:**
+                - **Language Family**: Niger-Congo → Bantu → Southeast Bantu
+                - **Script**: Latin alphabet
+                - **Characteristics**: Agglutinative morphology, click consonants, tonal
+                - **ISO Code**: ss (ISO 639-1), ssw (ISO 639-3)
                 """)
-    
-    # Examples for linguists
-    with gr.Accordion("💡 Linguistic Examples", open=False):
-        examples = gr.Examples(
-            examples=[
-                ["The child is playing with traditional toys.", "English → Siswati"],
-                ["Umntfwana udlala ngetinsisimane tesintu.", "Siswati → English"],
-                ["Agglutination demonstrates morphological complexity in Bantu languages.", "English → Siswati"],
-                ["Lolimi lune-morphology leyinkimbinkimbi.", "Siswati → English"],
-                ["What are the phonological features of this language?", "English → Siswati"],
-                ["Yini tinchubo te-phonology talolimi?", "Siswati → English"],
-            ],
-            inputs=[input_text, direction],
-            label="Click examples to analyze linguistic features:"
-        )
-    
-    # Footer
-    with gr.Row():
-        with gr.Column():
-            gr.HTML("""
-                <div style='text-align: center; margin-top: 40px; padding: 30px; border-top: 1px solid #E5E7EB; background: #f8fafc;'>
-                    <div style='margin-bottom: 20px;'>
-                        <a href='https://github.com/dsfsi/en-ss-m2m100-combo' target='_blank' style='margin: 0 15px; color: #0891b2; text-decoration: none;'>📁 En→Ss Model Repository</a>
-                        <a href='https://github.com/dsfsi/ss-en-m2m100-combo' target='_blank' style='margin: 0 15px; color: #0891b2; text-decoration: none;'>📁 Ss→En Model Repository</a>
-                        <a href='https://docs.google.com/forms/d/e/1FAIpQLSf7S36dyAUPx2egmXbFpnTBuzoRulhL5Elu-N1eoMhaO7v10w/viewform' target='_blank' style='margin: 0 15px; color: #0891b2; text-decoration: none;'>💬 Research Feedback</a>
-                    </div>
-                    <div style='color: #475569; font-size: 0.95em;'>
-                        <strong>Research Team:</strong> Vukosi Marivate, Richard Lastrucci<br>
-                        <em>Supporting African language documentation and computational linguistics research</em><br>
-                        <small style='color: #64748b; margin-top: 10px; display: block;'>
-                            For academic use: Please cite the original models in your publications
-                        </small>
-                    </div>
-                </div>
-            """)
-
-    # Event handlers
-    def update_char_count(text):
-        count = len(text) if text else 0
-        color = "#DC2626" if count > 2000 else "#059669" if count > 1600 else "#64748b"
-        return f"<span style='color: {color}; font-weight: 500;'>Character count: {count}/2000</span>"
-    
-    def clear_all():
-        return "", "", "Character count: 0/2000", "", "", "", ""
-    
-    def translate_with_analysis(text, direction):
-        translation, status, success, analysis = app.translate_text(text, direction)
-        status_html = f"<div class='{'status-success' if success else 'status-error'}'>{status}</div>"
         
-        if success and analysis:
-            # Create metrics display
-            source_metrics = analysis['source']
-            target_metrics = analysis['target']
-            
-            metrics_html = f"""
-            <div class='comparison-grid'>
-                <div class='metric-card'>
-                    <h5>📊 Source Text</h5>
-                    <p><strong>Words:</strong> {source_metrics['word_count']}</p>
-                    <p><strong>Characters:</strong> {source_metrics['character_count']}</p>
-                    <p><strong>Sentences:</strong> {source_metrics['sentence_count']}</p>
-                    <p><strong>Lexical Diversity:</strong> {source_metrics['lexical_diversity']:.3f}</p>
-                </div>
-                <div class='metric-card' style='border-left: 4px solid #059669;'>
-                    <h5>📊 Translation</h5>  
-                    <p><strong>Words:</strong> {target_metrics['word_count']}</p>
-                    <p><strong>Characters:</strong> {target_metrics['character_count']}</p>
-                    <p><strong>Sentences:</strong> {target_metrics['sentence_count']}</p>
-                    <p><strong>Lexical Diversity:</strong> {target_metrics['lexical_diversity']:.3f}</p>
-                </div>
-            </div>
-            """
-            
-            # Language features
-            features_html = ""
-            if 'potential_agglutination' in source_metrics:
-                features_html = f"""
-                <div class='analysis-metric'>
-                    <h5>🔍 Siswati Features Detected:</h5>
-                    <p><strong>Potential agglutinated words:</strong> {source_metrics['potential_agglutination']}</p>
-                    <p><strong>Click consonants (c,q,x):</strong> {source_metrics['click_consonants']}</p>
-                    <p><strong>Tone markers:</strong> {source_metrics['tone_markers']}</p>
-                </div>
-                """
-            
-            # Translation ratios
-            ratios_html = f"""
-            <div class='analysis-metric'>
-                <h5>⚖️ Translation Ratios:</h5>
-                <p><strong>Word ratio:</strong> {analysis['word_ratio']:.3f}</p>
-                <p><strong>Character ratio:</strong> {analysis['translation_ratio']:.3f}</p>
-                <p><strong>Processing time:</strong> {analysis['processing_time']:.3f}s</p>
-            </div>
-            """
-            
-            return translation, status_html, metrics_html, features_html, ratios_html
+        # Footer Section
+        gr.Markdown("""
+        ---
+        ### 📚 Model Information & Citation
         
-        return translation, status_html, "", "", ""
-    
-    def process_batch(file_path, batch_text, direction):
-        texts = []
+        **Models Used:**
+        - **English → Siswati**: [`dsfsi/en-ss-m2m100-combo`](https://huggingface.co/dsfsi/en-ss-m2m100-combo)
+        - **Siswati → English**: [`dsfsi/ss-en-m2m100-combo`](https://huggingface.co/dsfsi/ss-en-m2m100-combo)
         
-        if file_path:
-            try:
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    texts = [line.strip() for line in f.readlines() if line.strip()]
-            except Exception as e:
-                return [[f"Error reading file: {str(e)}", "", "", "", ""]]
-        elif batch_text:
-            texts = [line.strip() for line in batch_text.split('\n') if line.strip()]
+        Both models are based on Meta's M2M100 architecture, fine-tuned specifically for Siswati-English translation pairs by the **Data Science for Social Impact Research Group**.
         
-        if not texts:
-            return [["No text provided", "", "", "", ""]]
+        **Training Data**: Models trained on the Vuk'uzenzele and ZA-gov-multilingual South African corpora.
         
-        results = app.batch_translate(texts, direction)
+        ### 🙏 Acknowledgments
+        We thank **Thapelo Sindanie** and **Unarine Netshifhefhe** for their contributions to this work.
         
-        # Format for display
-        display_data = []
-        for r in results:
-            if r['success']:
-                word_ratio = f"{r['analysis']['source']['word_count']}→{r['analysis']['target']['word_count']}"
-                char_ratio = f"{r['analysis']['source']['character_count']}→{r['analysis']['target']['character_count']}"
-            else:
-                word_ratio = "Error"
-                char_ratio = "Error"
-            
-            display_data.append([
-                r['index'],
-                r['source'][:50] + "..." if len(r['source']) > 50 else r['source'],
-                r['translation'][:50] + "..." if len(r['translation']) > 50 else r['translation'],
-                word_ratio,
-                char_ratio
-            ])
+        ### 📖 Citation
+        ```bibtex
+        @inproceedings{lastrucci2023preparing,
+          title={Preparing the Vuk'uzenzele and ZA-gov-multilingual South African multilingual corpora},
+          author={Lastrucci, Richard and Rajab, Jenalea and Shingange, Matimba and Njini, Daniel and Marivate, Vukosi},
+          booktitle={Proceedings of the Fourth workshop on Resources for African Indigenous Languages (RAIL 2023)},
+          pages={18--25},
+          year={2023}
+        }
+        ```
         
-        return display_data
-    
-    def get_history():
-        if not app.translation_history:
-            return []
+        **Links**: 
+        - [DSFSI](https://www.dsfsi.co.za/) 
+        - [En→Ss Model](https://huggingface.co/dsfsi/en-ss-m2m100-combo) | [Ss→En Model](https://huggingface.co/dsfsi/ss-en-m2m100-combo)
+        - [Vuk'uzenzele Data](https://github.com/dsfsi/vukuzenzele-nlp) | [ZA-gov Data](https://github.com/dsfsi/gov-za-multilingual)
+        - [Research Feedback](https://docs.google.com/forms/d/e/1FAIpQLSf7S36dyAUPx2egmXbFpnTBuzoRulhL5Elu-N1eoMhaO7v10w/viewform)
         
-        return [[
-            entry['timestamp'][:19],  # Remove microseconds
-            entry['direction'],
-            entry['source_text'][:50] + "..." if len(entry['source_text']) > 50 else entry['source_text'],
-            entry['translated_text'][:50] + "..." if len(entry['translated_text']) > 50 else entry['translated_text']
-        ] for entry in app.translation_history[-20:]]  # Show last 20
-    
-    def export_csv():
-        csv_content = app.export_history_csv()
-        if csv_content:
-            filename = f"translation_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-            return gr.File.update(value=csv_content, visible=True, label=f"📊 {filename}")
-        return gr.File.update(visible=False)
-    
-    def clear_history():
-        app.translation_history = []
-        return []
-    
-    # Wire up events
-    input_text.change(fn=update_char_count, inputs=input_text, outputs=char_count)
-    
-    translate_btn.click(
-        fn=translate_with_analysis,
-        inputs=[input_text, direction],
-        outputs=[output_text, status_display, metrics_display, features_display, ratios_display]
-    )
-    
-    clear_btn.click(
-        fn=clear_all,
-        outputs=[input_text, output_text, char_count, status_display, metrics_display, features_display, ratios_display]
-    )
-    
-    batch_btn.click(
-        fn=process_batch,
-        inputs=[batch_input, batch_text, batch_direction],
-        outputs=batch_results
-    )
-    
-    refresh_history_btn.click(fn=get_history, outputs=history_display)
-    export_csv_btn.click(fn=export_csv, outputs=csv_download)
-    clear_history_btn.click(fn=clear_history, outputs=history_display)
+        ---
+        **Built with ❤️ for the African NLP community**
+        """)
     
-    # Auto-translate on Enter
-    input_text.submit(
-        fn=translate_with_analysis,
-        inputs=[input_text, direction],
-        outputs=[output_text, status_display, metrics_display, features_display, ratios_display]
-    )
+    return demo
 
+# Create and launch the interface
 if __name__ == "__main__":
+    demo = create_gradio_interface()
     demo.launch(
+        share=True,
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        debug=True
+        show_error=True
     )