Create app.py

app.py

@@ -1,524 +1,357 @@
 import gradio as gr
 import pandas as pd
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
 import numpy as np
-import os
-import json
-import logging
-import traceback
 from datetime import datetime
-import plotly.graph_objects as go
-import plotly.express as px
-from models import ModelManager
-from analyzer import MessageAnalyzer
-from utils import (
-    parse_chat_data, generate_timeline_chart, generate_pattern_frequency_chart,
-    generate_sender_comparison_chart, generate_time_of_day_heatmap
-)
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Initialize models
-model_manager = ModelManager()
-model_manager.load_models()
-
-# Initialize analyzer
-analyzer = MessageAnalyzer(model_manager)
-
-def analyze_file(file_path):
-    """Analyze uploaded chat file"""
-    try:
-        # Parse chat data
-        df = parse_chat_data(file_path)
-        
-        # Analyze chat history
-        results_df, summary = analyzer.analyze_chat_history(df)
-        
-        return results_df, summary
-    except Exception as e:
-        logger.error(f"Error analyzing file: {e}")
-        logger.error(traceback.format_exc())
-        return None, {"error": str(e)}
+import io
+import json
 
-def analyze_single_message(message):
-    """Analyze a single message"""
-    try:
-        if not message.strip():
-            return {
-                "abuse_score": 0,
-                "detected_patterns": [],
-                "sentiment": "neutral",
-                "emotional_tone": "neutral",
-                "boundary_assessment": {"assessment": "neutral"},
-                "risk_level": "Low"
-            }
-        
-        # Analyze message
-        analysis = analyzer.analyze_message(message)
+class CommunicationAnalyzer:
+    def __init__(self):
+        self.load_models()
         
-        return analysis
-    except Exception as e:
-        logger.error(f"Error analyzing message: {e}")
-        logger.error(traceback.format_exc())
-        return {
-            "error": str(e),
-            "abuse_score": 0,
-            "detected_patterns": [],
-            "sentiment": "error",
-            "emotional_tone": "error",
-            "boundary_assessment": {"assessment": "error"},
-            "risk_level": "Unknown"
-        }
-
-def get_risk_color(risk_level):
-    """Get color for risk level"""
-    colors = {
-        "Critical": "#ef4444",
-        "High": "#f97316",
-        "Moderate": "#f59e0b",
-        "Low": "#10b981",
-        "Unknown": "#6b7280"
-    }
-    return colors.get(risk_level, "#6b7280")
-
-def format_analysis_results(analysis):
-    """Format analysis results for display"""
-    try:
-        # Format abuse score
-        abuse_score_html = f"""
-        <div style="margin-bottom: 20px;">
-            <h3 style="color: #1f2937;">Abuse Score: {analysis['abuse_score']:.1f}%</h3>
-            <div style="background: #f0f0f0; height: 20px; width: 100%; border-radius: 10px;">
-                <div style="background: {get_risk_color(analysis['risk_level'])}; 
-                            height: 100%; 
-                            width: {min(100, max(0, analysis['abuse_score']))}%; 
-                            border-radius: 10px;">
-                </div>
-            </div>
-            <p style="color: #1f2937;">Risk Level: <strong style="color: #1f2937;">{analysis['risk_level']}</strong></p>
-        </div>
-        """
-        
-        # Format detected patterns
-        patterns_html = "<h3 style='color: #1f2937;'>Detected Patterns</h3>"
-        if analysis['detected_patterns']:
-            patterns_html += "<ul>"
-            for pattern in analysis['detected_patterns']:
-                patterns_html += f"<li style='color: #1f2937;'>{pattern}</li>"
-            patterns_html += "</ul>"
-        else:
-            patterns_html += "<p style='color: #1f2937;'>No concerning patterns detected.</p>"
-        
-        # Format sentiment and emotional tone
-        sentiment_html = f"""
-        <h3 style="color: #1f2937;">Communication Analysis</h3>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Sentiment:</strong> {analysis['sentiment']}</p>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Emotional Tone:</strong> {analysis['emotional_tone']}</p>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">DARVO Score:</strong> {analysis['darvo_score']:.3f}</p>
-        """
-        
-        # Format boundary assessment
-        boundary_html = f"""
-        <h3 style="color: #1f2937;">Boundary Health</h3>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Assessment:</strong> {analysis['boundary_assessment']['assessment']}</p>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Description:</strong> {analysis['boundary_assessment']['description']}</p>
-        """
-        
-        # Combine all sections
-        html = f"""
-        <div style="padding: 20px; border: 1px solid #ddd; border-radius: 10px; background-color: #ffffff;">
-            {abuse_score_html}
-            {patterns_html}
-            {sentiment_html}
-            {boundary_html}
-        </div>
-        """
-        
-        return html
-    except Exception as e:
-        logger.error(f"Error formatting analysis results: {e}")
-        return f"<p style='color: #1f2937;'>Error formatting results: {str(e)}</p>"
-
-def format_summary_results(summary):
-    """Format summary results for display"""
-    try:
-        # Format basic info
-        basic_info = f"""
-        <h2 style="color: #1f2937;">Chat Analysis Summary</h2>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Messages Analyzed:</strong> {summary['message_count']}</p>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Date Range:</strong> {summary['date_range']['start']} to {summary['date_range']['end']}</p>
-        <p style="color: #1f2937;"><strong style="color: #1f2937;">Overall Risk Level:</strong> <span style="color: {get_risk_color(summary['overall_risk_level'])}; 
-                                                        font-weight: bold;">
-                                                {summary['overall_risk_level']}</span></p>
-        """
-        
-        # Format sender stats
-        sender_stats = "<h3 style='color: #1f2937;'>Sender Analysis</h3>"
-        if summary['sender_stats']:
-            sender_stats += "<table style='width: 100%; border-collapse: collapse;'>"
-            sender_stats += "<tr><th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>Sender</th>"
-            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>Messages</th>"
-            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>Avg. Abuse Score</th>"
-            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>Common Patterns</th></tr>"
+    def load_models(self):
+        """Load all the analysis models"""
+        try:
+            # DARVO Detection
+            self.darvo_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1")
+            self.darvo_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1")
             
-            for sender, stats in summary['sender_stats'].items():
-                common_patterns = ", ".join([p[0] for p in stats['common_patterns'][:2]]) if stats['common_patterns'] else "None"
-                sender_stats += f"<tr><td style='padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>{sender}</td>"
-                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>{stats['message_count']}</td>"
-                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>{stats['avg_abuse_score']:.1f}%</td>"
-                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd; color: #1f2937;'>{common_patterns}</td></tr>"
+            # Sentiment Analysis
+            self.sentiment_pipeline = pipeline("text-classification", model="SamanthaStorm/tether-sentiment-v3")
             
-            sender_stats += "</table>"
-        else:
-            sender_stats += "<p style='color: #1f2937;'>No sender statistics available.</p>"
-        
-        # Format primary abuser section
-        primary_abuser_html = "<h3 style='color: #1f2937;'>Primary Concern</h3>"
-        if summary['primary_abuser']:
-            primary_abuser_html += f"<p style='color: #1f2937;'>The analysis indicates that <strong style='color: #1f2937;'>{summary['primary_abuser']}</strong> "
-            primary_abuser_html += "shows the highest percentage of concerning communication patterns.</p>"
+            # Multilabel Classification
+            self.multilabel_pipeline = pipeline("text-classification", model="SamanthaStorm/tether-multilabel-v6")
             
-            # Add detailed primary abuser analysis if available
-            if summary.get('primary_abuser_analysis'):
-                analysis = summary['primary_abuser_analysis']
-                
-                # Add pattern section with collapsible details
-                primary_abuser_html += "<div style='margin-top: 20px; border: 1px solid #e5e7eb; border-radius: 8px; padding: 15px; background-color: #f9fafb;'>"
-                primary_abuser_html += "<h4 style='color: #1f2937; margin-top: 0;'>Most Common Patterns</h4>"
-                
-                # Get patterns from sender stats
-                if summary['sender_stats'].get(summary['primary_abuser']):
-                    abuser_stats = summary['sender_stats'][summary['primary_abuser']]
-                    if abuser_stats.get('common_patterns'):
-                        primary_abuser_html += "<ul style='color: #1f2937;'>"
-                        for pattern, count in abuser_stats['common_patterns'][:5]:  # Top 5 patterns
-                            primary_abuser_html += f"<li style='color: #1f2937; margin-bottom: 8px;'><strong>{pattern}</strong> ({count} occurrences)</li>"
-                        primary_abuser_html += "</ul>"
-                    else:
-                        primary_abuser_html += "<p style='color: #1f2937;'>No specific patterns detected.</p>"
-                
-                # Add emotional tones section
-                primary_abuser_html += "<h4 style='color: #1f2937; margin-top: 20px;'>Emotional Tone Analysis</h4>"
-                if analysis.get('emotional_tones'):
-                    primary_abuser_html += "<ul style='color: #1f2937;'>"
-                    for tone, count in analysis['emotional_tones']:
-                        if tone != "neutral":
-                            primary_abuser_html += f"<li style='color: #1f2937;'><strong>{tone}</strong> ({count} messages)</li>"
-                    primary_abuser_html += "</ul>"
-                else:
-                    primary_abuser_html += "<p style='color: #1f2937;'>No significant emotional tones detected.</p>"
-                
-                # Add DARVO score
-                darvo_level = "High" if analysis.get('darvo_score', 0) >= 0.65 else "Moderate" if analysis.get('darvo_score', 0) >= 0.25 else "Low"
-                darvo_color = "#ef4444" if darvo_level == "High" else "#f59e0b" if darvo_level == "Moderate" else "#10b981"
-                
-                primary_abuser_html += f"""
-                <h4 style='color: #1f2937; margin-top: 20px;'>DARVO Analysis</h4>
-                <p style='color: #1f2937;'>DARVO Score: <strong style='color: {darvo_color};'>{analysis.get('darvo_score', 0):.3f}</strong> ({darvo_level})</p>
-                <p style='color: #1f2937; font-size: 0.9em;'>DARVO (Deny, Attack, Reverse Victim & Offender) indicates attempts to shift blame and manipulate the narrative.</p>
-                """
-                
-                # Add time patterns section
-                primary_abuser_html += "<h4 style='color: #1f2937; margin-top: 20px;'>Communication Timing Patterns</h4>"
-                
-                # Peak hours
-                primary_abuser_html += "<p style='color: #1f2937;'><strong>Peak Hours:</strong> "
-                if analysis.get('peak_hours'):
-                    peak_hours_formatted = [f"{h}:00" for h in analysis['peak_hours']]
-                    primary_abuser_html += f"{', '.join(peak_hours_formatted)}</p>"
-                else:
-                    primary_abuser_html += "No clear pattern</p>"
-                    
-                # Peak days
-                primary_abuser_html += "<p style='color: #1f2937;'><strong>Peak Days:</strong> "
-                if analysis.get('peak_days'):
-                    primary_abuser_html += f"{', '.join(analysis['peak_days'])}</p>"
-                else:
-                    primary_abuser_html += "No clear pattern</p>"
-                
-                primary_abuser_html += "</div>"
-        else:
-            primary_abuser_html += "<p style='color: #1f2937;'>No clear pattern of concerning communication from a specific sender.</p>"
-        
-        # Format escalation data
-        escalation = "<h3 style='color: #1f2937;'>Escalation Analysis</h3>"
-        if summary['escalation_data']:
-            trend = summary['escalation_data'].get('trend_direction', 'unknown')
-            trend_strength = summary['escalation_data'].get('trend_strength', 0)
-            recent_avg = summary['escalation_data'].get('recent_average', 0)
-            future_prediction = summary['escalation_data'].get('future_prediction')
-            cyclic_pattern = summary['escalation_data'].get('cyclic_pattern', False)
+            # Healthy Boundary Detection
+            self.boundary_pipeline = pipeline("text-classification", model="SamanthaStorm/healthy-boundary-predictor")
             
-            # Add color coding for trend direction
-            trend_color = "#ef4444" if trend == "escalating" else "#10b981" if trend == "de-escalating" else "#6b7280"
+            # Fallacy Detection
+            self.fallacy_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/fallacyfinder")
+            self.fallacy_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/fallacyfinder")
             
-            escalation += f"<p style='color: #1f2937;'><strong style='color: #1f2937;'>Trend Direction:</strong> <span style='color: {trend_color};'>{trend.title()}</span></p>"
-            escalation += f"<p style='color: #1f2937;'><strong style='color: #1f2937;'>Trend Strength:</strong> {trend_strength:.2f}</p>"
-            escalation += f"<p style='color: #1f2937;'><strong style='color: #1f2937;'>Recent Average:</strong> {recent_avg:.1f}%</p>"
+        except Exception as e:
+            print(f"Error loading models: {e}")
+    
+    def analyze_darvo(self, text):
+        """Analyze DARVO tactics in text"""
+        try:
+            inputs = self.darvo_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
+            with torch.no_grad():
+                outputs = self.darvo_model(**inputs)
+                darvo_score = torch.sigmoid(outputs.logits).item()
+            return darvo_score
+        except:
+            return 0.0
+    
+    def analyze_fallacy(self, text):
+        """Detect logical fallacies in text"""
+        try:
+            inputs = self.fallacy_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
+            with torch.no_grad():
+                outputs = self.fallacy_model(**inputs)
+                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                predicted_class_id = predictions.argmax().item()
+                confidence = predictions.max().item()
             
-            if future_prediction is not None:
-                future_color = "#ef4444" if future_prediction > 70 else "#f59e0b" if future_prediction > 50 else "#10b981"
-                escalation += f"<p style='color: #1f2937;'><strong style='color: #1f2937;'>7-Day Prediction:</strong> <span style='color: {future_color};'>{future_prediction:.1f}%</span></p>"
+            if hasattr(self.fallacy_model.config, 'id2label'):
+                predicted_label = self.fallacy_model.config.id2label[predicted_class_id]
+            else:
+                predicted_label = f"Fallacy_Type_{predicted_class_id}"
             
-            if cyclic_pattern:
-                cycle_period = summary['escalation_data'].get('cycle_period', 'unknown')
-                escalation += f"""
-                <div style='margin-top: 15px; padding: 10px; background-color: #fffbeb; border-left: 4px solid #f59e0b; border-radius: 4px;'>
-                    <p style='color: #1f2937; margin: 0;'><strong style='color: #1f2937;'>⚠️ Cyclic Abuse Pattern Detected</strong></p>
-                    <p style='color: #1f2937; margin-top: 5px;'>The analysis shows a repeating cycle of approximately {cycle_period} days. This is consistent with the cycle of abuse, where periods of tension and abuse are followed by reconciliation and calm before repeating.</p>
-                </div>
-                """
-        else:
-            escalation += "<p style='color: #1f2937;'>No escalation data available.</p>"
-        
-        # Format recommendations
-        recommendations = "<h3 style='color: #1f2937;'>Professional Recommendations</h3>"
-        if summary['recommendations']:
-            recommendations += "<div style='max-height: 300px; overflow-y: auto;'>"
-            for rec in summary['recommendations']:
-                recommendations += f"<div style='margin-bottom: 15px; padding: 15px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #3b82f6;'>"
-                recommendations += f"<h4 style='color: #1f2937; margin-top: 0;'>{rec['title']}</h4>"
-                recommendations += f"<p style='color: #1f2937;'>{rec['description']}</p>"
-                
-                if rec['actions']:
-                    recommendations += "<ul style='color: #1f2937;'>"
-                    for action in rec['actions']:
-                        recommendations += f"<li style='color: #1f2937; margin-bottom: 5px;'>{action}</li>"
-                    recommendations += "</ul>"
-                
-                recommendations += "</div>"
-            recommendations += "</div>"
-        else:
-            recommendations += "<p style='color: #1f2937;'>No recommendations available.</p>"
-        
-        # Combine all sections
-        html = f"""
-        <div style="padding: 20px; border: 1px solid #ddd; border-radius: 10px; background-color: #ffffff;">
-            {basic_info}
-            {sender_stats}
-            {primary_abuser_html}
-            {escalation}
-            {recommendations}
-        </div>
-        """
-        
-        return html
-    except Exception as e:
-        logger.error(f"Error formatting summary results: {e}")
-        logger.error(traceback.format_exc())
-        return f"<p style='color: #1f2937;'>Error formatting summary: {str(e)}</p>"
-
-def format_safety_plan(safety_plan):
-    """Format safety plan for display"""
-    try:
-        # Convert markdown-like formatting to HTML
-        html = safety_plan.replace("**", "<strong>").replace("**", "</strong>")
-        html = html.replace("\n\n", "<br><br>")
-        html = html.replace("\n•", "<br>•")
-        
-        # Wrap in styled div
-        html = f"""
-        <div style="padding: 20px; border: 1px solid #ddd; border-radius: 10px; background-color: #ffffff;">
-            <h2 style="color: #1f2937;">Safety Plan</h2>
-            <div style="white-space: pre-wrap; color: #1f2937;">
-                {html}
-            </div>
-        </div>
-        """
-        
-        return html
-    except Exception as e:
-        logger.error(f"Error formatting safety plan: {e}")
-        return f"<p style='color: #1f2937;'>Error formatting safety plan: {str(e)}</p>"
-
-def handle_file_analysis(file_path):
-    if not file_path:
-        return (
-            "<p style='color: #1f2937;'>Please upload a file first.</p>",
-            None, None, None, None,
-            "<p style='color: #1f2937;'>Please upload a file first.</p>"
-        )
+            return predicted_label, confidence
+        except:
+            return "No Fallacy", 0.0
     
-    try:
-        # Analyze file
-        results_df, summary = analyze_file(file_path)
-        
-        if "error" in summary:
-            return (
-                f"<p style='color: #1f2937;'>Error: {summary['error']}</p>",
-                None, None, None, None,
-                "<p style='color: #1f2937;'>Error analyzing file.</p>"
-            )
-        
-        # Format summary
-        summary_html = format_summary_results(summary)
-        
-        # Generate plots
-        timeline = generate_timeline_chart(results_df)
-        pattern_freq = generate_pattern_frequency_chart(results_df)
-        sender_comp = generate_sender_comparison_chart(results_df)
-        time_heatmap = generate_time_of_day_heatmap(results_df)
-        
-        # Format safety plan
-        safety_plan_html = format_safety_plan(summary['safety_plan'])
-        
-        # Debug output
-        logger.info(f"Summary HTML length: {len(summary_html)}")
-        logger.info(f"Generated {len(results_df)} results")
-        logger.info(f"Timeline chart generated: {timeline is not None}")
-        logger.info(f"Pattern frequency chart generated: {pattern_freq is not None}")
-        logger.info(f"Sender comparison chart generated: {sender_comp is not None}")
-        logger.info(f"Time heatmap generated: {time_heatmap is not None}")
-        
-        return (
-            summary_html,
-            timeline,
-            pattern_freq,
-            sender_comp,
-            time_heatmap,
-            safety_plan_html
-        )
-    except Exception as e:
-        logger.error(f"Error in handle_file_analysis: {e}")
-        logger.error(traceback.format_exc())
-        return (
-            f"<p style='color: #1f2937;'>Error analyzing file: {str(e)}</p>",
-            None, None, None, None,
-            "<p style='color: #1f2937;'>Error analyzing file.</p>"
+    def analyze_message(self, text):
+        """Comprehensive analysis of a single message"""
+        if not text or len(text.strip()) < 3:
+            return {}
+        
+        analysis = {}
+        
+        # DARVO Analysis
+        analysis['darvo_score'] = self.analyze_darvo(text)
+        
+        # Sentiment Analysis
+        try:
+            sentiment_result = self.sentiment_pipeline(text)
+            analysis['sentiment'] = sentiment_result[0]['label']
+            analysis['sentiment_confidence'] = sentiment_result[0]['score']
+        except:
+            analysis['sentiment'] = 'NEUTRAL'
+            analysis['sentiment_confidence'] = 0.5
+        
+        # Multilabel Analysis
+        try:
+            multilabel_result = self.multilabel_pipeline(text)
+            analysis['categories'] = multilabel_result
+        except:
+            analysis['categories'] = []
+        
+        # Boundary Analysis
+        try:
+            boundary_result = self.boundary_pipeline(text)
+            analysis['boundary_type'] = boundary_result[0]['label']
+            analysis['boundary_confidence'] = boundary_result[0]['score']
+        except:
+            analysis['boundary_type'] = 'UNCLEAR'
+            analysis['boundary_confidence'] = 0.5
+        
+        # Fallacy Analysis
+        fallacy_type, fallacy_confidence = self.analyze_fallacy(text)
+        analysis['fallacy_type'] = fallacy_type
+        analysis['fallacy_confidence'] = fallacy_confidence
+        
+        return analysis
+    
+    def calculate_abuse_indicators(self, person_data):
+        """Calculate abuse indicators for a person based on their messages"""
+        if not person_data:
+            return {}
+        
+        # Aggregate scores
+        darvo_scores = [msg.get('darvo_score', 0) for msg in person_data]
+        negative_sentiments = sum(1 for msg in person_data if msg.get('sentiment') == 'NEGATIVE')
+        fallacy_count = sum(1 for msg in person_data if msg.get('fallacy_confidence', 0) > 0.7)
+        
+        total_messages = len(person_data)
+        
+        indicators = {
+            'avg_darvo_score': np.mean(darvo_scores) if darvo_scores else 0,
+            'max_darvo_score': max(darvo_scores) if darvo_scores else 0,
+            'negative_sentiment_ratio': negative_sentiments / total_messages if total_messages > 0 else 0,
+            'fallacy_ratio': fallacy_count / total_messages if total_messages > 0 else 0,
+            'total_messages': total_messages,
+            'high_darvo_messages': sum(1 for score in darvo_scores if score > 0.7)
+        }
+        
+        # Calculate overall abuse likelihood
+        abuse_score = (
+            indicators['avg_darvo_score'] * 0.4 +
+            indicators['negative_sentiment_ratio'] * 0.2 +
+            indicators['fallacy_ratio'] * 0.2 +
+            (indicators['high_darvo_messages'] / total_messages if total_messages > 0 else 0) * 0.2
         )
+        
+        indicators['abuse_likelihood'] = min(abuse_score, 1.0)
+        
+        return indicators
 
-def handle_message_analysis(message):
-    if not message.strip():
-        return "<p style='color: #1f2937;'>Please enter a message first.</p>"
+def analyze_csv_file(file, message_col, sender_col, report_type):
+    """Main function to analyze uploaded CSV file"""
+    if file is None:
+        return "Please upload a CSV file.", "", ""
     
     try:
-        # Analyze message
-        analysis = analyze_single_message(message)
+        # Read CSV file
+        df = pd.read_csv(file.name)
+        
+        if message_col not in df.columns or sender_col not in df.columns:
+            return f"Columns '{message_col}' or '{sender_col}' not found in CSV.", "", ""
+        
+        # Initialize analyzer
+        analyzer = CommunicationAnalyzer()
+        
+        # Analyze each message
+        results = []
+        person_analyses = {}
         
-        if "error" in analysis:
-            return f"<p style='color: #1f2937;'>Error: {analysis['error']}</p>"
+        for idx, row in df.iterrows():
+            message = str(row[message_col])
+            sender = str(row[sender_col])
+            
+            if sender not in person_analyses:
+                person_analyses[sender] = []
+            
+            analysis = analyzer.analyze_message(message)
+            analysis['message'] = message
+            analysis['sender'] = sender
+            analysis['message_id'] = idx
+            
+            results.append(analysis)
+            person_analyses[sender].append(analysis)
+        
+        # Calculate abuse indicators for each person
+        person_indicators = {}
+        for person, messages in person_analyses.items():
+            person_indicators[person] = analyzer.calculate_abuse_indicators(messages)
         
-        # Format analysis
-        html = format_analysis_results(analysis)
+        # Generate reports
+        summary_report = generate_summary_report(person_indicators, results, report_type)
+        detailed_report = generate_detailed_report(results, person_indicators, report_type)
+        downloadable_report = generate_downloadable_report(results, person_indicators, report_type)
+        
+        return summary_report, detailed_report, downloadable_report
         
-        return html
     except Exception as e:
-        logger.error(f"Error in handle_message_analysis: {e}")
-        logger.error(traceback.format_exc())
-        return f"<p style='color: #1f2937;'>Error analyzing message: {str(e)}</p>"
+        return f"Error processing file: {str(e)}", "", ""
+
+def generate_summary_report(person_indicators, results, report_type):
+    """Generate summary report identifying potential abuser"""
+    
+    # Sort people by abuse likelihood
+    sorted_people = sorted(person_indicators.items(), key=lambda x: x[1]['abuse_likelihood'], reverse=True)
+    
+    report = f"# Communication Analysis Summary Report\n"
+    report += f"**Report Type:** {report_type}\n"
+    report += f"**Analysis Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+    report += f"**Total Messages Analyzed:** {len(results)}\n\n"
+    
+    report += "## Abuse Likelihood Rankings\n\n"
+    
+    for i, (person, indicators) in enumerate(sorted_people, 1):
+        risk_level = "HIGH" if indicators['abuse_likelihood'] > 0.7 else "MEDIUM" if indicators['abuse_likelihood'] > 0.4 else "LOW"
+        
+        report += f"### {i}. {person}\n"
+        report += f"- **Risk Level:** {risk_level}\n"
+        report += f"- **Abuse Likelihood Score:** {indicators['abuse_likelihood']:.3f}\n"
+        report += f"- **Average DARVO Score:** {indicators['avg_darvo_score']:.3f}\n"
+        report += f"- **Negative Sentiment Ratio:** {indicators['negative_sentiment_ratio']:.3f}\n"
+        report += f"- **Fallacy Usage Ratio:** {indicators['fallacy_ratio']:.3f}\n"
+        report += f"- **Total Messages:** {indicators['total_messages']}\n\n"
+    
+    if sorted_people:
+        primary_concern = sorted_people[0]
+        if primary_concern[1]['abuse_likelihood'] > 0.6:
+            report += f"## ⚠️ Primary Concern\n"
+            report += f"**{primary_concern[0]}** shows the highest indicators of potentially abusive communication patterns.\n\n"
+    
+    return report
+
+def generate_detailed_report(results, person_indicators, report_type):
+    """Generate detailed analysis report"""
+    
+    report = f"# Detailed Communication Analysis\n\n"
+    
+    # High-risk messages
+    high_risk_messages = [r for r in results if r.get('darvo_score', 0) > 0.7]
+    
+    if high_risk_messages:
+        report += "## High-Risk Messages (DARVO Score > 0.7)\n\n"
+        for msg in high_risk_messages[:10]:  # Limit to top 10
+            report += f"**Sender:** {msg['sender']}\n"
+            report += f"**Message:** \"{msg['message'][:200]}{'...' if len(msg['message']) > 200 else ''}\"\n"
+            report += f"**DARVO Score:** {msg['darvo_score']:.3f}\n"
+            report += f"**Sentiment:** {msg.get('sentiment', 'N/A')}\n"
+            report += f"**Fallacy Type:** {msg.get('fallacy_type', 'N/A')}\n\n"
+    
+    # Pattern analysis
+    report += "## Communication Patterns\n\n"
+    for person, indicators in person_indicators.items():
+        if indicators['abuse_likelihood'] > 0.5:
+            report += f"### {person} - Pattern Analysis\n"
+            report += f"- Frequently uses DARVO tactics ({indicators['high_darvo_messages']} high-scoring messages)\n"
+            report += f"- {indicators['negative_sentiment_ratio']*100:.1f}% of messages have negative sentiment\n"
+            report += f"- Uses logical fallacies in {indicators['fallacy_ratio']*100:.1f}% of messages\n\n"
+    
+    return report
+
+def generate_downloadable_report(results, person_indicators, report_type):
+    """Generate downloadable comprehensive report"""
+    
+    report_data = {
+        "analysis_metadata": {
+            "report_type": report_type,
+            "analysis_date": datetime.now().isoformat(),
+            "total_messages": len(results),
+            "total_participants": len(person_indicators)
+        },
+        "person_indicators": person_indicators,
+        "high_risk_messages": [r for r in results if r.get('darvo_score', 0) > 0.6],
+        "summary": {
+            "primary_concern": max(person_indicators.items(), key=lambda x: x[1]['abuse_likelihood']) if person_indicators else None
+        }
+    }
+    
+    # Convert to JSON string for download
+    return json.dumps(report_data, indent=2, default=str)
 
+# Create Gradio interface
 def create_interface():
-    """Create Gradio interface"""
-    with gr.Blocks(title="Relationship Pattern Analyzer Pro") as demo:
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px;">
-            <h1>Relationship Pattern Analyzer Pro</h1>
-            <p>Upload a chat history file to analyze communication patterns and identify concerning behaviors.</p>
-        </div>
+    with gr.Blocks(title="Communication Analysis Tool", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🔍 Communication Analysis Tool
+        
+        This tool analyzes communication patterns to identify potentially abusive behavior using multiple AI models:
+        - **DARVO Detection**: Identifies Deny, Attack, Reverse Victim & Offender tactics
+        - **Sentiment Analysis**: Analyzes emotional tone
+        - **Fallacy Detection**: Identifies logical fallacies
+        - **Boundary Analysis**: Detects healthy vs unhealthy boundaries
+        
+        **For use by therapists, counselors, and law enforcement professionals.**
         """)
         
-        with gr.Tab("Chat Analysis"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    file_input = gr.File(
-                        label="Upload Chat File (CSV, XLSX, or JSON)",
-                        file_types=["csv", "xlsx", "json"]
-                    )
-                    analyze_button = gr.Button("Analyze Chat History")
-                
-                with gr.Column(scale=2):
-                    summary_output = gr.HTML(
-                        label="Analysis Summary",
-                        value="<p style='color: #1f2937;'>Upload a file and click 'Analyze Chat History' to see results.</p>",
-                        elem_id="summary_output"
-                    )
-            
-            with gr.Row():
-                with gr.Column():
-                    timeline_plot = gr.Plot(label="Abuse Score Timeline")
-                
-                with gr.Column():
-                    pattern_plot = gr.Plot(label="Pattern Frequency")
-            
-            with gr.Row():
-                with gr.Column():
-                    sender_plot = gr.Plot(label="Sender Comparison")
-                
-                with gr.Column():
-                    heatmap_plot = gr.Plot(label="Time of Day Analysis")
-            
-            with gr.Row():
-                safety_plan_output = gr.HTML(
-                    label="Safety Plan",
-                    value="<p style='color: #1f2937;'>Safety plan will appear here after analysis.</p>"
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(
+                    label="Upload CSV File",
+                    file_types=[".csv"],
+                    type="filepath"
                 )
-        
-        with gr.Tab("Single Message Analysis"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    message_input = gr.Textbox(
-                        label="Enter Message",
-                        placeholder="Type or paste a message to analyze...",
-                        lines=5
-                    )
-                    analyze_message_button = gr.Button("Analyze Message")
                 
-                with gr.Column(scale=2):
-                    message_analysis_output = gr.HTML(
-                        label="Message Analysis",
-                        value="<p style='color: #1f2937;'>Enter a message and click 'Analyze Message' to see results.</p>"
-                    )
-        
-        with gr.Tab("About"):
-            gr.HTML("""
-            <div style="padding: 20px;">
-                <h2>About Relationship Pattern Analyzer Pro</h2>
-                <p>This tool helps identify potentially concerning communication patterns in relationships.</p>
+                message_col = gr.Textbox(
+                    label="Message Column Name",
+                    value="message",
+                    placeholder="Enter the column name containing messages"
+                )
                 
-                <h3>Features</h3>
-                <ul>
-                    <li><strong>Chat Analysis:</strong> Upload an entire chat history to analyze communication patterns over time</li>
-                    <li><strong>Temporal Analysis:</strong> Detect escalation patterns, cycles of abuse, and time-based trends</li>
-                    <li><strong>Boundary Health:</strong> Assess whether messages demonstrate healthy or unhealthy relational boundaries</li>
-                    <li><strong>Intent Analysis:</strong> Identify manipulative tactics and emotional tone</li>
-                    <li><strong>Safety Planning:</strong> Get personalized safety recommendations based on detected patterns</li>
-                    <li><strong>Professional Insights:</strong> View recommendations for professional intervention</li>
-                </ul>
+                sender_col = gr.Textbox(
+                    label="Sender Column Name", 
+                    value="sender",
+                    placeholder="Enter the column name containing sender names"
+                )
                 
-                <h3>Privacy Notice</h3>
-                <p>Your data is processed locally and is not stored or shared. This tool is for educational purposes only and not a substitute for professional counseling or legal advice.</p>
+                report_type = gr.Radio(
+                    choices=["Therapeutic Assessment", "Legal Documentation", "General Analysis"],
+                    label="Report Type",
+                    value="General Analysis"
+                )
                 
-                <h3>Emergency Resources</h3>
-                <p><strong>National Domestic Violence Hotline:</strong> 1-800-799-7233</p>
-                <p><strong>Crisis Text Line:</strong> Text START to 88788</p>
-                <p><strong>Emergency:</strong> Call 911</p>
-            </div>
-            """)
-        
-        # Connect event handlers
-        analyze_button.click(
-            handle_file_analysis,
-            inputs=[file_input],
-            outputs=[
-                summary_output,
-                timeline_plot,
-                pattern_plot,
-                sender_plot,
-                heatmap_plot,
-                safety_plan_output
-            ]
-        )
+                analyze_btn = gr.Button("Analyze Communication", variant="primary")
         
-        analyze_message_button.click(
-            handle_message_analysis,
-            inputs=[message_input],
-            outputs=[message_analysis_output]
+        with gr.Row():
+            with gr.Column():
+                summary_output = gr.Markdown(label="Summary Report")
+            
+            with gr.Column():
+                detailed_output = gr.Markdown(label="Detailed Analysis")
+        
+        download_output = gr.File(label="Download Complete Report (JSON)")
+        
+        def process_and_create_download(file, message_col, sender_col, report_type):
+            summary, detailed, report_data = analyze_csv_file(file, message_col, sender_col, report_type)
+            
+            # Create downloadable file
+            if report_data:
+                filename = f"communication_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+                with open(filename, 'w') as f:
+                    f.write(report_data)
+                return summary, detailed, filename
+            
+            return summary, detailed, None
+        
+        analyze_btn.click(
+            fn=process_and_create_download,
+            inputs=[file_input, message_col, sender_col, report_type],
+            outputs=[summary_output, detailed_output, download_output]
         )
+        
+        gr.Markdown("""
+        ## Instructions:
+        1. Upload a CSV file containing communication data
+        2. Specify the column names for messages and senders
+        3. Choose the appropriate report type
+        4. Click "Analyze Communication" to generate reports
+        5. Download the complete analysis for your records
+        
+        **Note:** This tool is designed to assist professionals in identifying concerning communication patterns. 
+        Results should be interpreted by qualified professionals and used as part of a comprehensive assessment.
+        """)
     
-    return demo
+    return interface
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-
+    interface = create_interface()
+    interface.launch()