Update app.py

app.py

@@ -11,6 +11,8 @@ from datetime import datetime
 from torch.nn.functional import sigmoid
 from collections import Counter
 import logging
+import traceback
+
 
 # Set up logging
 logging.basicConfig(level=logging.DEBUG)
@@ -490,32 +492,50 @@ def generate_abuse_score_chart(dates, scores, patterns):
 
 def analyze_composite(msg1, msg2, msg3, *answers_and_none):
     """Analyze multiple messages and checklist responses"""
+    logger.debug("\n====== STARTING NEW ANALYSIS ======")
     try:
         # Process checklist responses
+        logger.debug("\n--- Checklist Processing ---")
         none_selected_checked = answers_and_none[-1]
         responses_checked = any(answers_and_none[:-1])
         none_selected = not responses_checked and none_selected_checked
+        
+        logger.debug(f"None selected checked: {none_selected_checked}")
+        logger.debug(f"Responses checked: {responses_checked}")
+        logger.debug(f"None selected: {none_selected}")
 
         if none_selected:
             escalation_score = 0
             escalation_note = "Checklist completed: no danger items reported."
             escalation_completed = True
+            logger.debug("No items selected in checklist")
         elif responses_checked:
             escalation_score = sum(w for (_, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]) if a)
             escalation_note = "Checklist completed."
             escalation_completed = True
+            logger.debug(f"Checklist completed with score: {escalation_score}")
+            # Log checked items
+            logger.debug("Checked items:")
+            for (q, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]):
+                if a:
+                    logger.debug(f"• {q} (weight: {w})")
         else:
             escalation_score = None
             escalation_note = "Checklist not completed."
             escalation_completed = False
+            logger.debug("Checklist not completed")
 
         # Process messages
+        logger.debug("\n--- Message Processing ---")
         messages = [msg1, msg2, msg3]
         active = [(m, f"Message {i+1}") for i, m in enumerate(messages) if m.strip()]
+        logger.debug(f"Number of active messages: {len(active)}")
         if not active:
+            logger.debug("No messages provided")
             return "Please enter at least one message.", None
 
         # Detect threats
+        logger.debug("\n--- Threat Detection ---")
         def normalize(text):
             import unicodedata
             text = text.lower().strip()
@@ -532,8 +552,32 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         flat_threats = [t for sublist in immediate_threats for t in sublist]
         threat_risk = "Yes" if flat_threats else "No"
         
+        if flat_threats:
+            logger.debug("Detected threats:")
+            for threat in flat_threats:
+                logger.debug(f"• {threat}")
+        else:
+            logger.debug("No explicit threats detected")
+        
         # Analyze each message
-        results = [(analyze_single_message(m, THRESHOLDS.copy()), d) for m, d in active]
+        logger.debug("\n--- Individual Message Analysis ---")
+        results = []
+        for m, d in active:
+            logger.debug(f"\nAnalyzing {d}:")
+            logger.debug("-" * 40)
+            result = analyze_single_message(m, THRESHOLDS.copy())
+            results.append((result, d))
+            
+            # Log results for each message
+            abuse_score, patterns, matched_scores, sentiment, stage, darvo_score, tone = result
+            logger.debug(f"Results for {d}:")
+            logger.debug(f"• Abuse Score: {abuse_score}")
+            logger.debug(f"• Patterns: {patterns}")
+            logger.debug(f"• Matched Scores: {matched_scores}")
+            logger.debug(f"• Sentiment: {sentiment['label']}")
+            logger.debug(f"• Stage: {stage}")
+            logger.debug(f"• DARVO Score: {darvo_score}")
+            logger.debug(f"• Tone: {tone}")
 
         # Extract scores and metadata
         abuse_scores = [r[0][0] for r in results]
@@ -542,8 +586,11 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         tone_tags = [r[0][6] for r in results]
         dates_used = [r[1] for r in results]
 
-        # Analyze patterns
+        logger.debug("\n--- Pattern Analysis ---")
         predicted_labels = [label for r in results for label in r[0][1]]
+        logger.debug(f"All detected patterns: {predicted_labels}")
+                # Pattern severity analysis
+        logger.debug("\n--- Pattern Severity Analysis ---")
         high = {'control'}
         moderate = {'gaslighting', 'dismissiveness', 'obscure language', 'insults', 
                    'contradictory statements', 'guilt tripping'}
@@ -553,65 +600,91 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         for label in predicted_labels:
             if label in high:
                 counts['high'] += 1
+                logger.debug(f"High severity pattern found: {label}")
             elif label in moderate:
                 counts['moderate'] += 1
+                logger.debug(f"Moderate severity pattern found: {label}")
             elif label in low:
                 counts['low'] += 1
+                logger.debug(f"Low severity pattern found: {label}")
+
+        logger.debug(f"Pattern counts - High: {counts['high']}, Moderate: {counts['moderate']}, Low: {counts['low']}")
 
         # Pattern escalation logic
+        logger.debug("\n--- Escalation Risk Assessment ---")
         if counts['high'] >= 2 and counts['moderate'] >= 2:
             pattern_escalation_risk = "Critical"
+            logger.debug("Critical risk: Multiple high and moderate patterns")
         elif (counts['high'] >= 2 and counts['moderate'] >= 1) or \
              (counts['moderate'] >= 3) or \
              (counts['high'] >= 1 and counts['moderate'] >= 2):
             pattern_escalation_risk = "High"
+            logger.debug("High risk: Significant pattern combination")
         elif (counts['moderate'] == 2) or \
              (counts['high'] == 1 and counts['moderate'] == 1) or \
              (counts['moderate'] == 1 and counts['low'] >= 2) or \
              (counts['high'] == 1 and sum(counts.values()) == 1):
             pattern_escalation_risk = "Moderate"
+            logger.debug("Moderate risk: Concerning pattern combination")
         else:
             pattern_escalation_risk = "Low"
+            logger.debug("Low risk: Limited pattern severity")
 
-        # Calculate escalation risk
+        # Calculate checklist escalation risk
+        logger.debug("\n--- Checklist Risk Assessment ---")
         checklist_escalation_risk = "Unknown" if escalation_score is None else (
             "Critical" if escalation_score >= 20 else
             "Moderate" if escalation_score >= 10 else
             "Low"
         )
+        logger.debug(f"Checklist escalation risk: {checklist_escalation_risk}")
 
         # Calculate escalation bump
+        logger.debug("\n--- Escalation Bump Calculation ---")
         escalation_bump = 0
-        for result, _ in results:
+        for result, msg_id in results:
             abuse_score, _, _, sentiment, stage, darvo_score, tone_tag = result
+            logger.debug(f"\nChecking escalation factors for {msg_id}:")
             if darvo_score > 0.65:
                 escalation_bump += 3
+                logger.debug("• +3 for high DARVO score")
             if tone_tag in ["forced accountability flip", "emotional threat"]:
                 escalation_bump += 2
+                logger.debug("• +2 for concerning tone")
             if abuse_score > 80:
                 escalation_bump += 2
+                logger.debug("• +2 for high abuse score")
             if stage == 2:
                 escalation_bump += 3
+                logger.debug("• +3 for escalation stage")
+
+        logger.debug(f"Total escalation bump: +{escalation_bump}")
 
         # Calculate combined risk
+        logger.debug("\n--- Combined Risk Calculation ---")
         def rank(label):
             return {"Low": 0, "Moderate": 1, "High": 2, "Critical": 3, "Unknown": 0}.get(label, 0)
 
         combined_score = rank(pattern_escalation_risk) + rank(checklist_escalation_risk) + escalation_bump
+        logger.debug(f"Combined risk score: {combined_score}")
+        
         escalation_risk = (
             "Critical" if combined_score >= 6 else
             "High" if combined_score >= 4 else
             "Moderate" if combined_score >= 2 else
             "Low"
         )
+        logger.debug(f"Final escalation risk: {escalation_risk}")
 
         # Build escalation text
+        logger.debug("\n--- Building Output Text ---")
         if escalation_score is None:
             escalation_text = (
                 "🚫 **Escalation Potential: Unknown** (Checklist not completed)\n"
                 "⚠️ This section was not completed. Escalation potential is estimated using message data only.\n"
             )
             hybrid_score = 0
+            logger.debug("Generated unknown escalation text")
         elif escalation_score == 0:
             escalation_text = (
                 "✅ **Escalation Checklist Completed:** No danger items reported.\n"
@@ -621,6 +694,7 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
                 f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
             )
             hybrid_score = escalation_bump
+            logger.debug("Generated no-risk escalation text")
         else:
             hybrid_score = escalation_score + escalation_bump
             escalation_text = (
@@ -630,15 +704,20 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
                 f"• Checklist Risk: {checklist_escalation_risk}\n"
                 f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
             )
+            logger.debug(f"Generated escalation text with hybrid score: {hybrid_score}")
 
-        # Composite Abuse Score
+        # Calculate composite abuse score
+        logger.debug("\n--- Final Scores ---")
         composite_abuse = int(round(sum(abuse_scores) / len(abuse_scores)))
+        logger.debug(f"Composite abuse score: {composite_abuse}")
 
         # Get most common stage
         most_common_stage = max(set(stages), key=stages.count)
         stage_text = RISK_STAGE_LABELS[most_common_stage]
+        logger.debug(f"Most common stage: {most_common_stage}")
 
-        # Build output text
+        # Build final output
+        logger.debug("\n--- Generating Final Output ---")
         out = f"Abuse Intensity: {composite_abuse}%\n"
         out += "📊 This reflects the strength and severity of detected abuse patterns in the message(s).\n\n"
 
@@ -649,6 +728,7 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
             "Moderate" if composite_abuse >= 50 or hybrid_score >= 10 else
             "Low"
         )
+        logger.debug(f"Final risk level: {risk_level}")
         
         risk_descriptions = {
             "Critical": (
@@ -678,40 +758,52 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
 
         # Add DARVO analysis
         avg_darvo = round(sum(darvo_scores) / len(darvo_scores), 3)
+        logger.debug(f"Average DARVO score: {avg_darvo}")
         if avg_darvo > 0.25:
             level = "moderate" if avg_darvo < 0.65 else "high"
             out += f"\n\n🎭 **DARVO Score: {avg_darvo}** → This indicates a **{level} likelihood** of narrative reversal (DARVO), where the speaker may be denying, attacking, or reversing blame."
 
         # Add emotional tones
+        logger.debug("\n--- Adding Emotional Tones ---")
         out += "\n\n🎭 **Emotional Tones Detected:**\n"
         for i, tone in enumerate(tone_tags):
             out += f"• Message {i+1}: *{tone or 'none'}*\n"
+            logger.debug(f"Message {i+1} tone: {tone}")
 
         # Add threats section
+        logger.debug("\n--- Adding Threat Analysis ---")
         if flat_threats:
             out += "\n\n🚨 **Immediate Danger Threats Detected:**\n"
             for t in set(flat_threats):
                 out += f"• \"{t}\"\n"
             out += "\n⚠️ These phrases may indicate an imminent risk to physical safety."
+            logger.debug(f"Added {len(flat_threats)} threat warnings")
         else:
             out += "\n\n🧩 **Immediate Danger Threats:** None explicitly detected.\n"
             out += "This does *not* rule out risk, but no direct threat phrases were matched."
+            logger.debug("No threats to add")
 
         # Generate timeline
+        logger.debug("\n--- Generating Timeline ---")
         pattern_labels = [
             pats[0][0] if (pats := r[0][2]) else "none"
             for r in results
         ]
         timeline_image = generate_abuse_score_chart(dates_used, abuse_scores, pattern_labels)
+        logger.debug("Timeline generated successfully")
         
         # Add escalation text
         out += "\n\n" + escalation_text
+        
+        logger.debug("\n====== ANALYSIS COMPLETE ======\n")
         return out, timeline_image
 
     except Exception as e:
         logger.error(f"Error in analyze_composite: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
         return "An error occurred during analysis.", None
 
+
 # Gradio Interface Setup
 def create_interface():
     try: