Upload 9 files

app/main.py

@@ -67,7 +67,11 @@ class QuizRequest(BaseModel):
     @field_validator('url')
     @classmethod
     def validate_url(cls, v):
-        if not v or not v.startswith(('http://', 'https://')):
+        if not v:
+            raise ValueError('Invalid URL format')
+        # Strip whitespace (handles newlines, spaces from JSON formatting)
+        v = v.strip()
+        if not v.startswith(('http://', 'https://')):
             raise ValueError('Invalid URL format')
         return v
 

app/solver.py

@@ -191,13 +191,13 @@ class BrowserHelper:
         try:
             logger.info(f"Loading page: {url}")
             await self.page.goto(url, wait_until='load', timeout=timeout)
-            await asyncio.sleep(min(wait_time, 2))
+            await asyncio.sleep(0.1)  # Minimal wait - just enough for JS to execute
             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),
+                # Skip screenshot to save time - not needed for solving
             }
             try:
                 content['all_text'] = await self.page.evaluate("""() => {
@@ -295,18 +295,21 @@ async def ask_openrouter(prompt: str, model: Optional[str] = None, max_tokens: i
         "X-Title": OPENROUTER_APP_NAME,
         "Content-Type": "application/json",
     }
-    system_content = system_prompt if system_prompt else "You are a helpful assistant that solves quiz questions accurately and concisely."
+    system_content = system_prompt if system_prompt else "You are a helpful assistant that solves quiz questions accurately and concisely. Be direct and brief."
+    # Optimize max_tokens - reduce for faster responses (default 1000 instead of 2000)
+    optimized_max_tokens = min(max_tokens, 1000) if max_tokens > 1000 else max_tokens
     payload = {
         "model": model,
         "messages": [
             {"role": "system", "content": system_content},
             {"role": "user", "content": prompt}
         ],
-        "max_tokens": max_tokens,
-        "temperature": 0.2
+        "max_tokens": optimized_max_tokens,
+        "temperature": 0.1  # Lower temperature for more deterministic, faster responses
     }
     try:
-        async with httpx.AsyncClient(timeout=30) as http_client:
+        # Reduced timeout for faster responses - 15s is enough for most LLM calls
+        async with httpx.AsyncClient(timeout=15) as http_client:
             response = await http_client.post(url, headers=headers, json=payload)
             response.raise_for_status()
             data = response.json()
@@ -328,26 +331,12 @@ async def test_prompt_with_custom_messages(system_prompt: str, user_prompt: str,
 
 async def parse_question_with_llm(question_text: str, context: str = "") -> Optional[Dict[str, Any]]:
     """Use LLM to parse and understand a quiz question."""
-    prompt = f"""Analyze this quiz question and provide a structured response:
+    # Optimized prompt - more concise for faster processing
+    prompt = f"""Analyze: {question_text[:500]}
 
-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)
+Type? Data needed? Format? JSON: {{"type":"...","requirements":[],"answer_format":"..."}}"""
+    # Reduced max_tokens for faster response
+    response = await ask_gpt(prompt, max_tokens=500)
     if not response:
         return None
     json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', response, re.DOTALL)
@@ -389,22 +378,14 @@ async def solve_with_llm(question: str, available_data: Dict[str, Any], question
     # Format available_data more clearly
     data_str = json.dumps(available_data, indent=2) if available_data else "No additional data"
     
-    prompt = f"""Solve this quiz question:
+    # Optimized prompt - more concise for faster LLM processing
+    prompt = f"""Solve: {question}
 
-Question: {question}
-
-Available Data:
-{data_str}
-{email_instruction}
-{audio_data}
-{format_instructions}
+Data: {data_str[:1000]}{email_instruction}{audio_data}{format_instructions}
 
-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.
-If it's a command or path, return ONLY that command or path without any explanation.
-If it's an audio transcription, return the spoken phrase with any codes or numbers EXACTLY as transcribed above.
-"""
-    return await ask_gpt(prompt, max_tokens=3000)
+Answer directly. JSON if needed. Command/path: return ONLY that. Audio: use transcription exactly."""
+    # Reduced max_tokens for faster response
+    return await ask_gpt(prompt, max_tokens=1500)
 
 async def ocr_image_with_llm(image_base64: str) -> Optional[str]:
     """Use OpenRouter vision model to extract text from an image."""
@@ -432,7 +413,8 @@ async def ocr_image_with_llm(image_base64: str) -> Optional[str]:
                 }],
                 "max_tokens": 1000
             }
-            async with httpx.AsyncClient(timeout=60) as http_client:
+            # Reduced timeout for vision calls - 30s should be enough
+            async with httpx.AsyncClient(timeout=30) as http_client:
                 response = await http_client.post(url, headers=headers, json=payload)
                 response.raise_for_status()
                 data = response.json()
@@ -677,7 +659,7 @@ class MediaProcessor:
         """Download and transcribe audio from URL."""
         try:
             logger.info(f"Processing audio from URL: {audio_url}")
-            response = requests.get(audio_url, timeout=30)
+            response = requests.get(audio_url, timeout=15)
             response.raise_for_status()
             audio_data = response.content
             audio_base64 = base64.b64encode(audio_data).decode('utf-8')
@@ -696,7 +678,7 @@ class MediaProcessor:
         if openai_key and OPENAI_AVAILABLE:
             try:
                 client = OpenAI(api_key=openai_key)
-                response = requests.get(audio_url, timeout=30)
+                response = requests.get(audio_url, timeout=15)
                 response.raise_for_status()
                 with tempfile.NamedTemporaryFile(suffix='.opus', delete=False) as tmp_file:
                     tmp_file.write(response.content)
@@ -719,7 +701,7 @@ class MediaProcessor:
         """Process video from URL - extract frames, transcribe audio, OCR text."""
         try:
             logger.info(f"Processing video from URL: {video_url}")
-            response = requests.get(video_url, timeout=30, stream=True)
+            response = requests.get(video_url, timeout=15, stream=True)
             response.raise_for_status()
             video_info = {
                 'url': video_url,
@@ -747,7 +729,7 @@ Provide a comprehensive description."""
         """Process image from URL - extract text using OCR."""
         try:
             logger.info(f"Processing image from URL: {image_url}")
-            response = requests.get(image_url, timeout=30)
+            response = requests.get(image_url, timeout=15)
             response.raise_for_status()
             image_data = response.content
             image_base64 = base64.b64encode(image_data).decode('utf-8')
@@ -838,7 +820,7 @@ async def extract_image_color(image_url: str, base_url: str = '') -> Optional[st
         if image_url.startswith('/') and base_url:
             image_url = urljoin(base_url, image_url)
         logger.info(f"Processing image for color extraction: {image_url}")
-        response = requests.get(image_url, timeout=30)
+        response = requests.get(image_url, timeout=15)
         response.raise_for_status()
         img = Image.open(io.BytesIO(response.content))
         if img.mode != 'RGB':
@@ -859,7 +841,7 @@ async def convert_csv_to_json(csv_url: str, base_url: str = '', normalize: bool
         if csv_url.startswith('/') and base_url:
             csv_url = urljoin(base_url, csv_url)
         logger.info(f"Converting CSV to JSON: {csv_url}")
-        response = requests.get(csv_url, timeout=30)
+        response = requests.get(csv_url, timeout=15)
         response.raise_for_status()
         df = pd.read_csv(io.StringIO(response.text))
         if normalize:
@@ -907,7 +889,7 @@ async def call_github_api(endpoint: str, token: Optional[str] = None) -> Optiona
         if token:
             headers['Authorization'] = f'token {token}'
         logger.info(f"Calling GitHub API: {url}")
-        async with httpx.AsyncClient(timeout=30) as client:
+        async with httpx.AsyncClient(timeout=15) as client:
             response = await client.get(url, headers=headers)
             response.raise_for_status()
             return response.json()
@@ -1061,7 +1043,7 @@ def solve_project2_png(image_url: str, base_url: str) -> str:
     try:
         if image_url.startswith('/'):
             image_url = urljoin(base_url, image_url)
-        response = requests.get(image_url, timeout=30)
+        response = requests.get(image_url, timeout=15)
         response.raise_for_status()
         img = Image.open(io.BytesIO(response.content))
         if img.mode != 'RGB':
@@ -1079,7 +1061,7 @@ def solve_project2_json(json_url: str, base_url: str) -> str:
     try:
         if json_url.startswith('/'):
             json_url = urljoin(base_url, json_url)
-        response = requests.get(json_url, timeout=30)
+        response = requests.get(json_url, timeout=15)
         response.raise_for_status()
         data = response.json()
         if isinstance(data, list):
@@ -1196,7 +1178,7 @@ def solve_project2_sql(sql_query: str, csv_url: str, base_url: str) -> str:
     try:
         if csv_url.startswith('/'):
             csv_url = urljoin(base_url, csv_url)
-        response = requests.get(csv_url, timeout=30)
+        response = requests.get(csv_url, timeout=15)
         response.raise_for_status()
         df = pd.read_csv(io.StringIO(response.text))
         conn = duckdb.connect(':memory:')
@@ -1304,10 +1286,10 @@ class QuizSolver:
             return {"error": "Timeout imminent - insufficient time remaining"}
         
         try:
-            # Optimize wait time based on remaining time (min 0.5s, max 1.5s) - reduced for speed
-            wait_time = min(1.5, max(0.5, int(remaining / 15)))
+            # Minimal wait time - just enough for page to load
+            wait_time = 0.1  # Fixed minimal wait - no dynamic calculation needed
             # Load the quiz page with optimized timeout - use less time for page load
-            page_timeout = min(12000, int(remaining * 1000 * 0.6))  # 60% of remaining time, max 12s
+            page_timeout = min(8000, int(remaining * 1000 * 0.4))  # 40% of remaining time, max 8s (reduced from 12s)
             page_content = await self.browser.load_page(url, wait_time=wait_time, timeout=page_timeout)
             
             # Extract submit URL
@@ -1502,8 +1484,9 @@ class QuizSolver:
         logger.info("Analyzing question type...")
         
         # Try to parse question with LLM first (only if we have enough time)
+        # Reduced threshold - parse even with less time for better adaptability
         remaining = self._check_time_remaining()
-        if remaining >= 30.0:  # Only parse with LLM if we have at least 30s remaining
+        if remaining >= 10.0:  # Reduced from 30s to 10s - parse faster
             parsed = await parse_question_with_llm(question, page_content.get('text', ''))
         else:
             parsed = None
@@ -1745,7 +1728,7 @@ class QuizSolver:
                                             from openai import OpenAI
                                             import tempfile
                                             client = OpenAI(api_key=openai_key)
-                                            response = requests.get(audio_url, timeout=30)
+                                            response = requests.get(audio_url, timeout=15)
                                             response.raise_for_status()
                                             with tempfile.NamedTemporaryFile(suffix='.opus', delete=False) as tmp_file:
                                                 tmp_file.write(response.content)
@@ -1926,10 +1909,10 @@ class QuizSolver:
         # Use LLM more aggressively - lower thresholds to prioritize LLM solving
         is_audio_question = 'transcribe' in question.lower() or 'passphrase' in question.lower() or 'spoken phrase' in question.lower()
         # Very low thresholds - use LLM as primary solver whenever possible
-        min_time_needed = 5.0 if is_audio_question else 10.0  # Very low - use LLM whenever possible
+        min_time_needed = 3.0 if is_audio_question else 5.0  # Reduced further - use LLM more aggressively
         
         # Use LLM if we have enough time AND haven't found answer yet
-        # Reserve at least 3s for submission
+        # Reduced threshold - use LLM more aggressively for adaptability
         if remaining >= min_time_needed:
             logger.info("Attempting to solve with LLM...")
             try:
@@ -1954,7 +1937,7 @@ class QuizSolver:
                 # Try to extract any useful information from the error
                 pass
         else:
-            logger.warning(f"Skipping LLM call - insufficient time remaining ({remaining:.1f}s, need {min_time_needed}s)")
+            logger.debug(f"Skipping LLM call - insufficient time remaining ({remaining:.1f}s, need {min_time_needed}s)")
         
         # Strategy 8: Fallback - try to extract a simple answer from the question
         # Many quiz pages have the answer in the question itself
@@ -2497,8 +2480,8 @@ class QuizSolver:
                     break
                 
                 logger.info(f"Downloading file: {url}")
-                # Use adaptive timeout based on remaining time (max 10s, min 3s) - faster
-                file_timeout = min(10, max(3, int(remaining * 0.4)))  # Use less time for downloads
+                # Use adaptive timeout based on remaining time (max 8s, min 2s) - faster
+                file_timeout = min(8, max(2, int(remaining * 0.3)))  # Use less time for downloads
                 response = requests.get(url, timeout=file_timeout)
                 response.raise_for_status()