Upload 12 files

app/__init__.py

@@ -0,0 +1,3 @@
+# IITM LLM Quiz Solver
+__version__ = "1.0.0"
+

app/browser.py

@@ -0,0 +1,247 @@
+"""
+Playwright browser helper for loading and interacting with quiz pages.
+"""
+import asyncio
+import logging
+from typing import Optional, Dict, Any, List
+from playwright.async_api import async_playwright, Browser, Page, BrowserContext
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class BrowserHelper:
+    """Helper class for managing Playwright browser sessions."""
+    
+    def __init__(self):
+        self.browser: Optional[Browser] = None
+        self.context: Optional[BrowserContext] = None
+        self.page: Optional[Page] = None
+        self.playwright = None
+    
+    async def start(self, headless: bool = True) -> None:
+        """
+        Start Playwright browser.
+        
+        Args:
+            headless: Run in headless mode
+        """
+        try:
+            self.playwright = await async_playwright().start()
+            self.browser = await self.playwright.chromium.launch(
+                headless=headless,
+                args=[
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-accelerated-2d-canvas',
+                    '--disable-gpu'
+                ]
+            )
+            self.context = await self.browser.new_context(
+                viewport={'width': 1920, 'height': 1080},
+                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+            )
+            self.page = await self.context.new_page()
+            logger.info("Browser started successfully")
+        except Exception as e:
+            logger.error(f"Error starting browser: {e}")
+            raise
+    
+    async def load_page(self, url: str, wait_time: int = 5, timeout: int = 30000) -> Dict[str, Any]:
+        """
+        Load a page and extract all content.
+        
+        Args:
+            url: URL to load
+            wait_time: Seconds to wait for page to load
+            timeout: Page load timeout in milliseconds
+            
+        Returns:
+            Dictionary with page content
+        """
+        if not self.page:
+            await self.start()
+        
+        try:
+            logger.info(f"Loading page: {url}")
+            await self.page.goto(url, wait_until='networkidle', timeout=timeout)
+            
+            # Wait for dynamic content
+            await asyncio.sleep(wait_time)
+            
+            # Extract page content
+            content = {
+                'url': url,
+                'title': await self.page.title(),
+                'text': await self.page.inner_text('body'),
+                'html': await self.page.content(),
+                'screenshot': await self.page.screenshot(full_page=True),
+            }
+            
+            # Try to extract all visible text elements
+            try:
+                content['all_text'] = await self.page.evaluate("""
+                    () => {
+                        const walker = document.createTreeWalker(
+                            document.body,
+                            NodeFilter.SHOW_TEXT,
+                            null,
+                            false
+                        );
+                        let text = [];
+                        let node;
+                        while (node = walker.nextNode()) {
+                            if (node.textContent.trim()) {
+                                text.push(node.textContent.trim());
+                            }
+                        }
+                        return text.join('\\n');
+                    }
+                """)
+            except Exception as e:
+                logger.warning(f"Error extracting all text: {e}")
+                content['all_text'] = content['text']
+            
+            # Extract links
+            try:
+                content['links'] = await self.page.evaluate("""
+                    () => {
+                        const links = Array.from(document.querySelectorAll('a[href]'));
+                        return links.map(a => ({text: a.textContent.trim(), href: a.href}));
+                    }
+                """)
+            except Exception as e:
+                logger.warning(f"Error extracting links: {e}")
+                content['links'] = []
+            
+            # Extract images
+            try:
+                content['images'] = await self.page.evaluate("""
+                    () => {
+                        const images = Array.from(document.querySelectorAll('img[src]'));
+                        return images.map(img => ({alt: img.alt, src: img.src}));
+                    }
+                """)
+            except Exception as e:
+                logger.warning(f"Error extracting images: {e}")
+                content['images'] = []
+            
+            logger.info(f"Page loaded successfully: {content['title']}")
+            return content
+            
+        except Exception as e:
+            logger.error(f"Error loading page {url}: {e}")
+            raise
+    
+    async def click_element(self, selector: str) -> bool:
+        """
+        Click an element on the page.
+        
+        Args:
+            selector: CSS selector
+            
+        Returns:
+            True if successful
+        """
+        try:
+            await self.page.click(selector)
+            await asyncio.sleep(1)
+            return True
+        except Exception as e:
+            logger.error(f"Error clicking element {selector}: {e}")
+            return False
+    
+    async def fill_input(self, selector: str, value: str) -> bool:
+        """
+        Fill an input field.
+        
+        Args:
+            selector: CSS selector
+            value: Value to fill
+            
+        Returns:
+            True if successful
+        """
+        try:
+            await self.page.fill(selector, value)
+            return True
+        except Exception as e:
+            logger.error(f"Error filling input {selector}: {e}")
+            return False
+    
+    async def wait_for_element(self, selector: str, timeout: int = 10000) -> bool:
+        """
+        Wait for an element to appear.
+        
+        Args:
+            selector: CSS selector
+            timeout: Timeout in milliseconds
+            
+        Returns:
+            True if element found
+        """
+        try:
+            await self.page.wait_for_selector(selector, timeout=timeout)
+            return True
+        except Exception as e:
+            logger.warning(f"Element {selector} not found: {e}")
+            return False
+    
+    async def evaluate_script(self, script: str) -> Any:
+        """
+        Execute JavaScript on the page.
+        
+        Args:
+            script: JavaScript code to execute
+            
+        Returns:
+            Result of script execution
+        """
+        try:
+            return await self.page.evaluate(script)
+        except Exception as e:
+            logger.error(f"Error evaluating script: {e}")
+            return None
+    
+    async def close(self) -> None:
+        """Close browser and cleanup."""
+        try:
+            if self.page:
+                await self.page.close()
+            if self.context:
+                await self.context.close()
+            if self.browser:
+                await self.browser.close()
+            if self.playwright:
+                await self.playwright.stop()
+            logger.info("Browser closed")
+        except Exception as e:
+            logger.error(f"Error closing browser: {e}")
+
+
+# Global browser instance
+_browser: Optional[BrowserHelper] = None
+
+
+async def get_browser() -> BrowserHelper:
+    """
+    Get or create a browser instance.
+    
+    Returns:
+        BrowserHelper instance
+    """
+    global _browser
+    if _browser is None:
+        _browser = BrowserHelper()
+        await _browser.start()
+    return _browser
+
+
+async def cleanup_browser() -> None:
+    """Cleanup browser instance."""
+    global _browser
+    if _browser:
+        await _browser.close()
+        _browser = None
+

app/llm.py

@@ -0,0 +1,251 @@
+"""
+LLM helper module for OpenAI GPT integration.
+Used for reasoning, OCR, and complex question parsing.
+"""
+import os
+import logging
+from typing import Optional, Dict, Any
+import openai
+from openai import AsyncOpenAI
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Initialize OpenAI client
+client: Optional[AsyncOpenAI] = None
+
+# OpenRouter configuration
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
+OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "gpt-5-nano")
+OPENROUTER_SITE_URL = os.getenv("OPENROUTER_SITE_URL", "http://localhost")
+OPENROUTER_APP_NAME = os.getenv("OPENROUTER_APP_NAME", "IITM LLM Quiz Solver")
+
+
+def initialize_llm() -> None:
+    """
+    Initialize OpenAI client with API key from environment.
+    """
+    global client
+    api_key = os.getenv("OPENAI_API_KEY")
+    if api_key:
+        client = AsyncOpenAI(api_key=api_key)
+        logger.info("OpenAI client initialized")
+    else:
+        if OPENROUTER_API_KEY:
+            logger.info("OPENAI_API_KEY not set, using OpenRouter only")
+        else:
+            logger.warning("No OPENAI_API_KEY or OPENROUTER_API_KEY set, LLM features will be disabled")
+
+
+async def ask_gpt(prompt: str, model: str = "gpt-4o-mini", max_tokens: int = 2000) -> Optional[str]:
+    """
+    Query OpenAI GPT model with a prompt.
+    
+    Args:
+        prompt: The prompt/question to ask
+        model: Model to use (default: gpt-4o-mini)
+        max_tokens: Maximum tokens in response
+        
+    Returns:
+        Response text or None if error
+    """
+    global client
+    
+    try:
+        if client:
+            response = await client.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant that solves quiz questions accurately and concisely."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=max_tokens,
+                temperature=0.3
+            )
+            
+            answer = response.choices[0].message.content
+            logger.info(f"GPT response received (model: {model})")
+            return answer
+        else:
+            logger.warning("OpenAI client not initialized, attempting OpenRouter fallback")
+            return await ask_openrouter(prompt, max_tokens=max_tokens)
+        
+    except Exception as e:
+        logger.error(f"Error calling OpenAI API: {e}")
+        # Fallback to OpenRouter if configured
+        fallback = await ask_openrouter(prompt, max_tokens=max_tokens)
+        if fallback:
+            return fallback
+        return None
+
+
+async def ask_openrouter(prompt: str, model: Optional[str] = None, max_tokens: int = 2000) -> Optional[str]:
+    """
+    Query OpenRouter (e.g., GPT-5-nano) with a prompt.
+    
+    Args:
+        prompt: Prompt text
+        model: Model to use (defaults to OPENROUTER_MODEL)
+        max_tokens: Maximum tokens
+        
+    Returns:
+        Response text or None
+    """
+    if not OPENROUTER_API_KEY:
+        logger.warning("OPENROUTER_API_KEY not set, cannot call OpenRouter")
+        return None
+    
+    if not model:
+        model = OPENROUTER_MODEL
+    
+    url = f"{OPENROUTER_BASE_URL.rstrip('/')}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "HTTP-Referer": OPENROUTER_SITE_URL,
+        "X-Title": OPENROUTER_APP_NAME,
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant that solves quiz questions accurately and concisely."},
+            {"role": "user", "content": prompt}
+        ],
+        "max_tokens": max_tokens,
+        "temperature": 0.2
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=60) as http_client:
+            response = await http_client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+            answer = data["choices"][0]["message"]["content"]
+            logger.info(f"OpenRouter response received (model: {model})")
+            return answer
+    except Exception as e:
+        logger.error(f"Error calling OpenRouter API: {e}")
+        return None
+
+
+async def parse_question_with_llm(question_text: str, context: str = "") -> Optional[Dict[str, Any]]:
+    """
+    Use LLM to parse and understand a quiz question.
+    
+    Args:
+        question_text: The question text
+        context: Additional context from the page
+        
+    Returns:
+        Parsed question structure or None
+    """
+    prompt = f"""Analyze this quiz question and provide a structured response:
+
+Question: {question_text}
+
+Context: {context}
+
+Please identify:
+1. What type of question is this? (scraping, calculation, API call, data analysis, etc.)
+2. What data or resources are needed?
+3. What is the expected answer format? (JSON, number, text, etc.)
+
+Respond in JSON format:
+{{
+    "type": "question_type",
+    "requirements": ["requirement1", "requirement2"],
+    "answer_format": "format_type",
+    "reasoning": "your reasoning"
+}}
+"""
+    
+    response = await ask_gpt(prompt)
+    if not response:
+        return None
+    
+    # Try to extract JSON from response
+    import json
+    import re
+    
+    json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', response, re.DOTALL)
+    if json_match:
+        try:
+            return json.loads(json_match.group())
+        except json.JSONDecodeError:
+            pass
+    
+    return {"raw_response": response}
+
+
+async def solve_with_llm(question: str, available_data: Dict[str, Any]) -> Optional[str]:
+    """
+    Use LLM to solve a quiz question.
+    
+    Args:
+        question: The question text
+        available_data: Any data extracted from the page
+        
+    Returns:
+        Answer or None
+    """
+    prompt = f"""Solve this quiz question:
+
+Question: {question}
+
+Available Data:
+{available_data}
+
+Provide a clear, concise answer. If the answer should be in JSON format, provide valid JSON.
+If it's a calculation, show your work briefly.
+"""
+    
+    return await ask_gpt(prompt, max_tokens=3000)
+
+
+async def ocr_image_with_llm(image_base64: str) -> Optional[str]:
+    """
+    Use GPT-4 Vision to extract text from an image.
+    
+    Note: Requires GPT-4 Vision model (gpt-4o or gpt-4-vision-preview).
+    gpt-4o-mini does not support vision.
+    
+    Args:
+        image_base64: Base64 encoded image
+        
+    Returns:
+        Extracted text or None
+    """
+    global client
+    
+    if not client:
+        return None
+    
+    # Try vision-capable models
+    vision_models = ["gpt-4o", "gpt-4-vision-preview"]
+    
+    for model in vision_models:
+        try:
+            response = await client.chat.completions.create(
+                model=model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": "Extract all text from this image. Return only the text content."},
+                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
+                        ]
+                    }
+                ],
+                max_tokens=1000
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            logger.warning(f"Error with model {model}: {e}")
+            continue
+    
+    logger.error("No vision-capable model available")
+    return None
+

app/main.py

@@ -0,0 +1,250 @@
+"""
+FastAPI main server for IITM LLM Quiz Solver.
+"""
+import os
+import logging
+import asyncio
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field, field_validator
+import uvicorn
+
+# Try to load .env file if python-dotenv is available
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass  # python-dotenv is optional
+
+from app.solver import solve_quiz
+from app.utils import validate_secret
+from app.browser import cleanup_browser
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Get secret from environment
+EXPECTED_SECRET = os.getenv("QUIZ_SECRET", "default_secret_change_me")
+
+# Lifespan context manager for startup and shutdown
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup and shutdown."""
+    # Startup
+    logger.info("Application starting up...")
+    yield
+    # Shutdown
+    logger.info("Shutting down, cleaning up browser...")
+    await cleanup_browser()
+
+# Initialize FastAPI app with lifespan
+app = FastAPI(
+    title="IITM LLM Quiz Solver",
+    description="API endpoint to automatically solve dynamic quiz tasks",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+
+class QuizRequest(BaseModel):
+    """Request model for quiz solving."""
+    email: str = Field(..., description="User email address")
+    secret: str = Field(..., description="Secret key for authentication")
+    url: str = Field(..., description="Quiz page URL")
+    
+    @field_validator('email')
+    @classmethod
+    def validate_email(cls, v):
+        if not v or '@' not in v:
+            raise ValueError('Invalid email format')
+        return v
+    
+    @field_validator('url')
+    @classmethod
+    def validate_url(cls, v):
+        if not v or not v.startswith(('http://', 'https://')):
+            raise ValueError('Invalid URL format')
+        return v
+
+
+@app.get("/")
+async def root():
+    """Root endpoint."""
+    return {
+        "message": "IITM LLM Quiz Solver API",
+        "version": "1.0.0",
+        "endpoints": {
+            "/solve": "POST - Solve a quiz",
+            "/health": "GET - Health check",
+            "/demo": "POST - Demo endpoint"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+@app.get("/env-check")
+async def env_check():
+    """
+    Check environment variables status (returns JSON).
+    Useful for verifying configuration.
+    """
+    quiz_secret = os.getenv("QUIZ_SECRET")
+    openai_key = os.getenv("OPENAI_API_KEY")
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
+    port = os.getenv("PORT", "8000")
+    
+    return {
+        "status": "ok",
+        "variables": {
+            "QUIZ_SECRET": {
+                "set": quiz_secret is not None,
+                "length": len(quiz_secret) if quiz_secret else 0,
+                "preview": f"{quiz_secret[:4]}...{quiz_secret[-4:]}" if quiz_secret and len(quiz_secret) > 8 else "***" if quiz_secret else None
+            },
+            "OPENAI_API_KEY": {
+                "set": openai_key is not None,
+                "length": len(openai_key) if openai_key else 0,
+                "preview": f"{openai_key[:7]}...{openai_key[-4:]}" if openai_key and len(openai_key) > 11 else "***" if openai_key else None,
+                "valid_format": openai_key.startswith("sk-") if openai_key else False
+            },
+            "OPENROUTER_API_KEY": {
+                "set": openrouter_key is not None,
+                "length": len(openrouter_key) if openrouter_key else 0,
+                "preview": f"{openrouter_key[:7]}...{openrouter_key[-4:]}" if openrouter_key and len(openrouter_key) > 11 else "***" if openrouter_key else None,
+                "valid_format": openrouter_key.startswith("sk-or-") if openrouter_key else False
+            },
+            "PORT": {
+                "set": True,
+                "value": port
+            }
+        },
+        "ready": quiz_secret is not None,
+        "llm_enabled": any([openai_key, openrouter_key])
+    }
+
+
+@app.post("/solve")
+async def solve_quiz_endpoint(request: QuizRequest):
+    """
+    Main endpoint to solve a quiz.
+    
+    Validates secret and solves the quiz recursively.
+    """
+    try:
+        # Validate secret
+        if not validate_secret(request.secret, EXPECTED_SECRET):
+            logger.warning(f"Invalid secret provided for email: {request.email}")
+            raise HTTPException(
+                status_code=403,
+                detail={"error": "forbidden"}
+            )
+        
+        logger.info(f"Solving quiz for {request.email} at {request.url}")
+        
+        # Solve quiz with timeout
+        try:
+            result = await asyncio.wait_for(
+                solve_quiz(request.url, request.email, request.secret),
+                timeout=180.0  # 3 minutes
+            )
+            return result
+        except asyncio.TimeoutError:
+            logger.error("Quiz solving timed out")
+            raise HTTPException(
+                status_code=504,
+                detail={"error": "Request timeout - quiz solving took too long"}
+            )
+        except Exception as e:
+            logger.error(f"Error solving quiz: {e}", exc_info=True)
+            raise HTTPException(
+                status_code=500,
+                detail={"error": str(e)}
+            )
+            
+    except HTTPException:
+        raise
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=400,
+            detail={"error": "Invalid request format", "message": str(e)}
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail={"error": "Internal server error", "message": str(e)}
+        )
+
+
+@app.post("/demo")
+async def demo_endpoint(request: QuizRequest):
+    """
+    Demo endpoint for testing.
+    
+    Same as /solve but with more lenient error handling.
+    """
+    try:
+        # Validate secret (can be more lenient for demo)
+        if not validate_secret(request.secret, EXPECTED_SECRET):
+            logger.warning(f"Invalid secret in demo request")
+            return JSONResponse(
+                status_code=403,
+                content={"error": "forbidden"}
+            )
+        
+        logger.info(f"Demo: Solving quiz for {request.email} at {request.url}")
+        
+        # Solve quiz
+        try:
+            result = await asyncio.wait_for(
+                solve_quiz(request.url, request.email, request.secret),
+                timeout=180.0
+            )
+            return result
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                status_code=504,
+                content={"error": "Request timeout"}
+            )
+        except Exception as e:
+            logger.error(f"Error in demo: {e}", exc_info=True)
+            return JSONResponse(
+                status_code=500,
+                content={"error": str(e)}
+            )
+            
+    except ValueError as e:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid request format", "message": str(e)}
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in demo: {e}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={"error": "Internal server error", "message": str(e)}
+        )
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8000))
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )
+

app/solver.py

@@ -0,0 +1,593 @@
+"""
+Quiz solver module - main logic for solving quizzes.
+"""
+import asyncio
+import json
+import logging
+import re
+from typing import Optional, Dict, Any, List
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+import io
+import base64
+
+from app.browser import get_browser, cleanup_browser
+from app.llm import ask_gpt, parse_question_with_llm, solve_with_llm, initialize_llm
+from app.utils import extract_submit_url, clean_text, extract_json_from_text, is_valid_url
+
+logger = logging.getLogger(__name__)
+
+# Initialize LLM on module load
+initialize_llm()
+
+
+class QuizSolver:
+    """Main quiz solver class."""
+    
+    def __init__(self):
+        self.browser = None
+        self.max_recursion = 10
+        self.current_recursion = 0
+    
+    async def solve_quiz(self, url: str, email: str, secret: str) -> Dict[str, Any]:
+        """
+        Main entry point for solving a quiz.
+        
+        Args:
+            url: Quiz page URL
+            email: User email
+            secret: Secret key
+            
+        Returns:
+            Final response from quiz system
+        """
+        self.current_recursion = 0
+        self.browser = await get_browser()
+        
+        try:
+            return await self._solve_recursive(url, email, secret)
+        finally:
+            # Don't close browser here as it might be reused
+            pass
+    
+    async def _solve_recursive(self, url: str, email: str, secret: str) -> Dict[str, Any]:
+        """
+        Recursively solve quizzes.
+        
+        Args:
+            url: Current quiz URL
+            email: User email
+            secret: Secret key
+            
+        Returns:
+            Response from quiz system
+        """
+        if self.current_recursion >= self.max_recursion:
+            logger.error("Maximum recursion depth reached")
+            return {"error": "Maximum recursion depth reached"}
+        
+        self.current_recursion += 1
+        logger.info(f"Solving quiz {self.current_recursion}: {url}")
+        
+        try:
+            # Load the quiz page
+            page_content = await self.browser.load_page(url, wait_time=3)
+            
+            # Extract submit URL
+            submit_url = extract_submit_url(page_content['text'], url)
+            if not submit_url:
+                # Try from HTML
+                soup = BeautifulSoup(page_content['html'], 'html.parser')
+                submit_url = extract_submit_url(soup.get_text(), url)
+            
+            if not submit_url:
+                logger.error("Could not find submit URL")
+                return {"error": "Submit URL not found"}
+            
+            # Extract question and solve
+            question_text = self._extract_question(page_content)
+            logger.info(f"Question extracted: {question_text[:200]}...")
+            
+            # Solve the question
+            answer = await self._solve_question(question_text, page_content)
+            
+            # Ensure answer is in the correct format (string or simple JSON-serializable)
+            answer = self._normalize_answer(answer)
+            logger.info(f"Answer computed: {str(answer)[:200]}...")
+            
+            # Submit answer
+            response = await self._submit_answer(
+                submit_url, email, secret, url, answer
+            )
+            
+            # Check if there's a next quiz
+            if isinstance(response, dict) and 'url' in response:
+                next_url = response['url']
+                if next_url and next_url != url and is_valid_url(next_url):
+                    logger.info(f"Next quiz found: {next_url}")
+                    # Recursively solve next quiz
+                    next_response = await self._solve_recursive(next_url, email, secret)
+                    return next_response
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error solving quiz: {e}", exc_info=True)
+            return {"error": str(e)}
+    
+    def _extract_question(self, page_content: Dict[str, Any]) -> str:
+        """
+        Extract question text from page content.
+        
+        Args:
+            page_content: Page content dictionary
+            
+        Returns:
+            Question text
+        """
+        text = page_content.get('all_text', page_content.get('text', ''))
+        
+        # Try to find question markers
+        question_patterns = [
+            r'[Qq]uestion[:\s]+(.*?)(?:\n\n|\n[A-Z]|$)',
+            r'[Pp]roblem[:\s]+(.*?)(?:\n\n|\n[A-Z]|$)',
+            r'[Tt]ask[:\s]+(.*?)(?:\n\n|\n[A-Z]|$)',
+        ]
+        
+        for pattern in question_patterns:
+            match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+            if match:
+                return clean_text(match.group(1))
+        
+        # If no pattern matches, return first substantial paragraph
+        paragraphs = [p.strip() for p in text.split('\n\n') if len(p.strip()) > 50]
+        if paragraphs:
+            return paragraphs[0]
+        
+        return clean_text(text[:1000])  # Return first 1000 chars
+    
+    async def _solve_question(self, question: str, page_content: Dict[str, Any]) -> Any:
+        """
+        Solve a quiz question using various strategies.
+        
+        Args:
+            question: Question text
+            page_content: Full page content
+            
+        Returns:
+            Answer (can be dict, list, string, number, etc.)
+        """
+        logger.info("Analyzing question type...")
+        
+        # Try to parse question with LLM first
+        parsed = await parse_question_with_llm(question, page_content.get('text', ''))
+        
+        # Extract data from page
+        available_data = self._extract_data_from_page(page_content)
+        
+        # Strategy 1: Check if answer is already in the page
+        answer_in_page = self._find_answer_in_page(page_content, question)
+        if answer_in_page:
+            logger.info("Answer found in page content")
+            return answer_in_page
+        
+        # Strategy 2: Check for data files/links to download
+        data_files = self._find_data_files(page_content)
+        if data_files:
+            logger.info(f"Found data files: {data_files}")
+            processed_data = await self._process_data_files(data_files)
+            if processed_data:
+                answer = await self._solve_with_data(question, processed_data)
+                if answer:
+                    return answer
+        
+        # Strategy 3: Use LLM to solve
+        logger.info("Attempting to solve with LLM...")
+        llm_answer = await solve_with_llm(question, available_data)
+        if llm_answer:
+            # Try to parse as JSON if it looks like JSON
+            json_answer = extract_json_from_text(llm_answer)
+            if json_answer:
+                return json_answer
+            return llm_answer
+        
+        # Strategy 4: Fallback - try to extract a simple answer from the question
+        # Many quiz pages have the answer in the question itself
+        simple_answer = self._extract_simple_answer(question, page_content)
+        if simple_answer:
+            logger.info("Extracted simple answer from question")
+            return simple_answer
+        
+        # Strategy 5: Last resort - return a default answer
+        logger.warning("Could not solve question, using default answer")
+        return "answer"
+    
+    def _extract_data_from_page(self, page_content: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract structured data from page.
+        
+        Args:
+            page_content: Page content dictionary
+            
+        Returns:
+            Dictionary of extracted data
+        """
+        data = {
+            'text': page_content.get('text', ''),
+            'html': page_content.get('html', ''),
+            'links': page_content.get('links', []),
+            'images': page_content.get('images', []),
+        }
+        
+        # Try to extract tables
+        try:
+            soup = BeautifulSoup(page_content.get('html', ''), 'html.parser')
+            tables = soup.find_all('table')
+            if tables:
+                data['tables'] = []
+                for table in tables:
+                    try:
+                        df = pd.read_html(str(table))[0]
+                        data['tables'].append(df.to_dict('records'))
+                    except:
+                        pass
+        except Exception as e:
+            logger.warning(f"Error extracting tables: {e}")
+        
+        # Try to extract JSON from page
+        json_data = extract_json_from_text(page_content.get('text', ''))
+        if json_data:
+            data['json'] = json_data
+        
+        return data
+    
+    def _find_answer_in_page(self, page_content: Dict[str, Any], question: str) -> Optional[Any]:
+        """
+        Check if answer is already present in page content.
+        
+        Args:
+            page_content: Page content
+            question: Question text
+            
+        Returns:
+            Answer if found, None otherwise
+        """
+        text = page_content.get('all_text', page_content.get('text', ''))
+        
+        # Look for answer patterns
+        answer_patterns = [
+            r'[Aa]nswer[:\s]+(.*?)(?:\n\n|$)',
+            r'[Ss]olution[:\s]+(.*?)(?:\n\n|$)',
+            r'[Rr]esult[:\s]+(.*?)(?:\n\n|$)',
+        ]
+        
+        for pattern in answer_patterns:
+            match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+            if match:
+                answer_text = clean_text(match.group(1))
+                # Try to parse as JSON
+                json_answer = extract_json_from_text(answer_text)
+                if json_answer:
+                    return json_answer
+                return answer_text
+        
+        return None
+    
+    def _find_data_files(self, page_content: Dict[str, Any]) -> List[str]:
+        """
+        Find data files (CSV, JSON, PDF, etc.) linked in the page.
+        
+        Args:
+            page_content: Page content
+            
+        Returns:
+            List of file URLs
+        """
+        files = []
+        
+        # Check links
+        for link in page_content.get('links', []):
+            href = link.get('href', '')
+            if any(href.lower().endswith(ext) for ext in ['.csv', '.json', '.pdf', '.xlsx', '.txt']):
+                files.append(href)
+        
+        # Check text for file URLs
+        text = page_content.get('text', '')
+        file_pattern = r'https?://[^\s<>"\'\)]+\.(csv|json|pdf|xlsx|txt)'
+        matches = re.findall(file_pattern, text, re.IGNORECASE)
+        files.extend([m[0] for m in matches if m[0] not in files])
+        
+        return files
+    
+    async def _process_data_files(self, file_urls: List[str]) -> Dict[str, Any]:
+        """
+        Download and process data files.
+        
+        Args:
+            file_urls: List of file URLs
+            
+        Returns:
+            Dictionary of processed data
+        """
+        processed = {}
+        
+        for url in file_urls:
+            try:
+                logger.info(f"Downloading file: {url}")
+                response = requests.get(url, timeout=30)
+                response.raise_for_status()
+                
+                content_type = response.headers.get('content-type', '').lower()
+                filename = url.split('/')[-1]
+                
+                if 'csv' in content_type or filename.endswith('.csv'):
+                    df = pd.read_csv(io.StringIO(response.text))
+                    processed[filename] = df.to_dict('records')
+                    
+                elif 'json' in content_type or filename.endswith('.json'):
+                    processed[filename] = response.json()
+                    
+                elif 'pdf' in content_type or filename.endswith('.pdf'):
+                    # PDF processing - try pdfplumber first, then PyPDF2
+                    text = None
+                    
+                    # Try pdfplumber
+                    try:
+                        import pdfplumber
+                        with pdfplumber.open(io.BytesIO(response.content)) as pdf:
+                            text = ""
+                            for page in pdf.pages:
+                                page_text = page.extract_text()
+                                if page_text:
+                                    text += page_text + "\n"
+                        if text:
+                            processed[filename] = text.strip()
+                    except ImportError:
+                        logger.debug("pdfplumber not available")
+                    except Exception as e:
+                        logger.warning(f"Error reading PDF with pdfplumber {filename}: {e}")
+                    
+                    # Fallback to PyPDF2
+                    if not text or filename not in processed:
+                        try:
+                            import PyPDF2
+                            pdf_file = io.BytesIO(response.content)
+                            pdf_reader = PyPDF2.PdfReader(pdf_file)
+                            text = ""
+                            for page in pdf_reader.pages:
+                                page_text = page.extract_text()
+                                if page_text:
+                                    text += page_text + "\n"
+                            if text:
+                                processed[filename] = text.strip()
+                        except ImportError:
+                            logger.warning("Neither pdfplumber nor PyPDF2 available for PDF processing")
+                        except Exception as e:
+                            logger.warning(f"Error reading PDF with PyPDF2 {filename}: {e}")
+                
+                elif filename.endswith('.txt'):
+                    processed[filename] = response.text
+                    
+            except Exception as e:
+                logger.error(f"Error processing file {url}: {e}")
+                continue
+        
+        return processed
+    
+    def _normalize_answer(self, answer: Any) -> Any:
+        """
+        Normalize answer to ensure it's JSON-serializable and in correct format.
+        
+        Args:
+            answer: Raw answer (can be dict, list, string, etc.)
+            
+        Returns:
+            Normalized answer (preferably string or simple JSON)
+        """
+        if answer is None:
+            return "answer"
+        
+        # If it's a dict with question/analysis, extract a simple answer
+        if isinstance(answer, dict):
+            # If it contains an 'answer' key, use that
+            if 'answer' in answer:
+                return self._normalize_answer(answer['answer'])
+            # If it's an analysis dict, try to extract something useful
+            if 'question' in answer and len(answer) > 1:
+                # Return a simple string instead of the whole dict
+                return "answer"
+            # If it's a simple dict, convert to JSON string
+            if len(answer) <= 3:
+                try:
+                    return json.dumps(answer)
+                except:
+                    return str(answer)
+            # Complex dict - return as JSON string
+            try:
+                return json.dumps(answer)
+            except:
+                return str(answer)
+        
+        # If it's a list, convert to JSON string if small, otherwise string
+        if isinstance(answer, list):
+            if len(answer) <= 10:
+                try:
+                    return json.dumps(answer)
+                except:
+                    return str(answer)
+            return str(answer)
+        
+        # For strings, return as-is (but clean up)
+        if isinstance(answer, str):
+            # Remove excessive whitespace
+            answer = ' '.join(answer.split())
+            # If it's very long, truncate
+            if len(answer) > 1000:
+                answer = answer[:1000] + "..."
+            return answer
+        
+        # For other types, convert to string
+        return str(answer)
+    
+    def _extract_simple_answer(self, question: str, page_content: Dict[str, Any]) -> Optional[str]:
+        """
+        Try to extract a simple answer from the question or page.
+        
+        Args:
+            question: Question text
+            page_content: Page content
+            
+        Returns:
+            Simple answer string or None
+        """
+        text = page_content.get('all_text', page_content.get('text', ''))
+        combined = question + "\n\n" + text
+        
+        # Check if question says "anything" or similar - very common in demo quizzes
+        if re.search(r'"answer"\s*:\s*"anything\s+you\s+want"', combined, re.IGNORECASE):
+            return "answer"
+        if re.search(r'"answer"\s*:\s*"anything"', combined, re.IGNORECASE):
+            return "answer"
+        if re.search(r'anything\s+you\s+want|any\s+value|any\s+string|any\s+text|anything', question, re.IGNORECASE):
+            return "answer"
+        
+        # Look for patterns like "answer: X" or "the answer is X"
+        patterns = [
+            r'"answer"\s*:\s*"([^"]+)"',  # JSON format: "answer": "value"
+            r'[Aa]nswer[:\s]+["\']?([^"\'\n]+)["\']?',
+            r'[Tt]he\s+[Aa]nswer\s+[Ii]s[:\s]+["\']?([^"\'\n]+)["\']?',
+            r'[Yy]our\s+[Aa]nswer[:\s]+["\']?([^"\'\n]+)["\']?',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, combined, re.IGNORECASE)
+            if match:
+                answer = match.group(1).strip()
+                # Skip if it's a placeholder or instruction
+                if answer and len(answer) < 200 and answer.lower() not in ['your email', 'your secret', 'anything you want', 'anything']:
+                    return answer
+        
+        return None
+    
+    async def _solve_with_data(self, question: str, data: Dict[str, Any]) -> Optional[Any]:
+        """
+        Solve question using processed data.
+        
+        Args:
+            question: Question text
+            data: Processed data dictionary
+            
+        Returns:
+            Answer or None
+        """
+        # Use LLM to solve with data
+        prompt = f"""Solve this question using the provided data:
+
+Question: {question}
+
+Data:
+{json.dumps(data, indent=2, default=str)}
+
+Provide the answer. If JSON format is required, return valid JSON.
+"""
+        
+        answer = await ask_gpt(prompt, max_tokens=3000)
+        if answer:
+            json_answer = extract_json_from_text(answer)
+            if json_answer:
+                return json_answer
+            return answer
+        
+        return None
+    
+    async def _submit_answer(self, submit_url: str, email: str, secret: str, 
+                            quiz_url: str, answer: Any) -> Dict[str, Any]:
+        """
+        Submit answer to the quiz system.
+        
+        Args:
+            submit_url: URL to submit answer to
+            email: User email
+            secret: Secret key
+            quiz_url: Original quiz URL
+            answer: Computed answer
+            
+        Returns:
+            Response from submission endpoint
+        """
+        # Ensure answer is JSON-serializable
+        try:
+            # Try to serialize answer to check if it's valid JSON
+            json.dumps(answer)
+        except (TypeError, ValueError) as e:
+            logger.warning(f"Answer is not JSON-serializable, converting to string: {e}")
+            # Convert complex objects to string representation
+            if isinstance(answer, (dict, list)):
+                answer = json.dumps(answer)
+            else:
+                answer = str(answer)
+        
+        payload = {
+            "email": email,
+            "secret": secret,
+            "url": quiz_url,
+            "answer": answer
+        }
+        
+        try:
+            logger.info(f"Submitting answer to: {submit_url}")
+            logger.debug(f"Payload: {json.dumps(payload, indent=2, default=str)}")
+            
+            response = requests.post(
+                submit_url,
+                json=payload,
+                headers={'Content-Type': 'application/json'},
+                timeout=60
+            )
+            
+            # Log response details
+            logger.info(f"Response status: {response.status_code}")
+            logger.debug(f"Response headers: {dict(response.headers)}")
+            
+            response.raise_for_status()
+            
+            try:
+                result = response.json()
+                logger.info(f"Submission successful: {result}")
+                return result
+            except json.JSONDecodeError:
+                logger.warning(f"Response is not JSON, returning text: {response.text[:500]}")
+                return {"response": response.text, "status_code": response.status_code}
+            
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"HTTP error submitting answer: {e}")
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_response = e.response.json()
+                    logger.error(f"Error response: {error_response}")
+                    return error_response
+                except:
+                    logger.error(f"Error response text: {e.response.text[:500]}")
+                    return {"error": e.response.text, "status_code": e.response.status_code}
+            return {"error": str(e)}
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error submitting answer: {e}", exc_info=True)
+            return {"error": str(e)}
+
+
+async def solve_quiz(url: str, email: str, secret: str) -> Dict[str, Any]:
+    """
+    Convenience function to solve a quiz.
+    
+    Args:
+        url: Quiz page URL
+        email: User email
+        secret: Secret key
+        
+    Returns:
+        Final response from quiz system
+    """
+    solver = QuizSolver()
+    return await solver.solve_quiz(url, email, secret)
+

app/utils.py

@@ -0,0 +1,180 @@
+"""
+Utility functions for the IITM LLM Quiz Solver.
+"""
+import re
+import json
+import logging
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse, urljoin
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def extract_submit_url(text: str, base_url: str) -> Optional[str]:
+    """
+    Extract submit URL from page text.
+    
+    Looks for patterns like:
+    - "Submit your answer to: https://example.com/submit"
+    - "Submit to: https://example.com/submit"
+    - "URL: https://example.com/submit"
+    
+    Args:
+        text: The page text content
+        base_url: Base URL for relative URL resolution
+        
+    Returns:
+        Extracted submit URL or None
+    """
+    # Common patterns for submit URLs
+    patterns = [
+        r'[Ss]ubmit\s+(?:your\s+)?(?:answer\s+)?(?:to|at|via):\s*(https?://[^\s<>"\'\)]+)',
+        r'[Ss]ubmit\s+[Tt]o:\s*(https?://[^\s<>"\'\)]+)',
+        r'[Uu][Rr][Ll]:\s*(https?://[^\s<>"\'\)]+)',
+        r'[Pp]ost\s+(?:to|at):\s*(https?://[^\s<>"\'\)]+)',
+        r'[Ss]end\s+(?:to|at):\s*(https?://[^\s<>"\'\)]+)',
+        r'(https?://[^\s<>"\'\)]*submit[^\s<>"\'\)]*)',
+        r'(https?://[^\s<>"\'\)]*answer[^\s<>"\'\)]*)',
+    ]
+    
+    for pattern in patterns:
+        matches = re.findall(pattern, text, re.IGNORECASE)
+        if matches:
+            url = matches[0].strip().rstrip('.,;:!?)}]{["\'')
+            # Validate URL
+            try:
+                parsed = urlparse(url)
+                if parsed.scheme and parsed.netloc:
+                    logger.info(f"Found submit URL: {url}")
+                    return url
+            except Exception as e:
+                logger.warning(f"Invalid URL pattern found: {url}, error: {e}")
+                continue
+    
+    # Try to find any URL that might be a submit endpoint
+    url_pattern = r'https?://[^\s<>"\'\)]+'
+    all_urls = re.findall(url_pattern, text)
+    for url in all_urls:
+        url_lower = url.lower()
+        if 'submit' in url_lower or 'answer' in url_lower:
+            try:
+                parsed = urlparse(url)
+                if parsed.scheme and parsed.netloc:
+                    logger.info(f"Found potential submit URL: {url}")
+                    return url
+            except:
+                continue
+    
+    # Try to find relative submit links (e.g. href="/submit")
+    rel_patterns = [
+        r'href=["\\\'](/[^"\\\']*submit[^"\\\']*)["\\\']',
+        r'(/[^\\s"<>\']*submit[^\\s"<>\']*)',
+    ]
+    for pattern in rel_patterns:
+        matches = re.findall(pattern, text, re.IGNORECASE)
+        if matches:
+            candidate = matches[0].strip().rstrip('.,;:!?)}]{["\'')
+            joined = urljoin(base_url, candidate)
+            logger.info(f"Found relative submit URL: {joined}")
+            return joined
+
+    logger.warning("No submit URL found in page text")
+    return None
+
+
+def validate_secret(secret: str, expected_secret: str) -> bool:
+    """
+    Validate the secret key.
+    
+    Args:
+        secret: Provided secret
+        expected_secret: Expected secret from environment
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    return secret == expected_secret
+
+
+def clean_text(text: str) -> str:
+    """
+    Clean and normalize text content.
+    
+    Args:
+        text: Raw text content
+        
+    Returns:
+        Cleaned text
+    """
+    if not text:
+        return ""
+    
+    # Remove excessive whitespace
+    text = re.sub(r'\s+', ' ', text)
+    # Remove leading/trailing whitespace
+    text = text.strip()
+    
+    return text
+
+
+def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Try to extract JSON objects from text.
+    
+    Args:
+        text: Text that may contain JSON
+        
+    Returns:
+        Parsed JSON dict or None
+    """
+    # Try to find JSON blocks
+    json_pattern = r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}'
+    matches = re.findall(json_pattern, text, re.DOTALL)
+    
+    for match in matches:
+        try:
+            return json.loads(match)
+        except json.JSONDecodeError:
+            continue
+    
+    return None
+
+
+def is_valid_url(url: str) -> bool:
+    """
+    Validate if a string is a valid URL.
+    
+    Args:
+        url: URL string to validate
+        
+    Returns:
+        True if valid URL, False otherwise
+    """
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except Exception:
+        return False
+
+
+def sanitize_filename(filename: str) -> str:
+    """
+    Sanitize a filename by removing invalid characters.
+    
+    Args:
+        filename: Original filename
+        
+    Returns:
+        Sanitized filename
+    """
+    # Remove invalid characters
+    filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    # Remove leading/trailing dots and spaces
+    filename = filename.strip('. ')
+    return filename
+