Create analyzer.py

analyzer.py

@@ -31,7 +31,6 @@ class MessageAnalyzer:
             "false equivalence": 0.317,
             "future faking": 0.385
         }
-        
     def analyze_message(self, text):
         """Analyze a single message for abuse patterns"""
         from utils import (
@@ -186,7 +185,6 @@ class MessageAnalyzer:
                 'boundary_assessment': {'assessment': 'error', 'confidence': 0.0},
                 'risk_level': "Unknown"
             }
-    
     def identify_primary_abuser(self, results_df):
         """Identify the primary abuser based on comprehensive abuse metrics with pattern severity weighting"""
         logger.info("Identifying primary abuser...")
@@ -297,9 +295,8 @@ class MessageAnalyzer:
         
         logger.info(f"Primary abuser identified: {primary_abuser}")
         return primary_abuser, sender_abuse_metrics
-    
     def analyze_chat_history(self, df):
-        """Analyze entire chat history with focus on primary abuser"""
+        """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")
@@ -330,10 +327,7 @@ class MessageAnalyzer:
                 results_df.at[i, 'boundary_health'] = analysis['boundary_assessment']['assessment']
                 results_df.at[i, 'risk_level'] = analysis['risk_level']
             
-            # Identify primary abuser FIRST
-            primary_abuser, sender_abuse_metrics = self.identify_primary_abuser(results_df)
-            
-            # Calculate traditional sender statistics for backward compatibility
+            # Calculate sender statistics
             sender_stats = {}
             for sender in results_df['sender'].unique():
                 sender_df = results_df[results_df['sender'] == sender]
@@ -382,107 +376,47 @@ class MessageAnalyzer:
                     'risk_levels': risk_counts
                 }
             
-            # If no primary abuser identified, provide basic analysis
-            if not primary_abuser:
-                logger.info("No primary abuser identified - providing general analysis")
-                
-                # 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)
-                
-                # Generate 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,
-                    'sender_abuse_metrics': sender_abuse_metrics,
-                    'primary_abuser': None,
-                    'primary_abuser_analysis': None,
-                    'escalation_data': escalation_data,
-                    'safety_plan': safety_plan,
-                    'recommendations': recommendations,
-                    'analysis_focus': 'general'
-                }
-                
-                return results_df, summary
-            
-            # Focus analysis on primary abuser
-            logger.info(f"Focusing analysis on primary abuser: {primary_abuser}")
-            abuser_df = results_df[results_df['sender'] == primary_abuser]
-            victim_df = results_df[results_df['sender'] != primary_abuser]
-            
-            # Generate comprehensive primary abuser analysis
-            primary_abuser_analysis = self._analyze_primary_abuser(
-                abuser_df, victim_df, results_df, primary_abuser
-            ) if hasattr(self, '_analyze_primary_abuser') else None
+            # Identify primary abuser
+            primary_abuser, sender_abuse_metrics = self.identify_primary_abuser(results_df)
             
-            # Detect escalation patterns (focus on abuser's messages)
-            escalation_data = detect_escalation_patterns(abuser_df)
+            # Detect escalation patterns
+            escalation_data = detect_escalation_patterns(results_df)
             
-            # Determine overall risk level based on primary abuser
-            abuser_risk_levels = abuser_df['risk_level'].value_counts()
-            if 'Critical' in abuser_risk_levels and abuser_risk_levels['Critical'] > 0:
+            # Determine overall risk level
+            if results_df['risk_level'].isin(['Critical']).any():
                 overall_risk = "Critical"
-            elif 'High' in abuser_risk_levels and abuser_risk_levels['High'] > 0:
+            elif results_df['risk_level'].isin(['High']).any():
                 overall_risk = "High"
-            elif 'Moderate' in abuser_risk_levels and abuser_risk_levels['Moderate'] > 0:
+            elif results_df['risk_level'].isin(['Moderate']).any():
                 overall_risk = "Moderate"
             else:
                 overall_risk = "Low"
             
-            # Generate safety plan based on abuser's patterns
-            abuser_patterns = []
-            for patterns in abuser_df['detected_patterns']:
+            # Generate safety plan
+            all_patterns = []
+            for patterns in results_df['detected_patterns']:
                 if patterns:
-                    abuser_patterns.extend(patterns)
+                    all_patterns.extend(patterns)
             
-            safety_plan = generate_safety_plan(overall_risk, abuser_patterns, escalation_data)
+            safety_plan = generate_safety_plan(overall_risk, all_patterns, escalation_data)
             
-            # Generate recommendations focused on the abuser's behavior
-            recommendations = generate_professional_recommendations(abuser_df, escalation_data, overall_risk)
+            # Generate professional recommendations
+            recommendations = generate_professional_recommendations(results_df, escalation_data, overall_risk)
             
-            # Prepare focused summary
+            # Prepare summary
             summary = {
                 'message_count': len(results_df),
-                'abuser_message_count': len(abuser_df),
-                'victim_message_count': len(victim_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,  # Include traditional sender stats for backward compatibility
-                'sender_abuse_metrics': sender_abuse_metrics,  # Include detailed abuse metrics
+                'sender_stats': sender_stats,
+                'sender_abuse_metrics': sender_abuse_metrics,
                 'primary_abuser': primary_abuser,
-                'primary_abuser_analysis': primary_abuser_analysis,
                 'escalation_data': escalation_data,
                 'safety_plan': safety_plan,
-                'recommendations': recommendations,
-                'analysis_focus': 'primary_abuser'  # Flag to indicate focused analysis
+                'recommendations': recommendations
             }
             
             return results_df, summary
@@ -500,192 +434,7 @@ class MessageAnalyzer:
                 'sender_stats': {},
                 'sender_abuse_metrics': {},
                 'primary_abuser': None,
-                'primary_abuser_analysis': None,
                 'escalation_data': {},
                 'safety_plan': "Error generating safety plan.",
-                'recommendations': [],
-                'analysis_focus': 'error'
+                'recommendations': []
             }
-
-    def _analyze_primary_abuser(self, abuser_df, victim_df, full_df, primary_abuser):
-        """Generate comprehensive analysis of the primary abuser"""
-        
-        # Basic statistics
-        avg_abuse = abuser_df['abuse_score'].mean()
-        max_abuse = abuser_df['abuse_score'].max()
-        abusive_count = len(abuser_df[abuser_df['abuse_score'] >= 50])
-        abusive_pct = (abusive_count / len(abuser_df)) * 100
-        
-        # Pattern analysis
-        all_patterns = []
-        for patterns in abuser_df['detected_patterns']:
-            if patterns:
-                all_patterns.extend(patterns)
-        
-        pattern_counts = Counter(all_patterns)
-        most_common_patterns = pattern_counts.most_common(10)
-        
-        # Get example messages for top patterns
-        pattern_examples = {}
-        for pattern, count in most_common_patterns[:5]:  # Top 5 patterns
-            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'),
-                    'frequency': count
-                }
-        
-        # Temporal patterns
-        abuser_df_copy = abuser_df.copy()
-        abuser_df_copy['hour'] = abuser_df_copy['timestamp'].dt.hour
-        abuser_df_copy['day_of_week'] = abuser_df_copy['timestamp'].dt.day_name()
-        
-        # Peak abuse times
-        hour_abuse = abuser_df_copy.groupby('hour')['abuse_score'].mean()
-        peak_hours = hour_abuse.nlargest(3).index.tolist() if not hour_abuse.empty else []
-        
-        day_abuse = abuser_df_copy.groupby('day_of_week')['abuse_score'].mean()
-        peak_days = day_abuse.nlargest(3).index.tolist() if not day_abuse.empty else []
-        
-        # Response pattern analysis
-        response_patterns = self._analyze_response_patterns(full_df, primary_abuser)
-        
-        # Escalation triggers
-        escalation_triggers = self._identify_escalation_triggers(abuser_df, victim_df)
-        
-        # Emotional and psychological profile
-        emotional_profile = {
-            'emotional_tones': Counter(abuser_df['emotional_tone']).most_common(5),
-            'avg_darvo_score': abuser_df['darvo_score'].mean(),
-            'high_darvo_incidents': len(abuser_df[abuser_df['darvo_score'] >= 0.65]),
-            'boundary_violations': len(abuser_df[abuser_df['boundary_health'] == 'unhealthy']),
-            'sentiment_distribution': Counter(abuser_df['sentiment']).most_common()
-        }
-        
-        # Risk assessment
-        risk_distribution = Counter(abuser_df['risk_level'])
-        critical_incidents = abuser_df[abuser_df['risk_level'] == 'Critical']
-        
-        return {
-            'sender': primary_abuser,
-            'message_count': len(abuser_df),
-            'avg_abuse_score': avg_abuse,
-            'max_abuse_score': max_abuse,
-            'abusive_message_count': abusive_count,
-            'abusive_message_pct': abusive_pct,
-            'most_common_patterns': most_common_patterns,
-            'pattern_examples': pattern_examples,
-            'peak_hours': peak_hours,
-            'peak_days': peak_days,
-            'response_patterns': response_patterns,
-            'escalation_triggers': escalation_triggers,
-            'emotional_profile': emotional_profile,
-            'risk_distribution': dict(risk_distribution),
-            'critical_incidents': len(critical_incidents),
-            'critical_incident_examples': [
-                {
-                    'message': row['message'],
-                    'score': row['abuse_score'],
-                    'patterns': row['detected_patterns'],
-                    'timestamp': row['timestamp'].strftime('%Y-%m-%d %H:%M')
-                }
-                for _, row in critical_incidents.head(3).iterrows()
-            ] if not critical_incidents.empty else []
-        }
-    
-    def _analyze_response_patterns(self, full_df, primary_abuser):
-        """Analyze how the primary abuser responds to the victim"""
-        response_patterns = []
-        
-        if len(full_df) < 10:
-            return response_patterns
-        
-        sorted_df = full_df.sort_values('timestamp')
-        
-        for i in range(1, len(sorted_df)):
-            current_msg = sorted_df.iloc[i]
-            previous_msg = sorted_df.iloc[i-1]
-            
-            # Check if this is abuser responding to victim
-            if (current_msg['sender'] == primary_abuser and 
-                previous_msg['sender'] != primary_abuser and
-                current_msg['abuse_score'] >= 40):  # Lowered threshold for response analysis
-                
-                response_patterns.append({
-                    'trigger_message': previous_msg['message'][:100] + "..." if len(previous_msg['message']) > 100 else previous_msg['message'],
-                    'trigger_sentiment': previous_msg['sentiment'],
-                    'response_message': current_msg['message'][:100] + "..." if len(current_msg['message']) > 100 else current_msg['message'],
-                    'response_score': current_msg['abuse_score'],
-                    'response_patterns': current_msg['detected_patterns'],
-                    'timestamp': current_msg['timestamp'].strftime('%Y-%m-%d %H:%M')
-                })
-        
-        # Return top 5 most abusive responses
-        return sorted(response_patterns, key=lambda x: x['response_score'], reverse=True)[:5]
-    
-    def _identify_escalation_triggers(self, abuser_df, victim_df):
-        """Identify what triggers escalation in the abuser's behavior"""
-        # This is a simplified version - could be expanded with more sophisticated analysis
-        triggers = []
-        
-        # Look for patterns in high-abuse messages
-        high_abuse_msgs = abuser_df[abuser_df['abuse_score'] >= 70]
-        
-        if not high_abuse_msgs.empty:
-            # Common words/themes in high-abuse messages
-            high_abuse_text = ' '.join(high_abuse_msgs['message'].str.lower())
-            
-            # Simple keyword analysis (could be enhanced with NLP)
-            trigger_keywords = ['leave', 'divorce', 'break up', 'end', 'done', 'over', 'police', 'help', 'family', 'friends']
-            found_triggers = [word for word in trigger_keywords if word in high_abuse_text]
-            
-            triggers.extend(found_triggers)
-        
-        return list(set(triggers))  # Remove duplicates
-    
-    def _generate_general_analysis(self, results_df, sender_abuse_metrics):
-        """Generate general analysis when no primary abuser is identified"""
-        from utils import detect_escalation_patterns, generate_safety_plan, generate_professional_recommendations
-        
-        # Calculate sender statistics for all participants
-        sender_stats = {}
-        for sender in results_df['sender'].unique():
-            sender_df = results_df[results_df['sender'] == sender]
-            
-            avg_abuse = sender_df['abuse_score'].mean()
-            max_abuse = sender_df['abuse_score'].max()
-            
-            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(5)
-            
-            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
-            
-            tone_counts = Counter(sender_df['emotional_tone'])
-            most_common_tones = tone_counts.most_common(3)
-            
-            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
-            
-            risk_counts = Counter(sender_df['risk_level'])
-            
-            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_