from fastapi import FastAPI, HTTPException from pydantic import BaseModel from typing import List import requests import base64 import json import os from bs4 import BeautifulSoup import logging import re from dotenv import load_dotenv load_dotenv() # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) app = FastAPI(title="HackRx Mission API", version="1.0.0") class ChallengeRequest(BaseModel): url: str questions: List[str] class ChallengeResponse(BaseModel): answers: List[str] # LLM API configuration LLM_URL = "https://register.hackrx.in/llm/openai" SUBSCRIPTION_KEY = os.getenv("SUBSCRIPTION_KEY", "sk-****") def call_llm(messages: List[dict], max_tokens: int = 150) -> str: """Call the LLM API with token optimization""" try: headers = { 'Content-Type': 'application/json', 'x-subscription-key': SUBSCRIPTION_KEY } data = { "messages": messages, "model": "gpt-5-nano", "max_tokens": max_tokens, "temperature": 0.1 } response = requests.post(LLM_URL, headers=headers, json=data) response.raise_for_status() result = response.json() return result.get('choices', [{}])[0].get('message', {}).get('content', '') except Exception as e: logger.error(f"LLM API call failed: {e}") return "" def extract_hidden_elements(html_content: str) -> List[str]: """Extract hidden elements from HTML""" soup = BeautifulSoup(html_content, 'html.parser') hidden_elements = [] # Look for hidden inputs hidden_inputs = soup.find_all('input', {'type': 'hidden'}) for inp in hidden_inputs: if inp.get('value'): hidden_elements.append(f"Hidden input: {inp.get('name', 'unnamed')} = {inp.get('value')}") # Look for HTML comments comments = soup.find_all(string=lambda text: isinstance(text, str) and text.strip().startswith('', '').strip() if clean_comment: hidden_elements.append(f"Comment: {clean_comment}") # Look for elements with display:none hidden_divs = soup.find_all(attrs={'style': re.compile(r'display\s*:\s*none', re.I)}) for div in hidden_divs: text = div.get_text(strip=True) if text: hidden_elements.append(f"Hidden element: {text}") # Look for data attributes elements_with_data = soup.find_all(attrs=lambda x: x and any(key.startswith('data-') for key in x.keys())) for elem in elements_with_data: for attr, value in elem.attrs.items(): if attr.startswith('data-') and value: hidden_elements.append(f"Data attribute {attr}: {value}") return hidden_elements def advanced_scrape(url: str) -> dict: """Enhanced scraping with better hidden element detection""" try: session = requests.Session() session.headers.update({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.5', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'keep-alive' }) response = session.get(url, timeout=30) response.raise_for_status() soup = BeautifulSoup(response.text, 'html.parser') # Extract comprehensive information title = soup.find('title') title_text = title.get_text().strip() if title else "No title" # Get all text content visible_text = soup.get_text(separator=' ', strip=True) # Extract hidden elements hidden_elements = extract_hidden_elements(response.text) # Look for scripts that might contain data scripts = soup.find_all('script') script_data = [] for script in scripts: if script.string: script_content = script.string.strip() if any(keyword in script_content.lower() for keyword in ['challenge', 'code', 'answer', 'hidden']): script_data.append(f"Script data: {script_content[:200]}") # Look for meta tags meta_data = [] meta_tags = soup.find_all('meta') for meta in meta_tags: if meta.get('content'): meta_data.append(f"Meta {meta.get('name', 'unknown')}: {meta.get('content')}") return { 'title': title_text, 'visible_text': visible_text[:2000], 'hidden_elements': hidden_elements, 'script_data': script_data, 'meta_data': meta_data[:5], # Limit meta data 'html': response.text } except Exception as e: logger.error(f"Advanced scraping failed for {url}: {e}") return {} def analyze_content_intelligently(content: dict, question: str) -> str: """Intelligent content analysis with multiple strategies""" if not content: return "Unable to access page content" # Strategy 1: Direct pattern matching for common questions if "challenge name" in question.lower(): # Look in title first if content.get('title') and content['title'] != "No title": return content['title'] # Look in hidden elements for element in content.get('hidden_elements', []): if 'challenge' in element.lower(): parts = element.split(':') if len(parts) > 1: return parts[-1].strip().strip('"').strip("'") # Look in visible text for patterns visible = content.get('visible_text', '') challenge_patterns = [ r'challenge[:\s]+([^.\n]+)', r'name[:\s]+([^.\n]+)', r'title[:\s]+([^.\n]+)' ] for pattern in challenge_patterns: match = re.search(pattern, visible, re.IGNORECASE) if match: return match.group(1).strip() # Strategy 2: Use LLM for complex analysis context_parts = [] if content.get('title'): context_parts.append(f"Title: {content['title']}") if content.get('visible_text'): context_parts.append(f"Text: {content['visible_text'][:800]}") if content.get('hidden_elements'): context_parts.append(f"Hidden: {'; '.join(content['hidden_elements'][:3])}") if content.get('script_data'): context_parts.append(f"Scripts: {'; '.join(content['script_data'][:2])}") context = "\n".join(context_parts) messages = [ { "role": "system", "content": "Extract the specific answer from webpage content. Be direct and concise. Focus on challenge names, codes, or specific elements requested." }, { "role": "user", "content": f"Question: {question}\n\nContent:\n{context}\n\nAnswer:" } ] llm_answer = call_llm(messages, max_tokens=50) # Strategy 3: Fallback to first meaningful hidden element if not llm_answer or len(llm_answer.strip()) < 3: for element in content.get('hidden_elements', []): if len(element.split(':')) > 1: return element.split(':')[-1].strip() return llm_answer.strip() if llm_answer else "Information not found" @app.post("/challenge", response_model=ChallengeResponse) async def solve_challenge(request: ChallengeRequest): """Main endpoint to solve HackRx challenges""" logger.info(f"Received challenge request - URL: {request.url}") logger.info(f"Questions: {request.questions}") answers = [] try: for question in request.questions: logger.info(f"Processing question: {question}") # Scrape the page page_content = advanced_scrape(request.url) # Analyze and get answer answer = analyze_content_intelligently(page_content, question) answers.append(answer) logger.info(f"Answer found: {answer}") except Exception as e: logger.error(f"Error processing challenge: {e}") raise HTTPException(status_code=500, detail=f"Challenge processing failed: {str(e)}") return ChallengeResponse(answers=answers) @app.get("/health") async def health_check(): return {"status": "healthy", "selenium_available": False} @app.get("/") async def root(): return { "message": "HackRx Mission API - Ready for action!", "mode": "requests-only", "endpoints": { "challenge": "/challenge (POST)", "health": "/health (GET)" } } if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", 8000)))