Update app.py

app.py

@@ -113,7 +113,7 @@ class ModelManager:
 model_manager = ModelManager()
 
 class HistoryManager:
-    """Manages analysis history"""
+    """Enhanced history manager with more features"""
     def __init__(self):
         self._history = []
     
@@ -122,9 +122,32 @@ class HistoryManager:
         if len(self._history) > config.MAX_HISTORY_SIZE:
             self._history = self._history[-config.MAX_HISTORY_SIZE:]
     
+    def add_batch_entries(self, entries: List[Dict]):
+        """Add multiple entries at once"""
+        for entry in entries:
+            self.add_entry(entry)
+    
     def get_history(self) -> List[Dict]:
         return self._history.copy()
     
+    def get_recent_history(self, n: int = 10) -> List[Dict]:
+        """Get n most recent entries"""
+        return self._history[-n:] if self._history else []
+    
+    def filter_history(self, sentiment: str = None, language: str = None, 
+                      min_confidence: float = None) -> List[Dict]:
+        """Filter history by criteria"""
+        filtered = self._history
+        
+        if sentiment:
+            filtered = [h for h in filtered if h['sentiment'] == sentiment]
+        if language:
+            filtered = [h for h in filtered if h.get('language', 'en') == language]
+        if min_confidence:
+            filtered = [h for h in filtered if h['confidence'] >= min_confidence]
+            
+        return filtered
+    
     def clear(self) -> int:
         count = len(self._history)
         self._history.clear()
@@ -136,13 +159,19 @@ class HistoryManager:
         
         sentiments = [item['sentiment'] for item in self._history]
         confidences = [item['confidence'] for item in self._history]
+        languages = [item.get('language', 'en') for item in self._history]
         
         return {
             'total_analyses': len(self._history),
             'positive_count': sentiments.count('Positive'),
             'negative_count': sentiments.count('Negative'),
+            'neutral_count': sentiments.count('Neutral'),
             'avg_confidence': np.mean(confidences),
-            'languages_detected': len(set(item.get('language', 'en') for item in self._history))
+            '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',
+            'avg_text_length': np.mean([len(item.get('full_text', '')) for item in self._history])
         }
 
 history_manager = HistoryManager()
@@ -182,6 +211,12 @@ class TextProcessor:
             word_freq = Counter(words)
             return [word for word, _ in word_freq.most_common(top_k)]
 
+    @staticmethod
+    def parse_batch_input(text: str) -> List[str]:
+        """Parse batch input from textarea"""
+        lines = text.strip().split('\n')
+        return [line.strip() for line in lines if line.strip()]
+
 class SentimentAnalyzer:
     """Enhanced sentiment analysis"""
     
@@ -262,6 +297,27 @@ class SentimentAnalyzer:
             logger.error(f"Analysis failed: {e}")
             raise
 
+    @staticmethod
+    def analyze_batch(texts: List[str], language: str = 'auto', 
+                     preprocessing_options: Dict = None) -> List[Dict]:
+        """Analyze multiple texts"""
+        results = []
+        for i, text in enumerate(texts):
+            try:
+                result = SentimentAnalyzer.analyze_text(text, language, preprocessing_options)
+                result['batch_index'] = i
+                results.append(result)
+            except Exception as e:
+                # Add error result
+                results.append({
+                    'sentiment': 'Error',
+                    'confidence': 0.0,
+                    'error': str(e),
+                    'batch_index': i,
+                    'text': text
+                })
+        return results
+
 class PlotlyVisualizer:
     """Enhanced visualizations with Plotly"""
     
@@ -340,6 +396,55 @@ class PlotlyVisualizer:
         )
         
         return fig
+
+    @staticmethod
+    def create_batch_summary(results: List[Dict], theme: str = 'default') -> go.Figure:
+        """Create batch analysis summary"""
+        colors = config.THEMES[theme]
+        
+        # Count sentiments
+        sentiments = [r['sentiment'] for r in results if 'sentiment' in r]
+        sentiment_counts = Counter(sentiments)
+        
+        # Create pie chart
+        fig = go.Figure(data=[go.Pie(
+            labels=list(sentiment_counts.keys()),
+            values=list(sentiment_counts.values()),
+            marker_colors=[colors.get(s.lower()[:3], '#999999') for s in sentiment_counts.keys()],
+            textinfo='label+percent',
+            hole=0.3
+        )])
+        
+        fig.update_layout(
+            title=f"Batch Analysis Summary ({len(results)} texts)",
+            height=400
+        )
+        
+        return fig
+
+    @staticmethod
+    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
     def create_history_dashboard(history: List[Dict]) -> go.Figure:
@@ -435,7 +540,8 @@ def analyze_single_text(text: str, language: str, theme: str, clean_text: bool,
             'neg_prob': result['neg_prob'],
             'neu_prob': result.get('neu_prob', 0),
             'language': result['language'],
-            'timestamp': datetime.now().isoformat()
+            'timestamp': datetime.now().isoformat(),
+            'analysis_type': 'single'
         }
         history_manager.add_entry(history_entry)
         
@@ -458,20 +564,256 @@ def analyze_single_text(text: str, language: str, theme: str, clean_text: bool,
         logger.error(f"Analysis failed: {e}")
         return f"Error: {str(e)}", None, None
 
+def analyze_batch_texts(batch_text: str, language: str, theme: str, 
+                       clean_text: bool, remove_punct: bool, remove_nums: bool):
+    """Batch text analysis"""
+    try:
+        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 back to language codes
+        language_map = {
+            'Auto Detect': 'auto',
+            'English': 'en',
+            'Chinese': 'zh',
+            'Spanish': 'es',
+            'French': 'fr',
+            'German': 'de',
+            'Swedish': 'sv'
+        }
+        language_code = language_map.get(language, 'auto')
+        
+        preprocessing_options = {
+            'clean_text': clean_text,
+            'remove_punctuation': remove_punct,
+            'remove_numbers': remove_nums
+        }
+        
+        # Analyze all texts
+        results = SentimentAnalyzer.analyze_batch(texts, language_code, preprocessing_options)
+        
+        # Add to history
+        batch_entries = []
+        for i, (text, result) in enumerate(zip(texts, results)):
+            if 'error' not in result:
+                entry = {
+                    'text': text[:100] + '...' if len(text) > 100 else text,
+                    'full_text': text,
+                    'sentiment': result['sentiment'],
+                    'confidence': result['confidence'],
+                    'pos_prob': result['pos_prob'],
+                    'neg_prob': result['neg_prob'],
+                    'neu_prob': result.get('neu_prob', 0),
+                    'language': result['language'],
+                    'timestamp': datetime.now().isoformat(),
+                    'analysis_type': 'batch',
+                    'batch_index': i
+                }
+                batch_entries.append(entry)
+        
+        history_manager.add_batch_entries(batch_entries)
+        
+        # Create visualizations
+        summary_fig = PlotlyVisualizer.create_batch_summary(results, theme)
+        confidence_fig = PlotlyVisualizer.create_confidence_distribution(results)
+        
+        # Create results table
+        df_data = []
+        for i, (text, result) in enumerate(zip(texts, results)):
+            if 'error' in result:
+                df_data.append({
+                    'Index': i+1,
+                    'Text': text[:50] + '...' if len(text) > 50 else text,
+                    'Sentiment': 'Error',
+                    'Confidence': 0.0,
+                    'Language': 'Unknown',
+                    'Error': result['error']
+                })
+            else:
+                df_data.append({
+                    'Index': i+1,
+                    'Text': text[:50] + '...' if len(text) > 50 else text,
+                    'Sentiment': result['sentiment'],
+                    'Confidence': f"{result['confidence']:.3f}",
+                    'Language': result['language'].upper(),
+                    'Keywords': ', '.join(result['keywords'][:3])
+                })
+        
+        df = pd.DataFrame(df_data)
+        
+        # Summary info
+        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])
+            
+            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)}
+            """
+        else:
+            summary_text = f"All {len(texts)} texts failed to analyze."
+        
+        return summary_text, df, summary_fig, confidence_fig
+        
+    except Exception as e:
+        logger.error(f"Batch analysis failed: {e}")
+        return f"Error: {str(e)}", None, None, None
+
+def analyze_advanced_text(text: str, language: str, theme: str, include_keywords: bool,
+                         keyword_count: int, min_confidence: float):
+    """Advanced analysis with additional features"""
+    try:
+        if not text.strip():
+            return "Please enter text", None, None
+        
+        # Map display names back to language codes
+        language_map = {
+            'Auto Detect': 'auto',
+            'English': 'en',
+            'Chinese': 'zh',
+            'Spanish': 'es',
+            'French': 'fr',
+            'German': 'de',
+            'Swedish': 'sv'
+        }
+        language_code = language_map.get(language, 'auto')
+        
+        result = SentimentAnalyzer.analyze_text(text, language_code)
+        
+        # Advanced keyword extraction
+        if include_keywords:
+            result['keywords'] = TextProcessor.extract_keywords(text, keyword_count)
+        
+        # Confidence filtering
+        meets_confidence = result['confidence'] >= min_confidence
+        
+        # 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['pos_prob'],
+            'neg_prob': result['neg_prob'],
+            'neu_prob': result.get('neu_prob', 0),
+            'language': result['language'],
+            'timestamp': datetime.now().isoformat(),
+            'analysis_type': 'advanced',
+            'meets_confidence_threshold': meets_confidence
+        }
+        history_manager.add_entry(history_entry)
+        
+        # Create visualizations
+        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
+        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
+        
+        # Create detailed info text
+        confidence_status = "✅ High Confidence" if meets_confidence else "⚠️ Low Confidence"
+        
+        info_text = f"""
+**Advanced Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+- **Confidence Status:** {confidence_status}
+- **Language:** {result['language'].upper()}
+- **Text Statistics:**
+  - Words: {result['word_count']}
+  - Characters: {result['char_count']}
+  - Average word length: {result['char_count']/max(result['word_count'], 1):.1f}
+        """
+        
+        if include_keywords:
+            info_text += f"\n- **Top Keywords:** {', '.join(result['keywords'])}"
+        
+        if not meets_confidence:
+            info_text += f"\n\n⚠️ **Note:** Confidence ({result['confidence']:.3f}) is below threshold ({min_confidence})"
+        
+        return info_text, gauge_fig, bars_fig
+        
+    except Exception as e:
+        logger.error(f"Advanced analysis failed: {e}")
+        return f"Error: {str(e)}", None, None
+
 def get_history_stats():
-    """Get history statistics"""
+    """Get enhanced history statistics"""
     stats = history_manager.get_stats()
     if not stats:
         return "No analysis history available"
     
     return f"""
-**History Statistics:**
+**Comprehensive History Statistics:**
+
+**Analysis Counts:**
 - Total Analyses: {stats['total_analyses']}
-- Positive: {stats['positive_count']} | Negative: {stats['negative_count']}
+- Positive: {stats['positive_count']}
+- Negative: {stats['negative_count']}
+- Neutral: {stats['neutral_count']}
+
+**Confidence Metrics:**
 - Average Confidence: {stats['avg_confidence']:.3f}
+- Highest Confidence: {stats['max_confidence']:.3f}
+- Lowest Confidence: {stats['min_confidence']:.3f}
+
+**Language Statistics:**
 - Languages Detected: {stats['languages_detected']}
+- Most Common Language: {stats['most_common_language'].upper()}
+
+**Text Statistics:**
+- Average Text Length: {stats['avg_text_length']:.1f} characters
     """
 
+def filter_history_display(sentiment_filter: str, language_filter: str, min_confidence: float):
+    """Display filtered history"""
+    # Convert filters
+    sentiment = sentiment_filter if sentiment_filter != "All" else None
+    language = language_filter.lower() if language_filter != "All" else None
+    
+    filtered_history = history_manager.filter_history(
+        sentiment=sentiment,
+        language=language,
+        min_confidence=min_confidence if min_confidence > 0 else None
+    )
+    
+    if not filtered_history:
+        return "No entries match the filter criteria", None
+    
+    # Create DataFrame for display
+    df_data = []
+    for entry in filtered_history[-20:]:  # Show last 20 entries
+        df_data.append({
+            'Timestamp': entry['timestamp'][:16],  # YYYY-MM-DD HH:MM
+            'Text': entry['text'],
+            'Sentiment': entry['sentiment'],
+            'Confidence': f"{entry['confidence']:.3f}",
+            'Language': entry['language'].upper(),
+            'Type': entry.get('analysis_type', 'single')
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    summary = f"""
+**Filtered Results:**
+- Found {len(filtered_history)} entries matching criteria
+- Showing most recent {min(20, len(filtered_history))} entries
+    """
+    
+    return summary, df
+
 def plot_history_dashboard():
     """Create history dashboard"""
     history = history_manager.get_history()
@@ -481,6 +823,20 @@ def plot_history_dashboard():
     fig = PlotlyVisualizer.create_history_dashboard(history)
     return fig, f"Dashboard showing {len(history)} analyses"
 
+def export_history_csv():
+    """Export history to CSV"""
+    history = history_manager.get_history()
+    if not history:
+        return None, "No history to export"
+    
+    try:
+        df = pd.DataFrame(history)
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', mode='w')
+        df.to_csv(temp_file.name, index=False)
+        return temp_file.name, f"Exported {len(history)} entries to CSV"
+    except Exception as e:
+        return None, f"Export failed: {str(e)}"
+
 def export_history_excel():
     """Export history to Excel"""
     history = history_manager.get_history()
@@ -500,6 +856,18 @@ def clear_all_history():
     count = history_manager.clear()
     return f"Cleared {count} entries from history"
 
+def get_recent_analyses():
+    """Get recent analysis summary"""
+    recent = history_manager.get_recent_history(10)
+    if not recent:
+        return "No recent analyses available"
+    
+    summary_text = "**Recent Analyses (Last 10):**\n\n"
+    for i, entry in enumerate(recent, 1):
+        summary_text += f"{i}. **{entry['sentiment']}** ({entry['confidence']:.3f}) - {entry['text']}\n"
+    
+    return summary_text
+
 # Sample data
 SAMPLE_TEXTS = [
     # Auto Detect
@@ -524,11 +892,16 @@ SAMPLE_TEXTS = [
     ["Filmen var en besvikelse – tråkig handling, överdrivet skådespeleri och ett slut som inte gav något avslut alls."]
 ]
 
+BATCH_SAMPLE = """I love this product! It works perfectly.
+The service was terrible and slow.
+Not sure if I like it or not.
+Amazing quality and fast delivery!
+Could be better, but it's okay."""
 
 # Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Sentiment Analyzer") as demo:
-    gr.Markdown("# 🎭 Multilingual Sentiment Analyzer")
-    gr.Markdown("Analyze sentiment with multiple languages, themes, and advanced visualizations")
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Multilingual Sentiment Analyzer") as demo:
+    gr.Markdown("# 🎭 Advanced Multilingual Sentiment Analyzer")
+    gr.Markdown("Comprehensive sentiment analysis with batch processing, advanced analytics, and multilingual support")
     
     with gr.Tab("📝 Single Analysis"):
         with gr.Row():
@@ -541,7 +914,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Sentiment Analyzer") as d
                 
                 with gr.Row():
                     language_select = gr.Dropdown(
-                        choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German'],
+                        choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
                         value='Auto Detect',
                         label="Language"
                     )
@@ -571,37 +944,201 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Sentiment Analyzer") as d
             gauge_plot = gr.Plot(label="Sentiment Gauge")
             bars_plot = gr.Plot(label="Probability Distribution")
     
-    with gr.Tab("📊 History & Analytics"):
+    with gr.Tab("📊 Batch Analysis"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                batch_input = gr.Textbox(
+                    label="Batch Text Input (One text per line)",
+                    placeholder="Enter multiple texts, one per line...",
+                    lines=8
+                )
+                
+                with gr.Row():
+                    batch_language = gr.Dropdown(
+                        choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
+                        value='Auto Detect',
+                        label="Language"
+                    )
+                    batch_theme = gr.Dropdown(
+                        choices=list(config.THEMES.keys()),
+                        value='default',
+                        label="Theme"
+                    )
+                
+                with gr.Row():
+                    batch_clean = gr.Checkbox(label="Clean Text", value=False)
+                    batch_remove_punct = gr.Checkbox(label="Remove Punctuation", value=True)
+                    batch_remove_nums = gr.Checkbox(label="Remove Numbers", value=False)
+                
+                batch_analyze_btn = gr.Button("🔍 Analyze Batch", variant="primary", size="lg")
+                
+                gr.Examples(
+                    examples=[[BATCH_SAMPLE]],
+                    inputs=batch_input,
+                    label="Sample Batch Input"
+                )
+            
+            with gr.Column(scale=1):
+                batch_summary = gr.Markdown("Enter texts and click Analyze Batch")
+        
+        with gr.Row():
+            batch_results_table = gr.DataFrame(
+                label="Detailed Results",
+                interactive=False
+            )
+        
+        with gr.Row():
+            batch_summary_plot = gr.Plot(label="Sentiment Summary")
+            batch_confidence_plot = gr.Plot(label="Confidence Distribution")
+    
+    with gr.Tab("🔬 Advanced Analysis"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                advanced_input = gr.Textbox(
+                    label="Text for Advanced Analysis",
+                    placeholder="Enter text for detailed analysis...",
+                    lines=4
+                )
+                
+                with gr.Row():
+                    advanced_language = gr.Dropdown(
+                        choices=['Auto Detect', 'English', 'Chinese', 'Spanish', 'French', 'German', 'Swedish'],
+                        value='Auto Detect',
+                        label="Language"
+                    )
+                    advanced_theme = gr.Dropdown(
+                        choices=list(config.THEMES.keys()),
+                        value='default',
+                        label="Theme"
+                    )
+                
+                with gr.Row():
+                    include_keywords = gr.Checkbox(label="Extract Keywords", value=True)
+                    keyword_count = gr.Slider(
+                        minimum=3,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Number of Keywords"
+                    )
+                
+                min_confidence_slider = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Minimum Confidence Threshold"
+                )
+                
+                advanced_analyze_btn = gr.Button("🔬 Advanced Analyze", variant="primary", size="lg")
+            
+            with gr.Column(scale=1):
+                advanced_result_info = gr.Markdown("Configure settings and click Advanced Analyze")
+        
+        with gr.Row():
+            advanced_gauge_plot = gr.Plot(label="Sentiment Gauge")
+            advanced_bars_plot = gr.Plot(label="Probability Distribution")
+    
+    with gr.Tab("📈 History & Analytics"):
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📊 Statistics")
+                stats_btn = gr.Button("📈 Get Statistics")
+                recent_btn = gr.Button("🕒 Recent Analyses")
+                stats_output = gr.Markdown("Click 'Get Statistics' to view analysis history")
+            
+            with gr.Column():
+                gr.Markdown("### 🔍 Filter History")
+                with gr.Row():
+                    sentiment_filter = gr.Dropdown(
+                        choices=["All", "Positive", "Negative", "Neutral"],
+                        value="All",
+                        label="Filter by Sentiment"
+                    )
+                    language_filter = gr.Dropdown(
+                        choices=["All", "English", "Chinese", "Spanish", "French", "German", "Swedish"],
+                        value="All",
+                        label="Filter by Language"
+                    )
+                
+                confidence_filter = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.0,
+                    step=0.1,
+                    label="Minimum Confidence"
+                )
+                
+                filter_btn = gr.Button("🔍 Filter History")
+        
         with gr.Row():
-            stats_btn = gr.Button("📈 Get Statistics")
             dashboard_btn = gr.Button("📊 View Dashboard")
             clear_btn = gr.Button("🗑️ Clear History", variant="stop")
         
         with gr.Row():
-            export_excel_btn = gr.Button("📁 Export Excel")
+            export_csv_btn = gr.Button("📄 Export CSV")
+            export_excel_btn = gr.Button("📊 Export Excel")
         
-        stats_output = gr.Markdown("Click 'Get Statistics' to view analysis history")
         dashboard_plot = gr.Plot(label="Analytics Dashboard")
+        
+        with gr.Row():
+            filtered_results = gr.Markdown("Use filters to view specific entries")
+            filtered_table = gr.DataFrame(label="Filtered History", interactive=False)
+        
+        csv_file = gr.File(label="Download CSV Report")
         excel_file = gr.File(label="Download Excel Report")
         history_status = gr.Textbox(label="Status", interactive=False)
     
     # Event handlers
+    
+    # Single Analysis
     analyze_btn.click(
         analyze_single_text,
         inputs=[text_input, language_select, theme_select, clean_text, remove_punct, remove_nums],
         outputs=[result_info, gauge_plot, bars_plot]
     )
     
+    # Batch Analysis
+    batch_analyze_btn.click(
+        analyze_batch_texts,
+        inputs=[batch_input, batch_language, batch_theme, batch_clean, batch_remove_punct, batch_remove_nums],
+        outputs=[batch_summary, batch_results_table, batch_summary_plot, batch_confidence_plot]
+    )
+    
+    # Advanced Analysis
+    advanced_analyze_btn.click(
+        analyze_advanced_text,
+        inputs=[advanced_input, advanced_language, advanced_theme, include_keywords, keyword_count, min_confidence_slider],
+        outputs=[advanced_result_info, advanced_gauge_plot, advanced_bars_plot]
+    )
+    
+    # History & Analytics
     stats_btn.click(
         get_history_stats,
         outputs=stats_output
     )
     
+    recent_btn.click(
+        get_recent_analyses,
+        outputs=stats_output
+    )
+    
+    filter_btn.click(
+        filter_history_display,
+        inputs=[sentiment_filter, language_filter, confidence_filter],
+        outputs=[filtered_results, filtered_table]
+    )
+    
     dashboard_btn.click(
         plot_history_dashboard,
         outputs=[dashboard_plot, history_status]
     )
     
+    export_csv_btn.click(
+        export_history_csv,
+        outputs=[csv_file, history_status]
+    )
+    
     export_excel_btn.click(
         export_history_excel,
         outputs=[excel_file, history_status]