Create app.py

app.py

@@ -0,0 +1,255 @@
+import numpy as np
+import pandas as pd
+from collections import Counter
+from typing import List, Dict, Optional, Tuple
+import logging
+
+from config import config
+from models import SentimentEngine, memory_cleanup, ThemeContext, handle_errors
+from analysis import AdvancedAnalysisEngine
+from visualization import PlotlyVisualizer
+from data_utils import HistoryManager, DataHandler, TextProcessor
+
+logger = logging.getLogger(__name__)
+
+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
+    
+    @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']}
+        """