Create app.py

app.py

@@ -1,74 +1,445 @@
 import gradio as gr
-import os
-import json
 import pandas as pd
-from datetime import datetime, timedelta
 import numpy as np
-from analyzer import TetherProAnalyzer
+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)}
 
-# --- Sample data for testing ---
-def create_sample_data():
-    sample = []
-    now = datetime.now() - timedelta(days=30)
-    for i in range(15):
-        base = 25 + i*3.5 + (20 if i%5==0 else 0)
-        abuse = min(95, max(5, base + np.random.normal(0,8)))
-        sample.append({
-            'timestamp': (now + timedelta(days=i*2)).isoformat(),
-            'id': f'msg_{i:03d}',
-            'text': f"Sample message {i}",
-            'sender': 'A' if i%2==0 else 'B',
-            'abuse_score': round(abuse,1),
-            'darvo_score': round(min(1, max(0,0.2 + i*0.05)),3),
-            'boundary_health': 'unhealthy' if abuse>50 else 'healthy',
-            'patterns': ['control','gaslighting'] if abuse>60 else ['dismissiveness'],
-            'emotional_tone': 'neutral',
-            'risk_level': 'low'
-        })
-    return json.dumps(sample, indent=2)
+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)
+        
+        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"
+        }
 
-# --- CSV/XLS loader with timestamp conversion ---
-def load_messages_from_file(file_obj):
-    ext = os.path.splitext(file_obj.name)[1].lower()
+def format_analysis_results(analysis):
+    """Format analysis results for display"""
     try:
-        if ext == '.csv':
-            df = pd.read_csv(file_obj.name)
-        elif ext in ('.xls','.xlsx'):
-            df = pd.read_excel(file_obj.name)
+        # Format abuse score
+        abuse_score_html = f"""
+        <div style="margin-bottom: 20px;">
+            <h3>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>Risk Level: <strong>{analysis['risk_level']}</strong></p>
+        </div>
+        """
+        
+        # Format detected patterns
+        patterns_html = "<h3>Detected Patterns</h3>"
+        if analysis['detected_patterns']:
+            patterns_html += "<ul>"
+            for pattern in analysis['detected_patterns']:
+                patterns_html += f"<li>{pattern}</li>"
+            patterns_html += "</ul>"
         else:
-            return {'error': 'Upload a .csv or .xlsx'}
+            patterns_html += "<p>No concerning patterns detected.</p>"
+        
+        # Format sentiment and emotional tone
+        sentiment_html = f"""
+        <h3>Communication Analysis</h3>
+        <p><strong>Sentiment:</strong> {analysis['sentiment']}</p>
+        <p><strong>Emotional Tone:</strong> {analysis['emotional_tone']}</p>
+        <p><strong>DARVO Score:</strong> {analysis['darvo_score']:.3f}</p>
+        """
+        
+        # Format boundary assessment
+        boundary_html = f"""
+        <h3>Boundary Health</h3>
+        <p><strong>Assessment:</strong> {analysis['boundary_assessment']['assessment']}</p>
+        <p><strong>Description:</strong> {analysis['boundary_assessment']['description']}</p>
+        """
+        
+        # Combine all sections
+        html = f"""
+        <div style="padding: 20px; border: 1px solid #ddd; border-radius: 10px;">
+            {abuse_score_html}
+            {patterns_html}
+            {sentiment_html}
+            {boundary_html}
+        </div>
+        """
+        
+        return html
     except Exception as e:
-        return {'error': f'Failed to read file: {e}'}
+        logger.error(f"Error formatting analysis results: {e}")
+        return f"<p>Error formatting results: {str(e)}</p>"
 
-    records = df.to_dict(orient='records')
-    for r in records:
-        for k,v in r.items():
-            if hasattr(v, 'isoformat'):
-                r[k] = v.isoformat()
-    return json.dumps(records)
+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 analyze_uploaded_file(file_obj):
-    js = load_messages_from_file(file_obj)
-    if isinstance(js, dict):
-        return js
-    return TetherProAnalyzer().analyze_conversation_history(js)
+def format_summary_results(summary):
+    """Format summary results for display"""
+    try:
+        # Format basic info
+        basic_info = f"""
+        <h2>Chat Analysis Summary</h2>
+        <p><strong>Messages Analyzed:</strong> {summary['message_count']}</p>
+        <p><strong>Date Range:</strong> {summary['date_range']['start']} to {summary['date_range']['end']}</p>
+        <p><strong>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>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;'>Sender</th>"
+            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd;'>Messages</th>"
+            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd;'>Avg. Abuse Score</th>"
+            sender_stats += "<th style='text-align: left; padding: 8px; border-bottom: 1px solid #ddd;'>Common Patterns</th></tr>"
+            
+            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;'>{sender}</td>"
+                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd;'>{stats['message_count']}</td>"
+                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd;'>{stats['avg_abuse_score']:.1f}%</td>"
+                sender_stats += f"<td style='padding: 8px; border-bottom: 1px solid #ddd;'>{common_patterns}</td></tr>"
+            
+            sender_stats += "</table>"
+        else:
+            sender_stats += "<p>No sender statistics available.</p>"
+        
+        # Format primary abuser
+        primary_abuser = "<h3>Primary Concern</h3>"
+        if summary['primary_abuser']:
+            primary_abuser += f"<p>The analysis indicates that <strong>{summary['primary_abuser']}</strong> "
+            primary_abuser += "shows the highest percentage of concerning communication patterns.</p>"
+        else:
+            primary_abuser += "<p>No clear pattern of concerning communication from a specific sender.</p>"
+        
+        # Format escalation data
+        escalation = "<h3>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)
+            
+            escalation += f"<p><strong>Trend Direction:</strong> {trend.title()}</p>"
+            escalation += f"<p><strong>Trend Strength:</strong> {trend_strength:.2f}</p>"
+            escalation += f"<p><strong>Recent Average:</strong> {recent_avg:.1f}%</p>"
+            
+            if future_prediction is not None:
+                escalation += f"<p><strong>7-Day Prediction:</strong> {future_prediction:.1f}%</p>"
+            
+            if cyclic_pattern:
+                cycle_period = summary['escalation_data'].get('cycle_period', 'unknown')
+                escalation += f"<p><strong>Cyclic Pattern Detected:</strong> Yes (approximately {cycle_period} days)</p>"
+        else:
+            escalation += "<p>No escalation data available.</p>"
+        
+        # Format recommendations
+        recommendations = "<h3>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: 10px; background: #f8f9fa; border-radius: 5px;'>"
+                recommendations += f"<h4>{rec['title']}</h4>"
+                recommendations += f"<p>{rec['description']}</p>"
+                
+                if rec['actions']:
+                    recommendations += "<ul>"
+                    for action in rec['actions']:
+                        recommendations += f"<li>{action}</li>"
+                    recommendations += "</ul>"
+                
+                recommendations += "</div>"
+            recommendations += "</div>"
+        else:
+            recommendations += "<p>No recommendations available.</p>"
+        
+        # Combine all sections
+        html = f"""
+        <div style="padding: 20px; border: 1px solid #ddd; border-radius: 10px;">
+            {basic_info}
+            {sender_stats}
+            {primary_abuser}
+            {escalation}
+            {recommendations}
+        </div>
+        """
+        
+        return html
+    except Exception as e:
+        logger.error(f"Error formatting summary results: {e}")
+        return f"<p>Error formatting summary: {str(e)}</p>"
 
-# --- Gradio UI ---
-css = """
-.gradio-container { max-width: 1200px !important; margin: auto; }
-"""
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("# Tether Pro Conversation Analyzer")
-    with gr.Row():
-        uploader = gr.File(label="Upload .csv or .xlsx", file_types=[".csv",".xlsx"])
-        btn = gr.Button("Analyze")
-    result = gr.JSON(label="Analysis Results")
-    btn.click(analyze_uploaded_file, inputs=uploader, outputs=result)
+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: #f8f9fa;">
+            <h2>Safety Plan</h2>
+            <div style="white-space: pre-wrap;">
+                {html}
+            </div>
+        </div>
+        """
+        
+        return html
+    except Exception as e:
+        logger.error(f"Error formatting safety plan: {e}")
+        return f"<p>Error formatting safety plan: {str(e)}</p>"
 
-    gr.Markdown("## Sample Data")
-    sample_btn = gr.Button("Load Sample")
-    sample_box = gr.Textbox(lines=10)
-    sample_btn.click(create_sample_data, inputs=None, outputs=sample_box)
+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.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>Upload a file and click 'Analyze Chat History' to see results.</p>"
+                    )
+            
+            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>Safety plan will appear here after analysis.</p>"
+                )
+        
+        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>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>
+                
+                <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>
+                
+                <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>
+                
+                <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>
+            """)
+        
+        # Define event handlers
+        def handle_file_analysis(file_path):
+            if not file_path:
+                return (
+                    "<p>Please upload a file first.</p>",
+                    None, None, None, None,
+                    "<p>Please upload a file first.</p>"
+                )
+            
+            try:
+                # Analyze file
+                results_df, summary = analyze_file(file_path)
+                
+                if "error" in summary:
+                    return (
+                        f"<p>Error: {summary['error']}</p>",
+                        None, None, None, None,
+                        "<p>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'])
+                
+                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>Error analyzing file: {str(e)}</p>",
+                    None, None, None, None,
+                    "<p>Error analyzing file.</p>"
+                )
+        
+        def handle_message_analysis(message):
+            if not message.strip():
+                return "<p>Please enter a message first.</p>"
+            
+            try:
+                # Analyze message
+                analysis = analyze_single_message(message)
+                
+                if "error" in analysis:
+                    return f"<p>Error: {analysis['error']}</p>"
+                
+                # Format analysis
+                html = format_analysis_results(analysis)
+                
+                return html
+            except Exception as e:
+                logger.error(f"Error in handle_message_analysis: {e}")
+                logger.error(traceback.format_exc())
+                return f"<p>Error analyzing message: {str(e)}</p>"
+        
+        # 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_message_button.click(
+            handle_message_analysis,
+            inputs=[message_input],
+            outputs=[message_analysis_output]
+        )
+    
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = create_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)