Update app.py

app.py

@@ -8,6 +8,11 @@ import gradio as gr
 import uvicorn
 import time
 import uuid
+import asyncio
+import aiohttp
+import json
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from fastapi import FastAPI, Request, Depends
 from fastapi.responses import RedirectResponse
 from starlette.middleware.sessions import SessionMiddleware
@@ -25,6 +30,13 @@ except Exception as e:
     print("Please ensure all environment variables are set correctly.")
     raise
 
+# DeBERTa API Configuration from environment
+DEBERTA_API_URL = os.getenv('DEBERTA_API_URL', 'https://rahulkc-dev--deberta-fever-vllm-pattern-serve.modal.run')
+DEBERTA_API_KEY = os.getenv('DEBERTA_API_KEY', 'deberta-fever-secret-key')
+
+print(f"DEBUG: DeBERTa API URL: {DEBERTA_API_URL}")
+print(f"DEBUG: DeBERTa API Key: {'***' + DEBERTA_API_KEY[-4:] if DEBERTA_API_KEY else 'Not set'}")
+
 # Create FastAPI app
 app = FastAPI(title="DGaze - News Verification")
 
@@ -102,6 +114,295 @@ def get_base_url(request: Request) -> str:
         base_url = base_url.replace('http://', 'https://')
     return base_url
 
+# DeBERTa API Functions
+async def call_deberta_api_async(evidence: str, claim: str, session_timeout: int = 30) -> dict:
+    """Async call to DeBERTa FEVER API for fact verification."""
+    try:
+        headers = {
+            "Authorization": f"Bearer {DEBERTA_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "messages": [
+                {
+                    "role": "user", 
+                    "content": f"Evidence: {evidence} Claim: {claim}"
+                }
+            ],
+            "model": "MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli"
+        }
+        
+        timeout = aiohttp.ClientTimeout(total=session_timeout)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.post(
+                f"{DEBERTA_API_URL}/v1/chat/completions",
+                headers=headers,
+                json=payload
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    content = result["choices"][0]["message"]["content"]
+                    
+                    # Parse the response to extract verdict and confidence
+                    verdict = "UNKNOWN"
+                    confidence = 0.0
+                    
+                    if "✅ SUPPORTED" in content:
+                        verdict = "SUPPORTED"
+                    elif "❌ CONTRADICTED" in content:
+                        verdict = "CONTRADICTED"
+                    elif "🤔 NEUTRAL" in content:
+                        verdict = "NEUTRAL"
+                    
+                    # Extract confidence percentage
+                    confidence_match = re.search(r'(\d+\.?\d*)%', content)
+                    if confidence_match:
+                        confidence = float(confidence_match.group(1))
+                    
+                    # Calculate truthfulness score based on verdict and confidence
+                    if verdict == "SUPPORTED":
+                        truthfulness_score = confidence  # High confidence support = high truthfulness
+                    elif verdict == "CONTRADICTED":
+                        truthfulness_score = 100 - confidence  # High confidence contradiction = low truthfulness
+                    else:  # NEUTRAL
+                        truthfulness_score = 50  # Neutral claims get middle truthfulness score
+                    
+                    return {
+                        "success": True,
+                        "verdict": verdict,
+                        "confidence": confidence,
+                        "truthfulness_score": truthfulness_score,
+                        "raw_response": content,
+                        "claim": claim,
+                        "evidence": evidence
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": f"API returned status {response.status}",
+                        "claim": claim,
+                        "evidence": evidence
+                    }
+                    
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "claim": claim,
+            "evidence": evidence
+        }
+
+def call_deberta_api_sync(evidence: str, claim: str) -> dict:
+    """Synchronous wrapper for DeBERTa API call."""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        result = loop.run_until_complete(call_deberta_api_async(evidence, claim))
+        return result
+    finally:
+        loop.close()
+
+def extract_claims_and_evidence(verification_data: dict) -> list:
+    """Extract claims and evidence from verification pipeline results."""
+    claims_evidence_pairs = []
+    
+    try:
+        # Try to extract from the verification pipeline results
+        # This will depend on your existing API structure
+        
+        # Example extraction - adapt this to your actual data structure
+        if 'claims' in verification_data:
+            claims = verification_data['claims']
+            evidence_text = verification_data.get('evidence', verification_data.get('sources', ''))
+            
+            for claim in claims:
+                claims_evidence_pairs.append({
+                    'claim': claim,
+                    'evidence': evidence_text
+                })
+        
+        # Fallback: try to extract from other possible structures
+        elif 'pipeline_results' in verification_data:
+            pipeline_data = verification_data['pipeline_results']
+            
+            # Extract claims from step 2 (if available)
+            if len(pipeline_data) > 1 and 'claims' in pipeline_data[1]:
+                claims = pipeline_data[1]['claims']
+                
+                # Extract evidence from step 1 (sources)
+                evidence_text = ""
+                if len(pipeline_data) > 0 and 'sources' in pipeline_data[0]:
+                    sources = pipeline_data[0]['sources']
+                    evidence_text = " ".join([source.get('snippet', '') for source in sources[:3]])
+                
+                for claim in claims:
+                    claims_evidence_pairs.append({
+                        'claim': claim,
+                        'evidence': evidence_text
+                    })
+        
+        # If no structured claims found, create a general claim from input
+        if not claims_evidence_pairs and 'input_text' in verification_data:
+            input_text = verification_data['input_text']
+            # Use a simple heuristic to create evidence from sources
+            evidence_text = "General knowledge and web sources"
+            if 'sources' in verification_data:
+                sources = verification_data['sources']
+                evidence_text = " ".join([source.get('snippet', '') for source in sources[:3]])
+            
+            claims_evidence_pairs.append({
+                'claim': input_text[:500],  # Limit claim length
+                'evidence': evidence_text
+            })
+            
+    except Exception as e:
+        print(f"ERROR extracting claims and evidence: {e}")
+        # Fallback to empty list
+        pass
+    
+    return claims_evidence_pairs
+
+def process_deberta_results_parallel(claims_evidence_pairs: list, max_workers: int = 3) -> list:
+    """Process DeBERTa API calls in parallel."""
+    if not claims_evidence_pairs:
+        return []
+    
+    deberta_results = []
+    
+    # Limit the number of parallel requests to avoid overwhelming the API
+    with ThreadPoolExecutor(max_workers=min(max_workers, len(claims_evidence_pairs))) as executor:
+        # Submit all tasks
+        future_to_pair = {
+            executor.submit(call_deberta_api_sync, pair['evidence'], pair['claim']): pair
+            for pair in claims_evidence_pairs[:5]  # Limit to 5 claims max
+        }
+        
+        # Collect results as they complete
+        for future in as_completed(future_to_pair, timeout=45):
+            try:
+                result = future.result()
+                deberta_results.append(result)
+            except Exception as e:
+                pair = future_to_pair[future]
+                deberta_results.append({
+                    "success": False,
+                    "error": str(e),
+                    "claim": pair['claim'],
+                    "evidence": pair['evidence']
+                })
+    
+    return deberta_results
+
+def format_deberta_results(deberta_results: list) -> str:
+    """Format DeBERTa results for display."""
+    if not deberta_results:
+        return ""
+    
+    html = """
+    <div style="background: #f8f9fa; border: 1px solid #e9ecef; border-radius: 8px; padding: 1.5rem; margin: 1rem 0;">
+        <h3 style="margin: 0 0 1rem 0; color: #495057; font-size: 1.2rem; display: flex; align-items: center;">
+            🧠 AI Fact-Checking Analysis (DeBERTa FEVER)
+        </h3>
+    """
+    
+    successful_results = [r for r in deberta_results if r.get('success', False)]
+    failed_results = [r for r in deberta_results if not r.get('success', False)]
+    
+    if successful_results:
+        # Calculate overall score
+        verdicts = [r['verdict'] for r in successful_results]
+        confidences = [r['confidence'] for r in successful_results]
+        avg_confidence = sum(confidences) / len(confidences) if confidences else 0
+        
+        # Count verdicts
+        supported_count = verdicts.count('SUPPORTED')
+        contradicted_count = verdicts.count('CONTRADICTED')
+        neutral_count = verdicts.count('NEUTRAL')
+        
+        # Calculate average truthfulness score
+        truthfulness_scores = [r.get('truthfulness_score', 50) for r in successful_results]
+        avg_truthfulness = sum(truthfulness_scores) / len(truthfulness_scores) if truthfulness_scores else 50
+        
+        # Overall assessment
+        if supported_count > contradicted_count:
+            overall_verdict = "MOSTLY SUPPORTED"
+            verdict_color = "#28a745"
+            verdict_icon = "✅"
+        elif contradicted_count > supported_count:
+            overall_verdict = "MOSTLY CONTRADICTED"
+            verdict_color = "#dc3545"
+            verdict_icon = "❌"
+        else:
+            overall_verdict = "MIXED/NEUTRAL"
+            verdict_color = "#ffc107"
+            verdict_icon = "🤔"
+        
+        html += f"""
+        <div style="background: {verdict_color}; color: white; padding: 1rem; border-radius: 6px; margin-bottom: 1rem; text-align: center;">
+            <div style="font-size: 1.5rem; font-weight: bold; margin-bottom: 0.5rem;">
+                {verdict_icon} {overall_verdict}
+            </div>
+            <div style="font-size: 1rem; opacity: 0.9;">
+                Average Confidence: {avg_confidence:.1f}% | Truthfulness: {avg_truthfulness:.1f}% | Claims Analyzed: {len(successful_results)}
+            </div>
+            <div style="font-size: 0.9rem; opacity: 0.8; margin-top: 0.5rem;">
+                ✅ {supported_count} Supported • ❌ {contradicted_count} Contradicted • 🤔 {neutral_count} Neutral
+            </div>
+        </div>
+        """
+        
+        # Individual results
+        html += "<div style='margin-top: 1rem;'><h4 style='margin-bottom: 0.5rem; color: #495057;'>Individual Claim Analysis:</h4>"
+        
+        for i, result in enumerate(successful_results, 1):
+            verdict = result['verdict']
+            confidence = result['confidence']
+            truthfulness_score = result.get('truthfulness_score', 50)
+            claim = result['claim'][:150] + "..." if len(result['claim']) > 150 else result['claim']
+            
+            # Choose colors and icons
+            if verdict == "SUPPORTED":
+                color = "#d4edda"
+                border_color = "#c3e6cb"
+                icon = "✅"
+            elif verdict == "CONTRADICTED":
+                color = "#f8d7da"
+                border_color = "#f5c6cb"
+                icon = "❌"
+            else:
+                color = "#fff3cd"
+                border_color = "#ffeaa7"
+                icon = "🤔"
+            
+            html += f"""
+            <div style="background: {color}; border: 1px solid {border_color}; border-radius: 4px; padding: 0.75rem; margin: 0.5rem 0;">
+                <div style="font-weight: 600; margin-bottom: 0.25rem; color: #495057;">
+                    {icon} Claim {i}: {verdict} ({confidence:.1f}% confidence | {truthfulness_score:.1f}% truthfulness)
+                </div>
+                <div style="font-size: 0.9rem; color: #6c757d; font-style: italic;">
+                    "{claim}"
+                </div>
+            </div>
+            """
+        
+        html += "</div>"
+    
+    if failed_results:
+        html += f"""
+        <div style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 4px; padding: 0.75rem; margin: 1rem 0;">
+            <div style="font-weight: 600; color: #721c24; margin-bottom: 0.25rem;">
+                ⚠️ Some claims could not be analyzed ({len(failed_results)} failed)
+            </div>
+            <div style="font-size: 0.9rem; color: #721c24;">
+                DeBERTa API may be temporarily unavailable for some requests.
+            </div>
+        </div>
+        """
+    
+    html += "</div>"
+    return html
+
 # Authentication routes - using specific HTTP methods to avoid conflicts
 @app.get('/api/login')
 @app.post('/api/login')
@@ -166,9 +467,9 @@ async def auth(request: Request):
         print(f"DEBUG: Auth error: {e}")
         return RedirectResponse(url='/')
 
-# Verification function with trial tracking and loading states
+# Verification function with trial tracking, loading states, and DeBERTa integration
 def verify_news_with_trial_check(input_text: str, request: gr.Request, progress=gr.Progress()) -> str:
-    """Verification function with free trial tracking and loading progress."""
+    """Verification function with free trial tracking, loading progress, and DeBERTa fact-checking."""
     if not input_text.strip():
         return "Please enter some text or URL to verify"
     
@@ -185,11 +486,30 @@ def verify_news_with_trial_check(input_text: str, request: gr.Request, progress=
             progress(0.3, desc="🔍 Analyzing content...")
             time.sleep(0.5)
             
-            progress(0.7, desc="🧠 Processing with AI...")
+            progress(0.6, desc="🧠 Processing with AI...")
             data = api_client.verify_news(input_text)
             
+            # Add input text to data for DeBERTa processing
+            data['input_text'] = input_text
+            
+            progress(0.8, desc="🤖 Running DeBERTa fact-checking...")
+            
+            # Extract claims and evidence
+            claims_evidence_pairs = extract_claims_and_evidence(data)
+            deberta_results = []
+            
+            if claims_evidence_pairs and DEBERTA_API_URL:
+                deberta_results = process_deberta_results_parallel(claims_evidence_pairs)
+            
             progress(1.0, desc="✅ Verification complete!")
-            return format_verification_results(data)
+            
+            # Format main results
+            main_result = format_verification_results(data)
+            
+            # Add DeBERTa results if available
+            deberta_html = format_deberta_results(deberta_results) if deberta_results else ""
+            
+            return main_result + deberta_html
         
         # Check if user is authenticated
         user = get_user(fastapi_request)
@@ -243,8 +563,29 @@ def verify_news_with_trial_check(input_text: str, request: gr.Request, progress=
             progress(0.7, desc="🧠 Processing with AI...")
             data = api_client.verify_news(input_text)
             
+            # Add input text to data for DeBERTa processing
+            data['input_text'] = input_text
+            
+            progress(0.8, desc="🤖 Running DeBERTa fact-checking...")
+            
+            # Extract claims and evidence
+            claims_evidence_pairs = extract_claims_and_evidence(data)
+            deberta_results = []
+            
+            if claims_evidence_pairs and DEBERTA_API_URL:
+                try:
+                    deberta_results = process_deberta_results_parallel(claims_evidence_pairs)
+                except Exception as e:
+                    print(f"DeBERTa processing error: {e}")
+                    # Continue without DeBERTa results
+            
             progress(0.9, desc="📊 Formatting results...")
-            result = format_verification_results(data)
+            
+            # Format main results
+            main_result = format_verification_results(data)
+            
+            # Add DeBERTa results if available
+            deberta_html = format_deberta_results(deberta_results) if deberta_results else ""
             
             progress(1.0, desc="✅ Verification complete!")
             
@@ -257,7 +598,7 @@ def verify_news_with_trial_check(input_text: str, request: gr.Request, progress=
                 </p>
             </div>
             """
-            return trial_info + result
+            return trial_info + main_result + deberta_html
         else:
             # Authenticated user - proceed normally with progress
             progress(0.3, desc="🔍 Analyzing content...")
@@ -269,11 +610,32 @@ def verify_news_with_trial_check(input_text: str, request: gr.Request, progress=
             progress(0.7, desc="🧠 Processing with AI...")
             data = api_client.verify_news(input_text)
             
+            # Add input text to data for DeBERTa processing
+            data['input_text'] = input_text
+            
+            progress(0.8, desc="🤖 Running DeBERTa fact-checking...")
+            
+            # Extract claims and evidence
+            claims_evidence_pairs = extract_claims_and_evidence(data)
+            deberta_results = []
+            
+            if claims_evidence_pairs and DEBERTA_API_URL:
+                try:
+                    deberta_results = process_deberta_results_parallel(claims_evidence_pairs)
+                except Exception as e:
+                    print(f"DeBERTa processing error: {e}")
+                    # Continue without DeBERTa results
+            
             progress(0.9, desc="📊 Formatting results...")
-            result = format_verification_results(data)
+            
+            # Format main results
+            main_result = format_verification_results(data)
+            
+            # Add DeBERTa results if available
+            deberta_html = format_deberta_results(deberta_results) if deberta_results else ""
             
             progress(1.0, desc="✅ Verification complete!")
-            return result
+            return main_result + deberta_html
             
     except Exception as e:
         print(f"ERROR: {e}")