Update analyzer.py

analyzer.py

@@ -188,136 +188,223 @@ class MessageAnalyzer:
             }
     
     def analyze_chat_history(self, df):
-        """Analyze entire chat history"""
-        from utils import detect_escalation_patterns, generate_safety_plan, generate_professional_recommendations
+    """Analyze entire chat history"""
+    from utils import detect_escalation_patterns, generate_safety_plan, generate_professional_recommendations
+    
+    logger.info(f"Analyzing chat history with {len(df)} messages")
+    
+    try:
+        # Create results dataframe
+        results_df = df.copy()
         
-        logger.info(f"Analyzing chat history with {len(df)} messages")
+        # Add analysis columns
+        results_df['abuse_score'] = 0.0
+        results_df['detected_patterns'] = [[] for _ in range(len(results_df))]
+        results_df['sentiment'] = "neutral"
+        results_df['darvo_score'] = 0.0
+        results_df['emotional_tone'] = "neutral"
+        results_df['boundary_health'] = "unknown"
+        results_df['risk_level'] = "Low"
         
-        try:
-            # Create results dataframe
-            results_df = df.copy()
-            
-            # Add analysis columns
-            results_df['abuse_score'] = 0.0
-            results_df['detected_patterns'] = [[] for _ in range(len(results_df))]
-            results_df['sentiment'] = "neutral"
-            results_df['darvo_score'] = 0.0
-            results_df['emotional_tone'] = "neutral"
-            results_df['boundary_health'] = "unknown"
-            results_df['risk_level'] = "Low"
-            
-            # Analyze each message
-            for i, row in results_df.iterrows():
-                analysis = self.analyze_message(row['message'])
-                
-                # Update dataframe with analysis results
-                results_df.at[i, 'abuse_score'] = analysis['abuse_score']
-                results_df.at[i, 'detected_patterns'] = analysis['detected_patterns']
-                results_df.at[i, 'sentiment'] = analysis['sentiment']
-                results_df.at[i, 'darvo_score'] = analysis['darvo_score']
-                results_df.at[i, 'emotional_tone'] = analysis['emotional_tone']
-                results_df.at[i, 'boundary_health'] = analysis['boundary_assessment']['assessment']
-                results_df.at[i, 'risk_level'] = analysis['risk_level']
-            
-            # Calculate sender statistics
-            sender_stats = {}
-            for sender in results_df['sender'].unique():
-                sender_df = results_df[results_df['sender'] == sender]
-                
-                # Calculate key metrics
-                avg_abuse = sender_df['abuse_score'].mean()
-                max_abuse = sender_df['abuse_score'].max()
-                
-                # Get most common patterns
-                all_patterns = []
-                for patterns in sender_df['detected_patterns']:
-                    if patterns:
-                        all_patterns.extend(patterns)
-                
-                pattern_counts = Counter(all_patterns)
-                most_common = pattern_counts.most_common(3)
-                
-                # Calculate percentage of abusive messages
-                abusive_count = len(sender_df[sender_df['abuse_score'] >= 50])
-                abusive_pct = (abusive_count / len(sender_df)) * 100 if len(sender_df) > 0 else 0
-                
-                # Store stats
-                sender_stats[sender] = {
-                    'message_count': len(sender_df),
-                    'avg_abuse_score': avg_abuse,
-                    'max_abuse_score': max_abuse,
-                    'abusive_message_count': abusive_count,
-                    'abusive_message_pct': abusive_pct,
-                    'common_patterns': most_common
-                }
-            
-            # Detect escalation patterns
-            escalation_data = detect_escalation_patterns(results_df)
+        # Analyze each message
+        for i, row in results_df.iterrows():
+            analysis = self.analyze_message(row['message'])
+            
+            # Update dataframe with analysis results
+            results_df.at[i, 'abuse_score'] = analysis['abuse_score']
+            results_df.at[i, 'detected_patterns'] = analysis['detected_patterns']
+            results_df.at[i, 'sentiment'] = analysis['sentiment']
+            results_df.at[i, 'darvo_score'] = analysis['darvo_score']
+            results_df.at[i, 'emotional_tone'] = analysis['emotional_tone']
+            results_df.at[i, 'boundary_health'] = analysis['boundary_assessment']['assessment']
+            results_df.at[i, 'risk_level'] = analysis['risk_level']
+        
+        # Calculate sender statistics
+        sender_stats = {}
+        for sender in results_df['sender'].unique():
+            sender_df = results_df[results_df['sender'] == sender]
             
-            # Determine overall risk level
-            if results_df['risk_level'].isin(['Critical']).any():
-                overall_risk = "Critical"
-            elif results_df['risk_level'].isin(['High']).any():
-                overall_risk = "High"
-            elif results_df['risk_level'].isin(['Moderate']).any():
-                overall_risk = "Moderate"
-            else:
-                overall_risk = "Low"
+            # Calculate key metrics
+            avg_abuse = sender_df['abuse_score'].mean()
+            max_abuse = sender_df['abuse_score'].max()
             
-            # Generate safety plan
+            # Get most common patterns
             all_patterns = []
-            for patterns in results_df['detected_patterns']:
+            for patterns in sender_df['detected_patterns']:
                 if patterns:
                     all_patterns.extend(patterns)
             
-            safety_plan = generate_safety_plan(overall_risk, all_patterns, escalation_data)
+            pattern_counts = Counter(all_patterns)
+            most_common = pattern_counts.most_common(5)  # Get top 5 patterns
+            
+            # Calculate percentage of abusive messages
+            abusive_count = len(sender_df[sender_df['abuse_score'] >= 50])
+            abusive_pct = (abusive_count / len(sender_df)) * 100 if len(sender_df) > 0 else 0
+            
+            # Calculate emotional tone distribution
+            tone_counts = Counter(sender_df['emotional_tone'])
+            most_common_tones = tone_counts.most_common(3)  # Get top 3 emotional tones
+            
+            # Calculate DARVO score statistics
+            avg_darvo = sender_df['darvo_score'].mean()
+            high_darvo_count = len(sender_df[sender_df['darvo_score'] >= 0.65])
+            high_darvo_pct = (high_darvo_count / len(sender_df)) * 100 if len(sender_df) > 0 else 0
+            
+            # Calculate risk level distribution
+            risk_counts = Counter(sender_df['risk_level'])
+            
+            # Store stats
+            sender_stats[sender] = {
+                'message_count': len(sender_df),
+                'avg_abuse_score': avg_abuse,
+                'max_abuse_score': max_abuse,
+                'abusive_message_count': abusive_count,
+                'abusive_message_pct': abusive_pct,
+                'common_patterns': most_common,
+                'emotional_tones': most_common_tones,
+                'avg_darvo_score': avg_darvo,
+                'high_darvo_count': high_darvo_count,
+                'high_darvo_pct': high_darvo_pct,
+                'risk_levels': risk_counts
+            }
+        
+        # Detect escalation patterns
+        escalation_data = detect_escalation_patterns(results_df)
+        
+        # Determine overall risk level
+        if results_df['risk_level'].isin(['Critical']).any():
+            overall_risk = "Critical"
+        elif results_df['risk_level'].isin(['High']).any():
+            overall_risk = "High"
+        elif results_df['risk_level'].isin(['Moderate']).any():
+            overall_risk = "Moderate"
+        else:
+            overall_risk = "Low"
+        
+        # Generate safety plan
+        all_patterns = []
+        for patterns in results_df['detected_patterns']:
+            if patterns:
+                all_patterns.extend(patterns)
+        
+        safety_plan = generate_safety_plan(overall_risk, all_patterns, escalation_data)
+        
+        # Identify primary abuser (if any)
+        primary_abuser = None
+        max_abusive_pct = 0
+        
+        for sender, stats in sender_stats.items():
+            if stats['message_count'] >= 5 and stats['abusive_message_pct'] > max_abusive_pct:
+                max_abusive_pct = stats['abusive_message_pct']
+                primary_abuser = sender
+        
+        # Only identify primary abuser if they have significant abusive content
+        if max_abusive_pct < 20:
+            primary_abuser = None
             
-            # Generate professional recommendations
-            recommendations = generate_professional_recommendations(results_df, escalation_data, overall_risk)
+        # Create detailed primary abuser analysis
+        primary_abuser_analysis = None
+        if primary_abuser:
+            abuser_df = results_df[results_df['sender'] == primary_abuser]
+            
+            # Get example messages for each pattern
+            pattern_examples = {}
+            for pattern in set([p for patterns in abuser_df['detected_patterns'] for p in patterns]):
+                # Find messages with this pattern
+                pattern_msgs = abuser_df[abuser_df['detected_patterns'].apply(lambda x: pattern in x)]
+                if not pattern_msgs.empty:
+                    # Get highest scoring example
+                    example = pattern_msgs.iloc[pattern_msgs['abuse_score'].argmax()]
+                    pattern_examples[pattern] = {
+                        'message': example['message'],
+                        'abuse_score': example['abuse_score'],
+                        'timestamp': example['timestamp'].strftime('%Y-%m-%d %H:%M')
+                    }
             
-            # Identify primary abuser (if any)
-            primary_abuser = None
-            max_abusive_pct = 0
-            
-            for sender, stats in sender_stats.items():
-                if stats['message_count'] >= 5 and stats['abusive_message_pct'] > max_abusive_pct:
-                    max_abusive_pct = stats['abusive_message_pct']
-                    primary_abuser = sender
-            
-            # Only identify primary abuser if they have significant abusive content
-            if max_abusive_pct < 20:
-                primary_abuser = None
-            
-            # Prepare summary
-            summary = {
-                'message_count': len(results_df),
-                'date_range': {
-                    'start': results_df['timestamp'].min().strftime('%Y-%m-%d'),
-                    'end': results_df['timestamp'].max().strftime('%Y-%m-%d')
-                },
-                'overall_risk_level': overall_risk,
-                'sender_stats': sender_stats,
-                'primary_abuser': primary_abuser,
-                'escalation_data': escalation_data,
-                'safety_plan': safety_plan,
-                'recommendations': recommendations
-            }
+            # Get time-based patterns
+            abuser_df['hour'] = abuser_df['timestamp'].dt.hour
+            abuser_df['day_of_week'] = abuser_df['timestamp'].dt.day_name()
             
-            return results_df, summary
+            # Find peak abuse hours
+            hour_abuse = abuser_df.groupby('hour')['abuse_score'].mean()
+            peak_hours = hour_abuse.nlargest(3).index.tolist() if not hour_abuse.empty else []
             
-        except Exception as e:
-            logger.error(f"Error in analyze_chat_history: {e}")
-            logger.error(traceback.format_exc())
-            return df, {
-                'message_count': len(df),
-                'date_range': {
-                    'start': df['timestamp'].min().strftime('%Y-%m-%d') if not df.empty else 'unknown',
-                    'end': df['timestamp'].max().strftime('%Y-%m-%d') if not df.empty else 'unknown'
-                },
-                'overall_risk_level': "Unknown",
-                'sender_stats': {},
-                'primary_abuser': None,
-                'escalation_data': {},
-                'safety_plan': "Error generating safety plan.",
-                'recommendations': []
+            # Find peak abuse days
+            day_abuse = abuser_df.groupby('day_of_week')['abuse_score'].mean()
+            peak_days = day_abuse.nlargest(3).index.tolist() if not day_abuse.empty else []
+            
+            # Calculate response patterns (how they respond to the other person)
+            response_patterns = []
+            if len(results_df) >= 10:  # Need enough messages for meaningful analysis
+                # Sort by timestamp
+                sorted_df = results_df.sort_values('timestamp')
+                
+                # Find messages where primary abuser responds to other person
+                for i in range(1, len(sorted_df)):
+                    if (sorted_df.iloc[i]['sender'] == primary_abuser and 
+                        sorted_df.iloc[i-1]['sender'] != primary_abuser):
+                        # This is a response
+                        trigger_msg = sorted_df.iloc[i-1]
+                        response_msg = sorted_df.iloc[i]
+                        
+                        if response_msg['abuse_score'] >= 50:  # Only track abusive responses
+                            response_patterns.append({
+                                'trigger': trigger_msg['message'],
+                                'response': response_msg['message'],
+                                'response_patterns': response_msg['detected_patterns'],
+                                'response_score': response_msg['abuse_score'],
+                                'timestamp': response_msg['timestamp'].strftime('%Y-%m-%d %H:%M')
+                            })
+            
+            # Store the detailed analysis
+            primary_abuser_analysis = {
+                'sender': primary_abuser,
+                'message_count': len(abuser_df),
+                'avg_abuse_score': abuser_df['abuse_score'].mean(),
+                'pattern_examples': pattern_examples,
+                'peak_hours': peak_hours,
+                'peak_days': peak_days,
+                'response_patterns': response_patterns[:5],  # Limit to top 5
+                'emotional_tones': sender_stats[primary_abuser]['emotional_tones'],
+                'darvo_score': sender_stats[primary_abuser]['avg_darvo_score']
             }
+        
+        # Generate professional recommendations
+        recommendations = generate_professional_recommendations(results_df, escalation_data, overall_risk)
+        
+        # Prepare summary
+        summary = {
+            'message_count': len(results_df),
+            'date_range': {
+                'start': results_df['timestamp'].min().strftime('%Y-%m-%d'),
+                'end': results_df['timestamp'].max().strftime('%Y-%m-%d')
+            },
+            'overall_risk_level': overall_risk,
+            'sender_stats': sender_stats,
+            'primary_abuser': primary_abuser,
+            'primary_abuser_analysis': primary_abuser_analysis,  # Add detailed analysis
+            'escalation_data': escalation_data,
+            'safety_plan': safety_plan,
+            'recommendations': recommendations
+        }
+        
+        return results_df, summary
+        
+    except Exception as e:
+        logger.error(f"Error in analyze_chat_history: {e}")
+        logger.error(traceback.format_exc())
+        return df, {
+            'message_count': len(df),
+            'date_range': {
+                'start': df['timestamp'].min().strftime('%Y-%m-%d') if not df.empty else 'unknown',
+                'end': df['timestamp'].max().strftime('%Y-%m-%d') if not df.empty else 'unknown'
+            },
+            'overall_risk_level': "Unknown",
+            'sender_stats': {},
+            'primary_abuser': None,
+            'primary_abuser_analysis': None,
+            'escalation_data': {},
+            'safety_plan': "Error generating safety plan.",
+            'recommendations': []
+        }
+