Update app.py

app.py

@@ -21,6 +21,40 @@ logger = logging.getLogger(__name__)
 # Device configuration
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 logger.info(f"Using device: {device}")
+# Set up custom logging
+class CustomFormatter(logging.Formatter):
+    """Custom formatter with colors and better formatting"""
+    grey = "\x1b[38;21m"
+    blue = "\x1b[38;5;39m"
+    yellow = "\x1b[38;5;226m"
+    red = "\x1b[38;5;196m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+
+    format_str = "%(message)s"
+
+    FORMATS = {
+        logging.DEBUG: blue + format_str + reset,
+        logging.INFO: grey + format_str + reset,
+        logging.WARNING: yellow + format_str + reset,
+        logging.ERROR: red + format_str + reset,
+        logging.CRITICAL: bold_red + format_str + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+# Setup logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+# Create console handler with custom formatter
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(CustomFormatter())
+logger.handlers = [ch]
 
 # Model initialization
 model_name = "SamanthaStorm/tether-multilabel-v4"
@@ -492,50 +526,57 @@ 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 ======")
+    logger.debug("\n🔄 STARTING NEW ANALYSIS")
+    logger.debug("=" * 50)
     try:
         # Process checklist responses
-        logger.debug("\n--- Checklist Processing ---")
+        logger.debug("\n📋 CHECKLIST PROCESSING")
+        logger.debug("=" * 50)
         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}")
+        logger.debug("Checklist Status:")
+        logger.debug(f"  • None Selected Box: {'✓' if none_selected_checked else '✗'}")
+        logger.debug(f"  • Has Responses: {'✓' if responses_checked else '✗'}")
+        logger.debug(f"  • Final Status: {'None Selected' if none_selected else 'Has Selections'}")
 
         if none_selected:
             escalation_score = 0
             escalation_note = "Checklist completed: no danger items reported."
             escalation_completed = True
-            logger.debug("No items selected in checklist")
+            logger.debug("\n✓ Checklist: No items selected")
         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}")
+            logger.debug(f"\n📊 Checklist Score: {escalation_score}")
+            
             # Log checked items
-            logger.debug("Checked items:")
+            logger.debug("\n⚠️ Selected Risk Factors:")
             for (q, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]):
                 if a:
-                    logger.debug(f"• {q} (weight: {w})")
+                    logger.debug(f"  • [{w} points] {q}")
         else:
             escalation_score = None
             escalation_note = "Checklist not completed."
             escalation_completed = False
-            logger.debug("Checklist not completed")
+            logger.debug("\n❗ Checklist: Not completed")
 
         # Process messages
-        logger.debug("\n--- Message Processing ---")
+        logger.debug("\n📝 MESSAGE PROCESSING")
+        logger.debug("=" * 50)
         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)}")
+        logger.debug(f"Active Messages: {len(active)} of 3")
+        
         if not active:
-            logger.debug("No messages provided")
+            logger.debug("❌ Error: No messages provided")
             return "Please enter at least one message.", None
 
         # Detect threats
-        logger.debug("\n--- Threat Detection ---")
+        logger.debug("\n🚨 THREAT DETECTION")
+        logger.debug("=" * 50)
         def normalize(text):
             import unicodedata
             text = text.lower().strip()
@@ -553,31 +594,40 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         threat_risk = "Yes" if flat_threats else "No"
         
         if flat_threats:
-            logger.debug("Detected threats:")
+            logger.debug("⚠️ DETECTED THREATS:")
             for threat in flat_threats:
-                logger.debug(f"• {threat}")
+                logger.debug(f"  • {threat}")
         else:
-            logger.debug("No explicit threats detected")
-        
+            logger.debug("✓ No explicit threats detected")
         # Analyze each message
-        logger.debug("\n--- Individual Message Analysis ---")
+        logger.debug("\n🔍 INDIVIDUAL MESSAGE ANALYSIS")
+        logger.debug("=" * 50)
         results = []
         for m, d in active:
-            logger.debug(f"\nAnalyzing {d}:")
-            logger.debug("-" * 40)
+            logger.debug(f"\n📝 ANALYZING {d}")
+            logger.debug("=" * 40)
             result = analyze_single_message(m, THRESHOLDS.copy())
             results.append((result, d))
             
-            # Log results for each message
+            # Unpack results for cleaner logging
             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}")
+            
+            # Log core metrics
+            logger.debug("\n📊 CORE METRICS")
+            logger.debug(f"  • Abuse Score: {abuse_score:.1f}%")
+            logger.debug(f"  • DARVO Score: {darvo_score:.3f}")
+            logger.debug(f"  • Risk Stage: {stage}")
+            logger.debug(f"  • Sentiment: {sentiment['label']}")
+            logger.debug(f"  • Tone: {tone}")
+
+            # Log detected patterns with scores
+            if patterns:
+                logger.debug("\n🎯 DETECTED PATTERNS")
+                for label, score, weight in matched_scores:
+                    severity = "❗HIGH" if label in high else "⚠️ MODERATE" if label in moderate else "📝 LOW"
+                    logger.debug(f"  • {severity} | {label}: {score:.3f} (weight: {weight})")
+            else:
+                logger.debug("\n✓ No abuse patterns detected")
 
         # Extract scores and metadata
         abuse_scores = [r[0][0] for r in results]
@@ -586,87 +636,115 @@ 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]
 
-        logger.debug("\n--- Pattern Analysis ---")
+        # Pattern Analysis
+        logger.debug("\n📈 PATTERN ANALYSIS SUMMARY")
+        logger.debug("=" * 50)
         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'}
-        low = {'blame shifting', 'projection', 'recovery'}
         
+        if predicted_labels:
+            logger.debug("Detected Patterns Across All Messages:")
+            for label in set(predicted_labels):
+                count = predicted_labels.count(label)
+                if label in high:
+                    logger.debug(f"  ❗ HIGH: {label} (×{count})")
+                elif label in moderate:
+                    logger.debug(f"  ⚠️ MODERATE: {label} (×{count})")
+                elif label in low:
+                    logger.debug(f"  📝 LOW: {label} (×{count})")
+        else:
+            logger.debug("✓ No patterns detected across messages")
+
+        # Pattern Severity Analysis
+        logger.debug("\n⚖️ SEVERITY ANALYSIS")
+        logger.debug("=" * 50)
         counts = {'high': 0, 'moderate': 0, 'low': 0}
         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']}")
+        logger.debug("Pattern Distribution:")
+        logger.debug(f"  ❗ High Severity: {counts['high']}")
+        logger.debug(f"  ⚠️ Moderate Severity: {counts['moderate']}")
+        logger.debug(f"  📝 Low Severity: {counts['low']}")
 
-        # Pattern escalation logic
-        logger.debug("\n--- Escalation Risk Assessment ---")
+        # Risk Assessment
+        logger.debug("\n🎯 RISK ASSESSMENT")
+        logger.debug("=" * 50)
         if counts['high'] >= 2 and counts['moderate'] >= 2:
             pattern_escalation_risk = "Critical"
-            logger.debug("Critical risk: Multiple high and moderate patterns")
+            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")
+            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")
+            logger.debug("⚡ MODERATE RISK: Concerning pattern combination")
         else:
             pattern_escalation_risk = "Low"
-            logger.debug("Low risk: Limited pattern severity")
+            logger.debug("📝 LOW RISK: Limited pattern severity")
 
-        # Calculate checklist escalation risk
-        logger.debug("\n--- Checklist Risk Assessment ---")
+        # Checklist Risk Assessment
+        logger.debug("\n📋 CHECKLIST RISK ASSESSMENT")
+        logger.debug("=" * 50)
         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 ---")
+        logger.debug(f"Risk Level: {checklist_escalation_risk}")
+        if escalation_score is not None:
+            logger.debug(f"Score: {escalation_score}/29")
+        # Escalation Analysis
+        logger.debug("\n📈 ESCALATION ANALYSIS")
+        logger.debug("=" * 50)
         escalation_bump = 0
         for result, msg_id in results:
             abuse_score, _, _, sentiment, stage, darvo_score, tone_tag = result
-            logger.debug(f"\nChecking escalation factors for {msg_id}:")
+            logger.debug(f"\n🔍 Message {msg_id} Escalation Factors:")
+            
+            factors = []
             if darvo_score > 0.65:
                 escalation_bump += 3
-                logger.debug("• +3 for high DARVO score")
+                factors.append("▲ +3: High DARVO score ({darvo_score:.3f})")
             if tone_tag in ["forced accountability flip", "emotional threat"]:
                 escalation_bump += 2
-                logger.debug("• +2 for concerning tone")
+                factors.append(f"▲ +2: Concerning tone ({tone_tag})")
             if abuse_score > 80:
                 escalation_bump += 2
-                logger.debug("• +2 for high abuse score")
+                factors.append(f"▲ +2: High abuse score ({abuse_score:.1f}%)")
             if stage == 2:
                 escalation_bump += 3
-                logger.debug("• +3 for escalation stage")
+                factors.append("▲ +3: Escalation stage")
+                
+            if factors:
+                for factor in factors:
+                    logger.debug(f"  {factor}")
+            else:
+                logger.debug("  ✓ No escalation factors")
 
-        logger.debug(f"Total escalation bump: +{escalation_bump}")
+        logger.debug(f"\n📊 Total Escalation Bump: +{escalation_bump}")
 
-        # Calculate combined risk
-        logger.debug("\n--- Combined Risk Calculation ---")
+        # Combined Risk Calculation
+        logger.debug("\n🎯 FINAL RISK CALCULATION")
+        logger.debug("=" * 50)
         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}")
+        logger.debug("Risk Components:")
+        logger.debug(f"  • Pattern Risk: {pattern_escalation_risk} (+{rank(pattern_escalation_risk)})")
+        logger.debug(f"  • Checklist Risk: {checklist_escalation_risk} (+{rank(checklist_escalation_risk)})")
+        logger.debug(f"  • Escalation Bump: +{escalation_bump}")
+        logger.debug(f"  = Combined Score: {combined_score}")
         
         escalation_risk = (
             "Critical" if combined_score >= 6 else
@@ -674,17 +752,18 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
             "Moderate" if combined_score >= 2 else
             "Low"
         )
-        logger.debug(f"Final escalation risk: {escalation_risk}")
+        logger.debug(f"\n⚠️ Final Escalation Risk: {escalation_risk}")
 
-        # Build escalation text
-        logger.debug("\n--- Building Output Text ---")
+        # Generate Output Text
+        logger.debug("\n📝 GENERATING OUTPUT")
+        logger.debug("=" * 50)
         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")
+            logger.debug("Generated output for incomplete checklist")
         elif escalation_score == 0:
             escalation_text = (
                 "✅ **Escalation Checklist Completed:** No danger items reported.\n"
@@ -694,7 +773,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")
+            logger.debug("Generated output for no-risk checklist")
         else:
             hybrid_score = escalation_score + escalation_bump
             escalation_text = (
@@ -704,32 +783,36 @@ 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}")
+            logger.debug(f"Generated output with hybrid score: {hybrid_score}/29")
 
-        # Calculate composite abuse score
-        logger.debug("\n--- Final Scores ---")
+        # Final Metrics
+        logger.debug("\n📊 FINAL METRICS")
+        logger.debug("=" * 50)
         composite_abuse = int(round(sum(abuse_scores) / len(abuse_scores)))
-        logger.debug(f"Composite abuse score: {composite_abuse}")
-
-        # Get most common stage
+        logger.debug(f"Composite Abuse Score: {composite_abuse}%")
+        
         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}")
+        logger.debug(f"Most Common Stage: {most_common_stage}")
+        
+        avg_darvo = round(sum(darvo_scores) / len(darvo_scores), 3)
+        logger.debug(f"Average DARVO Score: {avg_darvo}")
 
-        # Build final output
-        logger.debug("\n--- Generating Final Output ---")
+        # Generate Final Output
+        logger.debug("\n📄 GENERATING FINAL REPORT")
+        logger.debug("=" * 50)
         out = f"Abuse Intensity: {composite_abuse}%\n"
         out += "📊 This reflects the strength and severity of detected abuse patterns in the message(s).\n\n"
 
-        # Add risk assessment
+        # Risk Level Assessment
         risk_level = (
             "Critical" if composite_abuse >= 85 or hybrid_score >= 20 else
             "High" if composite_abuse >= 70 or hybrid_score >= 15 else
             "Moderate" if composite_abuse >= 50 or hybrid_score >= 10 else
             "Low"
         )
-        logger.debug(f"Final risk level: {risk_level}")
-        
+        logger.debug(f"Final Risk Level: {risk_level}")
+
+        # Add Risk Description
         risk_descriptions = {
             "Critical": (
                 "🚨 **Risk Level: Critical**\n"
@@ -754,24 +837,23 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         }
         
         out += risk_descriptions[risk_level]
-        out += f"\n\n{stage_text}"
+        out += f"\n\n{RISK_STAGE_LABELS[most_common_stage]}"
 
-        # Add DARVO analysis
-        avg_darvo = round(sum(darvo_scores) / len(darvo_scores), 3)
-        logger.debug(f"Average DARVO score: {avg_darvo}")
+        # Add DARVO Analysis
         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."
+            logger.debug(f"Added DARVO analysis ({level} level)")
 
-        # Add emotional tones
-        logger.debug("\n--- Adding Emotional Tones ---")
+        # 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 ---")
+        # 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):
@@ -783,8 +865,8 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
             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 ---")
+        # Generate Timeline
+        logger.debug("\n📈 Generating Timeline")
         pattern_labels = [
             pats[0][0] if (pats := r[0][2]) else "none"
             for r in results
@@ -792,18 +874,23 @@ def analyze_composite(msg1, msg2, msg3, *answers_and_none):
         timeline_image = generate_abuse_score_chart(dates_used, abuse_scores, pattern_labels)
         logger.debug("Timeline generated successfully")
         
-        # Add escalation text
+        # Add Escalation Text
         out += "\n\n" + escalation_text
         
-        logger.debug("\n====== ANALYSIS COMPLETE ======\n")
+        logger.debug("\n✅ ANALYSIS COMPLETE")
+        logger.debug("=" * 50)
         return out, timeline_image
 
     except Exception as e:
-        logger.error(f"Error in analyze_composite: {e}")
-        logger.error(f"Traceback: {traceback.format_exc()}")
+        logger.error("\n❌ ERROR IN ANALYSIS")
+        logger.error("=" * 50)
+        logger.error(f"Error type: {type(e).__name__}")
+        logger.error(f"Error message: {str(e)}")
+        logger.error(f"Traceback:\n{traceback.format_exc()}")
         return "An error occurred during analysis.", None
 
 
+
 # Gradio Interface Setup
 def create_interface():
     try: