Update app.py

app.py

@@ -1,7 +1,9 @@
 import torch
 import gradio as gr
-from transformers import BertTokenizer, BertForSequenceClassification
-import matplotlib.pyplot as plt
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
 import numpy as np
 from wordcloud import WordCloud
 from collections import Counter, defaultdict
@@ -16,6 +18,10 @@ from functools import lru_cache, wraps
 from dataclasses import dataclass
 from typing import List, Dict, Optional, Tuple, Any, Callable
 from contextlib import contextmanager
+import nltk
+from nltk.corpus import stopwords
+import langdetect
+import pandas as pd
 import gc
 
 # Configuration
@@ -28,27 +34,45 @@ class Config:
     CACHE_SIZE: int = 128
     BATCH_PROCESSING_SIZE: int = 8
     
-    # Visualization settings
-    FIGURE_SIZE_SINGLE: Tuple[int, int] = (8, 5)
-    FIGURE_SIZE_BATCH: Tuple[int, int] = (12, 8)
-    WORDCLOUD_SIZE: Tuple[int, int] = (10, 5)
+    # Supported languages and models
+    SUPPORTED_LANGUAGES = {
+        'auto': 'Auto Detect',
+        'en': 'English',
+        'zh': 'Chinese',
+        'es': 'Spanish',
+        'fr': 'French',
+        'de': 'German',
+        'sv': 'Swedish'
+    }
     
-    THEMES = {
-        'default': {'pos': '#4ecdc4', 'neg': '#ff6b6b'},
-        'ocean': {'pos': '#0077be', 'neg': '#ff6b35'},
-        'forest': {'pos': '#228b22', 'neg': '#dc143c'},
-        'sunset': {'pos': '#ff8c00', 'neg': '#8b0000'}
+    MODELS = {
+        'en': "cardiffnlp/twitter-roberta-base-sentiment-latest",
+        'multilingual': "cardiffnlp/twitter-xlm-roberta-base-sentiment",
+        'zh': "uer/roberta-base-finetuned-dianping-chinese"
     }
     
-    STOP_WORDS = {
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
-        'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 
-        'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should'
+    # Color themes for Plotly
+    THEMES = {
+        'default': {'pos': '#4CAF50', 'neg': '#F44336', 'neu': '#FF9800'},
+        'ocean': {'pos': '#0077BE', 'neg': '#FF6B35', 'neu': '#00BCD4'},
+        'dark': {'pos': '#66BB6A', 'neg': '#EF5350', 'neu': '#FFA726'},
+        'rainbow': {'pos': '#9C27B0', 'neg': '#E91E63', 'neu': '#FF5722'}
     }
 
 config = Config()
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Initialize NLTK
+try:
+    nltk.download('stopwords', quiet=True)
+    nltk.download('punkt', quiet=True)
+    STOP_WORDS = set(stopwords.words('english'))
+except:
+    STOP_WORDS = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
+
 # Decorators and Context Managers
 def handle_errors(default_return=None):
     """Centralized error handling decorator"""
@@ -64,13 +88,11 @@ def handle_errors(default_return=None):
     return decorator
 
 @contextmanager
-def managed_figure(*args, **kwargs):
-    """Context manager for matplotlib figures to prevent memory leaks"""
-    fig = plt.figure(*args, **kwargs)
+def memory_cleanup():
+    """Context manager for memory cleanup"""
     try:
-        yield fig
+        yield
     finally:
-        plt.close(fig)
         gc.collect()
 
 class ThemeContext:
@@ -79,72 +101,152 @@ class ThemeContext:
         self.theme = theme
         self.colors = config.THEMES.get(theme, config.THEMES['default'])
 
-# Lazy Model Manager
+# Enhanced Model Manager with Multi-language Support
 class ModelManager:
-    """Lazy loading model manager"""
+    """Multi-language model manager with lazy loading"""
     _instance = None
-    _model = None
-    _tokenizer = None
-    _device = None
     
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
         return cls._instance
     
-    @property
-    def model(self):
-        if self._model is None:
-            self._load_model()
-        return self._model
-    
-    @property
-    def tokenizer(self):
-        if self._tokenizer is None:
-            self._load_model()
-        return self._tokenizer
-    
-    @property
-    def device(self):
-        if self._device is None:
-            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        return self._device
-    
-    def _load_model(self):
-        """Load model and tokenizer"""
+    def __init__(self):
+        if not self._initialized:
+            self.models = {}
+            self.tokenizers = {}
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self._load_default_models()
+            self._initialized = True
+    
+    def _load_default_models(self):
+        """Load default models"""
         try:
-            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            self._tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
-            self._model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis")
-            self._model.to(self._device)
-            logger.info(f"Model loaded on {self._device}")
+            # Load multilingual model as default
+            model_name = config.MODELS['multilingual']
+            self.tokenizers['default'] = AutoTokenizer.from_pretrained(model_name)
+            self.models['default'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.models['default'].to(self.device)
+            logger.info(f"Default model loaded: {model_name}")
+            
+            # Load Chinese model
+            zh_model_name = config.MODELS['zh']
+            self.tokenizers['zh'] = AutoTokenizer.from_pretrained(zh_model_name)
+            self.models['zh'] = AutoModelForSequenceClassification.from_pretrained(zh_model_name)
+            self.models['zh'].to(self.device)
+            logger.info(f"Chinese model loaded: {zh_model_name}")
+            
         except Exception as e:
-            logger.error(f"Model loading failed: {e}")
+            logger.error(f"Failed to load models: {e}")
             raise
+    
+    def get_model(self, language='en'):
+        """Get model for specific language"""
+        if language == 'zh':
+            return self.models['zh'], self.tokenizers['zh']
+        return self.models['default'], self.tokenizers['default']
+    
+    @staticmethod
+    def detect_language(text: str) -> str:
+        """Detect text language"""
+        try:
+            detected = langdetect.detect(text)
+            language_mapping = {
+                'zh-cn': 'zh',
+                'zh-tw': 'zh'
+            }
+            detected = language_mapping.get(detected, detected)
+            return detected if detected in config.SUPPORTED_LANGUAGES else 'en'
+        except:
+            return 'en'
 
-# Simplified Core Classes
+# Simplified Text Processing
 class TextProcessor:
-    """Optimized text processing"""
+    """Optimized text processing with multi-language support"""
+    
     @staticmethod
     @lru_cache(maxsize=config.CACHE_SIZE)
-    def clean_text(text: str) -> Tuple[str, ...]:
-        """Single-pass text cleaning"""
-        words = re.findall(r'\b\w{3,}\b', text.lower())
-        return tuple(w for w in words if w not in config.STOP_WORDS)
+    def clean_text(text: str, remove_punctuation: bool = True, remove_numbers: bool = False) -> str:
+        """Clean text with language awareness"""
+        text = text.strip()
+        
+        # Don't clean Chinese text aggressively
+        if re.search(r'[\u4e00-\u9fff]', text):
+            return text
+        
+        text = text.lower()
+        
+        if remove_numbers:
+            text = re.sub(r'\d+', '', text)
+        
+        if remove_punctuation:
+            text = re.sub(r'[^\w\s]', '', text)
+        
+        words = text.split()
+        cleaned_words = [w for w in words if w not in STOP_WORDS and len(w) >= config.MIN_WORD_LENGTH]
+        return ' '.join(cleaned_words)
+    
+    @staticmethod
+    def extract_keywords(text: str, top_k: int = 5) -> List[str]:
+        """Extract keywords with language support"""
+        if re.search(r'[\u4e00-\u9fff]', text):
+            # Chinese text processing
+            words = re.findall(r'[\u4e00-\u9fff]+', text)
+            all_chars = ''.join(words)
+            char_freq = Counter(all_chars)
+            return [char for char, _ in char_freq.most_common(top_k)]
+        else:
+            # Other languages
+            cleaned = TextProcessor.clean_text(text)
+            words = cleaned.split()
+            word_freq = Counter(words)
+            return [word for word, _ in word_freq.most_common(top_k)]
+    
+    @staticmethod
+    def parse_batch_input(text: str) -> List[str]:
+        """Parse batch input from textarea"""
+        lines = text.strip().split('\n')
+        return [line.strip() for line in lines if line.strip()]
 
+# Enhanced History Manager
 class HistoryManager:
-    """Simplified history management"""
+    """Enhanced history management with filtering"""
     def __init__(self):
         self._history = []
     
     def add(self, entry: Dict):
-        self._history.append({**entry, 'timestamp': datetime.now().isoformat()})
+        """Add entry with timestamp"""
+        entry['timestamp'] = datetime.now().isoformat()
+        self._history.append(entry)
         if len(self._history) > config.MAX_HISTORY_SIZE:
             self._history = self._history[-config.MAX_HISTORY_SIZE:]
     
+    def add_batch(self, entries: List[Dict]):
+        """Add multiple entries"""
+        for entry in entries:
+            self.add(entry)
+    
     def get_all(self) -> List[Dict]:
         return self._history.copy()
     
+    def get_recent(self, n: int = 10) -> List[Dict]:
+        return self._history[-n:] if self._history else []
+    
+    def filter_by(self, sentiment: str = None, language: str = None, 
+                  min_confidence: float = None) -> List[Dict]:
+        """Filter history by criteria"""
+        filtered = self._history
+        
+        if sentiment:
+            filtered = [h for h in filtered if h['sentiment'] == sentiment]
+        if language:
+            filtered = [h for h in filtered if h.get('language', 'en') == language]
+        if min_confidence:
+            filtered = [h for h in filtered if h['confidence'] >= min_confidence]
+            
+        return filtered
+    
     def clear(self) -> int:
         count = len(self._history)
         self._history.clear()
@@ -152,107 +254,175 @@ class HistoryManager:
     
     def size(self) -> int:
         return len(self._history)
+    
+    def get_stats(self) -> Dict:
+        """Get comprehensive statistics"""
+        if not self._history:
+            return {}
+        
+        sentiments = [item['sentiment'] for item in self._history]
+        confidences = [item['confidence'] for item in self._history]
+        languages = [item.get('language', 'en') for item in self._history]
+        
+        return {
+            'total_analyses': len(self._history),
+            'positive_count': sentiments.count('Positive'),
+            'negative_count': sentiments.count('Negative'),
+            'neutral_count': sentiments.count('Neutral'),
+            'avg_confidence': np.mean(confidences),
+            'max_confidence': np.max(confidences),
+            'min_confidence': np.min(confidences),
+            'languages_detected': len(set(languages)),
+            'most_common_language': Counter(languages).most_common(1)[0][0] if languages else 'en'
+        }
 
-# Core Analysis Engine
+# Core Sentiment Analysis Engine
 class SentimentEngine:
-    """Streamlined sentiment analysis with attention-based keyword extraction"""
+    """Multi-language sentiment analysis engine"""
+    
     def __init__(self):
         self.model_manager = ModelManager()
     
-    def extract_key_words(self, text: str, top_k: int = 10) -> List[Tuple[str, float]]:
-        """Extract contributing words using BERT attention weights"""
+    def extract_attention_keywords(self, text: str, language: str = 'auto', top_k: int = 10) -> List[Tuple[str, float]]:
+        """Extract keywords using attention weights"""
         try:
-            inputs = self.model_manager.tokenizer(
+            if language == 'auto':
+                language = self.model_manager.detect_language(text)
+            
+            model, tokenizer = self.model_manager.get_model(language)
+            
+            inputs = tokenizer(
                 text, return_tensors="pt", padding=True, 
                 truncation=True, max_length=config.MAX_TEXT_LENGTH
             ).to(self.model_manager.device)
             
-            # Get model outputs with attention weights
             with torch.no_grad():
-                outputs = self.model_manager.model(**inputs, output_attentions=True)
-                attention = outputs.attentions  # Tuple of attention tensors for each layer
-                
-                # Use the last layer's attention, average over all heads
-                last_attention = attention[-1]  # Shape: [batch_size, num_heads, seq_len, seq_len]
-                avg_attention = last_attention.mean(dim=1)  # Average over heads: [batch_size, seq_len, seq_len]
-                
-                # Focus on attention to [CLS] token (index 0) as it represents the whole sequence
-                cls_attention = avg_attention[0, 0, :]  # Attention from CLS to all tokens
+                outputs = model(**inputs, output_attentions=True)
                 
-            # Get tokens and their attention scores
-            tokens = self.model_manager.tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
-            attention_scores = cls_attention.cpu().numpy()
-            
-            # Filter out special tokens and combine subword tokens
-            word_scores = {}
-            current_word = ""
-            current_score = 0.0
-            
-            for i, (token, score) in enumerate(zip(tokens, attention_scores)):
-                if token in ['[CLS]', '[SEP]', '[PAD]']:
-                    continue
+                if hasattr(outputs, 'attentions') and outputs.attentions:
+                    # Use attention weights
+                    attention = outputs.attentions[-1]
+                    avg_attention = attention.mean(dim=1)[0, 0, :]
+                    
+                    tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
+                    attention_scores = avg_attention.cpu().numpy()
+                    
+                    # Process tokens and scores
+                    word_scores = {}
+                    current_word = ""
+                    current_score = 0.0
+                    
+                    for token, score in zip(tokens, attention_scores):
+                        if token in ['[CLS]', '[SEP]', '[PAD]', '<s>', '</s>']:
+                            continue
+                            
+                        if token.startswith('##') or token.startswith('▁'):
+                            current_word += token.replace('##', '').replace('▁', '')
+                            current_score = max(current_score, score)
+                        else:
+                            if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
+                                word_scores[current_word.lower()] = current_score
+                            current_word = token
+                            current_score = score
                     
-                if token.startswith('##'):
-                    # Subword token, add to current word
-                    current_word += token[2:]
-                    current_score = max(current_score, score)  # Take max attention
-                else:
-                    # New word, save previous if exists
                     if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
                         word_scores[current_word.lower()] = current_score
                     
-                    current_word = token
-                    current_score = score
-            
-            # Don't forget the last word
-            if current_word and len(current_word) >= config.MIN_WORD_LENGTH:
-                word_scores[current_word.lower()] = current_score
-            
-            # Filter out stop words and sort by attention score
-            filtered_words = {
-                word: score for word, score in word_scores.items() 
-                if word not in config.STOP_WORDS and len(word) >= config.MIN_WORD_LENGTH
-            }
-            
-            # Sort by attention score and return top_k
-            sorted_words = sorted(filtered_words.items(), key=lambda x: x[1], reverse=True)
-            return sorted_words[:top_k]
-            
+                    # Filter and sort
+                    filtered_words = {
+                        word: score for word, score in word_scores.items() 
+                        if word not in STOP_WORDS and len(word) >= config.MIN_WORD_LENGTH
+                    }
+                    
+                    sorted_words = sorted(filtered_words.items(), key=lambda x: x[1], reverse=True)
+                    return sorted_words[:top_k]
+                
         except Exception as e:
-            logger.error(f"Key word extraction failed: {e}")
-            return []
+            logger.error(f"Attention keyword extraction failed: {e}")
+        
+        # Fallback to simple keyword extraction
+        keywords = TextProcessor.extract_keywords(text, top_k)
+        return [(word, 0.1) for word in keywords]
     
-    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'key_words': []})
-    def analyze_single(self, text: str) -> Dict:
-        """Analyze single text with key word extraction"""
+    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'keywords': []})
+    def analyze_single(self, text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
+        """Analyze single text with enhanced features"""
         if not text.strip():
-            raise ValueError("Empty text")
+            raise ValueError("Empty text provided")
+        
+        # Detect language
+        if language == 'auto':
+            detected_lang = self.model_manager.detect_language(text)
+        else:
+            detected_lang = language
+        
+        # Get appropriate model
+        model, tokenizer = self.model_manager.get_model(detected_lang)
+        
+        # Preprocessing
+        options = preprocessing_options or {}
+        processed_text = text
+        if options.get('clean_text', False) and not re.search(r'[\u4e00-\u9fff]', text):
+            processed_text = TextProcessor.clean_text(
+                text, 
+                options.get('remove_punctuation', True),
+                options.get('remove_numbers', False)
+            )
         
-        inputs = self.model_manager.tokenizer(
-            text, return_tensors="pt", padding=True, 
-            truncation=True, max_length=config.MAX_TEXT_LENGTH
-        ).to(self.model_manager.device)
+        # Tokenize and analyze
+        inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
+                         truncation=True, max_length=config.MAX_TEXT_LENGTH).to(self.model_manager.device)
         
         with torch.no_grad():
-            outputs = self.model_manager.model(**inputs)
+            outputs = model(**inputs)
             probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
         
-        sentiment = "Positive" if probs[1] > probs[0] else "Negative"
+        # Handle different model outputs
+        if len(probs) == 3:  # negative, neutral, positive
+            sentiment_idx = np.argmax(probs)
+            sentiment_labels = ['Negative', 'Neutral', 'Positive']
+            sentiment = sentiment_labels[sentiment_idx]
+            confidence = float(probs[sentiment_idx])
+            
+            result = {
+                'sentiment': sentiment,
+                'confidence': confidence,
+                'neg_prob': float(probs[0]),
+                'neu_prob': float(probs[1]),
+                'pos_prob': float(probs[2]),
+                'has_neutral': True
+            }
+        else:  # negative, positive
+            pred = np.argmax(probs)
+            sentiment = "Positive" if pred == 1 else "Negative"
+            confidence = float(probs[pred])
+            
+            result = {
+                'sentiment': sentiment,
+                'confidence': confidence,
+                'neg_prob': float(probs[0]),
+                'pos_prob': float(probs[1]),
+                'neu_prob': 0.0,
+                'has_neutral': False
+            }
         
-        # Extract key contributing words
-        key_words = self.extract_key_words(text)
+        # Extract keywords
+        keywords = self.extract_attention_keywords(text, detected_lang)
         
-        return {
-            'sentiment': sentiment,
-            'confidence': float(probs.max()),
-            'pos_prob': float(probs[1]),
-            'neg_prob': float(probs[0]),
-            'key_words': key_words
-        }
+        # Add metadata
+        result.update({
+            'language': detected_lang,
+            'keywords': keywords,
+            'word_count': len(text.split()),
+            'char_count': len(text)
+        })
+        
+        return result
     
     @handle_errors(default_return=[])
-    def analyze_batch(self, texts: List[str], progress_callback=None) -> List[Dict]:
-        """Optimized batch processing with key words"""
+    def analyze_batch(self, texts: List[str], language: str = 'auto', 
+                     preprocessing_options: Dict = None, progress_callback=None) -> List[Dict]:
+        """Optimized batch processing"""
         if len(texts) > config.BATCH_SIZE_LIMIT:
             texts = texts[:config.BATCH_SIZE_LIMIT]
         
@@ -265,185 +435,263 @@ class SentimentEngine:
             if progress_callback:
                 progress_callback((i + len(batch)) / len(texts))
             
-            inputs = self.model_manager.tokenizer(
-                batch, return_tensors="pt", padding=True, 
-                truncation=True, max_length=config.MAX_TEXT_LENGTH
-            ).to(self.model_manager.device)
-            
-            with torch.no_grad():
-                outputs = self.model_manager.model(**inputs)
-                probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
-            
-            for text, prob in zip(batch, probs):
-                sentiment = "Positive" if prob[1] > prob[0] else "Negative"
-                # Extract key words for each text in batch
-                key_words = self.extract_key_words(text, top_k=5)  # Fewer for batch processing
-                
-                results.append({
-                    'text': text[:50] + '...' if len(text) > 50 else text,
-                    'full_text': text,
-                    'sentiment': sentiment,
-                    'confidence': float(prob.max()),
-                    'pos_prob': float(prob[1]),
-                    'neg_prob': float(prob[0]),
-                    'key_words': key_words
-                })
+            for text in batch:
+                try:
+                    result = self.analyze_single(text, language, preprocessing_options)
+                    result['batch_index'] = len(results)
+                    result['text'] = text[:100] + '...' if len(text) > 100 else text
+                    result['full_text'] = text
+                    results.append(result)
+                except Exception as e:
+                    results.append({
+                        'sentiment': 'Error',
+                        'confidence': 0.0,
+                        'error': str(e),
+                        'batch_index': len(results),
+                        'text': text[:100] + '...' if len(text) > 100 else text,
+                        'full_text': text
+                    })
         
         return results
 
-# Unified Visualization System
-class PlotFactory:
-    """Factory for creating plots with proper memory management"""
+# Advanced Plotly Visualization System
+class PlotlyVisualizer:
+    """Enhanced Plotly visualizations"""
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_sentiment_bars(probs: np.ndarray, theme: ThemeContext) -> plt.Figure:
-        """Create sentiment probability bars"""
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
-            labels = ["Negative", "Positive"]
-            colors = [theme.colors['neg'], theme.colors['pos']]
-            
-            bars = ax.bar(labels, probs, color=colors, alpha=0.8)
-            ax.set_title("Sentiment Probabilities", fontweight='bold')
-            ax.set_ylabel("Probability")
-            ax.set_ylim(0, 1)
-            
-            # Add value labels
-            for bar, prob in zip(bars, probs):
-                ax.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.02,
-                       f'{prob:.3f}', ha='center', va='bottom', fontweight='bold')
-            
-            fig.tight_layout()
-            return fig
+    def create_sentiment_gauge(result: Dict, theme: ThemeContext) -> go.Figure:
+        """Create animated sentiment gauge"""
+        colors = theme.colors
+        
+        if result.get('has_neutral', False):
+            # Three-way gauge
+            fig = go.Figure(go.Indicator(
+                mode="gauge+number+delta",
+                value=result['pos_prob'] * 100,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                title={'text': f"Sentiment: {result['sentiment']}"},
+                delta={'reference': 50},
+                gauge={
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
+                    'steps': [
+                        {'range': [0, 33], 'color': colors['neg']},
+                        {'range': [33, 67], 'color': colors['neu']},
+                        {'range': [67, 100], 'color': colors['pos']}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 90
+                    }
+                }
+            ))
+        else:
+            # Two-way gauge
+            fig = go.Figure(go.Indicator(
+                mode="gauge+number",
+                value=result['confidence'] * 100,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                title={'text': f"Confidence: {result['sentiment']}"},
+                gauge={
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
+                    'steps': [
+                        {'range': [0, 50], 'color': "lightgray"},
+                        {'range': [50, 100], 'color': "gray"}
+                    ]
+                }
+            ))
+        
+        fig.update_layout(height=400, font={'size': 16})
+        return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_confidence_gauge(confidence: float, sentiment: str, theme: ThemeContext) -> plt.Figure:
-        """Create confidence gauge"""
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
-            
-            # Create gauge
-            theta = np.linspace(0, np.pi, 100)
-            colors = [theme.colors['neg'] if i < 50 else theme.colors['pos'] for i in range(100)]
-            
-            for i in range(len(theta)-1):
-                ax.fill_between([theta[i], theta[i+1]], [0, 0], [0.8, 0.8], 
-                               color=colors[i], alpha=0.7)
-            
-            # Needle position
-            pos = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
-            ax.plot([pos, pos], [0, 0.6], 'k-', linewidth=6)
-            ax.plot(pos, 0.6, 'ko', markersize=10)
-            
-            ax.set_xlim(0, np.pi)
-            ax.set_ylim(0, 1)
-            ax.set_title(f'{sentiment} - Confidence: {confidence:.3f}', fontweight='bold')
-            ax.set_xticks([0, np.pi/2, np.pi])
-            ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
-            ax.axis('off')
-            
-            fig.tight_layout()
-            return fig
+    def create_probability_bars(result: Dict, theme: ThemeContext) -> go.Figure:
+        """Create probability bar chart"""
+        colors = theme.colors
+        
+        if result.get('has_neutral', False):
+            labels = ['Negative', 'Neutral', 'Positive']
+            values = [result['neg_prob'], result['neu_prob'], result['pos_prob']]
+            bar_colors = [colors['neg'], colors['neu'], colors['pos']]
+        else:
+            labels = ['Negative', 'Positive']
+            values = [result['neg_prob'], result['pos_prob']]
+            bar_colors = [colors['neg'], colors['pos']]
+        
+        fig = go.Figure(data=[
+            go.Bar(x=labels, y=values, marker_color=bar_colors, 
+                   text=[f'{v:.3f}' for v in values], textposition='outside')
+        ])
+        
+        fig.update_layout(
+            title="Sentiment Probabilities",
+            yaxis_title="Probability",
+            height=400,
+            showlegend=False
+        )
+        
+        return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_keyword_chart(key_words: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
-        """Create horizontal bar chart for key contributing words"""
-        if not key_words:
-            return None
-        
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
-            
-            words = [word for word, score in key_words]
-            scores = [score for word, score in key_words]
-            
-            # Choose color based on sentiment
-            color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
-            
-            # Create horizontal bar chart
-            bars = ax.barh(range(len(words)), scores, color=color, alpha=0.7)
-            ax.set_yticks(range(len(words)))
-            ax.set_yticklabels(words)
-            ax.set_xlabel('Attention Weight')
-            ax.set_title(f'Top Contributing Words ({sentiment})', fontweight='bold')
-            
-            # Add value labels on bars
-            for i, (bar, score) in enumerate(zip(bars, scores)):
-                ax.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2.,
-                       f'{score:.3f}', ha='left', va='center', fontsize=9)
-            
-            # Invert y-axis to show highest scoring word at top
-            ax.invert_yaxis()
-            ax.grid(axis='x', alpha=0.3)
-            fig.tight_layout()
+    def create_keyword_chart(keywords: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> go.Figure:
+        """Create keyword importance chart"""
+        if not keywords:
+            fig = go.Figure()
+            fig.add_annotation(text="No keywords extracted", 
+                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            fig.update_layout(height=400, title="Keywords")
             return fig
+        
+        words = [word for word, score in keywords]
+        scores = [score for word, score in keywords]
+        
+        color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
+        
+        fig = go.Figure(data=[
+            go.Bar(
+                y=words,
+                x=scores,
+                orientation='h',
+                marker_color=color,
+                text=[f'{score:.3f}' for score in scores],
+                textposition='auto'
+            )
+        ])
+        
+        fig.update_layout(
+            title=f"Top Keywords ({sentiment})",
+            xaxis_title="Attention Weight",
+            yaxis_title="Keywords",
+            height=400,
+            showlegend=False
+        )
+        
+        return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_wordcloud(text: str, sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
-        """Create word cloud"""
-        if len(text.split()) < 3:
-            return None
-        
-        colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
-        wc = WordCloud(width=800, height=400, background_color='white',
-                      colormap=colormap, max_words=30).generate(text)
-        
-        with managed_figure(figsize=config.WORDCLOUD_SIZE) as fig:
-            ax = fig.add_subplot(111)
-            ax.imshow(wc, interpolation='bilinear')
-            ax.axis('off')
-            ax.set_title(f'{sentiment} Word Cloud', fontweight='bold')
-            fig.tight_layout()
-            return fig
+    def create_batch_summary(results: List[Dict], theme: ThemeContext) -> go.Figure:
+        """Create batch analysis summary"""
+        colors = theme.colors
+        
+        # Count sentiments
+        sentiments = [r['sentiment'] for r in results if 'sentiment' in r and r['sentiment'] != 'Error']
+        sentiment_counts = Counter(sentiments)
+        
+        # Create pie chart
+        fig = go.Figure(data=[go.Pie(
+            labels=list(sentiment_counts.keys()),
+            values=list(sentiment_counts.values()),
+            marker_colors=[colors.get(s.lower()[:3], '#999999') for s in sentiment_counts.keys()],
+            textinfo='label+percent',
+            hole=0.3
+        )])
+        
+        fig.update_layout(
+            title=f"Batch Analysis Summary ({len(results)} texts)",
+            height=400
+        )
+        
+        return fig
     
     @staticmethod
     @handle_errors(default_return=None)
-    def create_batch_analysis(results: List[Dict], theme: ThemeContext) -> plt.Figure:
-        """Create comprehensive batch visualization"""
-        with managed_figure(figsize=config.FIGURE_SIZE_BATCH) as fig:
-            gs = fig.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
-            
-            # Sentiment distribution
-            ax1 = fig.add_subplot(gs[0, 0])
-            sent_counts = Counter([r['sentiment'] for r in results])
-            colors = [theme.colors['pos'], theme.colors['neg']]
-            ax1.pie(sent_counts.values(), labels=sent_counts.keys(), 
-                   autopct='%1.1f%%', colors=colors[:len(sent_counts)])
-            ax1.set_title('Sentiment Distribution')
-            
-            # Confidence histogram
-            ax2 = fig.add_subplot(gs[0, 1])
-            confs = [r['confidence'] for r in results]
-            ax2.hist(confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
-            ax2.set_title('Confidence Distribution')
-            ax2.set_xlabel('Confidence')
-            
-            # Sentiment over time
-            ax3 = fig.add_subplot(gs[1, :])
-            pos_probs = [r['pos_prob'] for r in results]
-            indices = range(len(results))
-            colors_scatter = [theme.colors['pos'] if r['sentiment'] == 'Positive' 
-                            else theme.colors['neg'] for r in results]
-            ax3.scatter(indices, pos_probs, c=colors_scatter, alpha=0.7, s=60)
-            ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
-            ax3.set_title('Sentiment Progression')
-            ax3.set_xlabel('Review Index')
-            ax3.set_ylabel('Positive Probability')
-            
-            return fig
+    def create_confidence_distribution(results: List[Dict]) -> go.Figure:
+        """Create confidence distribution plot"""
+        confidences = [r['confidence'] for r in results if 'confidence' in r and r['sentiment'] != 'Error']
+        
+        if not confidences:
+            return go.Figure()
+        
+        fig = go.Figure(data=[go.Histogram(
+            x=confidences,
+            nbinsx=20,
+            marker_color='skyblue',
+            opacity=0.7
+        )])
+        
+        fig.update_layout(
+            title="Confidence Distribution",
+            xaxis_title="Confidence Score",
+            yaxis_title="Frequency",
+            height=400
+        )
+        
+        return fig
+    
+    @staticmethod
+    @handle_errors(default_return=None)
+    def create_history_dashboard(history: List[Dict], theme: ThemeContext) -> go.Figure:
+        """Create comprehensive history dashboard"""
+        if len(history) < 2:
+            return go.Figure()
+        
+        # Create subplots
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=['Sentiment Timeline', 'Confidence Distribution', 
+                           'Language Distribution', 'Sentiment Summary'],
+            specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                   [{"type": "pie"}, {"type": "bar"}]]
+        )
+        
+        # Extract data
+        indices = list(range(len(history)))
+        pos_probs = [item.get('pos_prob', 0) for item in history]
+        confidences = [item['confidence'] for item in history]
+        sentiments = [item['sentiment'] for item in history]
+        languages = [item.get('language', 'en') for item in history]
+        
+        # Sentiment timeline
+        colors_map = {'Positive': theme.colors['pos'], 'Negative': theme.colors['neg'], 'Neutral': theme.colors['neu']}
+        colors = [colors_map.get(s, '#999999') for s in sentiments]
+        
+        fig.add_trace(
+            go.Scatter(x=indices, y=pos_probs, mode='lines+markers', 
+                      marker=dict(color=colors, size=8),
+                      name='Positive Probability'),
+            row=1, col=1
+        )
+        
+        # Confidence distribution
+        fig.add_trace(
+            go.Histogram(x=confidences, nbinsx=10, name='Confidence'),
+            row=1, col=2
+        )
+        
+        # Language distribution
+        lang_counts = Counter(languages)
+        fig.add_trace(
+            go.Pie(labels=list(lang_counts.keys()), values=list(lang_counts.values()),
+                   name="Languages"),
+            row=2, col=1
+        )
+        
+        # Sentiment summary
+        sent_counts = Counter(sentiments)
+        sent_colors = [colors_map.get(k, '#999999') for k in sent_counts.keys()]
+        fig.add_trace(
+            go.Bar(x=list(sent_counts.keys()), y=list(sent_counts.values()),
+                   marker_color=sent_colors),
+            row=2, col=2
+        )
+        
+        fig.update_layout(height=800, showlegend=False)
+        return fig
 
-# Unified Data Handler
+# Universal Data Handler
 class DataHandler:
-    """Handles all data operations"""
+    """Enhanced data operations"""
     
     @staticmethod
     @handle_errors(default_return=(None, "Export failed"))
     def export_data(data: List[Dict], format_type: str) -> Tuple[Optional[str], str]:
-        """Universal data export"""
+        """Export data with comprehensive information"""
         if not data:
             return None, "No data to export"
         
@@ -452,16 +700,21 @@ class DataHandler:
         
         if format_type == 'csv':
             writer = csv.writer(temp_file)
-            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Pos_Prob', 'Neg_Prob', 'Key_Words'])
+            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Language', 
+                           'Pos_Prob', 'Neg_Prob', 'Neu_Prob', 'Keywords', 'Word_Count'])
             for entry in data:
+                keywords_str = "|".join([f"{word}:{score:.3f}" for word, score in entry.get('keywords', [])])
                 writer.writerow([
                     entry.get('timestamp', ''),
                     entry.get('text', ''),
                     entry.get('sentiment', ''),
                     f"{entry.get('confidence', 0):.4f}",
+                    entry.get('language', 'en'),
                     f"{entry.get('pos_prob', 0):.4f}",
                     f"{entry.get('neg_prob', 0):.4f}",
-                    "|".join([f"{word}:{score:.3f}" for word, score in entry.get('key_words', [])])
+                    f"{entry.get('neu_prob', 0):.4f}",
+                    keywords_str,
+                    entry.get('word_count', 0)
                 ])
         elif format_type == 'json':
             json.dump(data, temp_file, indent=2, ensure_ascii=False)
@@ -469,31 +722,29 @@ class DataHandler:
         temp_file.close()
         return temp_file.name, f"Exported {len(data)} entries"
     
-
     @staticmethod
     @handle_errors(default_return="")
     def process_file(file) -> str:
-        """Process uploaded file"""
+        """Process uploaded files"""
         if not file:
             return ""
-    
+        
         content = file.read().decode('utf-8')
         
         if file.name.endswith('.csv'):
-            import io
             csv_file = io.StringIO(content)
             reader = csv.reader(csv_file)
             try:
-                next(reader)
+                next(reader)  # Skip header
                 texts = []
                 for row in reader:
                     if row and row[0].strip():
                         text = row[0].strip().strip('"')
-                        if text:  
+                        if text:
                             texts.append(text)
                 return '\n'.join(texts)
-            except Exception as e:
-                lines = content.strip().split('\n')[1:] 
+            except:
+                lines = content.strip().split('\n')[1:]
                 texts = []
                 for line in lines:
                     if line.strip():
@@ -501,227 +752,762 @@ class DataHandler:
                         if text:
                             texts.append(text)
                 return '\n'.join(texts)
+        
         return content
 
-# Main Application
+# Main Application Class
 class SentimentApp:
-    """Main application orchestrator"""
+    """Main multilingual sentiment analysis application"""
     
     def __init__(self):
         self.engine = SentimentEngine()
         self.history = HistoryManager()
         self.data_handler = DataHandler()
         
-        # Example data
+        # Multi-language examples
         self.examples = [
-            ["While the film's visual effects were undeniably impressive, the story lacked emotional weight, and the pacing felt inconsistent throughout."],
-            ["An extraordinary achievement in filmmaking — the direction was masterful, the script was sharp, and every performance added depth and realism."],
-            ["Despite a promising start, the film quickly devolved into a series of clichés, with weak character development and an ending that felt rushed and unearned."],
-            ["A beautifully crafted story with heartfelt moments and a soundtrack that perfectly captured the emotional tone of each scene."],
-            ["The movie was far too long, with unnecessary subplots and dull dialogue that made it difficult to stay engaged until the end."]
+            ["This movie was absolutely fantastic! The acting was superb and the plot kept me engaged throughout."],
+            ["The film was disappointing with poor character development and a confusing storyline."],
+            ["这部电影真的很棒！演技精湛，情节引人入胜。"],  # Chinese
+            ["Esta película fue increíble, me encantó la cinematografía."],  # Spanish
+            ["Ce film était magnifique, j'ai adoré la réalisation."],  # French
         ]
-
     
-    @handle_errors(default_return=("Please enter text", None, None, None, None))
-    def analyze_single(self, text: str, theme: str = 'default'):
-        """Single text analysis with key words"""
+    @handle_errors(default_return=("Please enter text", None, None, None))
+    def analyze_single(self, text: str, language: str, theme: str, clean_text: bool, 
+                       remove_punct: bool, remove_nums: bool):
+        """Single text analysis with enhanced visualizations"""
         if not text.strip():
-            return "Please enter text", None, None, None, None
+            return "Please enter text", None, None, None
         
-        result = self.engine.analyze_single(text)
+        # Map display names to language codes
+        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
+        language_code = language_map.get(language, 'auto')
         
-        # Add to history
-        self.history.add({
-            'text': text[:100],
-            'full_text': text,
-            **result
-        })
+        preprocessing_options = {
+            'clean_text': clean_text,
+            'remove_punctuation': remove_punct,
+            'remove_numbers': remove_nums
+        }
+        
+        with memory_cleanup():
+            result = self.engine.analyze_single(text, language_code, preprocessing_options)
+            
+            # Add to history
+            history_entry = {
+                'text': text[:100] + '...' if len(text) > 100 else text,
+                'full_text': text,
+                'sentiment': result['sentiment'],
+                'confidence': result['confidence'],
+                'pos_prob': result.get('pos_prob', 0),
+                'neg_prob': result.get('neg_prob', 0),
+                'neu_prob': result.get('neu_prob', 0),
+                'language': result['language'],
+                'keywords': result['keywords'],
+                'word_count': result['word_count'],
+                'analysis_type': 'single'
+            }
+            self.history.add(history_entry)
+            
+            # Create visualizations
+            theme_ctx = ThemeContext(theme)
+            gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme_ctx)
+            bars_fig = PlotlyVisualizer.create_probability_bars(result, theme_ctx)
+            keyword_fig = PlotlyVisualizer.create_keyword_chart(result['keywords'], result['sentiment'], theme_ctx)
+            
+            # Create comprehensive result text
+            keywords_str = ", ".join([f"{word}({score:.3f})" for word, score in result['keywords'][:5]])
+            
+            info_text = f"""
+**Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+- **Language:** {result['language'].upper()}
+- **Keywords:** {keywords_str}
+- **Statistics:** {result['word_count']} words, {result['char_count']} characters
+            """
+            
+            return info_text, gauge_fig, bars_fig, keyword_fig
+    
+    @handle_errors(default_return=("Please enter texts", None, None, None))
+    def analyze_batch(self, batch_text: str, language: str, theme: str, 
+                     clean_text: bool, remove_punct: bool, remove_nums: bool):
+        """Enhanced batch analysis"""
+        if not batch_text.strip():
+            return "Please enter texts (one per line)", None, None, None
+        
+        # Parse batch input
+        texts = TextProcessor.parse_batch_input(batch_text)
+        
+        if len(texts) > config.BATCH_SIZE_LIMIT:
+            return f"Too many texts. Maximum {config.BATCH_SIZE_LIMIT} allowed.", None, None, None
+        
+        if not texts:
+            return "No valid texts found", None, None, None
+        
+        # Map display names to language codes
+        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
+        language_code = language_map.get(language, 'auto')
+        
+        preprocessing_options = {
+            'clean_text': clean_text,
+            'remove_punctuation': remove_punct,
+            'remove_numbers': remove_nums
+        }
+        
+        with memory_cleanup():
+            results = self.engine.analyze_batch(texts, language_code, preprocessing_options)
+            
+            # Add to history
+            batch_entries = []
+            for result in results:
+                if 'error' not in result:
+                    entry = {
+                        'text': result['text'],
+                        'full_text': result['full_text'],
+                        'sentiment': result['sentiment'],
+                        'confidence': result['confidence'],
+                        'pos_prob': result.get('pos_prob', 0),
+                        'neg_prob': result.get('neg_prob', 0),
+                        'neu_prob': result.get('neu_prob', 0),
+                        'language': result['language'],
+                        'keywords': result['keywords'],
+                        'word_count': result['word_count'],
+                        'analysis_type': 'batch',
+                        'batch_index': result['batch_index']
+                    }
+                    batch_entries.append(entry)
+            
+            self.history.add_batch(batch_entries)
+            
+            # Create visualizations
+            theme_ctx = ThemeContext(theme)
+            summary_fig = PlotlyVisualizer.create_batch_summary(results, theme_ctx)
+            confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
+            
+            # Create results DataFrame
+            df_data = []
+            for result in results:
+                if 'error' in result:
+                    df_data.append({
+                        'Index': result['batch_index'] + 1,
+                        'Text': result['text'],
+                        'Sentiment': 'Error',
+                        'Confidence': 0.0,
+                        'Language': 'Unknown',
+                        'Error': result['error']
+                    })
+                else:
+                    keywords_str = ', '.join([word for word, _ in result['keywords'][:3]])
+                    df_data.append({
+                        'Index': result['batch_index'] + 1,
+                        'Text': result['text'],
+                        'Sentiment': result['sentiment'],
+                        'Confidence': f"{result['confidence']:.3f}",
+                        'Language': result['language'].upper(),
+                        'Keywords': keywords_str
+                    })
+            
+            df = pd.DataFrame(df_data)
+            
+            # Create summary text
+            successful_results = [r for r in results if 'error' not in r]
+            error_count = len(results) - len(successful_results)
+            
+            if successful_results:
+                sentiment_counts = Counter([r['sentiment'] for r in successful_results])
+                avg_confidence = np.mean([r['confidence'] for r in successful_results])
+                languages = Counter([r['language'] for r in successful_results])
+                
+                summary_text = f"""
+**Batch Analysis Summary:**
+- **Total Texts:** {len(texts)}
+- **Successful:** {len(successful_results)}
+- **Errors:** {error_count}
+- **Average Confidence:** {avg_confidence:.3f}
+- **Sentiments:** {dict(sentiment_counts)}
+- **Languages Detected:** {dict(languages)}
+                """
+            else:
+                summary_text = f"All {len(texts)} texts failed to analyze."
+            
+            return summary_text, df, summary_fig, confidence_fig
+    
+    @handle_errors(default_return=(None, "No history available"))
+    def plot_history(self, theme: str = 'default'):
+        """Plot comprehensive history analysis"""
+        history = self.history.get_all()
+        if len(history) < 2:
+            return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
         
-        # Create visualizations
         theme_ctx = ThemeContext(theme)
-        probs = np.array([result['neg_prob'], result['pos_prob']])
         
-        prob_plot = PlotFactory.create_sentiment_bars(probs, theme_ctx)
-        gauge_plot = PlotFactory.create_confidence_gauge(result['confidence'], result['sentiment'], theme_ctx)
-        cloud_plot = PlotFactory.create_wordcloud(text, result['sentiment'], theme_ctx)
-        keyword_plot = PlotFactory.create_keyword_chart(result['key_words'], result['sentiment'], theme_ctx)
+        with memory_cleanup():
+            fig = PlotlyVisualizer.create_history_dashboard(history, theme_ctx)
+            stats = self.history.get_stats()
+            
+            stats_text = f"""
+**History Statistics:**
+- **Total Analyses:** {stats.get('total_analyses', 0)}
+- **Positive:** {stats.get('positive_count', 0)}
+- **Negative:** {stats.get('negative_count', 0)}
+- **Neutral:** {stats.get('neutral_count', 0)}
+- **Average Confidence:** {stats.get('avg_confidence', 0):.3f}
+- **Languages:** {stats.get('languages_detected', 0)}
+- **Most Common Language:** {stats.get('most_common_language', 'N/A').upper()}
+            """
+            
+            return fig, stats_text
+    
+    @handle_errors(default_return=("No data available",))
+    def get_history_status(self):
+        """Get current history status"""
+        stats = self.history.get_stats()
+        if not stats:
+            return "No analyses performed yet"
+        
+        return f"""
+**Current Status:**
+- **Total Analyses:** {stats['total_analyses']}
+- **Recent Sentiment Distribution:** 
+  * Positive: {stats['positive_count']}
+  * Negative: {stats['negative_count']}  
+  * Neutral: {stats['neutral_count']}
+- **Average Confidence:** {stats['avg_confidence']:.3f}
+- **Languages Detected:** {stats['languages_detected']}
+        """
+
+# Gradio Interface
+def create_interface():
+    """Create comprehensive Gradio interface"""
+    app = SentimentApp()
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
+        gr.Markdown("# 🌍 Advanced Multilingual Sentiment Analyzer")
+        gr.Markdown("AI-powered sentiment analysis with support for multiple languages, advanced visualizations, and explainable AI features")
+        
+        with gr.Tab("Single Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Text for Analysis",
+                        placeholder="Enter your text in any supported language...",
+                        lines=5
+                    )
+                    
+                    with gr.Row():
+                        language_selector = gr.Dropdown(
+                            choices=list(config.SUPPORTED_LANGUAGES.values()),
+                            value="Auto Detect",
+                            label="Language"
+                        )
+                        theme_selector = gr.Dropdown(
+                            choices=list(config.THEMES.keys()),
+                            value="default",
+                            label="Theme"
+                        )
+                    
+                    with gr.Row():
+                        clean_text_cb = gr.Checkbox(label="Clean Text", value=False)
+                        remove_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
+                        remove_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
+                    
+                    analyze_btn = gr.Button("Analyze", variant="primary", size="lg")
+                    
+                    gr.Examples(
+                        examples=app.examples,
+                        inputs=text_input,
+                        cache_examples=False
+                    )
+                
+                with gr.Column():
+                    result_output = gr.Textbox(label="Analysis Results", lines=8)
+            
+            with gr.Row():
+                gauge_plot = gr.Plot(label="Sentiment Gauge")
+                probability_plot = gr.Plot(label="Probability Distribution")
+            
+            with gr.Row():
+                keyword_plot = gr.Plot(label="Key Contributing Words")
+        
+        with gr.Tab("Batch Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    file_upload = gr.File(
+                        label="Upload File (CSV/TXT)", 
+                        file_types=[".csv", ".txt"]
+                    )
+                    batch_input = gr.Textbox(
+                        label="Batch Input (one text per line)",
+                        placeholder="Enter multiple texts, one per line...",
+                        lines=10
+                    )
+                    
+                    with gr.Row():
+                        batch_language = gr.Dropdown(
+                            choices=list(config.SUPPORTED_LANGUAGES.values()),
+                            value="Auto Detect",
+                            label="Language"
+                        )
+                        batch_theme = gr.Dropdown(
+                            choices=list(config.THEMES.keys()),
+                            value="default",
+                            label="Theme"
+                        )
+                    
+                    with gr.Row():
+                        batch_clean_cb = gr.Checkbox(label="Clean Text", value=False)
+                        batch_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
+                        batch_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
+                    
+                    with gr.Row():
+                        load_file_btn = gr.Button("Load File")
+                        analyze_batch_btn = gr.Button("Analyze Batch", variant="primary")
+                
+                with gr.Column():
+                    batch_summary = gr.Textbox(label="Batch Summary", lines=8)
+                    batch_results_df = gr.Dataframe(
+                        label="Detailed Results",
+                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Keywords"],
+                        datatype=["number", "str", "str", "str", "str", "str"]
+                    )
+            
+            with gr.Row():
+                batch_plot = gr.Plot(label="Batch Analysis Summary")
+                confidence_dist_plot = gr.Plot(label="Confidence Distribution")
         
-        # Format result text with key words
-        key_words_str = ", ".join([f"{word}({score:.3f})" for word, score in result['key_words'][:5]])
-        result_text = (f"Sentiment: {result['sentiment']} (Confidence: {result['confidence']:.3f})\n"
-                      f"Key Words: {key_words_str}")
+        with gr.Tab("History & Analytics"):
+            with gr.Row():
+                with gr.Column():
+                    with gr.Row():
+                        refresh_history_btn = gr.Button("Refresh History")
+                        clear_history_btn = gr.Button("Clear History", variant="stop")
+                        status_btn = gr.Button("Get Status")
+                    
+                    history_theme = gr.Dropdown(
+                        choices=list(config.THEMES.keys()),
+                        value="default",
+                        label="Dashboard Theme"
+                    )
+                    
+                    with gr.Row():
+                        export_csv_btn = gr.Button("Export CSV")
+                        export_json_btn = gr.Button("Export JSON")
+                
+                with gr.Column():
+                    history_status = gr.Textbox(label="History Status", lines=8)
+            
+            history_dashboard = gr.Plot(label="History Analytics Dashboard")
+            
+            with gr.Row():
+                csv_download = gr.File(label="CSV Download", visible=True)
+                json_download = gr.File(label="JSON Download", visible=True)
+        
+        # Event Handlers
+        analyze_btn.click(
+            app.analyze_single,
+            inputs=[text_input, language_selector, theme_selector, 
+                   clean_text_cb, remove_punct_cb, remove_nums_cb],
+            outputs=[result_output, gauge_plot, probability_plot, keyword_plot]
+        )
+        
+        load_file_btn.click(
+            app.data_handler.process_file,
+            inputs=file_upload,
+            outputs=batch_input
+        )
+        
+        analyze_batch_btn.click(
+            app.analyze_batch,
+            inputs=[batch_input, batch_language, batch_theme,
+                   batch_clean_cb, batch_punct_cb, batch_nums_cb],
+            outputs=[batch_summary, batch_results_df, batch_plot, confidence_dist_plot]
+        )
         
-        return result_text, prob_plot, gauge_plot, cloud_plot, keyword_plot
+        refresh_history_btn.click(
+            app.plot_history,
+            inputs=history_theme,
+            outputs=[history_dashboard, history_status]
+        )
+        
+        clear_history_btn.click(
+            lambda: f"Cleared {app.history.clear()} entries",
+            outputs=history_status
+        )
+        
+        status_btn.click(
+            app.get_history_status,
+            outputs=history_status
+        )
+        
+        export_csv_btn.click(
+            lambda: app.data_handler.export_data(app.history.get_all(), 'csv'),
+            outputs=[csv_download, history_status]
+        )
+        
+        export_json_btn.click(
+            lambda: app.data_handler.export_data(app.history.get_all(), 'json'),
+            outputs=[json_download, history_status]
+        )
     
-    @handle_errors(default_return=None)
-    def analyze_batch(self, reviews: str, progress=None):
-        """Batch analysis"""
-        if not reviews.strip():
-            return None
+    return demo
+
+# Application Entry Point
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    try:
+        demo = create_interface()
+        demo.launch(
+            share=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch application: {e}")
+        raise
+    
+    @handle_errors(default_return=("Please enter texts", None, None, None))
+    def analyze_batch(self, batch_text: str, language: str, theme: str, 
+                     clean_text: bool, remove_punct: bool, remove_nums: bool):
+        """Enhanced batch analysis"""
+        if not batch_text.strip():
+            return "Please enter texts (one per line)", None, None, None
+        
+        # Parse batch input
+        texts = TextProcessor.parse_batch_input(batch_text)
         
-        texts = [r.strip() for r in reviews.split('\n') if r.strip()]
-        if len(texts) < 2:
-            return None
+        if len(texts) > config.BATCH_SIZE_LIMIT:
+            return f"Too many texts. Maximum {config.BATCH_SIZE_LIMIT} allowed.", None, None, None
+        
+        if not texts:
+            return "No valid texts found", None, None, None
         
-        results = self.engine.analyze_batch(texts, progress)
+        # Map display names to language codes
+        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
+        language_code = language_map.get(language, 'auto')
         
-        # Add to history
-        for result in results:
-            self.history.add(result)
+        preprocessing_options = {
+            'clean_text': clean_text,
+            'remove_punctuation': remove_punct,
+            'remove_numbers': remove_nums
+        }
         
-        # Create visualization
-        theme_ctx = ThemeContext('default')
-        return PlotFactory.create_batch_analysis(results, theme_ctx)
+        with memory_cleanup():
+            results = self.engine.analyze_batch(texts, language_code, preprocessing_options)
+            
+            # Add to history
+            batch_entries = []
+            for result in results:
+                if 'error' not in result:
+                    entry = {
+                        'text': result['text'],
+                        'full_text': result['full_text'],
+                        'sentiment': result['sentiment'],
+                        'confidence': result['confidence'],
+                        'pos_prob': result.get('pos_prob', 0),
+                        'neg_prob': result.get('neg_prob', 0),
+                        'neu_prob': result.get('neu_prob', 0),
+                        'language': result['language'],
+                        'keywords': result['keywords'],
+                        'word_count': result['word_count'],
+                        'analysis_type': 'batch',
+                        'batch_index': result['batch_index']
+                    }
+                    batch_entries.append(entry)
+            
+            self.history.add_batch(batch_entries)
+            
+            # Create visualizations
+            theme_ctx = ThemeContext(theme)
+            summary_fig = PlotlyVisualizer.create_batch_summary(results, theme_ctx)
+            confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
+            
+            # Create results DataFrame
+            df_data = []
+            for result in results:
+                if 'error' in result:
+                    df_data.append({
+                        'Index': result['batch_index'] + 1,
+                        'Text': result['text'],
+                        'Sentiment': 'Error',
+                        'Confidence': 0.0,
+                        'Language': 'Unknown',
+                        'Error': result['error']
+                    })
+                else:
+                    keywords_str = ', '.join([word for word, _ in result['keywords'][:3]])
+                    df_data.append({
+                        'Index': result['batch_index'] + 1,
+                        'Text': result['text'],
+                        'Sentiment': result['sentiment'],
+                        'Confidence': f"{result['confidence']:.3f}",
+                        'Language': result['language'].upper(),
+                        'Keywords': keywords_str
+                    })
+            
+            df = pd.DataFrame(df_data)
+            
+            # Create summary text
+            successful_results = [r for r in results if 'error' not in r]
+            error_count = len(results) - len(successful_results)
+            
+            if successful_results:
+                sentiment_counts = Counter([r['sentiment'] for r in successful_results])
+                avg_confidence = np.mean([r['confidence'] for r in successful_results])
+                languages = Counter([r['language'] for r in successful_results])
+                
+                summary_text = f"""
+**Batch Analysis Summary:**
+- **Total Texts:** {len(texts)}
+- **Successful:** {len(successful_results)}
+- **Errors:** {error_count}
+- **Average Confidence:** {avg_confidence:.3f}
+- **Sentiments:** {dict(sentiment_counts)}
+- **Languages Detected:** {dict(languages)}
+                """
+            else:
+                summary_text = f"All {len(texts)} texts failed to analyze."
+            
+            return summary_text, df, summary_fig, confidence_fig
     
     @handle_errors(default_return=(None, "No history available"))
     def plot_history(self, theme: str = 'default'):
-        """Plot analysis history"""
+        """Plot comprehensive history analysis"""
         history = self.history.get_all()
         if len(history) < 2:
             return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
         
         theme_ctx = ThemeContext(theme)
         
-        with managed_figure(figsize=(12, 8)) as fig:
-            gs = fig.add_gridspec(2, 1, hspace=0.3)
-            
-            indices = list(range(len(history)))
-            pos_probs = [item['pos_prob'] for item in history]
-            confs = [item['confidence'] for item in history]
-            
-            # Sentiment trend
-            ax1 = fig.add_subplot(gs[0, 0])
-            colors = [theme_ctx.colors['pos'] if p > 0.5 else theme_ctx.colors['neg'] 
-                     for p in pos_probs]
-            ax1.scatter(indices, pos_probs, c=colors, alpha=0.7, s=60)
-            ax1.plot(indices, pos_probs, alpha=0.5, linewidth=2)
-            ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
-            ax1.set_title('Sentiment History')
-            ax1.set_ylabel('Positive Probability')
-            ax1.grid(True, alpha=0.3)
-            
-            # Confidence trend
-            ax2 = fig.add_subplot(gs[1, 0])
-            ax2.bar(indices, confs, alpha=0.7, color='lightblue', edgecolor='navy')
-            ax2.set_title('Confidence Over Time')
-            ax2.set_xlabel('Analysis Number')
-            ax2.set_ylabel('Confidence')
-            ax2.grid(True, alpha=0.3)
-            
-            fig.tight_layout()
-            return fig, f"History: {len(history)} analyses"
+        with memory_cleanup():
+            fig = PlotlyVisualizer.create_history_dashboard(history, theme_ctx)
+            stats = self.history.get_stats()
+            
+            stats_text = f"""
+**History Statistics:**
+- **Total Analyses:** {stats.get('total_analyses', 0)}
+- **Positive:** {stats.get('positive_count', 0)}
+- **Negative:** {stats.get('negative_count', 0)}
+- **Neutral:** {stats.get('neutral_count', 0)}
+- **Average Confidence:** {stats.get('avg_confidence', 0):.3f}
+- **Languages:** {stats.get('languages_detected', 0)}
+- **Most Common Language:** {stats.get('most_common_language', 'N/A').upper()}
+            """
+            
+            return fig, stats_text
+    
+    @handle_errors(default_return=("No data available",))
+    def get_history_status(self):
+        """Get current history status"""
+        stats = self.history.get_stats()
+        if not stats:
+            return "No analyses performed yet"
+        
+        return f"""
+**Current Status:**
+- **Total Analyses:** {stats['total_analyses']}
+- **Recent Sentiment Distribution:** 
+  * Positive: {stats['positive_count']}
+  * Negative: {stats['negative_count']}  
+  * Neutral: {stats['neutral_count']}
+- **Average Confidence:** {stats['avg_confidence']:.3f}
+- **Languages Detected:** {stats['languages_detected']}
+        """
 
-# Gradio Interface Setup
+# Gradio Interface
 def create_interface():
-    """Create streamlined Gradio interface"""
+    """Create comprehensive Gradio interface"""
     app = SentimentApp()
     
-    with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as demo:
-        gr.Markdown("# 🎬 AI Movie Sentiment Analyzer")
-        gr.Markdown("Optimized sentiment analysis with advanced visualizations and key word extraction")
+    with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
+        gr.Markdown("# 🌍 Advanced Multilingual Sentiment Analyzer")
+        gr.Markdown("AI-powered sentiment analysis with support for multiple languages, advanced visualizations, and explainable AI features")
         
         with gr.Tab("Single Analysis"):
             with gr.Row():
                 with gr.Column():
                     text_input = gr.Textbox(
-                        label="Movie Review",
-                        placeholder="Enter your movie review...",
+                        label="Enter Text for Analysis",
+                        placeholder="Enter your text in any supported language...",
                         lines=5
                     )
+                    
                     with gr.Row():
-                        analyze_btn = gr.Button("Analyze", variant="primary")
+                        language_selector = gr.Dropdown(
+                            choices=list(config.SUPPORTED_LANGUAGES.values()),
+                            value="Auto Detect",
+                            label="Language"
+                        )
                         theme_selector = gr.Dropdown(
                             choices=list(config.THEMES.keys()),
                             value="default",
                             label="Theme"
                         )
                     
+                    with gr.Row():
+                        clean_text_cb = gr.Checkbox(label="Clean Text", value=False)
+                        remove_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
+                        remove_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
+                    
+                    analyze_btn = gr.Button("Analyze", variant="primary", size="lg")
+                    
                     gr.Examples(
                         examples=app.examples,
-                        inputs=text_input
+                        inputs=text_input,
+                        cache_examples=False
                     )
                 
                 with gr.Column():
-                    result_output = gr.Textbox(label="Result", lines=3)
+                    result_output = gr.Textbox(label="Analysis Results", lines=8)
             
             with gr.Row():
-                prob_plot = gr.Plot(label="Probabilities")
-                gauge_plot = gr.Plot(label="Confidence")
+                gauge_plot = gr.Plot(label="Sentiment Gauge")
+                probability_plot = gr.Plot(label="Probability Distribution")
             
             with gr.Row():
-                wordcloud_plot = gr.Plot(label="Word Cloud")
                 keyword_plot = gr.Plot(label="Key Contributing Words")
         
         with gr.Tab("Batch Analysis"):
             with gr.Row():
                 with gr.Column():
-                    file_upload = gr.File(label="Upload File", file_types=[".csv", ".txt"])
+                    file_upload = gr.File(
+                        label="Upload File (CSV/TXT)", 
+                        file_types=[".csv", ".txt"]
+                    )
                     batch_input = gr.Textbox(
-                        label="Reviews (one per line)",
-                        lines=8
+                        label="Batch Input (one text per line)",
+                        placeholder="Enter multiple texts, one per line...",
+                        lines=10
                     )
+                    
+                    with gr.Row():
+                        batch_language = gr.Dropdown(
+                            choices=list(config.SUPPORTED_LANGUAGES.values()),
+                            value="Auto Detect",
+                            label="Language"
+                        )
+                        batch_theme = gr.Dropdown(
+                            choices=list(config.THEMES.keys()),
+                            value="default",
+                            label="Theme"
+                        )
+                    
+                    with gr.Row():
+                        batch_clean_cb = gr.Checkbox(label="Clean Text", value=False)
+                        batch_punct_cb = gr.Checkbox(label="Remove Punctuation", value=False)
+                        batch_nums_cb = gr.Checkbox(label="Remove Numbers", value=False)
+                    
+                    with gr.Row():
+                        load_file_btn = gr.Button("Load File")
+                        analyze_batch_btn = gr.Button("Analyze Batch", variant="primary")
                 
                 with gr.Column():
-                    load_btn = gr.Button("Load File")
-                    batch_btn = gr.Button("Analyze Batch", variant="primary")
+                    batch_summary = gr.Textbox(label="Batch Summary", lines=8)
+                    batch_results_df = gr.Dataframe(
+                        label="Detailed Results",
+                        headers=["Index", "Text", "Sentiment", "Confidence", "Language", "Keywords"],
+                        datatype=["number", "str", "str", "str", "str", "str"]
+                    )
             
-            batch_plot = gr.Plot(label="Batch Results")
+            with gr.Row():
+                batch_plot = gr.Plot(label="Batch Analysis Summary")
+                confidence_dist_plot = gr.Plot(label="Confidence Distribution")
         
-        with gr.Tab("History & Export"):
+        with gr.Tab("History & Analytics"):
             with gr.Row():
-                refresh_btn = gr.Button("Refresh")
-                clear_btn = gr.Button("Clear", variant="stop")
-                status_btn = gr.Button("Status")
+                with gr.Column():
+                    with gr.Row():
+                        refresh_history_btn = gr.Button("Refresh History")
+                        clear_history_btn = gr.Button("Clear History", variant="stop")
+                        status_btn = gr.Button("Get Status")
+                    
+                    history_theme = gr.Dropdown(
+                        choices=list(config.THEMES.keys()),
+                        value="default",
+                        label="Dashboard Theme"
+                    )
+                    
+                    with gr.Row():
+                        export_csv_btn = gr.Button("Export CSV")
+                        export_json_btn = gr.Button("Export JSON")
+                
+                with gr.Column():
+                    history_status = gr.Textbox(label="History Status", lines=8)
             
-            with gr.Row():
-                csv_btn = gr.Button("Export CSV")
-                json_btn = gr.Button("Export JSON")
+            history_dashboard = gr.Plot(label="History Analytics Dashboard")
             
-            history_status = gr.Textbox(label="Status")
-            history_plot = gr.Plot(label="History Trends")
-            csv_file = gr.File(label="CSV Download", visible=True)
-            json_file = gr.File(label="JSON Download", visible=True)
+            with gr.Row():
+                csv_download = gr.File(label="CSV Download", visible=True)
+                json_download = gr.File(label="JSON Download", visible=True)
         
-        # Event bindings
+        # Event Handlers
         analyze_btn.click(
             app.analyze_single,
-            inputs=[text_input, theme_selector],
-            outputs=[result_output, prob_plot, gauge_plot, wordcloud_plot, keyword_plot]
+            inputs=[text_input, language_selector, theme_selector, 
+                   clean_text_cb, remove_punct_cb, remove_nums_cb],
+            outputs=[result_output, gauge_plot, probability_plot, keyword_plot]
         )
         
-        load_btn.click(app.data_handler.process_file, inputs=file_upload, outputs=batch_input)
-        batch_btn.click(app.analyze_batch, inputs=batch_input, outputs=batch_plot)
+        load_file_btn.click(
+            app.data_handler.process_file,
+            inputs=file_upload,
+            outputs=batch_input
+        )
         
-        refresh_btn.click(
-            lambda theme: app.plot_history(theme),
-            inputs=theme_selector,
-            outputs=[history_plot, history_status]
+        analyze_batch_btn.click(
+            app.analyze_batch,
+            inputs=[batch_input, batch_language, batch_theme,
+                   batch_clean_cb, batch_punct_cb, batch_nums_cb],
+            outputs=[batch_summary, batch_results_df, batch_plot, confidence_dist_plot]
         )
         
-        clear_btn.click(
+        refresh_history_btn.click(
+            app.plot_history,
+            inputs=history_theme,
+            outputs=[history_dashboard, history_status]
+        )
+        
+        clear_history_btn.click(
             lambda: f"Cleared {app.history.clear()} entries",
             outputs=history_status
         )
         
         status_btn.click(
-            lambda: f"History: {app.history.size()} entries",
+            app.get_history_status,
             outputs=history_status
         )
         
-        csv_btn.click(
+        export_csv_btn.click(
             lambda: app.data_handler.export_data(app.history.get_all(), 'csv'),
-            outputs=[csv_file, history_status]
+            outputs=[csv_download, history_status]
         )
         
-        json_btn.click(
+        export_json_btn.click(
             lambda: app.data_handler.export_data(app.history.get_all(), 'json'),
-            outputs=[json_file, history_status]
+            outputs=[json_download, history_status]
         )
     
     return demo
 
 # Application Entry Point
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    demo = create_interface()
-    demo.launch(share=True)
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    try:
+        demo = create_interface()
+        demo.launch(
+            share=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch application: {e}")
+        raise