Create app.py

app.py

@@ -1,1054 +1,7 @@
-# Import necessary libraries
-import gradio as gr
-import spaces
-import torch
-import numpy as np
-import pandas as pd
-from datetime import datetime, timedelta
-from collections import defaultdict, Counter
-import json
-from typing import List, Dict, Tuple, Optional
-from dataclasses import dataclass, asdict
-from enum import Enum
-import matplotlib.pyplot as plt
-import io
-from PIL import Image
-import logging
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline as hf_pipeline
-from torch.nn.functional import sigmoid
-import re
+# main.py
+# (launch point)
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Device configuration
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-logger.info(f"Using device: {device}")
-
-# =============================================================================
-# LOAD ALL TETHER MODELS
-# =============================================================================
-
-print("🔄 Loading Tether Pro models...")
-
-# Main abuse detection model
-model_name = "SamanthaStorm/tether-multilabel-v6"
-model = AutoModelForSequenceClassification.from_pretrained(model_name).to(device)
-tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False)
-
-# Sentiment model
-sentiment_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-sentiment-v3").to(device)
-sentiment_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-sentiment-v3", use_fast=False)
-sentiment_model.eval()
-
-# DARVO model
-darvo_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1").to(device)
-darvo_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1", use_fast=False)
-darvo_model.eval()
-
-# Boundary health model
-boundary_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/healthy-boundary-predictor").to(device)
-boundary_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/healthy-boundary-predictor", use_fast=False)
-boundary_model.eval()
-
-# Emotion pipeline
-emotion_pipeline = hf_pipeline(
-    "text-classification",
-    model="j-hartmann/emotion-english-distilroberta-base",
-    return_all_scores=True,
-    top_k=None,
-    truncation=True,
-    device=0 if torch.cuda.is_available() else -1
-)
-
-print("✅ All models loaded successfully!")
-
-# =============================================================================
-# TETHER ANALYSIS CONSTANTS
-# =============================================================================
-
-LABELS = [
-    "recovery phase", "control", "gaslighting", "guilt tripping", "dismissiveness", 
-    "blame shifting", "nonabusive", "projection", "insults", 
-    "contradictory statements", "obscure language",
-    "veiled threats", "stalking language", "false concern", 
-    "false equivalence", "future faking"
-]
-
-SENTIMENT_LABELS = ["supportive", "undermining"]
-
-THRESHOLDS = {
-    "recovery phase": 0.278, "control": 0.287, "gaslighting": 0.144,
-    "guilt tripping": 0.220, "dismissiveness": 0.142, "blame shifting": 0.183,
-    "projection": 0.253, "insults": 0.247, "contradictory statements": 0.200,
-    "obscure language": 0.455, "nonabusive": 0.281, "veiled threats": 0.310,
-    "stalking language": 0.339, "false concern": 0.334, "false equivalence": 0.317,
-    "future faking": 0.385
-}
-
-PATTERN_WEIGHTS = {
-    "recovery phase": 0.7, "control": 1.4, "gaslighting": 1.3, "guilt tripping": 1.2,
-    "dismissiveness": 0.9, "blame shifting": 1.0, "projection": 0.5, "insults": 1.4,
-    "contradictory statements": 1.0, "obscure language": 0.9, "nonabusive": 0.0,
-    "veiled threats": 1.6, "stalking language": 1.8, "false concern": 1.1,
-    "false equivalence": 1.3, "future faking": 0.8
-}
-
-# =============================================================================
-# FULL TETHER ANALYSIS FUNCTIONS
-# =============================================================================
-
-@spaces.GPU
-def analyze_single_message_complete(text: str) -> Dict:
-    """Run complete Tether analysis on a single message"""
-    
-    try:
-        if not text.strip():
-            return {
-                'abuse_score': 0.0, 'darvo_score': 0.0, 'boundary_health': 'healthy',
-                'detected_patterns': [], 'emotional_tone': 'neutral', 'risk_level': 'low',
-                'sentiment': 'supportive'
-            }
-        
-        # 1. BOUNDARY HEALTH ANALYSIS
-        boundary_inputs = boundary_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
-        boundary_inputs = {k: v.to(device) for k, v in boundary_inputs.items()}
-        with torch.no_grad():
-            boundary_outputs = boundary_model(**boundary_inputs)
-            boundary_prediction = torch.argmax(boundary_outputs.logits, dim=-1).item()
-        boundary_health = 'healthy' if boundary_prediction == 1 else 'unhealthy'
-        
-        # 2. SENTIMENT ANALYSIS
-        sent_inputs = sentiment_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
-        sent_inputs = {k: v.to(device) for k, v in sent_inputs.items()}
-        with torch.no_grad():
-            sent_logits = sentiment_model(**sent_inputs).logits[0]
-            sent_probs = torch.softmax(sent_logits, dim=-1).cpu().numpy()
-        sentiment = SENTIMENT_LABELS[int(np.argmax(sent_probs))]
-        
-        # 3. ABUSE PATTERN DETECTION
-        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
-        inputs = {k: v.to(device) for k, v in inputs.items()}
-        with torch.no_grad():
-            outputs = model(**inputs)
-        raw_scores = torch.sigmoid(outputs.logits.squeeze(0)).cpu().numpy()
-        
-        # Apply thresholds
-        detected_patterns = []
-        matched_scores = []
-        for label, score in zip(LABELS, raw_scores):
-            if score > THRESHOLDS.get(label, 0.25):
-                detected_patterns.append(label)
-                weight = PATTERN_WEIGHTS.get(label, 1.0)
-                matched_scores.append((label, score, weight))
-        
-        # Calculate abuse score
-        if matched_scores:
-            total_weight = sum(weight for _, _, weight in matched_scores)
-            weighted_sum = sum(score * weight for _, score, weight in matched_scores)
-            abuse_score = (weighted_sum / total_weight) * 100 if total_weight > 0 else 0
-            
-            # Apply sentiment modifier
-            if sentiment == "supportive":
-                abuse_score *= 0.85
-                
-            abuse_score = min(round(abuse_score, 1), 95.0)
-        else:
-            abuse_score = 0.0
-        
-        # 4. DARVO SCORE
-        darvo_inputs = darvo_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
-        darvo_inputs = {k: v.to(device) for k, v in darvo_inputs.items()}
-        with torch.no_grad():
-            darvo_logits = darvo_model(**darvo_inputs).logits
-        darvo_score = round(sigmoid(darvo_logits.cpu()).item(), 4)
-        
-        # 5. EMOTIONAL TONE ANALYSIS
-        emotions = emotion_pipeline(text)
-        if isinstance(emotions, list) and isinstance(emotions[0], list):
-            emotion_scores = emotions[0]
-            emotion_dict = {e['label'].lower(): e['score'] for e in emotion_scores}
-            
-            # Determine emotional tone based on patterns and emotions
-            emotional_tone = determine_emotional_tone(emotion_dict, detected_patterns, abuse_score, sentiment)
-        else:
-            emotional_tone = 'neutral'
-        
-        # 6. RISK LEVEL
-        if abuse_score >= 80:
-            risk_level = 'critical'
-        elif abuse_score >= 60:
-            risk_level = 'high'
-        elif abuse_score >= 35:
-            risk_level = 'moderate'
-        else:
-            risk_level = 'low'
-        
-        return {
-            'abuse_score': abuse_score,
-            'darvo_score': darvo_score,
-            'boundary_health': boundary_health,
-            'detected_patterns': detected_patterns,
-            'emotional_tone': emotional_tone,
-            'risk_level': risk_level,
-            'sentiment': sentiment
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in analyze_single_message_complete: {e}")
-        return {
-            'abuse_score': 0.0, 'darvo_score': 0.0, 'boundary_health': 'unknown',
-            'detected_patterns': [], 'emotional_tone': 'neutral', 'risk_level': 'low',
-            'sentiment': 'supportive'
-        }
-
-def determine_emotional_tone(emotions, patterns, abuse_score, sentiment):
-    """Determine emotional tone based on analysis"""
-    
-    anger = emotions.get("anger", 0)
-    sadness = emotions.get("sadness", 0)
-    fear = emotions.get("fear", 0)
-    joy = emotions.get("joy", 0)
-    disgust = emotions.get("disgust", 0)
-    
-    # High-risk tones
-    if "stalking language" in patterns and joy > 0.3:
-        return "obsessive_fixation"
-    elif "veiled threats" in patterns and anger < 0.2:
-        return "menacing_calm"
-    elif "false concern" in patterns and sentiment == "undermining":
-        return "predatory_concern"
-    elif "control" in patterns and anger > 0.4:
-        return "entitled_rage"
-    elif abuse_score > 70 and anger > 0.3:
-        return "emotional_threat"
-    elif "gaslighting" in patterns:
-        return "contradictory_gaslight"
-    elif sadness > 0.5 and "guilt tripping" in patterns:
-        return "weaponized_sadness"
-    elif disgust > 0.3 and "dismissiveness" in patterns:
-        return "cold_invalidation"
-    else:
-        return "neutral"
-
-# =============================================================================
-# TETHER PRO DATA STRUCTURES (Simplified for HuggingFace)
-# =============================================================================
-
-@dataclass
-class MessageAnalysis:
-    timestamp: str  # ISO format string for JSON compatibility
-    message_id: str
-    text: str
-    sender: str
-    abuse_score: float
-    darvo_score: float
-    boundary_health: str
-    detected_patterns: List[str]
-    emotional_tone: str
-    risk_level: str
-
-class RiskTrend(Enum):
-    ESCALATING = "escalating"
-    STABLE_HIGH = "stable_high"
-    STABLE_MODERATE = "stable_moderate"
-    IMPROVING = "improving"
-    CYCLICAL = "cyclical"
-    UNKNOWN = "unknown"
-
-# =============================================================================
-# TEMPORAL ANALYSIS ENGINE (HuggingFace Compatible)
-# =============================================================================
-
-class TetherProAnalyzer:
-    """Simplified Tether Pro analyzer for HuggingFace demo"""
-    
-    def __init__(self):
-        self.conversation_history = []
-        
-    def analyze_conversation_history(self, messages_json: str) -> Dict:
-        """Analyze uploaded conversation history"""
-        try:
-            # Parse messages
-            messages_data = json.loads(messages_json)
-            
-            # Convert to MessageAnalysis objects
-            self.conversation_history = []
-            for msg_data in messages_data:
-                analysis = MessageAnalysis(
-                    timestamp=msg_data.get('timestamp', datetime.now().isoformat()),
-                    message_id=msg_data.get('id', f"msg_{len(self.conversation_history
-                    message_id=msg_data.get('id', f"msg_{len(self.conversation_history)}"),
-                    text=msg_data.get('text', ''),
-                    sender=msg_data.get('sender', 'unknown'),
-                    abuse_score=float(msg_data.get('abuse_score', 0)),
-                    darvo_score=float(msg_data.get('darvo_score', 0)),
-                    boundary_health=msg_data.get('boundary_health', 'unknown'),
-                    detected_patterns=msg_data.get('patterns', []),
-                    emotional_tone=msg_data.get('emotional_tone', 'neutral'),
-                    risk_level=msg_data.get('risk_level', 'low')
-                )
-                self.conversation_history.append(analysis)
-            
-            # Perform temporal analysis
-            return self._perform_temporal_analysis()
-            
-        except Exception as e:
-            logger.error(f"Error in analyze_conversation_history: {e}")
-            return {
-                'error': f"Analysis failed: {str(e)}",
-                'total_messages': 0,
-                'temporal_patterns': {},
-                'recommendations': []
-            }
-    
-    def _perform_temporal_analysis(self) -> Dict:
-        """Perform comprehensive temporal analysis"""
-        if len(self.conversation_history) < 3:
-            return {
-                'total_messages': len(self.conversation_history),
-                'analysis_status': 'insufficient_data',
-                'message': 'Need at least 3 messages for temporal analysis',
-                'basic_stats': self._get_basic_stats(),
-                'recommendations': ['Upload more conversation history for detailed analysis']
-            }
-        
-        # Convert to DataFrame for analysis
-        df = self._to_dataframe()
-        
-        # Detect patterns
-        escalation_patterns = self._detect_escalation_trends(df)
-        cyclical_patterns = self._detect_cycles(df)
-        pattern_combinations = self._analyze_pattern_combinations(df)
-        risk_trajectory = self._calculate_risk_trajectory(df)
-        temporal_triggers = self._analyze_temporal_triggers(df)
-        
-        # Generate professional recommendations
-        recommendations = self._generate_recommendations(
-            escalation_patterns, pattern_combinations, risk_trajectory
-        )
-        
-        return {
-            'total_messages': len(self.conversation_history),
-            'analysis_status': 'complete',
-            'date_range': self._get_date_range(),
-            'basic_stats': self._get_basic_stats(),
-            'temporal_analysis': {
-                'escalation_patterns': escalation_patterns,
-                'cyclical_patterns': cyclical_patterns,
-                'pattern_combinations': pattern_combinations,
-                'temporal_triggers': temporal_triggers
-            },
-            'risk_assessment': risk_trajectory,
-            'professional_recommendations': recommendations,
-            'visualizations': self._generate_visualizations(df)
-        }
-    
-    def _to_dataframe(self) -> pd.DataFrame:
-        """Convert conversation history to DataFrame"""
-        data = []
-        for msg in self.conversation_history:
-            # Parse timestamp
-            try:
-                timestamp = datetime.fromisoformat(msg.timestamp.replace('Z', '+00:00'))
-            except:
-                timestamp = datetime.now()
-                
-            data.append({
-                'timestamp': timestamp,
-                'message_id': msg.message_id,
-                'sender': msg.sender,
-                'abuse_score': msg.abuse_score,
-                'darvo_score': msg.darvo_score,
-                'boundary_health': msg.boundary_health,
-                'emotional_tone': msg.emotional_tone,
-                'risk_level': msg.risk_level,
-                'patterns': '|'.join(msg.detected_patterns)
-            })
-        
-        df = pd.DataFrame(data)
-        df = df.sort_values('timestamp')
-        return df
-    
-    def _detect_escalation_t trends(self, df: pd.DataFrame) -> Dict:
-        """Detect escalating abuse patterns over time"""
-        if len(df) < 5:
-            return {'detected': False, 'reason': 'insufficient_data'}
-        
-        # Calculate 3-message rolling average
-        df['abuse_rolling'] = df['abuse_score'].rolling(window=3, min_periods=1).mean()
-        
-        # Check for sustained increases
-        recent_data = df.tail(10)  # Last 10 messages
-        
-        if len(recent_data) < 5:
-            return {'detected': False, 'reason': 'insufficient_recent_data'}
-        
-        # Calculate trend
-        x_vals = list(range(len(recent_data)))
-        y_vals = recent_data['abuse_rolling'].values
-        
-        # Simple linear regression
-        correlation = np.corrcoef(x_vals, y_vals)[0, 1] if len(x_vals) > 1 else 0
-        
-        escalating = correlation > 0.3  # Positive correlation indicates escalation
-        
-        if escalating:
-            start_score = recent_data['abuse_rolling'].iloc[0]
-            end_score = recent_data['abuse_rolling'].iloc[-1]
-            increase = end_score - start_score
-            
-            return {
-                'detected': True,
-                'severity': 'high' if increase > 20 else 'moderate' if increase > 10 else 'mild',
-                'increase_amount': round(increase, 1),
-                'timeframe': f"Last {len(recent_data)} messages",
-                'confidence': min(abs(correlation), 1.0),
-                'description': f"Abuse intensity increased by {increase:.1f}% over recent communications"
-            }
-        else:
-            return {'detected': False, 'reason': 'no_escalation_trend'}
-    
-    def _detect_cycles(self, df: pd.DataFrame) -> Dict:
-        """Detect cyclical abuse patterns"""
-        if len(df) < 15:
-            return {'detected': False, 'reason': 'insufficient_data_for_cycles'}
-        
-        # Group by day and calculate daily averages
-        df['date'] = df['timestamp'].dt.date
-        daily_scores = df.groupby('date')['abuse_score'].mean()
-        
-        if len(daily_scores) < 10:
-            return {'detected': False, 'reason': 'insufficient_days'}
-        
-        # Look for repeating patterns (simplified)
-        scores = daily_scores.values
-        
-        # Check for peaks and valleys
-        peaks = []
-        valleys = []
-        
-        for i in range(1, len(scores) - 1):
-            if scores[i] > scores[i-1] and scores[i] > scores[i+1] and scores[i] > 60:
-                peaks.append(i)
-            elif scores[i] < scores[i-1] and scores[i] < scores[i+1] and scores[i] < 40:
-                valleys.append(i)
-        
-        has_cycle = len(peaks) >= 2 and len(valleys) >= 2
-        
-        if has_cycle:
-            # Calculate average cycle length
-            if len(peaks) > 1:
-                peak_intervals = [peaks[i+1] - peaks[i] for i in range(len(peaks)-1)]
-                avg_cycle_length = np.mean(peak_intervals)
-            else:
-                avg_cycle_length = 0
-            
-            return {
-                'detected': True,
-                'cycle_count': min(len(peaks, len(valleys))),
-                'avg_cycle_length_days': round(avg_cycle_length, 1),
-                'pattern_type': 'tension_escalation_reconciliation',
-                'confidence': min(len(peaks) / 3.0, 1.0),
-                'description': f"Detected {min(len(peaks), len(valleys))} abuse cycles with average length of {avg_cycle_length:.1f} days"
-            }
-        else:
-            return {'detected': False, 'reason': 'no_cyclical_pattern'}
-    
-    def _analyze_pattern_combinations(self, df: pd.DataFrame) -> List[Dict]:
-        """Analyze dangerous pattern combinations"""
-        all_patterns = []
-        for patterns_str in df['patterns']:
-            if patterns_str:
-                all_patterns.extend(patterns_str.split('|'))
-        
-        pattern_counts = Counter(all_patterns)
-        
-        # Define dangerous combinations
-        dangerous_combos = [
-            {
-                'name': 'Control + Manipulation Complex',
-                'patterns': ['control', 'gaslighting', 'darvo'],
-                'severity': 'critical'
-            },
-            {
-                'name': 'Stalking + Threat Pattern',
-                'patterns': ['stalking language', 'veiled threats', 'control'],
-                'severity': 'critical'
-            },
-            {
-                'name': 'Emotional Manipulation',
-                'patterns': ['guilt tripping', 'future faking', 'false concern'],
-                'severity': 'high'
-            }
-        ]
-        
-        detected_combinations = []
-        
-        for combo in dangerous_combos:
-            present_patterns = [p for p in combo['patterns'] if pattern_counts.get(p, 0) >= 2]
-            
-            if len(present_patterns) >= 2:
-                total_frequency = sum(pattern_counts.get(p, 0) for p in present_patterns)
-                
-                detected_combinations.append({
-                    'name': combo['name'],
-                    'severity': combo['severity'],
-                    'present_patterns': present_patterns,
-                    'frequency': total_frequency,
-                    'risk_level': 'critical' if total_frequency > 8 else 'high' if total_frequency > 4 else 'moderate'
-                })
-        
-        return detected_combinations
-    
-    def _calculate_risk_trajectory(self, df: pd.DataFrame) -> Dict:
-        """Calculate risk trajectory and predictions"""
-        recent_messages = df.tail(10)
-        
-        if len(recent_messages) < 3:
-            return {
-                'current_risk': 0,
-                'trend': RiskTrend.UNKNOWN.value,
-                'confidence': 0,
-                'prediction': 'insufficient_data'
-            }
-        
-        current_risk = recent_messages['abuse_score'].mean()
-        
-        # Calculate trend
-        x_vals = list(range(len(recent_messages)))
-        y_vals = recent_messages['abuse_score'].values
-        
-        correlation = np.corrcoef(x_vals, y_vals)[0, 1] if len(x_vals) > 1 else 0
-        
-        # Determine trend
-        if correlation > 0.3:
-            trend = RiskTrend.ESCALATING
-        elif correlation < -0.3:
-            trend = RiskTrend.IMPROVING
-        elif current_risk > 70:
-            trend = RiskTrend.STABLE_HIGH
-        elif recent_messages['abuse_score'].std() > 25:
-            trend = RiskTrend.CYCLICAL
-        else:
-            trend = RiskTrend.STABLE_MODERATE
-        
-        return {
-            'current_risk': round(current_risk, 1),
-            'trend': trend.value,
-            'trend_strength': abs(correlation),
-            'confidence': min(len(recent_messages) / 10.0, 1.0),
-            'prediction_7_days': self._predict_future_risk(recent_messages, current_risk, correlation),
-            'intervention_urgency': self._assess_intervention_urgency(trend, current_risk)
-        }
-    
-    def _analyze_temporal_triggers(self, df: pd.DataFrame) -> Dict:
-        """Analyze temporal patterns in abuse"""
-        if len(df) < 10:
-            return {'analysis': 'insufficient_data'}
-        
-        # Add time features
-        df['hour'] = df['timestamp'].dt.hour
-        df['day_of_week'] = df['timestamp'].dt.day_name()
-        df['is_weekend'] = df['timestamp'].dt.weekday >= 5
-        
-        # High abuse messages (>60% score)
-        high_abuse = df[df['abuse_score'] > 60]
-        
-        if len(high_abuse) == 0:
-            return {'analysis': 'no_high_abuse_episodes'}
-        
-        # Analyze patterns
-        triggers = {}
-        
-        # Time of day patterns
-        if len(high_abuse) > 0:
-            hour_counts = high_abuse['hour'].value_counts()
-            peak_hours = hour_counts.head(3).to_dict()
-            
-            triggers['time_patterns'] = {
-                'peak_hours': peak_hours,
-                'evening_escalation': len(high_abuse[high_abuse['hour'] >= 18]) / len(high_abuse),
-                'late_night_abuse': len(high_abuse[high_abuse['hour'] >= 22]) / len(high_abuse)
-            }
-        
-        # Day of week patterns
-        if len(high_abuse) > 0:
-            day_counts = high_abuse['day_of_week'].value_counts()
-            weekend_abuse = len(high_abuse[
-            day_counts = high_abuse['day_of_week'].value_counts()
-            weekend_abuse = len(high_abuse[high_abuse['is_weekend']]) / len(high_abuse)
-            
-            triggers['day_patterns'] = {
-                'high_risk_days': day_counts.head(3).to_dict(),
-                'weekend_escalation': weekend_abuse
-            }
-        
-        return triggers
-    
-    def _generate_recommendations(self, escalation, combinations, risk_trajectory) -> Dict:
-        """Generate professional recommendations"""
-        recommendations = {
-            'immediate_actions': [],
-            'therapeutic_focus': [],
-            'safety_planning': [],
-            'monitoring': []
-        }
-        
-        # Based on escalation
-        if escalation.get('detected') and escalation.get('severity') in ['high', 'critical']:
-            recommendations['immediate_actions'].extend([
-                'Urgent safety assessment required - escalating abuse pattern detected',
-                'Consider emergency safety planning session',
-                'Increase support contact frequency'
-            ])
-        
-        # Based on combinations
-        for combo in combinations:
-            if combo['severity'] == 'critical':
-                recommendations['therapeutic_focus'].append(
-                    f"Address {combo['name']} - multiple manipulation tactics present"
-                )
-        
-        # Based on risk trajectory
-        if risk_trajectory['trend'] == 'escalating':
-            recommendations['safety_planning'].extend([
-                'Develop comprehensive safety plan',
-                'Identify safe locations and contacts',
-                'Document escalation pattern for potential legal use'
-            ])
-        elif risk_trajectory['current_risk'] > 70:
-            recommendations['monitoring'].extend([
-                'High-risk situation requires enhanced monitoring',
-                'Weekly check-ins recommended',
-                'Crisis intervention plan should be ready'
-            ])
-        
-        return recommendations
-    
-    def _generate_visualizations(self, df: pd.DataFrame) -> Dict:
-        """Generate visualization data for charts"""
-        # Timeline data
-        timeline_data = []
-        for _, row in df.iterrows():
-            timeline_data.append({
-                'date': row['timestamp'].strftime('%Y-%m-%d'),
-                'abuse_score': row['abuse_score'],
-                'darvo_score': row['darvo_score'] * 100,  # Convert to percentage
-                'risk_level': row['risk_level']
-            })
-        
-        # Pattern frequency data
-        all_patterns = []
-        for patterns_str in df['patterns']:
-            if patterns_str:
-                all_patterns.extend(patterns_str.split('|'))
-        
-        pattern_counts = Counter(all_patterns)
-        pattern_data = [{'pattern': k, 'count': v} for k, v in pattern_counts.most_common(10)]
-        
-        return {
-            'timeline': timeline_data,
-            'pattern_frequency': pattern_data,
-            'total_messages': len(df)
-        }
-    
-    def _get_basic_stats(self) -> Dict:
-        """Get basic conversation statistics"""
-        if not self.conversation_history:
-            return {}
-        
-        abuse_scores = [msg.abuse_score for msg in self.conversation_history]
-        darvo_scores = [msg.darvo_score for msg in self.conversation_history]
-        
-        return {
-            'avg_abuse_score': round(np.mean(abuse_scores), 1),
-            'max_abuse_score': round(max(abuse_scores), 1),
-            'avg_darvo_score': round(np.mean(darvo_scores), 3),
-            'high_risk_messages': len([s for s in abuse_scores if s > 70]),
-            'healthy_boundaries': len([msg for msg in self.conversation_history if msg.boundary_health == 'healthy'])
-        }
-    
-    def _get_date_range(self) -> Dict:
-        """Get conversation date range"""
-        if not self.conversation_history:
-            return {}
-        
-        timestamps = []
-        for msg in self.conversation_history:
-            try:
-                timestamps.append(datetime.fromisoformat(msg.timestamp.replace('Z', '+00:00'))
-            except:
-                continue
-        
-        if not timestamps:
-            return {}
-        
-        return {
-            'start_date': min(timestamps).strftime('%Y-%m-%d'),
-            'end_date': max(timestamps).strftime('%Y-%m-%d'),
-            'span_days': (max(timestamps) - min(timestamps)).days
-        }
-    
-    def _predict_future_risk(self, recent_data, current_risk, correlation):
-        """Simple risk prediction"""
-        if correlation > 0.3:  # Escalating
-            return min(100, current_risk + (correlation * 20))
-        elif correlation < -0.3:  # Improving
-            return max(0, current_risk + (correlation * 20))
-        else:
-            return current_risk
-    
-    def _assess_intervention_urgency(self, trend, current_risk):
-        """Assess urgency of intervention"""
-        if trend == RiskTrend.ESCALATING and current_risk > 70:
-            return 'critical'
-        elif trend == RiskTrend.ESCALATING or current_risk > 80:
-            return 'high'
-        elif current_risk > 60:
-            return 'moderate'
-        else:
-            return 'low'
-
-# =============================================================================
-# HUGGINGFACE GRADIO INTERFACE
-# =============================================================================
-
-def create_temporal_visualization(timeline_data):
-    """Create timeline visualization"""
-    if not timeline_data:
-        return None
-    
-    try:
-        # Create timeline chart
-        df_viz = pd.DataFrame(timeline_data)
-        
-        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)
-        
-        # Plot abuse scores
-        ax1.plot(df_viz['date'], df_viz['abuse_score'], 'o-', color='red', linewidth=2, markersize=6)
-        ax1.set_ylabel('Abuse Score (%)')
-        ax1.set_title('Abuse Pattern Timeline')
-        ax1.grid(True, alpha=0.3)
-        ax1.set_ylim(0, 100)
-        
-        # Add risk level bands
-        ax1.axhspan(0, 30, alpha=0.2, color='green', label='Low Risk')
-        ax1.axhspan(30, 60, alpha=0.2, color='yellow', label='Moderate Risk')
-        ax1.axhspan(60, 80, alpha=0.2, color='orange', label='High Risk')
-        ax1.axhspan(80, 100, alpha=0.2, color='red', label='Critical Risk')
-        
-        # Plot DARVO scores
-        ax2.plot(df_viz['date'], df_viz['darvo_score'], 's-', color='purple', linewidth=2, markersize=6)
-        ax2.set_ylabel('DARVO Score (%)')
-        ax2.set_xlabel('Date')
-        ax2.set_title('DARVO Pattern Timeline')
-        ax2.grid(True, alpha=0.3)
-        ax2.set_ylim(0, 100)
-        
-        # Rotate x-axis labels
-        plt.xticks(rotation=45)
-        plt.tight_layout()
-        
-        # Convert to image
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-        buf.seek(0)
-        plt.close()
-        
-        return Image.open(buf)
-        
-    except Exception as e:
-        logger.error(f"Error creating visualization: {e}")
-        return None
-
-def analyze_temporal_patterns(messages_json: str):
-    """Main analysis function - NOW WITH FULL TETHER ANALYSIS"""
-    
-    if not messages_json.strip():
-        return (
-            "Please provide conversation history in JSON format.",
-            None,
-            "No analysis performed."
-        )
-    
-    try:
-        # Parse input JSON (basic format from CSV conversion)
-        raw_messages = json.loads(messages_json)
-        
-        if not raw_messages:
-            return "No messages found in JSON.", None, "Empty dataset"
-        
-        print(f"🔄 Running full Tether analysis on {len(raw_messages)} messages...")
-        
-        # STEP 1: Run each message through complete Tether analysis
-        analyzed_messages = []
-        
-        for i, raw_msg in enumerate(raw_messages):
-            # Extract basic message info
-            text = raw_msg.get('message', raw_msg.get('text', ''))
-            timestamp = raw_msg.get('timestamp', datetime.now().isoformat())
-            sender = raw_msg.get('sender', 'unknown')
-            
-            if not text.strip():
-                continue
-                
-            # Run complete Tether analysis
-            print(f"📝 Analyzing message {i+1}: '{text[:50]}...'")
-            analysis = analyze_single_message_complete(text)
-            
-            # Create analyzed message
-            analyzed_msg = MessageAnalysis(
-                timestamp=timestamp,
-                message_id=f'msg_{i:03d}',
-                text=text,
-                sender=sender,
-                abuse_score=analysis['abuse_score'],
-                darvo_score=analysis['darvo_score'],
-                boundary_health=analysis['boundary_health'],
-                detected_patterns=analysis['detected_patterns'],
-                emotional_tone=analysis['emotional_tone'],
-                risk_level=analysis['risk_level']
-            )
-            analyzed_messages.append(analyzed_msg)
-        
-        if not analyzed_messages:
-            return "No valid messages to analyze.", None, "No analysis performed"
-        
-        print(f"✅ Completed analysis of {len(analyzed_messages)} messages")
-        
-        # STEP 2: Run temporal analysis on the analyzed messages
-        analyzer = TetherProAnalyzer()
-        analyzer.conversation_history = analyzed_messages
-        results = analyzer._perform_temporal_analysis()
-        
-        if results.get('analysis_status') == 'insufficient_data':
-            summary = f"""
-## ⚠️ Insufficient Data for Temporal Analysis
-
-**Messages Analyzed:** {results['total_messages']}
-
-{results.get('message', 'Need more messages for temporal patterns')}
-
-**Basic Statistics:**
-{json.dumps(results.get('basic_stats', {}), indent=2)}
-
-**Recommendations:"""
-            + '\n'.join([f"• {rec}" for rec in results.get('recommendations', [])])
-            
-            return summary, None, "Upload more conversation history for comprehensive temporal analysis."
-        
-        # STEP 3: Generate comprehensive report
-        report = f"""
-# 🎯 Tether Pro - Complete Analysis Report
-
-## 📊 Conversation Overview
-- **Total Messages:** {results['total_messages']}
-- **Date Range:** {results['date_range'].get('start_date', 'Unknown')} to {results['date_range'].get('end_date', 'Unknown')}
-- **Analysis Span:** {results['date_range'].get('span_days', 0)} days
-
-## 🤖 AI Analysis Results
-- **Average Abuse Score:** {results['basic_stats'].get('avg_abuse_score', 0)}%
-- **Peak Abuse Score:** {results['basic_stats'].get('max_abuse_score', 0)}%
-- **Average DARVO Score:** {results['basic_stats'].get('avg_darvo_score', 0)}
-- **High-Risk Messages:** {results['basic_stats'].get('high_risk_messages', 0)}
-- **Healthy Boundaries:** {results['basic_stats'].get('healthy_boundaries', 0)}
-
-## 📈 Temporal Pattern Analysis
-
-### 🔥 Escalation Detection
-"""
-        
-        escalation = results['temporal_analysis']['escalation_patterns']
-        if escalation.get('detected'):
-            report += f"""
-**⚠️ ESCALATION DETECTED**
-- **Severity:** {escalation['severity'].upper()}
-- **Increase:** {escalation['increase_amount']}% over {escalation['timeframe']}
-- **Confidence:** {escalation['confidence']:.1%}
-- **Description:** {escalation['description']}
-"""
-        else:
-            report += f"✅ No significant escalation detected ({escalation.get('reason', 'stable patterns')})"
-        
-        ### Cyclical Patterns
-        report += "\n### 🔄 Cyclical Abuse Patterns\n"
-        cycles = results['temporal_analysis']['cyclical_patterns']
-        if cycles.get('detected'):
-            report += f"""
-**🔄 ABUSE CYCLES DETECTED**
-- **Cycle Count:** {cycles['cycle_count']}
-- **Average Length:** {cycles['avg_cycle_length_days']} days
-- **Pattern:** {cycles['pattern_type'].replace('_', ' ').title()}
-- **Confidence:** {cycles['confidence']:.1%}
-- **Description:** {cycles['description']}
-"""
-        else:
-            report += f"✅ No cyclical patterns detected ({cycles.get('reason', 'linear patterns')})"
-        
-        ### Dangerous Combinations
-        report += "\n### ⚠️ Dangerous Pattern Combinations\n"
-        combinations = results['temporal_analysis']['pattern_combinations']
-        if combinations:
-            for combo in combinations:
-                severity_emoji = "🚨" if combo['severity'] == 'critical
-                severity_emoji = "🚨" if combo['severity'] == 'critical' else "⚠️"
-                report += f"""
-**{severity_emoji} {combo['name']}**
-- **Severity:** {combo['severity'].upper()}
-- **Patterns Found:** {', '.join(combo['present_patterns'])}
-- **Frequency:** {combo['frequency']} occurrences
-- **Risk Assessment:** {combo['risk_level'].upper()}
-"""
-        else:
-            report += "✅ No dangerous pattern combinations detected"
-        
-        ### Risk Trajectory
-        risk = results['risk_assessment']
-        report += f"""
-
-## 🎯 Risk Assessment & Prediction
-
-**Current Risk Level:** {risk['current_risk']}%
-**Trend Direction:** {risk['trend'].replace('_', ' ').title()}
-**Trend Strength:** {risk['trend_strength']:.2f}
-**Prediction Confidence:** {risk['confidence']:.1%}
-**7-Day Forecast:** {risk['prediction_7_days']:.1f}%
-**Intervention Priority:** {risk['intervention_urgency'].upper()}
-
-"""
-        
-        # Detected Patterns Summary
-        if analyzed_messages:
-            all_patterns = []
-            for msg in analyzed_messages:
-                all_patterns.extend(msg.detected_patterns)
-            
-            if all_patterns:
-                pattern_counts = Counter(all_patterns)
-                report += "## 🔍 Detected Abuse Patterns\n\n"
-                
-                for pattern, count in pattern_counts.most_common():
-                    report += f"- **{pattern.replace('_', ' ').title()}**: {count} occurrences\n"
-        
-        # Professional Recommendations
-        recommendations = results['professional_recommendations']
-        report += "\n## 💡 Professional Recommendations\n\n"
-        
-        for category, items in recommendations.items():
-            if items:
-                report += f"### {category.replace('_', ' ').title()}\n"
-                for item in items:
-                    report += f"• {item}\n"
-                report += "\n"
-        
-        # Create visualization
-        viz_data = results.get('visualizations', {}).get('timeline', [])
-        timeline_chart = create_temporal_visualization(viz_data)
-        
-        # Generate summary
-        if risk['intervention_urgency'] == 'critical':
-            summary = "🚨 CRITICAL: Immediate professional intervention recommended"
-        elif risk['intervention_urgency'] == 'high':
-            summary = "⚠️ HIGH RISK: Enhanced monitoring and support needed"
-        elif escalation.get('detected'):
-            summary = "📈 ESCALATION DETECTED: Abuse patterns show increasing intensity"
-        elif combinations:
-            summary = "⚠️ CONCERNING PATTERNS: Multiple manipulation tactics identified"
-        else:
-            summary = "📊 ANALYSIS COMPLETE: Full temporal and pattern analysis performed"
-        
-        return report, timeline_chart, summary
-        
-    except Exception as e:
-        logger.error(f"Error in analyze_temporal_patterns: {e}")
-        return (
-            f"❌ Analysis failed: {str(e)}\n\nPlease check your JSON format. Expected format:\n[\n  {{\n    \"timestamp\": \"2025-01-11 14:34:54\",\n    \"sender\": \"+1234567890\",\n    \"message\": \"Your message text here\"\n  }}\n]",
-            None,
-            "Analysis error occurred."
-        )
-
-def create_sample_data():
-    """Generate sample conversation data for testing"""
-    sample_data = []
-    base_date = datetime.now() - timedelta(days=30)
-    
-    # Generate 15 sample messages over 30 days
-    for i in range(15):
-        # Create escalating pattern
-        base_score = 25 + (i * 3.5)  # Gradual escalation
-        if i % 5 == 0:  # Periodic spikes
-            base_score += 20
-        
-        abuse_score = min(95, max(5, base_score + np.random.normal(0, 8)))
-        
-        sample_data.append({
-            'timestamp': (base_date + timedelta(days=i*2)).isoformat(),
-            'id': f'msg_{i:03d}',
-            'text': f'Sample message {i+1}',
-            'sender': 'person_a' if i % 2 == 0 else 'person_b',
-            'abuse_score': round(abuse_score, 1),
-            'darvo_score': round(min(1.0, max(0.0, 0.2 + (i * 0.05))), 3),
-            'boundary_health': 'unhealthy' if abuse_score > 50 else 'healthy',
-            'patterns': ['control', 'gaslighting'] if abuse_score > 60 else ['dismissiveness'],
-            'emotional_tone': 'menacing_calm' if abuse_score > 70 else 'neutral',
-            'risk_level': 'high' if abuse_score > 70 else 'moderate' if abuse_score > 40 else 'low'
-        })
-    
-    return json.dumps(sample_data, indent=2)
-
-def create_tether_pro_interface():
-    css = """
-    .gradio-container {
-        max-width: 1200px !important;
-        margin: 0 auto !important;
-    }
-    .pro-header {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        border-radius: 16px;
-        padding: 32px;
-        margin-bottom: 24px;
-        color: white;
-        text-align: center;
-    }
-    .demo-notice {
-        background: #fef3c7;
-        border: 1px solid #f59e0b;
-        border-radius: 8px;
-        padding: 16px;
-        margin: 16px 0;
-    }
-    """
-
-    with gr.Blocks(css=css) as demo:
-        gr.HTML("<div class='pro-header'><h1>Tether Pro Temporal Analysis</h1></div>")
-        gr.HTML("<div class='demo-notice'>Paste conversation history as JSON or load sample data.</div>")
-        input_json = gr.Textbox(
-            label="Conversation History (JSON)",
-            lines=10,
-            placeholder="Paste your JSON here..."
-        )
-        with gr.Row():
-            analyze_btn = gr.Button("Analyze")
-            sample_btn = gr.Button("Load Sample Data")
-        output_report = gr.Markdown(label="Analysis Report")
-        output_image = gr.Image(label="Timeline Chart")
-        output_summary = gr.Textbox(label="Summary", lines=1)
-
-        analyze_btn.click(
-            fn=analyze_temporal_patterns,
-            inputs=input_json,
-            outputs=[output_report, output_image, output_summary]
-        )
-        sample_btn.click(
-            fn=create_sample_data,
-            inputs=None,
-            outputs=input_json
-        )
-
-    return demo
+from interface import demo
 
 if __name__ == "__main__":
-    demo = create_tether_pro_interface()
-    demo.launch()
+    demo.launch()