Update app.py

app.py

@@ -1,4 +1,4 @@
-import streamlit as st
+import gradio as gr
 import pandas as pd
 import requests
 import openai
@@ -8,46 +8,69 @@ from typing import List, Dict, Tuple
 import re
 from urllib.parse import quote_plus
 from datetime import datetime, timedelta
-import asyncio
-import aiohttp
+import os
 
-# Page config
-st.set_page_config(
-    page_title="Citation Checker & Verification System",
-    page_icon="🔍",
-    layout="wide"
-)
+# Load environment variables for Hugging Face Spaces
+OPENAI_API_KEY = os.getenv("OaPI1")
+DEEPSEEK_API_KEY = os.getenv("DAPI")
+GOOGLE_CSE_KEYS = os.getenv("API1", "API2", "API3")  # comma-separated
+GOOGLE_CSE_IDS = os.getenv("CX1", "CX2", "CX3")    # comma-separated
 
 class CitationChecker:
     def __init__(self):
-        self.openai_api_key = "OAPI1"
-        self.deepseek_api_key = "DAPI"
-        self.google_cse_keys = ["API1", "API2", "API3"]
-        self.google_cse_ids = ["CX1", "CX2", "CX3"]
-        
-    def initialize_apis(self, openai_key, deepseek_key, google_keys, google_ids):
-        """Initialize API keys"""
-        self.openai_api_key = openai_key
-        self.deepseek_api_key = deepseek_key
-        self.google_cse_keys = google_keys
-        self.google_cse_ids = google_ids
+        self.openai_api_key = None
+        self.deepseek_api_key = None
+        self.google_cse_keys = []
+        self.google_cse_ids = []
+        
+    def initialize_apis(self, openai_key, deepseek_key, google_keys_str, google_ids_str):
+        """Initialize API keys - use provided keys or fall back to environment variables"""
+        
+        # Use provided keys if available, otherwise use environment variables
+        self.openai_api_key = openai_key if openai_key.strip() else OPENAI_API_KEY
+        self.deepseek_api_key = deepseek_key if deepseek_key.strip() else DEEPSEEK_API_KEY
+        
+        # Handle Google keys
+        if google_keys_str.strip():
+            self.google_cse_keys = [k.strip() for k in google_keys_str.split(',') if k.strip()]
+        elif GOOGLE_CSE_KEYS:
+            self.google_cse_keys = [k.strip() for k in GOOGLE_CSE_KEYS.split(',') if k.strip()]
+        else:
+            self.google_cse_keys = []
+            
+        # Handle Google CSE IDs
+        if google_ids_str.strip():
+            self.google_cse_ids = [i.strip() for i in google_ids_str.split(',') if i.strip()]
+        elif GOOGLE_CSE_IDS:
+            self.google_cse_ids = [i.strip() for i in GOOGLE_CSE_IDS.split(',') if i.strip()]
+        else:
+            self.google_cse_ids = []
         
         # Set OpenAI API key
-        openai.api_key = openai_key
+        if self.openai_api_key:
+            openai.api_key = self.openai_api_key
+        
+        # Validate that we have the required keys
+        if not self.openai_api_key:
+            raise ValueError("OpenAI API key is required")
+        if not self.google_cse_keys or not self.google_cse_ids:
+            raise ValueError("Google CSE keys and IDs are required")
+        if len(self.google_cse_keys) != len(self.google_cse_ids):
+            raise ValueError("Number of Google CSE keys must match number of CSE IDs")
     
     def parse_csv_data(self, df):
         """Parse CSV data and extract requirements"""
         requirements = []
         
         for idx, row in df.iterrows():
-            if pd.notna(row['Requirement']) and row['Requirement'].strip():
+            if pd.notna(row.get('Requirement', '')) and str(row['Requirement']).strip():
                 requirement_data = {
-                    'id': row['ID'],
-                    'rubric': row['Rubric'],
-                    'weight': row['Weight'],
-                    'requirement': row['Requirement'].strip(),
-                    'evaluation_rules': row.get('Important Evaluation Rules', '') if pd.notna(row.get('Important Evaluation Rules', '')) else '',
-                    'original_prompt': row['Prompt']
+                    'id': row.get('ID', f'req_{idx}'),
+                    'rubric': row.get('Rubric', 'Unknown'),
+                    'weight': row.get('Weight', 1),
+                    'requirement': str(row['Requirement']).strip(),
+                    'evaluation_rules': str(row.get('Important Evaluation Rules', '')) if pd.notna(row.get('Important Evaluation Rules', '')) else '',
+                    'original_prompt': row.get('Prompt', '')
                 }
                 requirements.append(requirement_data)
         
@@ -108,7 +131,7 @@ class CitationChecker:
                 return []
                 
         except Exception as e:
-            st.error(f"Error extracting claims: {str(e)}")
+            print(f"Error extracting claims: {str(e)}")
             return []
     
     def search_google_cse(self, query, cse_key, cse_id, num_results=10):
@@ -144,11 +167,11 @@ class CitationChecker:
                 
                 return results
             else:
-                st.warning(f"Google CSE API error: {response.status_code}")
+                print(f"Google CSE API error: {response.status_code}")
                 return []
                 
         except Exception as e:
-            st.error(f"Search error: {str(e)}")
+            print(f"Search error: {str(e)}")
             return []
     
     def verify_claim_with_sources(self, claim, search_results):
@@ -229,7 +252,7 @@ class CitationChecker:
                 }
                 
         except Exception as e:
-            st.error(f"Verification error: {str(e)}")
+            print(f"Verification error: {str(e)}")
             return {
                 "verification_status": "ERROR",
                 "confidence_score": 0.0,
@@ -241,7 +264,7 @@ class CitationChecker:
                 "recommendation": "Manual review required"
             }
     
-    def process_requirement(self, requirement_data, progress_callback=None):
+    def process_requirement(self, requirement_data, progress=gr.Progress()):
         """Process a single requirement - extract claims, search, and verify"""
         
         results = {
@@ -256,15 +279,13 @@ class CitationChecker:
             'timestamp': datetime.now().isoformat()
         }
         
-        if progress_callback:
-            progress_callback(f"Extracting claims for {requirement_data['id']}...")
+        progress(0.1, desc=f"Extracting claims for {requirement_data['id']}...")
         
         # Extract key claims
         claims = self.extract_key_claims(requirement_data['requirement'], requirement_data['evaluation_rules'])
         
         for i, claim in enumerate(claims):
-            if progress_callback:
-                progress_callback(f"Verifying claim {i+1}/{len(claims)} for {requirement_data['id']}...")
+            progress(0.1 + (0.8 * i / len(claims)), desc=f"Verifying claim {i+1}/{len(claims)} for {requirement_data['id']}...")
             
             # Search for each claim using multiple CSE instances
             all_search_results = []
@@ -297,6 +318,8 @@ class CitationChecker:
             results['claims'].append(claim_result)
             results['sources_found'].extend(unique_results[:5])  # Add top sources to overall list
         
+        progress(0.9, desc="Generating assessment...")
+        
         # Generate overall assessment
         results['overall_assessment'] = self.generate_overall_assessment(results)
         
@@ -390,203 +413,215 @@ class CitationChecker:
         except Exception as e:
             return f"Error generating final report: {str(e)}"
 
-# Streamlit UI
-def main():
-    st.title("🔍 Citation Checker & Verification System")
-    st.markdown("### Verify requirements against internet sources with comprehensive citation analysis")
+# Initialize the citation checker
+checker = CitationChecker()
+
+def process_csv_and_verify(csv_file, openai_key, deepseek_key, google_keys, google_ids, progress=gr.Progress()):
+    """Main function to process CSV and run verification"""
+    
+    if not csv_file:
+        return "❌ Please upload a CSV file", "", ""
     
-    # Sidebar for API configuration
-    with st.sidebar:
-        st.header("🔑 API Configuration")
+    try:
+        # Initialize APIs (will use environment variables if inputs are empty)
+        checker.initialize_apis(openai_key, deepseek_key, google_keys, google_ids)
         
-        openai_key = st.text_input("OpenAI API Key", type="password")
-        deepseek_key = st.text_input("DeepSeek API Key", type="password")
+    except ValueError as e:
+        return f"❌ API Configuration Error: {str(e)}", "", ""
+    except Exception as e:
+        return f"❌ Error initializing APIs: {str(e)}", "", ""
         
-        st.subheader("Google CSE Configuration")
-        num_cse = st.number_input("Number of Google CSE instances", min_value=1, max_value=3, value=3)
+        # Read CSV file
+        df = pd.read_csv(csv_file.name)
+        progress(0.05, desc="Parsing CSV data...")
         
-        google_keys = []
-        google_ids = []
+        # Parse requirements
+        requirements = checker.parse_csv_data(df)
         
-        for i in range(num_cse):
-            st.write(f"**CSE Instance {i+1}**")
-            key = st.text_input(f"Google API Key {i+1}", type="password", key=f"google_key_{i}")
-            cse_id = st.text_input(f"CSE ID {i+1}", key=f"cse_id_{i}")
-            
-            if key and cse_id:
-                google_keys.append(key)
-                google_ids.append(cse_id)
-    
-    # Main interface
-    tab1, tab2, tab3 = st.tabs(["📊 Upload & Process", "📋 Results", "📄 Final Report"])
-    
-    with tab1:
-        st.header("Upload CSV and Process Requirements")
-        
-        # File upload
-        uploaded_file = st.file_uploader(
-            "Upload your CSV file with requirements", 
-            type=['csv'],
-            help="CSV should contain columns: Prompt, Rubric, ID, Weight, Requirement, Important Evaluation Rules"
-        )
+        if not requirements:
+            return "❌ No valid requirements found in CSV", "", ""
         
-        if uploaded_file is not None:
-            # Load CSV
-            try:
-                df = pd.read_csv(uploaded_file)
-                st.success(f"✅ Loaded CSV with {len(df)} rows")
-                
-                # Show preview
-                st.subheader("📋 Data Preview")
-                st.dataframe(df.head())
-                
-                # Initialize checker
-                if all([openai_key, len(google_keys) > 0, len(google_ids) > 0]):
-                    checker = CitationChecker()
-                    checker.initialize_apis(openai_key, deepseek_key, google_keys, google_ids)
-                    
-                    # Parse requirements
-                    requirements = checker.parse_csv_data(df)
-                    st.info(f"📝 Found {len(requirements)} requirements to verify")
-                    
-                    # Process button
-                    if st.button("🚀 Start Verification Process", type="primary"):
-                        
-                        # Progress tracking
-                        progress_bar = st.progress(0)
-                        status_text = st.empty()
-                        results_container = st.container()
-                        
-                        all_results = []
-                        
-                        for i, requirement in enumerate(requirements):
-                            def progress_callback(message):
-                                status_text.text(f"Processing {i+1}/{len(requirements)}: {message}")
-                            
-                            # Process requirement
-                            result = checker.process_requirement(requirement, progress_callback)
-                            all_results.append(result)
-                            
-                            # Update progress
-                            progress_bar.progress((i + 1) / len(requirements))
-                            
-                            # Show intermediate results
-                            with results_container:
-                                st.write(f"**✅ Completed: {requirement['id']}**")
-                                st.write(f"Assessment: {result['overall_assessment']}")
-                        
-                        # Store results in session state
-                        st.session_state['verification_results'] = all_results
-                        st.session_state['final_report'] = checker.generate_final_report(all_results)
-                        
-                        status_text.text("✅ Verification complete!")
-                        st.success("All requirements have been processed successfully!")
-                        
-                else:
-                    st.warning("⚠️ Please configure all API keys in the sidebar before processing")
-            
-            except Exception as e:
-                st.error(f"Error loading CSV: {str(e)}")
-    
-    with tab2:
-        st.header("📋 Detailed Verification Results")
+        progress(0.1, desc=f"Found {len(requirements)} requirements to verify...")
+        
+        all_results = []
+        detailed_output = f"# 📊 Verification Results\n\n**Total Requirements:** {len(requirements)}\n\n"
         
-        if 'verification_results' in st.session_state:
-            results = st.session_state['verification_results']
+        # Process each requirement
+        for i, requirement in enumerate(requirements):
+            progress(0.1 + (0.7 * i / len(requirements)), desc=f"Processing requirement {i+1}/{len(requirements)}: {requirement['id']}")
             
-            # Summary metrics
-            col1, col2, col3, col4 = st.columns(4)
+            result = checker.process_requirement(requirement, progress)
+            all_results.append(result)
             
-            total_requirements = len(results)
-            verified_requirements = len([r for r in results if 'WELL_SUPPORTED' in r['overall_assessment']])
-            contradicted_requirements = len([r for r in results if 'CONTRADICTED' in r['overall_assessment']])
-            total_claims = sum(len(r['claims']) for r in results)
+            # Add to detailed output
+            detailed_output += f"## 📋 {result['requirement_id']} - {result['rubric']}\n\n"
+            detailed_output += f"**Weight:** {result['weight']}\n\n"
+            detailed_output += f"**Requirement:** {result['requirement_text']}\n\n"
+            detailed_output += f"**Overall Assessment:** {result['overall_assessment']}\n\n"
             
-            col1.metric("Total Requirements", total_requirements)
-            col2.metric("Well Supported", verified_requirements)
-            col3.metric("Contradicted", contradicted_requirements)
-            col4.metric("Total Claims Checked", total_claims)
+            if result['evaluation_rules']:
+                detailed_output += f"**Evaluation Rules:** {result['evaluation_rules']}\n\n"
             
-            # Detailed results
-            for result in results:
-                with st.expander(f"📊 {result['requirement_id']} - {result['rubric']}"):
-                    
-                    st.write(f"**Weight:** {result['weight']}")
-                    st.write(f"**Requirement:** {result['requirement_text']}")
-                    st.write(f"**Overall Assessment:** {result['overall_assessment']}")
-                    
-                    if result['evaluation_rules']:
-                        st.write(f"**Evaluation Rules:** {result['evaluation_rules']}")
-                    
-                    st.subheader("🔍 Claims Analysis")
-                    
-                    for i, claim_result in enumerate(result['claims'], 1):
-                        claim = claim_result['claim']
-                        verification = claim_result['verification']
-                        
-                        # Status color
-                        status_colors = {
-                            'VERIFIED': '🟢',
-                            'CONTRADICTED': '🔴',
-                            'PARTIALLY_VERIFIED': '🟡',
-                            'INSUFFICIENT_DATA': '⚪',
-                            'ERROR': '⚫'
-                        }
-                        
-                        status_icon = status_colors.get(verification['verification_status'], '⚪')
-                        
-                        st.write(f"**{status_icon} Claim {i}:** {claim['claim']}")
-                        st.write(f"**Status:** {verification['verification_status']} (Confidence: {verification['confidence_score']:.2f})")
-                        st.write(f"**Summary:** {verification['summary']}")
-                        
-                        if verification['specific_data_found']:
-                            st.write(f"**Data Found:** {verification['specific_data_found']}")
-                        
-                        if verification['recommendation']:
-                            st.write(f"**Recommendation:** {verification['recommendation']}")
-                        
-                        # Show sources
-                        if claim_result['search_results']:
-                            st.write("**📚 Sources Found:**")
-                            for j, source in enumerate(claim_result['search_results'][:3], 1):
-                                st.write(f"{j}. [{source['title']}]({source['link']}) - {source['displayLink']}")
-                        
-                        st.write("---")
-        else:
-            st.info("No results available. Please process requirements in the Upload & Process tab first.")
-    
-    with tab3:
-        st.header("📄 Comprehensive Final Report")
-        
-        if 'final_report' in st.session_state:
-            report = st.session_state['final_report']
+            detailed_output += "### 🔍 Claims Analysis\n\n"
             
-            # Display report
-            st.markdown(report)
+            for j, claim_result in enumerate(result['claims'], 1):
+                claim = claim_result['claim']
+                verification = claim_result['verification']
+                
+                status_icons = {
+                    'VERIFIED': '✅',
+                    'CONTRADICTED': '❌',
+                    'PARTIALLY_VERIFIED': '⚠️',
+                    'INSUFFICIENT_DATA': '❓',
+                    'ERROR': '❌'
+                }
+                
+                status_icon = status_icons.get(verification['verification_status'], '❓')
+                
+                detailed_output += f"**{status_icon} Claim {j}:** {claim['claim']}\n\n"
+                detailed_output += f"**Status:** {verification['verification_status']} (Confidence: {verification['confidence_score']:.2f})\n\n"
+                detailed_output += f"**Summary:** {verification['summary']}\n\n"
+                
+                if verification['specific_data_found']:
+                    detailed_output += f"**Data Found:** {verification['specific_data_found']}\n\n"
+                
+                if verification['recommendation']:
+                    detailed_output += f"**Recommendation:** {verification['recommendation']}\n\n"
+                
+                # Show top sources
+                if claim_result['search_results'][:3]:
+                    detailed_output += "**📚 Top Sources:**\n\n"
+                    for k, source in enumerate(claim_result['search_results'][:3], 1):
+                        detailed_output += f"{k}. [{source['title']}]({source['link']}) - {source['displayLink']}\n\n"
+                
+                detailed_output += "---\n\n"
+        
+        progress(0.9, desc="Generating final report...")
+        
+        # Generate final report
+        final_report = checker.generate_final_report(all_results)
+        
+        # Generate summary
+        verified_requirements = len([r for r in all_results if 'WELL_SUPPORTED' in r['overall_assessment']])
+        contradicted_requirements = len([r for r in all_results if 'CONTRADICTED' in r['overall_assessment']])
+        total_claims = sum(len(r['claims']) for r in all_results)
+        
+        summary = f"""# ✅ Processing Complete!
+
+**📊 Summary Metrics:**
+- Total Requirements: {len(requirements)}
+- Well Supported: {verified_requirements}
+- Contradicted: {contradicted_requirements} 
+- Total Claims Checked: {total_claims}
+
+**⏰ Processed at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+Use the tabs below to view detailed results and the comprehensive final report.
+"""
+        
+        progress(1.0, desc="Complete!")
+        
+        return summary, detailed_output, final_report
+        
+    except Exception as e:
+        return f"❌ Error processing file: {str(e)}", "", ""
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(title="🔍 Citation Checker & Verification System", theme=gr.themes.Soft()) as demo:
+        
+        gr.Markdown("""
+        # 🔍 Citation Checker & Verification System
+        ### Verify requirements against internet sources with comprehensive citation analysis
+        
+        Upload your CSV file with requirements and provide API credentials to start the verification process.
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("## 📁 File Upload")
+                csv_file = gr.File(
+                    label="Upload CSV File",
+                    file_types=[".csv"],
+                    type="filepath"
+                )
+                
+                gr.Markdown("""
+                **CSV Requirements:**
+                - Must contain columns: `Requirement`, `ID`, `Rubric`, `Weight`
+                - Optional: `Important Evaluation Rules`, `Prompt`
+                """)
             
-            # Download button
-            st.download_button(
-                label="📥 Download Full Report",
-                data=report,
-                file_name=f"citation_verification_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md",
-                mime="text/markdown"
+            with gr.Column(scale=1):
+                gr.Markdown("## 🔑 API Configuration")
+                
+                openai_key = gr.Textbox(
+                    label="OpenAI API Key",
+                    type="password",
+                    placeholder="sk-... (or set OPENAI_API_KEY environment variable)",
+                    value=OPENAI_API_KEY if OPENAI_API_KEY else ""
+                )
+                
+                deepseek_key = gr.Textbox(
+                    label="DeepSeek API Key (Optional)",
+                    type="password",
+                    placeholder="sk-... (or set DEEPSEEK_API_KEY environment variable)",
+                    value=DEEPSEEK_API_KEY if DEEPSEEK_API_KEY else ""
+                )
+                
+                google_keys = gr.Textbox(
+                    label="Google CSE API Keys",
+                    placeholder="key1,key2,key3 (comma-separated) or set GOOGLE_CSE_KEYS env var",
+                    info="Multiple keys for better rate limiting",
+                    value=GOOGLE_CSE_KEYS if GOOGLE_CSE_KEYS else ""
+                )
+                
+                google_ids = gr.Textbox(
+                    label="Google CSE IDs",
+                    placeholder="cx1,cx2,cx3 (comma-separated) or set GOOGLE_CSE_IDS env var",
+                    info="Corresponding CSE IDs for each API key",
+                    value=GOOGLE_CSE_IDS if GOOGLE_CSE_IDS else ""
+                )
+        
+        with gr.Row():
+            process_btn = gr.Button(
+                "🚀 Start Verification Process",
+                variant="primary",
+                size="lg"
             )
+        
+        with gr.Row():
+            summary_output = gr.Markdown(label="Summary")
+        
+        with gr.Tabs():
+            with gr.TabItem("📊 Detailed Results"):
+                detailed_output = gr.Markdown()
             
-            # Download detailed results as JSON
-            if 'verification_results' in st.session_state:
-                results_json = json.dumps(st.session_state['verification_results'], indent=2, default=str)
-                st.download_button(
-                    label="📥 Download Detailed Results (JSON)",
-                    data=results_json,
-                    file_name=f"verification_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-                    mime="application/json"
-                )
-        else:
-            st.info("No report available. Please process requirements first.")
+            with gr.TabItem("📄 Final Report"):
+                final_report = gr.Markdown()
+        
+        # Set up the processing function
+        process_btn.click(
+            fn=process_csv_and_verify,
+            inputs=[csv_file, openai_key, deepseek_key, google_keys, google_ids],
+            outputs=[summary_output, detailed_output, final_report],
+            show_progress=True
+        )
+        
+        gr.Markdown("""
+        ---
+        **Citation Checker & Verification System** - Powered by OpenAI GPT-4, DeepSeek, and Google Custom Search
+        
+        **🔐 For Hugging Face Deployment:**
+        - Set environment variables: `OPENAI_API_KEY`, `GOOGLE_CSE_KEYS`, `GOOGLE_CSE_IDS`
+        - Or enter API keys manually in the form above
+        - Environment variables will be used automatically if form fields are left empty
+        """)
     
-    # Footer
-    st.markdown("---")
-    st.markdown("**Citation Checker & Verification System** - Powered by OpenAI GPT-4, DeepSeek, and Google Custom Search")
+    return demo
 
+# Create and launch the interface
 if __name__ == "__main__":
-    main()
+    demo = create_interface()
+    demo.launch()