Delete app.py

app.py

@@ -1,643 +0,0 @@
-import gradio as gr
-import pandas as pd
-import requests
-import openai
-import json
-import time
-from typing import List, Dict, Tuple
-import re
-from urllib.parse import quote_plus
-from datetime import datetime, timedelta
-import os
-
-# 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", "")  # comma-separated
-GOOGLE_CSE_IDS = os.getenv("CX1", "")    # comma-separated
-
-class CitationChecker:
-    def __init__(self):
-        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
-        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.get('Requirement', '')) and str(row['Requirement']).strip():
-                requirement_data = {
-                    '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)
-        
-        return requirements
-    
-    def extract_key_claims(self, requirement_text, evaluation_rules):
-        """Use OpenAI to extract key factual claims that need verification"""
-        
-        prompt = f"""
-        Analyze the following requirement text and evaluation rules to extract specific factual claims that need verification:
-        
-        Requirement: {requirement_text}
-        
-        Evaluation Rules: {evaluation_rules}
-        
-        Extract specific, verifiable claims such as:
-        - Market share percentages
-        - Revenue figures
-        - Subscriber counts
-        - Growth rates
-        - Company statistics
-        - Technology capabilities
-        - Market data
-        
-        Return a JSON list of claims, each with:
-        - "claim": the specific factual statement
-        - "type": category (market_share, revenue, subscribers, growth, technology, etc.)
-        - "search_terms": suggested search terms for verification
-        - "priority": high/medium/low based on importance
-        
-        Focus only on concrete, verifiable facts, not opinions or projections.
-        """
-        
-        try:
-            response = openai.ChatCompletion.create(
-                model="gpt-4",
-                messages=[
-                    {"role": "system", "content": "You are a fact-checking analyst specializing in business and technology claims. Extract only verifiable factual statements."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.1
-            )
-            
-            content = response.choices[0].message.content
-            
-            # Try to parse JSON from the response
-            try:
-                # Look for JSON in the response
-                json_match = re.search(r'\[.*\]', content, re.DOTALL)
-                if json_match:
-                    claims = json.loads(json_match.group())
-                    return claims
-                else:
-                    # Fallback parsing
-                    return []
-            except json.JSONDecodeError:
-                return []
-                
-        except Exception as e:
-            print(f"Error extracting claims: {str(e)}")
-            return []
-    
-    def search_google_cse(self, query, cse_key, cse_id, num_results=10):
-        """Search using Google Custom Search Engine"""
-        
-        try:
-            url = "https://www.googleapis.com/customsearch/v1"
-            params = {
-                'key': cse_key,
-                'cx': cse_id,
-                'q': query,
-                'num': num_results,
-                'dateRestrict': 'y2',  # Last 2 years
-                'sort': 'date'
-            }
-            
-            response = requests.get(url, params=params, timeout=10)
-            
-            if response.status_code == 200:
-                data = response.json()
-                results = []
-                
-                if 'items' in data:
-                    for item in data['items']:
-                        results.append({
-                            'title': item.get('title', ''),
-                            'link': item.get('link', ''),
-                            'snippet': item.get('snippet', ''),
-                            'displayLink': item.get('displayLink', ''),
-                            'formattedUrl': item.get('formattedUrl', ''),
-                            'publishDate': item.get('pagemap', {}).get('metatags', [{}])[0].get('article:published_time', 'Unknown')
-                        })
-                
-                return results
-            else:
-                print(f"Google CSE API error: {response.status_code}")
-                return []
-                
-        except Exception as e:
-            print(f"Search error: {str(e)}")
-            return []
-    
-    def verify_claim_with_sources(self, claim, search_results):
-        """Use OpenAI to verify claim against search results"""
-        
-        # Prepare search results text
-        results_text = ""
-        for i, result in enumerate(search_results[:5], 1):
-            results_text += f"\nSource {i}:\nTitle: {result['title']}\nURL: {result['link']}\nContent: {result['snippet']}\nPublisher: {result['displayLink']}\nDate: {result['publishDate']}\n"
-        
-        prompt = f"""
-        Verify the following claim against the provided search results:
-        
-        CLAIM TO VERIFY: {claim['claim']}
-        
-        SEARCH RESULTS:
-        {results_text}
-        
-        Analyze whether the claim is:
-        1. VERIFIED - supported by the sources
-        2. CONTRADICTED - contradicted by the sources  
-        3. PARTIALLY_VERIFIED - partially supported
-        4. INSUFFICIENT_DATA - not enough information
-        
-        Provide your analysis in JSON format:
-        {{
-            "verification_status": "VERIFIED|CONTRADICTED|PARTIALLY_VERIFIED|INSUFFICIENT_DATA",
-            "confidence_score": 0.0-1.0,
-            "supporting_sources": [list of source numbers that support the claim],
-            "contradicting_sources": [list of source numbers that contradict],
-            "summary": "brief explanation of findings",
-            "specific_data_found": "any specific numbers or facts found",
-            "source_reliability": "assessment of source quality",
-            "recommendation": "what action to take"
-        }}
-        """
-        
-        try:
-            response = openai.ChatCompletion.create(
-                model="gpt-4",
-                messages=[
-                    {"role": "system", "content": "You are a fact-checking expert. Analyze claims against sources objectively and provide detailed verification analysis."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=800,
-                temperature=0.1
-            )
-            
-            content = response.choices[0].message.content
-            
-            # Parse JSON response
-            try:
-                json_match = re.search(r'\{.*\}', content, re.DOTALL)
-                if json_match:
-                    verification = json.loads(json_match.group())
-                    return verification
-                else:
-                    return {
-                        "verification_status": "INSUFFICIENT_DATA",
-                        "confidence_score": 0.0,
-                        "supporting_sources": [],
-                        "contradicting_sources": [],
-                        "summary": "Could not parse verification results",
-                        "specific_data_found": "",
-                        "source_reliability": "Unknown",
-                        "recommendation": "Manual review required"
-                    }
-            except json.JSONDecodeError:
-                return {
-                    "verification_status": "INSUFFICIENT_DATA",
-                    "confidence_score": 0.0,
-                    "supporting_sources": [],
-                    "contradicting_sources": [],
-                    "summary": content[:200],
-                    "specific_data_found": "",
-                    "source_reliability": "Unknown",
-                    "recommendation": "Manual review required"
-                }
-                
-        except Exception as e:
-            print(f"Verification error: {str(e)}")
-            return {
-                "verification_status": "ERROR",
-                "confidence_score": 0.0,
-                "supporting_sources": [],
-                "contradicting_sources": [],
-                "summary": f"Error during verification: {str(e)}",
-                "specific_data_found": "",
-                "source_reliability": "Unknown",
-                "recommendation": "Manual review required"
-            }
-    
-    def process_requirement(self, requirement_data, progress=gr.Progress()):
-        """Process a single requirement - extract claims, search, and verify"""
-        
-        results = {
-            'requirement_id': requirement_data['id'],
-            'rubric': requirement_data['rubric'],
-            'weight': requirement_data['weight'],
-            'requirement_text': requirement_data['requirement'],
-            'evaluation_rules': requirement_data['evaluation_rules'],
-            'claims': [],
-            'overall_assessment': '',
-            'sources_found': [],
-            'timestamp': datetime.now().isoformat()
-        }
-        
-        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):
-            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 = []
-            
-            for j, (cse_key, cse_id) in enumerate(zip(self.google_cse_keys, self.google_cse_ids)):
-                search_query = " ".join(claim.get('search_terms', [claim['claim']]))
-                search_results = self.search_google_cse(search_query, cse_key, cse_id)
-                all_search_results.extend(search_results)
-                
-                # Add delay between API calls
-                time.sleep(0.5)
-            
-            # Remove duplicates
-            seen_urls = set()
-            unique_results = []
-            for result in all_search_results:
-                if result['link'] not in seen_urls:
-                    seen_urls.add(result['link'])
-                    unique_results.append(result)
-            
-            # Verify claim against search results
-            verification = self.verify_claim_with_sources(claim, unique_results)
-            
-            claim_result = {
-                'claim': claim,
-                'search_results': unique_results[:10],  # Keep top 10 results
-                'verification': verification
-            }
-            
-            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)
-        
-        return results
-    
-    def generate_overall_assessment(self, results):
-        """Generate overall assessment for a requirement"""
-        
-        verified_claims = [c for c in results['claims'] if c['verification']['verification_status'] == 'VERIFIED']
-        contradicted_claims = [c for c in results['claims'] if c['verification']['verification_status'] == 'CONTRADICTED']
-        
-        total_claims = len(results['claims'])
-        verified_count = len(verified_claims)
-        contradicted_count = len(contradicted_claims)
-        
-        if total_claims == 0:
-            return "No specific claims found for verification"
-        
-        verification_rate = verified_count / total_claims
-        
-        if verification_rate >= 0.8:
-            status = "WELL_SUPPORTED"
-        elif verification_rate >= 0.6:
-            status = "MODERATELY_SUPPORTED"
-        elif contradicted_count > verified_count:
-            status = "CONTRADICTED"
-        else:
-            status = "INSUFFICIENT_EVIDENCE"
-        
-        return f"{status}: {verified_count}/{total_claims} claims verified, {contradicted_count} contradicted"
-    
-    def generate_final_report(self, all_results):
-        """Generate comprehensive final report with conclusions"""
-        
-        prompt = f"""
-        Generate a comprehensive citation and verification report based on the following analysis results:
-        
-        {json.dumps(all_results, indent=2, default=str)}
-        
-        Create a structured report with:
-        
-        1. EXECUTIVE SUMMARY
-           - Overall verification status
-           - Key findings
-           - Confidence level in the analysis
-        
-        2. DETAILED FINDINGS BY CATEGORY
-           - Domain Knowledge and Factual Accuracy
-           - Analysis Quality  
-           - Evidence and Sources
-           - Writing Quality
-           - Instruction Following
-           - Comprehensiveness
-        
-        3. SPECIFIC CITATION ISSUES
-           - Verified claims with strong sources
-           - Contradicted claims requiring correction
-           - Claims needing additional verification
-        
-        4. SOURCE QUALITY ASSESSMENT
-           - Credible sources identified
-           - Source reliability ratings
-           - Publication dates and currency
-        
-        5. RECOMMENDATIONS
-           - Priority corrections needed
-           - Additional research required
-           - Overall reliability assessment
-        
-        6. CONCLUSIONS
-           - Final assessment of citation quality
-           - Confidence in the overall analysis
-           - Next steps recommended
-        
-        Format as a professional report with clear sections and actionable insights.
-        """
-        
-        try:
-            response = openai.ChatCompletion.create(
-                model="gpt-4",
-                messages=[
-                    {"role": "system", "content": "You are a research analyst generating professional verification reports. Be thorough, objective, and actionable."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=2000,
-                temperature=0.2
-            )
-            
-            return response.choices[0].message.content
-            
-        except Exception as e:
-            return f"Error generating final report: {str(e)}"
-
-# 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", "", ""
-    
-    try:
-        # Initialize APIs (will use environment variables if inputs are empty)
-        checker.initialize_apis(openai_key, deepseek_key, google_keys, google_ids)
-        
-    except ValueError as e:
-        return f"❌ API Configuration Error: {str(e)}", "", ""
-    except Exception as e:
-        return f"❌ Error initializing APIs: {str(e)}", "", ""
-        
-        # Read CSV file
-        df = pd.read_csv(csv_file.name)
-        progress(0.05, desc="Parsing CSV data...")
-        
-        # Parse requirements
-        requirements = checker.parse_csv_data(df)
-        
-        if not requirements:
-            return "❌ No valid requirements found in CSV", "", ""
-        
-        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"
-        
-        # 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']}")
-            
-            result = checker.process_requirement(requirement, progress)
-            all_results.append(result)
-            
-            # 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"
-            
-            if result['evaluation_rules']:
-                detailed_output += f"**Evaluation Rules:** {result['evaluation_rules']}\n\n"
-            
-            detailed_output += "### 🔍 Claims Analysis\n\n"
-            
-            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`
-                """)
-            
-            with gr.Column(scale=1):
-                gr.Markdown("## 🔑 API Configuration")
-                
-                # Show status of environment variables without exposing them
-                env_status = []
-                if OPENAI_API_KEY:
-                    env_status.append("✅ OpenAI API Key (from environment)")
-                if DEEPSEEK_API_KEY:
-                    env_status.append("✅ DeepSeek API Key (from environment)")
-                if GOOGLE_CSE_KEYS:
-                    env_status.append("✅ Google CSE Keys (from environment)")
-                if GOOGLE_CSE_IDS:
-                    env_status.append("✅ Google CSE IDs (from environment)")
-                
-                if env_status:
-                    gr.Markdown("**🔐 Environment Variables Detected:**\n" + "\n".join(env_status) + "\n\n*Leave fields below empty to use environment variables*")
-                else:
-                    gr.Markdown("**⚠️ No environment variables detected - please enter API keys manually**")
-                
-                openai_key = gr.Textbox(
-                    label="OpenAI API Key",
-                    type="password",
-                    placeholder="sk-... (leave empty to use environment variable)",
-                    value=""  # NEVER pre-fill with actual keys!
-                )
-                
-                deepseek_key = gr.Textbox(
-                    label="DeepSeek API Key (Optional)",
-                    type="password",
-                    placeholder="sk-... (leave empty to use environment variable)",
-                    value=""  # NEVER pre-fill with actual keys!
-                )
-                
-                google_keys = gr.Textbox(
-                    label="Google CSE API Keys",
-                    placeholder="key1,key2,key3 (comma-separated, leave empty to use env var)",
-                    info="Multiple keys for better rate limiting",
-                    value=""  # NEVER pre-fill with actual keys!
-                )
-                
-                google_ids = gr.Textbox(
-                    label="Google CSE IDs",
-                    placeholder="cx1,cx2,cx3 (comma-separated, leave empty to use env var)",
-                    info="Corresponding CSE IDs for each API key",
-                    value=""  # NEVER pre-fill with actual keys!
-                )
-        
-        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()
-            
-            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
-        """)
-    
-    return demo
-
-# Create and launch the interface
-if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()