Update analyzer.py

analyzer.py

@@ -186,13 +186,12 @@ 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...")
-    
-    # Define pattern severity weights (higher = more concerning)
+        
+        # Define pattern severity weights (higher = more concerning)
         PATTERN_WEIGHTS = {
             "recovery phase": 0.7,
             "control": 1.4,
@@ -211,44 +210,44 @@ class MessageAnalyzer:
             "false equivalence": 1.3,
             "future faking": 0.8
         }
-    
+        
         sender_abuse_metrics = {}
-    
+        
         for sender in results_df['sender'].unique():
             sender_df = results_df[results_df['sender'] == sender]
-        
+            
             if len(sender_df) < 3:  # Need minimum messages for reliable assessment
                 continue
-            
+                
             # Calculate comprehensive abuse metrics
             avg_abuse = sender_df['abuse_score'].mean()
             max_abuse = sender_df['abuse_score'].max()
             abusive_count = len(sender_df[sender_df['abuse_score'] >= 50])
             abusive_pct = (abusive_count / len(sender_df)) * 100
-        
+            
             # Calculate pattern-weighted score
             pattern_counts = Counter()
             for patterns in sender_df['detected_patterns']:
                 pattern_counts.update(patterns)
-        
-        # Calculate weighted pattern score
+            
+            # Calculate weighted pattern score
             total_pattern_weight = 0
             for pattern, count in pattern_counts.items():
                 weight = PATTERN_WEIGHTS.get(pattern, 1.0)  # Default weight of 1.0
                 total_pattern_weight += count * weight
-        
-        # Normalize by message count
+            
+            # Normalize by message count
             weighted_pattern_score = total_pattern_weight / len(sender_df) if len(sender_df) > 0 else 0
-        
-        # DARVO score
+            
+            # DARVO score
             avg_darvo = sender_df['darvo_score'].mean()
             high_darvo_count = len(sender_df[sender_df['darvo_score'] >= 0.65])
-        
-        # Risk level distribution
+            
+            # Risk level distribution
             high_risk_count = len(sender_df[sender_df['risk_level'].isin(['High', 'Critical'])])
             high_risk_pct = (high_risk_count / len(sender_df)) * 100
-        
-        # Composite abuse score (weighted combination of factors)
+            
+            # Composite abuse score (weighted combination of factors)
             composite_score = (
                 avg_abuse * 0.25 +
                 abusive_pct * 0.2 +
@@ -256,8 +255,8 @@ class MessageAnalyzer:
                 avg_darvo * 100 * 0.15 +
                 high_risk_pct * 0.1
             )
-        
-        # Store detailed pattern information for reporting
+            
+            # Store detailed pattern information for reporting
             pattern_details = [
                 {
                     'pattern': pattern,
@@ -267,10 +266,10 @@ class MessageAnalyzer:
                 }
                 for pattern, count in pattern_counts.items()
             ]
-        
+            
             # Sort patterns by weighted score
             pattern_details.sort(key=lambda x: x['weighted_score'], reverse=True)
-        
+            
             sender_abuse_metrics[sender] = {
                 'message_count': len(sender_df),
                 'avg_abuse_score': avg_abuse,
@@ -282,234 +281,231 @@ class MessageAnalyzer:
                 'high_risk_pct': high_risk_pct,
                 'composite_score': composite_score
             }
-    
+        
         if not sender_abuse_metrics:
             return None, sender_abuse_metrics
-    
+        
         # Find primary abuser (highest composite score with minimum thresholds)
         primary_abuser = None
         max_composite = 0
-    
+        
         for sender, metrics in sender_abuse_metrics.items():
             if (metrics['composite_score'] > max_composite and 
                 metrics['message_count'] >= 5):
                 max_composite = metrics['composite_score']
                 primary_abuser = sender
-    
+        
         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"""
-    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()
-        
-        # 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']
-        
-        # Identify primary abuser FIRST
-        primary_abuser, sender_abuse_metrics = self.identify_primary_abuser(results_df)
-        
-        # Calculate traditional sender statistics for backward compatibility
-        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(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
+        """Analyze entire chat history with focus on primary abuser"""
+        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()
+            
+            # 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']
+            
+            # Identify primary abuser FIRST
+            primary_abuser, sender_abuse_metrics = self.identify_primary_abuser(results_df)
+            
+            # Calculate traditional sender statistics for backward compatibility
+            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(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
+                }
             
-            # 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
+            # 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
             
-            # Calculate risk level distribution
-            risk_counts = Counter(sender_df['risk_level'])
+            # 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]
             
-            # 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
-            }
-        
-        # If no primary abuser identified, provide basic analysis
-        if not primary_abuser:
-            logger.info("No primary abuser identified - providing general analysis")
+            # 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
             
-            # Detect escalation patterns
-            escalation_data = detect_escalation_patterns(results_df)
+            # Detect escalation patterns (focus on abuser's messages)
+            escalation_data = detect_escalation_patterns(abuser_df)
             
-            # Determine overall risk level
-            if results_df['risk_level'].isin(['Critical']).any():
+            # 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:
                 overall_risk = "Critical"
-            elif results_df['risk_level'].isin(['High']).any():
+            elif 'High' in abuser_risk_levels and abuser_risk_levels['High'] > 0:
                 overall_risk = "High"
-            elif results_df['risk_level'].isin(['Moderate']).any():
+            elif 'Moderate' in abuser_risk_levels and abuser_risk_levels['Moderate'] > 0:
                 overall_risk = "Moderate"
             else:
                 overall_risk = "Low"
             
-            # Generate safety plan
-            all_patterns = []
-            for patterns in results_df['detected_patterns']:
+            # Generate safety plan based on abuser's patterns
+            abuser_patterns = []
+            for patterns in abuser_df['detected_patterns']:
                 if patterns:
-                    all_patterns.extend(patterns)
+                    abuser_patterns.extend(patterns)
             
-            safety_plan = generate_safety_plan(overall_risk, all_patterns, escalation_data)
+            safety_plan = generate_safety_plan(overall_risk, abuser_patterns, escalation_data)
             
-            # Generate recommendations
-            recommendations = generate_professional_recommendations(results_df, escalation_data, overall_risk)
+            # Generate recommendations focused on the abuser's behavior
+            recommendations = generate_professional_recommendations(abuser_df, escalation_data, overall_risk)
             
-            # Prepare summary
+            # Prepare focused 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,
-                'sender_abuse_metrics': sender_abuse_metrics,
-                'primary_abuser': None,
-                'primary_abuser_analysis': None,
+                'sender_stats': sender_stats,  # Include traditional sender stats for backward compatibility
+                'sender_abuse_metrics': sender_abuse_metrics,  # Include detailed abuse metrics
+                'primary_abuser': primary_abuser,
+                'primary_abuser_analysis': primary_abuser_analysis,
                 'escalation_data': escalation_data,
                 'safety_plan': safety_plan,
                 'recommendations': recommendations,
-                'analysis_focus': 'general'
+                'analysis_focus': 'primary_abuser'  # Flag to indicate focused analysis
             }
             
             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
-        
-        # Detect escalation patterns (focus on abuser's messages)
-        escalation_data = detect_escalation_patterns(abuser_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:
-            overall_risk = "Critical"
-        elif 'High' in abuser_risk_levels and abuser_risk_levels['High'] > 0:
-            overall_risk = "High"
-        elif 'Moderate' in abuser_risk_levels and abuser_risk_levels['Moderate'] > 0:
-            overall_risk = "Moderate"
-        else:
-            overall_risk = "Low"
-        
-        # Generate safety plan based on abuser's patterns
-        abuser_patterns = []
-        for patterns in abuser_df['detected_patterns']:
-            if patterns:
-                abuser_patterns.extend(patterns)
-        
-        safety_plan = generate_safety_plan(overall_risk, abuser_patterns, escalation_data)
-        
-        # Generate recommendations focused on the abuser's behavior
-        recommendations = generate_professional_recommendations(abuser_df, escalation_data, overall_risk)
-        
-        # Prepare focused 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
-            '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
-        }
-        
-        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': {},
-            'sender_abuse_metrics': {},
-            'primary_abuser': None,
-            'primary_abuser_analysis': None,
-            'escalation_data': {},
-            'safety_plan': "Error generating safety plan.",
-            'recommendations': [],
-            'analysis_focus': 'error'
-        }
-
-
+            
+        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': {},
+                'sender_abuse_metrics': {},
+                'primary_abuser': None,
+                'primary_abuser_analysis': None,
+                'escalation_data': {},
+                'safety_plan': "Error generating safety plan.",
+                'recommendations': [],
+                'analysis_focus': 'error'
+            }
 
     def _analyze_primary_abuser(self, abuser_df, victim_df, full_df, primary_abuser):
         """Generate comprehensive analysis of the primary abuser"""
@@ -692,45 +688,4 @@ class MessageAnalyzer:
                 '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
-            }
-        
-        escalation_data = detect_escalation_patterns(results_df)
-        
-        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"
-        
-        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)
-        recommendations = generate_professional_recommendations(results_df, escalation_data, overall_risk)
-        
-        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': None,
-            'primary_abuser_analysis': None,
-            'sender_abuse_metrics': sender_abuse_metrics,
-            'escalation_data': escalation_data,
-            'safety_plan': safety_plan,
-            'recommendations': recommendations,
-            'analysis_focus': 'general'
-        }
-        
-        return results_df, summary
+                'high_