Update app.py

app.py

@@ -1,727 +1,1817 @@
+import torch
 import gradio as gr
-import pandas as pd
+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
-import json
+from wordcloud import WordCloud
+from collections import Counter, defaultdict, OrderedDict
 import re
+import json
+import csv
 import io
+import tempfile
 from datetime import datetime
-from typing import List, Dict, Tuple
-from transformers import pipeline, AutoTokenizer
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import sqlite3
-import hashlib
+import logging
+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
+import threading
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 import time
 
-# Initialize models
-sentiment_analyzer = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")
-absa_analyzer = pipeline("ner", model="yangheng/deberta-v3-base-absa-v1.1", aggregation_strategy="simple")
+# Advanced analysis imports
+import shap
+import lime
+from lime.lime_text import LimeTextExplainer
+
+# Configuration
+@dataclass
+class Config:
+    MAX_HISTORY_SIZE: int = 1000
+    BATCH_SIZE_LIMIT: int = 50
+    MAX_TEXT_LENGTH: int = 512
+    MIN_WORD_LENGTH: int = 2
+    CACHE_SIZE: int = 128
+    BATCH_PROCESSING_SIZE: int = 8
+    MODEL_CACHE_SIZE: int = 2  # Maximum models to keep in memory
+    
+    # Supported languages and models
+    SUPPORTED_LANGUAGES = {
+        'auto': 'Auto Detect',
+        'en': 'English',
+        'zh': 'Chinese',
+        'es': 'Spanish',
+        'fr': 'French',
+        'de': 'German',
+        'sv': 'Swedish'
+    }
+    
+    MODELS = {
+        'en': "cardiffnlp/twitter-roberta-base-sentiment-latest",
+        'multilingual': "cardiffnlp/twitter-xlm-roberta-base-sentiment",
+        'zh': "uer/roberta-base-finetuned-dianping-chinese"
+    }
+    
+    # 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"""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                logger.error(f"{func.__name__} failed: {e}")
+                return default_return if default_return is not None else f"Error: {str(e)}"
+        return wrapper
+    return decorator
+
+@contextmanager
+def memory_cleanup():
+    """Context manager for memory cleanup"""
+    try:
+        yield
+    finally:
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+class ThemeContext:
+    """Theme management context"""
+    def __init__(self, theme: str = 'default'):
+        self.theme = theme
+        self.colors = config.THEMES.get(theme, config.THEMES['default'])
+
+class LRUModelCache:
+    """LRU Cache for models with memory management"""
+    def __init__(self, max_size: int = 2):
+        self.max_size = max_size
+        self.cache = OrderedDict()
+        self.lock = threading.Lock()
+    
+    def get(self, key):
+        with self.lock:
+            if key in self.cache:
+                # Move to end (most recently used)
+                self.cache.move_to_end(key)
+                return self.cache[key]
+            return None
+    
+    def put(self, key, value):
+        with self.lock:
+            if key in self.cache:
+                self.cache.move_to_end(key)
+            else:
+                if len(self.cache) >= self.max_size:
+                    # Remove least recently used
+                    oldest_key = next(iter(self.cache))
+                    old_model, old_tokenizer = self.cache.pop(oldest_key)
+                    # Force cleanup
+                    del old_model, old_tokenizer
+                    gc.collect()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                
+                self.cache[key] = value
+    
+    def clear(self):
+        with self.lock:
+            for model, tokenizer in self.cache.values():
+                del model, tokenizer
+            self.cache.clear()
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
 
-class ReviewAnalyzer:
+# Enhanced Model Manager with Optimized Memory Management
+class ModelManager:
+    """Optimized multi-language model manager with LRU cache and lazy loading"""
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
     def __init__(self):
-        self.db_path = "reviews.db"
-        self._init_db()
-        
-    def _init_db(self):
-        conn = sqlite3.connect(self.db_path)
-        conn.execute('''
-            CREATE TABLE IF NOT EXISTS usage_log (
-                id INTEGER PRIMARY KEY,
-                user_id TEXT,
-                timestamp DATETIME,
-                analysis_type TEXT,
-                items_count INTEGER
+        if not self._initialized:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self.model_cache = LRUModelCache(config.MODEL_CACHE_SIZE)
+            self.loading_lock = threading.Lock()
+            self._initialized = True
+            logger.info(f"ModelManager initialized on device: {self.device}")
+    
+    def _load_model(self, model_name: str, cache_key: str):
+        """Load model with memory optimization"""
+        try:
+            logger.info(f"Loading model: {model_name}")
+            
+            # Load with memory optimization
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForSequenceClassification.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
             )
-        ''')
-        conn.close()
-    
-    def preprocess_text(self, text: str) -> str:
-        """Clean and preprocess review text"""
-        text = re.sub(r'http\S+', '', text)
-        text = re.sub(r'[^\w\s]', '', text)
-        text = text.strip().lower()
-        return text
-    
-    def extract_aspect_keywords(self, reviews: List[str]) -> Dict:
-        """Extract aspect-based sentiment keywords"""
-        all_aspects = {'positive': {}, 'negative': {}}
-        detailed_aspects = []
-        
-        for review in reviews:
-            if not review.strip() or len(review) < 10:
-                continue
-                
-            try:
-                aspects = absa_analyzer(review)
-                for aspect in aspects:
-                    word = aspect['word'].lower()
-                    label = aspect['entity_group'].lower()
-                    confidence = aspect['score']
-                    
-                    # Map labels to sentiment
-                    if 'pos' in label or label == 'positive':
-                        sentiment = 'positive'
-                    elif 'neg' in label or label == 'negative':
-                        sentiment = 'negative'
-                    else:
-                        continue
-                    
-                    # Count aspects
-                    if word not in all_aspects[sentiment]:
-                        all_aspects[sentiment][word] = 0
-                    all_aspects[sentiment][word] += 1
-                    
-                    detailed_aspects.append({
-                        'review': review[:50] + '...',
-                        'aspect': word,
-                        'sentiment': sentiment,
-                        'confidence': round(confidence, 3)
-                    })
-            except:
-                continue
+            
+            if not torch.cuda.is_available():
+                model.to(self.device)
+            
+            # Set to eval mode to save memory
+            model.eval()
+            
+            # Cache the model
+            self.model_cache.put(cache_key, (model, tokenizer))
+            logger.info(f"Model {model_name} loaded and cached successfully")
+            
+            return model, tokenizer
+            
+        except Exception as e:
+            logger.error(f"Failed to load model {model_name}: {e}")
+            raise
+    
+    def get_model(self, language='en'):
+        """Get model for specific language with lazy loading and caching"""
+        # Determine cache key and model name
+        if language == 'zh':
+            cache_key = 'zh'
+            model_name = config.MODELS['zh']
+        else:
+            cache_key = 'multilingual'
+            model_name = config.MODELS['multilingual']
         
-        # Get top aspects
-        top_positive = sorted(all_aspects['positive'].items(), key=lambda x: x[1], reverse=True)[:10]
-        top_negative = sorted(all_aspects['negative'].items(), key=lambda x: x[1], reverse=True)[:10]
+        # Try to get from cache first
+        cached_model = self.model_cache.get(cache_key)
+        if cached_model is not None:
+            return cached_model
         
-        return {
-            'top_positive_aspects': top_positive,
-            'top_negative_aspects': top_negative,
-            'detailed_aspects': detailed_aspects,
-            'summary': {
-                'total_positive_aspects': len(all_aspects['positive']),
-                'total_negative_aspects': len(all_aspects['negative'])
+        # Load model if not in cache (with thread safety)
+        with self.loading_lock:
+            # Double-check pattern
+            cached_model = self.model_cache.get(cache_key)
+            if cached_model is not None:
+                return cached_model
+            
+            return self._load_model(model_name, cache_key)
+    
+    @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 Text Processing
+class TextProcessor:
+    """Optimized text processing with multi-language support"""
     
-    def analyze_sentiment(self, reviews: List[str]) -> Dict:
-        """Analyze sentiment of reviews with keyword extraction"""
-        results = []
-        sentiments = {'positive': 0, 'negative': 0, 'neutral': 0}
+    @staticmethod
+    @lru_cache(maxsize=config.CACHE_SIZE)
+    def clean_text(text: str, remove_punctuation: bool = True, remove_numbers: bool = False) -> str:
+        """Clean text with language awareness"""
+        text = text.strip()
         
-        for review in reviews:
-            if not review.strip():
-                continue
-                
-            clean_review = self.preprocess_text(review)
-            result = sentiment_analyzer(clean_review)[0]
-            
-            label = result['label'].lower()
-            score = result['score']
-            
-            if 'pos' in label:
-                sentiment = 'positive'
-            elif 'neg' in label:
-                sentiment = 'negative'
-            else:
-                sentiment = 'neutral'
-            
-            sentiments[sentiment] += 1
-            results.append({
-                'text': review[:100] + '...' if len(review) > 100 else review,
-                'sentiment': sentiment,
-                'confidence': round(score, 3)
-            })
+        # Don't clean Chinese text aggressively
+        if re.search(r'[\u4e00-\u9fff]', text):
+            return text
         
-        total = len(results)
-        sentiment_percentages = {k: round(v/total*100, 1) for k, v in sentiments.items()}
+        text = text.lower()
         
-        # Extract keywords
-        keywords = self.extract_aspect_keywords(reviews)
+        if remove_numbers:
+            text = re.sub(r'\d+', '', text)
         
-        return {
-            'summary': sentiment_percentages,
-            'details': results,
-            'total_reviews': total,
-            'keywords': keywords
-        }
+        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 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:
+    """Enhanced history management with filtering"""
+    def __init__(self):
+        self._history = []
+    
+    def add(self, entry: Dict):
+        """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 detect_fake_reviews(self, reviews: List[str], metadata: Dict = None) -> Dict:
-        """Detect potentially fake reviews with optional metadata"""
-        fake_scores = []
+    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
         
-        # Process metadata if provided
-        metadata_flags = []
-        if metadata and 'timestamps' in metadata and 'usernames' in metadata:
-            metadata_flags = self._analyze_metadata(metadata['timestamps'], metadata['usernames'])
+        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()
+        return count
+    
+    def size(self) -> int:
+        return len(self._history)
+    
+    def get_stats(self) -> Dict:
+        """Get comprehensive statistics"""
+        if not self._history:
+            return {}
         
-        for i, review in enumerate(reviews):
-            if not review.strip():
-                continue
-                
-            score = 0
-            flags = []
-            
-            # Text-based checks
-            if len(review) < 20:
-                score += 0.3
-                flags.append("too_short")
-            
-            words = review.lower().split()
-            unique_ratio = len(set(words)) / len(words) if words else 0
-            if unique_ratio < 0.5:
-                score += 0.4
-                flags.append("repetitive")
-            
-            punct_ratio = len(re.findall(r'[!?.]', review)) / len(review) if review else 0
-            if punct_ratio > 0.1:
-                score += 0.2
-                flags.append("excessive_punctuation")
-            
-            generic_phrases = ['amazing', 'perfect', 'best ever', 'highly recommend']
-            if any(phrase in review.lower() for phrase in generic_phrases):
-                score += 0.1
-                flags.append("generic_language")
-            
-            # Add metadata flags if available
-            if i < len(metadata_flags):
-                if metadata_flags[i]:
-                    score += 0.3
-                    flags.extend(metadata_flags[i])
-            
-            fake_scores.append({
-                'text': review[:100] + '...' if len(review) > 100 else review,
-                'fake_probability': min(round(score, 3), 1.0),
-                'status': 'suspicious' if score > 0.5 else 'authentic',
-                'flags': flags
-            })
-        
-        suspicious_count = sum(1 for item in fake_scores if item['fake_probability'] > 0.5)
+        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 {
-            'summary': {
-                'total_reviews': len(fake_scores),
-                'suspicious_reviews': suspicious_count,
-                'authenticity_rate': round((len(fake_scores) - suspicious_count) / len(fake_scores) * 100, 1) if fake_scores else 0
-            },
-            'details': fake_scores,
-            'metadata_analysis': metadata_flags if metadata_flags else None
+            '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 Sentiment Analysis Engine with Performance Optimizations
+class SentimentEngine:
+    """Optimized multi-language sentiment analysis engine"""
+    
+    def __init__(self):
+        self.model_manager = ModelManager()
+        self.executor = ThreadPoolExecutor(max_workers=4)
     
-    def _analyze_metadata(self, timestamps: List[str], usernames: List[str]) -> List[List[str]]:
-        """Analyze metadata for suspicious patterns"""
-        flags_per_review = [[] for _ in range(len(timestamps))]
+    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0})
+    def analyze_single(self, text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
+        """Optimized single text analysis"""
+        if not text.strip():
+            raise ValueError("Empty text provided")
         
-        # Time density analysis
-        if len(timestamps) >= 5:
-            times = []
-            for i, ts in enumerate(timestamps):
-                try:
-                    dt = datetime.strptime(ts, "%Y-%m-%d %H:%M:%S")
-                    times.append((i, dt))
-                except:
-                    continue
-            
-            times.sort(key=lambda x: x[1])
-            
-            # Check for clusters
-            for i in range(len(times) - 5):
-                if (times[i + 5][1] - times[i][1]).total_seconds() < 300:  # 5 mins
-                    for j in range(i, i + 6):
-                        flags_per_review[times[j][0]].append("time_cluster")
-        
-        # Username pattern analysis
-        for i, username in enumerate(usernames):
-            if re.match(r"user_\d{4,}", username):
-                flags_per_review[i].append("suspicious_username")
-            if len(username) < 4:
-                flags_per_review[i].append("short_username")
-        
-        return flags_per_review
-    
-    def assess_quality(self, reviews: List[str], custom_weights: Dict = None) -> Tuple[Dict, go.Figure]:
-        """Assess review quality with customizable weights and radar chart"""
-        default_weights = {
-            'length': 0.25,
-            'detail': 0.25,
-            'structure': 0.25,
-            'helpfulness': 0.25
-        }
+        # Detect language
+        if language == 'auto':
+            detected_lang = self.model_manager.detect_language(text)
+        else:
+            detected_lang = language
         
-        weights = custom_weights if custom_weights else default_weights
-        quality_scores = []
+        # Get appropriate model
+        model, tokenizer = self.model_manager.get_model(detected_lang)
         
-        for review in reviews:
-            if not review.strip():
-                continue
-                
-            factors = {}
-            
-            # Length factor
-            length_score = min(len(review) / 200, 1.0)
-            factors['length'] = round(length_score, 2)
-            
-            # Detail factor
-            detail_words = ['because', 'however', 'although', 'specifically', 'particularly']
-            detail_score = min(sum(1 for word in detail_words if word in review.lower()) / 3, 1.0)
-            factors['detail'] = round(detail_score, 2)
-            
-            # Structure factor
-            sentences = len(re.split(r'[.!?]', review))
-            structure_score = min(sentences / 5, 1.0)
-            factors['structure'] = round(structure_score, 2)
-            
-            # Helpfulness factor
-            helpful_words = ['pros', 'cons', 'recommend', 'suggest', 'tip', 'advice']
-            helpful_score = min(sum(1 for word in helpful_words if word in review.lower()) / 2, 1.0)
-            factors['helpfulness'] = round(helpful_score, 2)
-            
-            # Calculate weighted score
-            total_score = sum(factors[k] * weights[k] for k in factors.keys())
-            
-            quality_scores.append({
-                'text': review[:100] + '...' if len(review) > 100 else review,
-                'quality_score': round(total_score, 3),
-                'factors': factors,
-                'grade': 'A' if total_score > 0.8 else 'B' if total_score > 0.6 else 'C' if total_score > 0.4 else 'D'
-            })
-        
-        avg_quality = sum(item['quality_score'] for item in quality_scores) / len(quality_scores) if quality_scores else 0
-        
-        # Create radar chart for average factors
-        avg_factors = {}
-        for factor in ['length', 'detail', 'structure', 'helpfulness']:
-            avg_factors[factor] = sum(item['factors'][factor] for item in quality_scores) / len(quality_scores) if quality_scores else 0
-        
-        fig = go.Figure()
-        fig.add_trace(go.Scatterpolar(
-            r=list(avg_factors.values()),
-            theta=list(avg_factors.keys()),
-            fill='toself',
-            name='Quality Factors'
-        ))
+        # 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)
+            )
         
-        fig.update_layout(
-            polar=dict(
-                radialaxis=dict(
-                    visible=True,
-                    range=[0, 1]
-                )),
-            showlegend=True,
-            title="Average Quality Factors"
-        )
+        # Tokenize and analyze with memory optimization
+        inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
+                         truncation=True, max_length=config.MAX_TEXT_LENGTH).to(self.model_manager.device)
         
-        return {
-            'summary': {
-                'average_quality': round(avg_quality, 3),
-                'total_reviews': len(quality_scores),
-                'high_quality_count': sum(1 for item in quality_scores if item['quality_score'] > 0.7),
-                'weights_used': weights
-            },
-            'details': quality_scores,
-            'factor_averages': avg_factors
-        }, fig
-    
-    def compare_competitors(self, product_a_reviews: List[str], product_b_reviews: List[str]) -> Tuple[Dict, go.Figure]:
-        """Compare sentiment between two products"""
-        analysis_a = self.analyze_sentiment(product_a_reviews)
-        analysis_b = self.analyze_sentiment(product_b_reviews)
+        # Use no_grad for inference to save memory
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
         
-        fig = make_subplots(
-            rows=1, cols=2,
-            specs=[[{'type': 'pie'}, {'type': 'pie'}]],
-            subplot_titles=['Product A', 'Product B']
-        )
+        # Clear GPU cache after inference
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         
-        fig.add_trace(go.Pie(
-            labels=list(analysis_a['summary'].keys()),
-            values=list(analysis_a['summary'].values()),
-            name="Product A"
-        ), row=1, col=1)
+        # 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
+            }
         
-        fig.add_trace(go.Pie(
-            labels=list(analysis_b['summary'].keys()),
-            values=list(analysis_b['summary'].values()),
-            name="Product B"
-        ), row=1, col=2)
+        # Add metadata
+        result.update({
+            'language': detected_lang,
+            'word_count': len(text.split()),
+            'char_count': len(text)
+        })
         
-        fig.update_layout(title_text="Sentiment Comparison")
+        return result
+    
+    def _analyze_text_batch(self, text: str, language: str, preprocessing_options: Dict, index: int) -> Dict:
+        """Single text analysis for batch processing"""
+        try:
+            result = self.analyze_single(text, language, preprocessing_options)
+            result['batch_index'] = index
+            result['text'] = text[:100] + '...' if len(text) > 100 else text
+            result['full_text'] = text
+            return result
+        except Exception as e:
+            return {
+                'sentiment': 'Error',
+                'confidence': 0.0,
+                'error': str(e),
+                'batch_index': index,
+                'text': text[:100] + '...' if len(text) > 100 else text,
+                'full_text': text
+            }
+
+    
+    @handle_errors(default_return=[])
+    def analyze_batch(self, texts: List[str], language: str = 'auto', 
+                     preprocessing_options: Dict = None, progress_callback=None) -> List[Dict]:
+        """Optimized parallel batch processing"""
+        if len(texts) > config.BATCH_SIZE_LIMIT:
+            texts = texts[:config.BATCH_SIZE_LIMIT]
         
-        comparison = {
-            'product_a': analysis_a,
-            'product_b': analysis_b,
-            'winner': 'Product A' if analysis_a['summary']['positive'] > analysis_b['summary']['positive'] else 'Product B'
-        }
+        if not texts:
+            return []
         
-        return comparison, fig
-    
-    def generate_report(self, analysis_data: Dict, report_type: str = "basic") -> str:
-        """Generate analysis report with export capability"""
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        # Pre-load model to avoid race conditions
+        self.model_manager.get_model(language if language != 'auto' else 'en')
         
-        if report_type == "sentiment":
-            keywords = analysis_data.get('keywords', {})
-            top_pos = keywords.get('top_positive_aspects', [])[:5]
-            top_neg = keywords.get('top_negative_aspects', [])[:5]
+        # Use ThreadPoolExecutor for parallel processing
+        with ThreadPoolExecutor(max_workers=min(4, len(texts))) as executor:
+            futures = []
+            for i, text in enumerate(texts):
+                future = executor.submit(
+                    self._analyze_text_batch, 
+                    text, language, preprocessing_options, i
+                )
+                futures.append(future)
             
-            return f"""# Sentiment Analysis Report
-Generated: {timestamp}
-
-## Summary
-- Total Reviews: {analysis_data.get('total_reviews', 0)}
-- Positive: {analysis_data.get('summary', {}).get('positive', 0)}%
-- Negative: {analysis_data.get('summary', {}).get('negative', 0)}%
-- Neutral: {analysis_data.get('summary', {}).get('neutral', 0)}%
-
-## Top Positive Aspects
-{chr(10).join([f"- {aspect[0]} (mentioned {aspect[1]} times)" for aspect in top_pos])}
-
-## Top Negative Aspects  
-{chr(10).join([f"- {aspect[0]} (mentioned {aspect[1]} times)" for aspect in top_neg])}
-
-## Key Insights
-- Overall sentiment: {'Positive' if analysis_data.get('summary', {}).get('positive', 0) > 50 else 'Mixed'}
-- Main complaints: {', '.join([aspect[0] for aspect in top_neg[:3]])}
-- Key strengths: {', '.join([aspect[0] for aspect in top_pos[:3]])}
-
-## Recommendations
-- Address negative aspects: {', '.join([aspect[0] for aspect in top_neg[:2]])}
-- Leverage positive aspects in marketing
-- Monitor sentiment trends over time
-"""
-        
-        elif report_type == "fake":
-            return f"""# Fake Review Detection Report
-Generated: {timestamp}
-
-## Summary
-- Total Reviews: {analysis_data.get('summary', {}).get('total_reviews', 0)}
-- Suspicious Reviews: {analysis_data.get('summary', {}).get('suspicious_reviews', 0)}
-- Authenticity Rate: {analysis_data.get('summary', {}).get('authenticity_rate', 0)}%
-
-## Risk Assessment
-- Overall Risk: {'High' if analysis_data.get('summary', {}).get('authenticity_rate', 0) < 70 else 'Low'}
-- Action Required: {'Yes' if analysis_data.get('summary', {}).get('suspicious_reviews', 0) > 0 else 'No'}
-
-## Common Fraud Indicators
-- Short reviews with generic language
-- Repetitive content patterns
-- Suspicious timing clusters
-- Unusual username patterns
-"""
+            results = []
+            for i, future in enumerate(futures):
+                if progress_callback:
+                    progress_callback((i + 1) / len(futures))
+                
+                try:
+                    result = future.result(timeout=30)  # 30 second timeout per text
+                    results.append(result)
+                except Exception as e:
+                    results.append({
+                        'sentiment': 'Error',
+                        'confidence': 0.0,
+                        'error': f"Timeout or error: {str(e)}",
+                        'batch_index': i,
+                        'text': texts[i][:100] + '...' if len(texts[i]) > 100 else texts[i],
+                        'full_text': texts[i]
+                    })
         
-        return "Report generated successfully"
-
-# Global analyzer instance
-analyzer = ReviewAnalyzer()
+        return results
 
-def process_reviews_input(text: str) -> List[str]:
-    """Process review input text into list"""
-    if not text.strip():
-        return []
+class AdvancedAnalysisEngine:
+    """Advanced analysis using SHAP and LIME with FIXED implementation"""
     
-    reviews = []
-    for line in text.split('\n'):
-        line = line.strip()
-        if line and len(line) > 10:
-            reviews.append(line)
-    
-    return reviews
-
-def process_csv_upload(file) -> Tuple[List[str], Dict]:
-    """Process uploaded CSV file"""
-    if file is None:
-        return [], {}
+    def __init__(self):
+        self.model_manager = ModelManager()
     
-    try:
-        df = pd.read_csv(file.name)
+    def create_prediction_function(self, model, tokenizer, device):
+        """Create FIXED prediction function for SHAP/LIME"""
+        def predict_proba(texts):
+            # Ensure texts is a list
+            if isinstance(texts, str):
+                texts = [texts]
+            elif isinstance(texts, np.ndarray):
+                texts = texts.tolist()
+            
+            # Convert all elements to strings
+            texts = [str(text) for text in texts]
+            
+            results = []
+            batch_size = 16  # Process in smaller batches
+            
+            for i in range(0, len(texts), batch_size):
+                batch_texts = texts[i:i + batch_size]
+                
+                try:
+                    with torch.no_grad():
+                        # Tokenize batch
+                        inputs = tokenizer(
+                            batch_texts, 
+                            return_tensors="pt", 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=config.MAX_TEXT_LENGTH
+                        ).to(device)
+                        
+                        # Batch inference
+                        outputs = model(**inputs)
+                        probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
+                        
+                        results.extend(probs)
+                        
+                except Exception as e:
+                    logger.error(f"Prediction batch failed: {e}")
+                    # Return neutral predictions for failed batch
+                    batch_size_actual = len(batch_texts)
+                    if hasattr(model.config, 'num_labels') and model.config.num_labels == 3:
+                        neutral_probs = np.array([[0.33, 0.34, 0.33]] * batch_size_actual)
+                    else:
+                        neutral_probs = np.array([[0.5, 0.5]] * batch_size_actual)
+                    results.extend(neutral_probs)
+            
+            return np.array(results)
         
-        # Look for common column names
-        review_col = None
-        time_col = None
-        user_col = None
+        return predict_proba
+    
+    @handle_errors(default_return=("Analysis failed", None, None))
+    def analyze_with_shap(self, text: str, language: str = 'auto', num_samples: int = 100) -> Tuple[str, go.Figure, Dict]:
+        """FIXED SHAP analysis implementation"""
+        if not text.strip():
+            return "Please enter text for analysis", None, {}
         
-        for col in df.columns:
-            col_lower = col.lower()
-            if 'review' in col_lower or 'comment' in col_lower or 'text' in col_lower:
-                review_col = col
-            elif 'time' in col_lower or 'date' in col_lower:
-                time_col = col
-            elif 'user' in col_lower or 'name' in col_lower:
-                user_col = col
+        # Detect language and get model
+        if language == 'auto':
+            detected_lang = self.model_manager.detect_language(text)
+        else:
+            detected_lang = language
         
-        if review_col is None:
-            return [], {"error": "No review column found. Expected columns: 'review', 'comment', or 'text'"}
+        model, tokenizer = self.model_manager.get_model(detected_lang)
         
-        reviews = df[review_col].dropna().astype(str).tolist()
+        try:
+            # Create FIXED prediction function
+            predict_fn = self.create_prediction_function(model, tokenizer, self.model_manager.device)
+            
+            # Test the prediction function first
+            test_pred = predict_fn([text])
+            if test_pred is None or len(test_pred) == 0:
+                return "Prediction function test failed", None, {}
+            
+            # Use SHAP Text Explainer instead of generic Explainer
+            explainer = shap.Explainer(predict_fn, masker=shap.maskers.Text(tokenizer))
+            
+            # Get SHAP values with proper text input
+            shap_values = explainer([text], max_evals=num_samples)
+            
+            # Extract data safely
+            if hasattr(shap_values, 'data') and hasattr(shap_values, 'values'):
+                tokens = shap_values.data[0] if len(shap_values.data) > 0 else []
+                values = shap_values.values[0] if len(shap_values.values) > 0 else []
+            else:
+                return "SHAP values extraction failed", None, {}
+            
+            if len(tokens) == 0 or len(values) == 0:
+                return "No tokens or values extracted from SHAP", None, {}
+            
+            # Handle multi-dimensional values
+            if len(values.shape) > 1:
+                # Use positive class values (last column for 3-class, second for 2-class)
+                pos_values = values[:, -1] if values.shape[1] >= 2 else values[:, 0]
+            else:
+                pos_values = values
+            
+            # Ensure we have matching lengths
+            min_len = min(len(tokens), len(pos_values))
+            tokens = tokens[:min_len]
+            pos_values = pos_values[:min_len]
+            
+            # Create visualization
+            fig = go.Figure()
+            
+            colors = ['red' if v < 0 else 'green' for v in pos_values]
+            
+            fig.add_trace(go.Bar(
+                x=list(range(len(tokens))),
+                y=pos_values,
+                text=tokens,
+                textposition='outside',
+                marker_color=colors,
+                name='SHAP Values',
+                hovertemplate='<b>%{text}</b><br>SHAP Value: %{y:.4f}<extra></extra>'
+            ))
+            
+            fig.update_layout(
+                title=f"SHAP Analysis - Token Importance (Samples: {num_samples})",
+                xaxis_title="Token Index",
+                yaxis_title="SHAP Value",
+                height=500,
+                xaxis=dict(tickmode='array', tickvals=list(range(len(tokens))), ticktext=tokens)
+            )
+            
+            # Create analysis summary
+            analysis_data = {
+                'method': 'SHAP',
+                'language': detected_lang,
+                'total_tokens': len(tokens),
+                'samples_used': num_samples,
+                'positive_influence': sum(1 for v in pos_values if v > 0),
+                'negative_influence': sum(1 for v in pos_values if v < 0),
+                'most_important_tokens': [(str(tokens[i]), float(pos_values[i])) 
+                                        for i in np.argsort(np.abs(pos_values))[-5:]]
+            }
+            
+            summary_text = f"""
+**SHAP Analysis Results:**
+- **Language:** {detected_lang.upper()}
+- **Total Tokens:** {analysis_data['total_tokens']}
+- **Samples Used:** {num_samples}
+- **Positive Influence Tokens:** {analysis_data['positive_influence']}
+- **Negative Influence Tokens:** {analysis_data['negative_influence']}
+- **Most Important Tokens:** {', '.join([f"{token}({score:.3f})" for token, score in analysis_data['most_important_tokens']])}
+- **Status:** SHAP analysis completed successfully
+            """
+            
+            return summary_text, fig, analysis_data
+            
+        except Exception as e:
+            logger.error(f"SHAP analysis failed: {e}")
+            error_msg = f"""
+**SHAP Analysis Failed:**
+- **Error:** {str(e)}
+- **Language:** {detected_lang.upper()}
+- **Suggestion:** Try with a shorter text or reduce number of samples
+
+**Common fixes:**
+- Reduce sample size to 50-100
+- Use shorter input text (< 200 words)
+- Check if model supports the text language
+            """
+            return error_msg, None, {}
+    
+    @handle_errors(default_return=("Analysis failed", None, None))
+    def analyze_with_lime(self, text: str, language: str = 'auto', num_samples: int = 100) -> Tuple[str, go.Figure, Dict]:
+        """FIXED LIME analysis implementation - Bug Fix for mode parameter"""
+        if not text.strip():
+            return "Please enter text for analysis", None, {}
         
-        metadata = {}
-        if time_col:
-            metadata['timestamps'] = df[time_col].dropna().astype(str).tolist()
-        if user_col:
-            metadata['usernames'] = df[user_col].dropna().astype(str).tolist()
+        # Detect language and get model
+        if language == 'auto':
+            detected_lang = self.model_manager.detect_language(text)
+        else:
+            detected_lang = language
         
-        return reviews, metadata
+        model, tokenizer = self.model_manager.get_model(detected_lang)
         
-    except Exception as e:
-        return [], {"error": f"Failed to process CSV: {str(e)}"}
+        try:
+            # Create FIXED prediction function
+            predict_fn = self.create_prediction_function(model, tokenizer, self.model_manager.device)
+            
+            # Test the prediction function first
+            test_pred = predict_fn([text])
+            if test_pred is None or len(test_pred) == 0:
+                return "Prediction function test failed", None, {}
+            
+            # Determine class names based on model output
+            num_classes = test_pred.shape[1] if len(test_pred.shape) > 1 else 2
+            if num_classes == 3:
+                class_names = ['Negative', 'Neutral', 'Positive']
+            else:
+                class_names = ['Negative', 'Positive']
+            
+            # Initialize LIME explainer - FIXED: Remove 'mode' parameter
+            explainer = LimeTextExplainer(class_names=class_names)
+            
+            # Get LIME explanation
+            exp = explainer.explain_instance(
+                text, 
+                predict_fn, 
+                num_features=min(20, len(text.split())),  # Limit features
+                num_samples=num_samples
+            )
+            
+            # Extract feature importance
+            lime_data = exp.as_list()
+            
+            if not lime_data:
+                return "No LIME features extracted", None, {}
+            
+            # Create visualization
+            words = [item[0] for item in lime_data]
+            scores = [item[1] for item in lime_data]
+            
+            fig = go.Figure()
+            
+            colors = ['red' if s < 0 else 'green' for s in scores]
+            
+            fig.add_trace(go.Bar(
+                y=words,
+                x=scores,
+                orientation='h',
+                marker_color=colors,
+                text=[f'{s:.3f}' for s in scores],
+                textposition='auto',
+                name='LIME Importance',
+                hovertemplate='<b>%{y}</b><br>Importance: %{x:.4f}<extra></extra>'
+            ))
+            
+            fig.update_layout(
+                title=f"LIME Analysis - Feature Importance (Samples: {num_samples})",
+                xaxis_title="Importance Score",
+                yaxis_title="Words/Phrases",
+                height=500
+            )
+            
+            # Create analysis summary
+            analysis_data = {
+                'method': 'LIME',
+                'language': detected_lang,
+                'features_analyzed': len(lime_data),
+                'samples_used': num_samples,
+                'positive_features': sum(1 for _, score in lime_data if score > 0),
+                'negative_features': sum(1 for _, score in lime_data if score < 0),
+                'feature_importance': lime_data
+            }
+            
+            summary_text = f"""
+**LIME Analysis Results:**
+- **Language:** {detected_lang.upper()}
+- **Features Analyzed:** {analysis_data['features_analyzed']}
+- **Classes:** {', '.join(class_names)}
+- **Samples Used:** {num_samples}
+- **Positive Features:** {analysis_data['positive_features']}
+- **Negative Features:** {analysis_data['negative_features']}
+- **Top Features:** {', '.join([f"{word}({score:.3f})" for word, score in lime_data[:5]])}
+- **Status:** LIME analysis completed successfully 
+            """
+            
+            return summary_text, fig, analysis_data
+            
+        except Exception as e:
+            logger.error(f"LIME analysis failed: {e}")
+            error_msg = f"""
+**LIME Analysis Failed:**
+- **Error:** {str(e)}
+- **Language:** {detected_lang.upper()}
+- **Suggestion:** Try with a shorter text or reduce number of samples
 
-def sentiment_analysis_interface(reviews_text: str, csv_file):
-    """Interface for sentiment analysis"""
-    reviews = []
-    
-    if csv_file is not None:
-        reviews, metadata = process_csv_upload(csv_file)
-        if 'error' in metadata:
-            return metadata['error'], None
-    else:
-        reviews = process_reviews_input(reviews_text)
+**Bug Fix Applied:**
+- ✅ Removed 'mode' parameter from LimeTextExplainer initialization
+- ✅ This should resolve the "unexpected keyword argument 'mode'" error
+
+**Common fixes:**
+- Reduce sample size to 50-100
+- Use shorter input text (< 200 words)  
+- Check if model supports the text language
+            """
+            return error_msg, None, {}
+
+# Optimized Plotly Visualization System
+class PlotlyVisualizer:
+    """Enhanced Plotly visualizations"""
     
-    if not reviews:
-        return "Please enter reviews or upload a CSV file.", None
+    @staticmethod
+    @handle_errors(default_return=None)
+    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
+
+
+
+
     
-    try:
-        result = analyzer.analyze_sentiment(reviews)
+    @staticmethod
+    @handle_errors(default_return=None)
+    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=list(result['summary'].keys()), 
-                   y=list(result['summary'].values()),
-                   marker_color=['green', 'red', 'gray'])
+            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 Distribution", yaxis_title="Percentage")
         
-        return json.dumps(result, indent=2), fig
-    except Exception as e:
-        return f"Error: {str(e)}", None
+        fig.update_layout(
+            title="Sentiment Probabilities",
+            yaxis_title="Probability",
+            height=400,
+            showlegend=False
+        )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-def fake_detection_interface(reviews_text: str, csv_file):
-    """Interface for fake review detection"""
-    reviews = []
-    metadata = {}
-    
-    if csv_file is not None:
-        reviews, metadata = process_csv_upload(csv_file)
-        if 'error' in metadata:
-            return metadata['error']
-    else:
-        reviews = process_reviews_input(reviews_text)
-    
-    if not reviews:
-        return "Please enter reviews or upload a CSV file."
-    
-    try:
-        result = analyzer.detect_fake_reviews(reviews, metadata if metadata else None)
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        return f"Error: {str(e)}"
 
-def quality_assessment_interface(reviews_text: str, csv_file, length_weight: float, detail_weight: float, structure_weight: float, help_weight: float):
-    """Interface for quality assessment with custom weights"""
-    reviews = []
-    
-    if csv_file is not None:
-        reviews, metadata = process_csv_upload(csv_file)
-        if 'error' in metadata:
-            return metadata['error'], None
-    else:
-        reviews = process_reviews_input(reviews_text)
-    
-    if not reviews:
-        return "Please enter reviews or upload a CSV file.", None
-    
-    try:
-        custom_weights = {
-            'length': length_weight,
-            'detail': detail_weight,
-            'structure': structure_weight,
-            'helpfulness': help_weight
-        }
         
-        result, radar_fig = analyzer.assess_quality(reviews, custom_weights)
-        return json.dumps(result, indent=2), radar_fig
-    except Exception as e:
-        return f"Error: {str(e)}", None
+        return fig
+
+
+
+
+
+
 
-def competitor_comparison_interface(product_a_text: str, product_b_text: str):
-    """Interface for competitor comparison"""
-    if not product_a_text.strip() or not product_b_text.strip():
-        return "Please enter reviews for both products.", None
-    
-    reviews_a = process_reviews_input(product_a_text)
-    reviews_b = process_reviews_input(product_b_text)
-    
-    if not reviews_a or not reviews_b:
-        return "Please provide valid reviews for both products.", None
-    
-    try:
-        result, fig = analyzer.compare_competitors(reviews_a, reviews_b)
-        return json.dumps(result, indent=2), fig
-    except Exception as e:
-        return f"Error: {str(e)}", None
 
-def generate_report_interface(analysis_result: str, report_type: str):
-    """Interface for report generation"""
-    if not analysis_result.strip():
-        return "No analysis data available. Please run an analysis first."
-    
-    try:
-        data = json.loads(analysis_result)
-        report = analyzer.generate_report(data, report_type.lower())
-        return report
-    except Exception as e:
-        return f"Error generating report: {str(e)}"
-
-# Create Gradio interface
-with gr.Blocks(title="SmartReview Pro", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🛒 SmartReview Pro")
-    gr.Markdown("Advanced review analysis platform with AI-powered insights")
-    
-    with gr.Tab("📊 Sentiment Analysis"):
-        gr.Markdown("### Analyze customer sentiment and extract key aspects")
-        with gr.Row():
-            with gr.Column():
-                sentiment_input = gr.Textbox(
-                    lines=8,
-                    placeholder="Enter reviews (one per line) or upload CSV...",
-                    label="Reviews"
-                )
-                sentiment_csv = gr.File(
-                    label="Upload CSV (columns: review/comment/text, optional: timestamp, username)",
-                    file_types=[".csv"]
-                )
-                sentiment_btn = gr.Button("Analyze Sentiment", variant="primary")
-            with gr.Column():
-                sentiment_output = gr.Textbox(label="Analysis Results", lines=15)
-                sentiment_chart = gr.Plot(label="Sentiment Distribution")
-        
-        sentiment_btn.click(
-            sentiment_analysis_interface,
-            inputs=[sentiment_input, sentiment_csv],
-            outputs=[sentiment_output, sentiment_chart]
-        )
-    
-    with gr.Tab("🔍 Fake Review Detection"):
-        gr.Markdown("### Detect suspicious reviews using text analysis and metadata")
-        with gr.Row():
-            with gr.Column():
-                fake_input = gr.Textbox(
-                    lines=8,
-                    placeholder="Enter reviews to analyze...",
-                    label="Reviews"
-                )
-                fake_csv = gr.File(
-                    label="Upload CSV (supports timestamp & username analysis)",
-                    file_types=[".csv"]
-                )
-                fake_btn = gr.Button("Detect Fake Reviews", variant="primary")
-            with gr.Column():
-                fake_output = gr.Textbox(label="Detection Results", lines=15)
-        
-        fake_btn.click(
-            fake_detection_interface,
-            inputs=[fake_input, fake_csv],
-            outputs=[fake_output]
-        )
-    
-    with gr.Tab("⭐ Quality Assessment"):
-        gr.Markdown("### Assess review quality with customizable weights")
-        with gr.Row():
-            with gr.Column():
-                quality_input = gr.Textbox(
-                    lines=8,
-                    placeholder="Enter reviews to assess...",
-                    label="Reviews"
-                )
-                quality_csv = gr.File(
-                    label="Upload CSV",
-                    file_types=[".csv"]
-                )
-                
-                gr.Markdown("**Customize Quality Weights:**")
-                with gr.Row():
-                    length_weight = gr.Slider(0, 1, 0.25, label="Length Weight")
-                    detail_weight = gr.Slider(0, 1, 0.25, label="Detail Weight")
-                with gr.Row():
-                    structure_weight = gr.Slider(0, 1, 0.25, label="Structure Weight")
-                    help_weight = gr.Slider(0, 1, 0.25, label="Helpfulness Weight")
-                
-                quality_btn = gr.Button("Assess Quality", variant="primary")
-            with gr.Column():
-                quality_output = gr.Textbox(label="Quality Assessment", lines=12)
-                quality_radar = gr.Plot(label="Quality Factors Radar Chart")
-        
-        quality_btn.click(
-            quality_assessment_interface,
-            inputs=[quality_input, quality_csv, length_weight, detail_weight, structure_weight, help_weight],
-            outputs=[quality_output, quality_radar]
-        )
     
-    with gr.Tab("🆚 Competitor Comparison"):
-        gr.Markdown("### Compare sentiment between competing products")
-        with gr.Row():
-            with gr.Column():
-                comp_product_a = gr.Textbox(
-                    lines=8,
-                    placeholder="Product A reviews...",
-                    label="Product A Reviews"
-                )
-                comp_product_b = gr.Textbox(
-                    lines=8,
-                    placeholder="Product B reviews...",
-                    label="Product B Reviews"
-                )
-                comp_btn = gr.Button("Compare Products", variant="primary")
-            with gr.Column():
-                comp_output = gr.Textbox(label="Comparison Results", lines=15)
-                comp_chart = gr.Plot(label="Comparison Chart")
-        
-        comp_btn.click(
-            competitor_comparison_interface,
-            inputs=[comp_product_a, comp_product_b],
-            outputs=[comp_output, comp_chart]
+    @staticmethod
+    @handle_errors(default_return=None)
+    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
     
-    with gr.Tab("📋 Report Generation"):
-        gr.Markdown("### Generate professional analysis reports")
-        with gr.Row():
-            with gr.Column():
-                report_data = gr.Textbox(
-                    lines=10,
-                    placeholder="Paste analysis results here...",
-                    label="Analysis Data (JSON)"
-                )
-                report_type = gr.Dropdown(
-                    choices=["sentiment", "fake", "quality"],
-                    value="sentiment",
-                    label="Report Type"
-                )
-                report_btn = gr.Button("Generate Report", variant="primary")
-            with gr.Column():
-                report_output = gr.Textbox(label="Generated Report", lines=15)
-        
-        report_btn.click(
-            generate_report_interface,
-            inputs=[report_data, report_type],
-            outputs=[report_output]
+    @staticmethod
+    @handle_errors(default_return=None)
+    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
+
+# Universal Data Handler
+class DataHandler:
+    """Enhanced data operations"""
+    
+    @staticmethod
+    @handle_errors(default_return=(None, "Export failed"))
+    def export_data(data: List[Dict], format_type: str) -> Tuple[Optional[str], str]:
+        """Export data with comprehensive information"""
+        if not data:
+            return None, "No data to export"
+        
+        temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, 
+                                               suffix=f'.{format_type}', encoding='utf-8')
+        
+        if format_type == 'csv':
+            writer = csv.writer(temp_file)
+            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Language', 
+                           'Pos_Prob', 'Neg_Prob', 'Neu_Prob', 'Word_Count'])
+            for entry in data:
+                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}",
+                    f"{entry.get('neu_prob', 0):.4f}",
+                    entry.get('word_count', 0)
+                ])
+        elif format_type == 'json':
+            json.dump(data, temp_file, indent=2, ensure_ascii=False)
+        
+        temp_file.close()
+        return temp_file.name, f"Exported {len(data)} entries"
+    
+    @staticmethod
+    @handle_errors(default_return="")
+    def process_file(file) -> str:
+        """Process uploaded files"""
+        if not file:
+            return ""
+        
+        content = file.read().decode('utf-8')
+        
+        if file.name.endswith('.csv'):
+            csv_file = io.StringIO(content)
+            reader = csv.reader(csv_file)
+            try:
+                next(reader)  # Skip header
+                texts = []
+                for row in reader:
+                    if row and row[0].strip():
+                        text = row[0].strip().strip('"')
+                        if text:
+                            texts.append(text)
+                return '\n'.join(texts)
+            except:
+                lines = content.strip().split('\n')[1:]
+                texts = []
+                for line in lines:
+                    if line.strip():
+                        text = line.strip().strip('"')
+                        if text:
+                            texts.append(text)
+                return '\n'.join(texts)
+        
+        return content
+
+
+
+
+
+
+
+
+
+
+
+
+
+class SentimentApp:
+    """Optimized multilingual sentiment analysis application"""
+    
+    def __init__(self):
+        self.engine = SentimentEngine()
+        self.advanced_engine = AdvancedAnalysisEngine()
+        self.history = HistoryManager()
+        self.data_handler = DataHandler()
+        
+        # Multi-language examples
+        self.examples = [
+    # Auto Detect
+    ["The film had its moments, but overall it felt a bit too long and lacked emotional depth. Some scenes were visually impressive, yet they failed to connect emotionally. By the end, I found myself disengaged and unsatisfied."],
+
+    # English
+    ["I was completely blown away by the movie — the performances were raw and powerful, and the story stayed with me long after the credits rolled. Every scene felt purposeful, and the emotional arc was handled with incredible nuance. It's the kind of film that makes you reflect deeply on your own life."],
+
+
+
+    # Chinese
+    ["这部电影节奏拖沓，剧情老套，完全没有让我产生任何共鸣，是一次失望的观影体验。演员的表演也显得做作，缺乏真实感。看到最后甚至有点不耐烦，整体表现乏善可陈。"],
+
+
+
+
+
+
+
+
+    # Spanish
+    ["Una obra maestra del cine contemporáneo, con actuaciones sobresalientes, un guion bien escrito y una dirección impecable. Cada plano parecía cuidadosamente pensado, y la historia avanzaba con una intensidad emocional que mantenía al espectador cautivado. Definitivamente una película que vale la pena volver a ver."],
+
+
+
+    # French
+    ["Je m'attendais à beaucoup mieux. Le scénario était confus, les dialogues ennuyeux, et je me suis presque endormi au milieu du film. Même la mise en scène, habituellement un point fort, manquait cruellement d'inspiration cette fois-ci."],
+
+
+    # German
+    ["Der Film war ein emotionales Erlebnis mit großartigen Bildern, einem mitreißenden Soundtrack und einer Geschichte, die zum Nachdenken anregt. Besonders beeindruckend war die schauspielerische Leistung der Hauptdarsteller, die eine tiefe Menschlichkeit vermittelten. Es ist ein Film, der lange nachwirkt."],
+
+
+
+
+
+
+
+    # Swedish
+    ["Filmen var en besvikelse – tråkig handling, överdrivet skådespeleri och ett slut som inte gav något avslut alls. Den kändes forcerad och saknade en tydlig röd tråd. Jag gick från biografen med en känsla av tomhet och frustration."]
+]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    
+    @handle_errors(default_return=("Please enter text", None, None))
+    def analyze_single(self, text: str, language: str, theme: str, clean_text: bool, 
+                       remove_punct: bool, remove_nums: bool):
+        """Optimized single text analysis"""
+        if not text.strip():
+            return "Please enter text", 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():
+            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'],
+                '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)
+            
+            # Create comprehensive result text
+            info_text = f"""
+**Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+- **Language:** {result['language'].upper()}
+- **Statistics:** {result['word_count']} words, {result['char_count']} characters
+- **Probabilities:** Positive: {result.get('pos_prob', 0):.3f}, Negative: {result.get('neg_prob', 0):.3f}, Neutral: {result.get('neu_prob', 0):.3f}
+            """
+            
+            return info_text, gauge_fig, bars_fig
     
-    with gr.Tab("ℹ️ About"):
-        gr.Markdown("""
-        ## SmartReview Pro Features
-        
-        ### 🆕 New Features:
-        - **Aspect-Based Sentiment Analysis**: Extract specific aspects customers love/hate
-        - **CSV Batch Processing**: Upload review files for bulk analysis
-        - **Metadata Analysis**: Detect fake reviews using timestamps and usernames
-        - **Customizable Quality Scoring**: Adjust quality factors to your needs
-        - **Advanced Visualizations**: Radar charts and enhanced reporting
-        
-        ### Core Capabilities:
-        - **Sentiment Analysis**: AI-powered emotion detection with keyword extraction
-        - **Fake Review Detection**: Multi-layer authenticity verification
-        - **Quality Assessment**: Comprehensive review helpfulness scoring
-        - **Competitor Comparison**: Side-by-side sentiment analysis
-        - **Professional Reports**: Detailed insights with actionable recommendations
-        
-        ### CSV Format:
-        Required columns: `review` or `comment` or `text`
-        Optional columns: `timestamp`, `username` (for enhanced fake detection)
-        
-        ### Pricing:
-        - **Free**: 50 analyses/day, basic features
-        - **Pro ($299/month)**: Unlimited analyses, CSV upload, custom reports
-        - **Enterprise**: API access, custom models, priority support
-        """)
+    @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 with parallel processing"""
+        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'],
+                        '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:
+                    df_data.append({
+                        'Index': result['batch_index'] + 1,
+                        'Text': result['text'],
+                        'Sentiment': result['sentiment'],
+                        'Confidence': f"{result['confidence']:.3f}",
+                        'Language': result['language'].upper(),
+                        'Word_Count': result.get('word_count', 0)
+                    })
+            
+            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
+    
+    # FIXED advanced analysis methods with sample size control
+    @handle_errors(default_return=("Please enter text", None))
+    def analyze_with_shap(self, text: str, language: str, num_samples: int = 100):
+        """Perform FIXED SHAP analysis with configurable samples"""
+        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
+        language_code = language_map.get(language, 'auto')
+        
+        return self.advanced_engine.analyze_with_shap(text, language_code, num_samples)
+    
+    @handle_errors(default_return=("Please enter text", None))
+    def analyze_with_lime(self, text: str, language: str, num_samples: int = 100):
+        """Perform FIXED LIME analysis with configurable samples"""
+        language_map = {v: k for k, v in config.SUPPORTED_LANGUAGES.items()}
+        language_code = language_map.get(language, 'auto')
+        
+        return self.advanced_engine.analyze_with_lime(text, language_code, num_samples)
+    
+    @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)}"
+        
+        theme_ctx = ThemeContext(theme)
+
+
+
+
+
+        
+        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']}
+        """
+
+# Optimized Gradio Interface
+def create_interface():
+    """Create comprehensive Gradio interface with optimizations"""
+    app = SentimentApp()
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="Multilingual Sentiment Analyzer") as demo:
+        gr.Markdown("# 🌍 Multilingual Sentiment Analyzer")
+        gr.Markdown("AI-powered sentiment analysis with SHAP & LIME 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")
+        
+        # FIXED Advanced Analysis Tab
+        with gr.Tab("Advanced Analysis"):
+            gr.Markdown("## Explainable AI Analysis")
+            gr.Markdown("**SHAP and LIME analysis with FIXED implementation** - now handles text input correctly!")
+            
+            with gr.Row():
+                with gr.Column():
+                    advanced_text_input = gr.Textbox(
+                        label="Enter Text for Advanced Analysis",
+                        placeholder="Enter text to analyze with SHAP and LIME...",
+                        lines=6,
+                        value="This movie is absolutely fantastic and amazing!"
+                    )
+                    
+                    with gr.Row():
+                        advanced_language = gr.Dropdown(
+                            choices=list(config.SUPPORTED_LANGUAGES.values()),
+                            value="Auto Detect",
+                            label="Language"
+                        )
+                        
+                        num_samples_slider = gr.Slider(
+                            minimum=50,
+                            maximum=300,
+                            value=100,
+                            step=25,
+                            label="Number of Samples",
+                            info="Lower = Faster, Higher = More Accurate"
+                        )
+                    
+                    with gr.Row():
+                        shap_btn = gr.Button("SHAP Analysis", variant="primary")
+                        lime_btn = gr.Button("LIME Analysis", variant="secondary")
+                    
+                    gr.Markdown("""
+                    
+                    **📊 Analysis Methods:**
+                    - **SHAP**: Token-level importance scores using Text masker
+                    - **LIME**: Feature importance through text perturbation
+                    
+                    **⚡ Expected Performance:**
+                    - 50 samples: ~10-20s | 100 samples: ~20-40s | 200+ samples: ~40-80s
+                    """)
+                
+                with gr.Column():
+                    advanced_results = gr.Textbox(label="Analysis Summary", lines=12)
+            
+            with gr.Row():
+                advanced_plot = gr.Plot(label="Feature Importance Visualization")
+        
+        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", "Word_Count"],
+                        datatype=["number", "str", "str", "str", "str", "number"]
+                    )
+            
+            with gr.Row():
+                batch_plot = gr.Plot(label="Batch Analysis Summary")
+                confidence_dist_plot = gr.Plot(label="Confidence Distribution")
+        
+        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
+        
+        # Single Analysis
+        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]
+        )
+        
+        # FIXED Advanced Analysis with sample size control
+        shap_btn.click(
+            app.analyze_with_shap,
+            inputs=[advanced_text_input, advanced_language, num_samples_slider],
+            outputs=[advanced_results, advanced_plot]
+        )
+        
+        lime_btn.click(
+            app.analyze_with_lime,
+            inputs=[advanced_text_input, advanced_language, num_samples_slider],
+            outputs=[advanced_results, advanced_plot]
+        )
+        
+        # Batch Analysis
+        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]
+        )
+        
+        # History & Analytics
+        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]
+
+        )
+    
+    return demo
+# Application Entry Point
 if __name__ == "__main__":
-    demo.launch()
+    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