Create solver.py

app/solver.py

@@ -0,0 +1,470 @@
+# app/solver.py
+
+import time
+import requests
+import tempfile
+import subprocess
+import httpx
+import sys
+import json
+import re
+import os
+from playwright.sync_api import sync_playwright
+from typing import Any, Dict, Optional
+from datetime import datetime, timedelta
+from urllib.parse import urlparse, urlunparse
+
+# LLM Integration (Assuming Google GenAI for demonstration)
+# from google import genai
+# from google.genai.errors import APIError
+
+from .models import QuizSubmitPayload, QuizSubmitResponse, QuizRequest
+from .config import STUDENT_SECRET, LLM_API_KEY
+
+TIMEOUT_SECONDS = 180
+# TEMP_DIR = "quiz_temp"
+
+# Initialize the LLM client 
+# try:
+#     llm_client = genai.Client(api_key=LLM_API_KEY)
+# except Exception as e:
+#     print(f"LLM Client initialization error: {e}")
+#     llm_client = None 
+
+class QuizSolver:
+    def __init__(self, request_payload: QuizRequest, start_time: datetime):
+        self.email = request_payload.email
+        self.secret = request_payload.secret
+        self.current_url = request_payload.url
+        self.start_time = start_time
+        # Ensure temporary directory exists
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+    def _get_time_remaining(self) -> float:
+        """Calculates the time remaining until the 3-minute deadline."""
+        elapsed = (datetime.now() - self.start_time).total_seconds()
+        remaining = TIMEOUT_SECONDS - elapsed
+        return max(0.0, remaining)
+
+    def _llm_analyze_and_generate_code(self, quiz_content_text: str, link_data_str: str) -> Optional[Dict[str, Any]]:
+        """
+        Uses an LLM to analyze the question and generate a structured JSON 
+        containing the necessary Python code.
+        """
+        print("-> LLM: Analyzing question and generating code...")
+        
+        system_prompt="""
+        You are a quiz-solving assistant.
+
+        Your task: Given the scraped text of a quiz page, you must extract:
+        1. The submission URL where the final answer must be Posted.
+        2. Accurate and executable Python code that computes ONLY the answer (a single value) and stores it in a variable that MUST be called answer.
+        3. All Python dependencies that the code requires as a list.
+
+        Return your output ONLY as JSON with this exact structure:
+
+        {
+        "submit_url": "string",
+        "python_code": ["line1", "line2", "..."],
+        "dependencies": ["package1", "package2"]
+        }
+
+        Rules:
+        - The submission URL ALWAYS appears in the text. It typically looks like: "Post your answer to https://....".
+        - You MUST extract the submission URL.
+        - DO NOT guess. Extract it literally from the text.
+        - Do NOT include any explanation or commentary.
+        - Only produce valid JSON output.
+        
+    
+
+        Python rules:
+        - The python_code section MUST contain only the code needed to compute the answer and store it in a variable called "answer".
+        - Ignore any submission JSON shown in the page.
+        - DO NOT include code to send the submission.
+        - The backend will run your code inside a Python subprocess.
+        - Store the final answer in the variable named "answer".
+        - Ensure that the final answer is a Python-native type (int, float, str, bool) and not a NumPy or pandas dtype. If the result is a NumPy scalar, call .item() to convert it.
+        - Always ensure the variable "answer" is JSON-serialisable.
+        - If your code imports libraries other than the standard library modules, then those libraries MUST be listed in "dependencies".
+        - DO NOT include standard library modules in "dependencies".
+
+        """
+        
+        # --- CRITICAL LLM PROMPT ---
+        user_prompt = f"""
+        You are a highly skilled Question Solver. Your task is to analyze the quiz question 
+        provided below and generate the executable Python code to solve it.
+
+        1. **Quiz Content:** (The main question and submission text scraped from the website)
+           ---
+           {quiz_content_text}
+           ---
+        
+        2. **Files Available:** (A list of paths of available files)
+           ---
+           {link_data_str}
+           ---
+        
+        The code must adhere to these rules:
+        1. All dependencies that your generated code requires must appear in "dependencies" key of json output structure.
+        2. ONLY include dependencies that are actually imported.
+        3. If no extra libraries are required, return an empty list.
+        4. Do NOT send or execute the submission request. Only generate the code that computes the answer.
+        5. The final answer must be assigned to a variable named **'answer'**.
+        
+        You must also extract the submission url (link to which the answer should be sent to) from the question content.
+
+        Respond ONLY with a single JSON object that strictly adheres to the schema below.
+        
+        JSON Schema:
+        ```json
+        {{
+          "submit_url": "The submission URL extracted from the content (e.g., [https://example.com/submit](https://example.com/submit)).",
+          "python_code": [
+            "import ...",
+            "# ... generated code to process data and set final_answer ...",
+            "answer = ..."
+          ],
+          "dependencies":[...] (eg. ["pandas","numpy",...])
+        }}
+        ```
+        """
+
+        # print('System prompt: ', system_prompt)
+        print('User prompt: ', user_prompt)
+
+        # --- END CRITICAL LLM PROMPT ---
+
+        # if not llm_client:
+        #     print("LLM client not initialized. Cannot generate code.")
+        #     return None
+        
+        try:
+            # In a real scenario, you would call the LLM API here.
+            # response = llm_client.models.generate_content(model='gemini-2.5-flash', contents=prompt)
+            # llm_output = response.text.strip()
+            api_url='https://aipipe.org/openai/v1/chat/completions'
+
+            headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer{LLM_API_KEY}"
+            }
+
+
+            data = {
+                "model": "gpt-5-mini",
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": system_prompt
+                    },
+                    {
+                        "role": "user",
+                        "content": user_prompt
+                    }
+                ],
+            }
+           
+            response=requests.post(api_url, headers=headers, json=data)
+
+            llm_output=response.json()["choices"][0]["message"]["content"]
+
+            llm_plan = json.loads(llm_output)
+
+            print(llm_plan)
+
+             # llm_output='''{
+            #     "submit_url":"https://submit",
+            #     "python_code":["import pandas as pd","df=pd.DataFrame({'a':[1,2,3,4,5]})","answer=df.a.sum().item()"],
+            #     "dependencies":["pandas"]
+            # }'''
+            
+       
+
+        except :
+            print(f"LLM or JSON parsing failed")
+            return None
+            
+        return llm_plan
+
+    def _download_file(self,file_list):
+        """
+        Downloads files one after another using requests.
+        
+        Parameters:
+            file_list (list): List of dicts with {"text": ..., "href": ...}
+            save_dir (str): Directory to save the downloaded files.
+        
+        Returns:
+            List of file paths to the downloaded files.
+        """
+    
+    # Create folder if missing
+       
+
+        downloaded_paths = []
+
+        for item in file_list:
+            name = item.get("text", "file").replace(" ", "_")
+            url = item["href"]
+
+            # Guess filename from URL
+            filename = os.path.basename(url)
+            if not filename:
+                filename = f"{name}.html"   # fallback
+            
+            save_path = os.path.join(self.temp_dir.name, filename)
+
+            try:
+                print(f"Downloading: {url} -> {save_path}")
+                response = requests.get(url, timeout=20)
+                response.raise_for_status()
+
+                # Save file
+                with open(save_path, "wb") as f:
+                    f.write(response.content)
+
+                downloaded_paths.append(save_path)
+
+            except Exception as e:
+                print(f"Failed to download {url}: {e}")
+                continue
+        print(downloaded_paths)
+        return downloaded_paths
+
+    def _execute_generated_code(self, code_lines: list,dependencies: list) -> Any:
+        """
+        Safely executes the LLM-generated Python code in an isolated environment.
+        """
+        print("-> Executing generated code locally...")
+        
+        code_block = "\n".join(code_lines)
+
+        if dependencies!=[]:
+
+            to_install=[sys.executable, "-m", "pip", "install"] + dependencies
+            
+            print('Starting package installation')
+
+            result = subprocess.run(
+            to_install,
+            check=True,
+            text=True,
+            capture_output=True
+            )
+
+            if result.returncode!=0:
+                return 'Error in installing packages'
+
+        file_path = os.path.join(self.temp_dir.name, "script.py")
+
+        print('Python file path: ',file_path)
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(code_block)
+            script_path = f.name
+
+        print('Starting python execution')
+        try:
+            namespace = {}
+            with open(file_path, "r", encoding="utf-8") as f:
+                code = f.read()
+
+            exec(code, namespace)
+
+            # Step 3: extract the answer
+            answer = namespace["answer"]
+            
+            return answer
+
+        except:
+            return 0
+
+    # (The _solve_and_submit method remains the same)
+    def _solve_and_submit(self, submission_url: str, answer: Any) -> QuizSubmitResponse:
+        # ... (implementation from previous response)
+        # time_remaining = self._get_time_remaining()
+        # if time_remaining <= 5: # Keep a 5s buffer
+        #      print("Submission cancelled: Deadline is approaching.")
+        #      return QuizSubmitResponse(correct=False, reason="Deadline exceeded.")
+
+        # submission_url="https://tds-llm-analysis.s-anand.net/submit"
+
+        payload = QuizSubmitPayload(
+            email=self.email,
+            secret=self.secret,
+            url=self.current_url,
+            answer=answer
+        ).model_dump()
+
+        print('Request to submit: ', payload)
+
+        try:
+            
+            headers = {"Content-Type": "application/json"}
+            response = requests.post(submission_url, json=payload)
+            response.raise_for_status() # Raise exception for bad status codes
+
+            print(response)
+            
+            submit_response = QuizSubmitResponse(**response.json())
+            print(submit_response)
+            return submit_response
+        except requests.exceptions.RequestException as e:
+            print(f"Submission failed for {submission_url}: {e}")
+            return QuizSubmitResponse(correct=False, reason=f"Submission failed: {e}")
+
+    # (The run_quiz_loop method is updated to use the new LLM and execution steps)
+    def run_quiz_loop(self) -> str:
+        """
+        Main loop to solve the quiz and follow new URLs until completion or timeout.
+        """
+        repeats=0
+
+        while self.current_url:
+
+            with sync_playwright() as p:
+                # Running headless to save resources
+                browser = p.chromium.launch(headless=True)
+                page = browser.new_page()
+
+                
+                print(f"\n--- Solving Quiz: {self.current_url} ---")
+                
+                # 1. Visit URL and get content
+                try:
+                    page.goto(self.current_url, wait_until="networkidle")
+                    
+                    # 1. Get entire rendered text content from the <body>
+                    quiz_content_text = page.content()
+                    final_quiz_url = page.url 
+                    
+                    # 2. Get ALL links on the page for the LLM to analyze
+                    # We capture the text and the URL for every anchor tag (<a>)
+                    all_links = page.evaluate('''() => {
+                        const links = Array.from(document.querySelectorAll('a'));
+                        const fileExtensions = [
+                            '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.csv', '.zip', '.rar',
+                            '.tar', '.gz', '.jpg', '.jpeg', '.png', '.gif', '.svg', '.mp3',
+                            '.mp4', '.avi', '.mov', '.json', '.xml', '.txt'
+                        ];
+                        return links.map(link => ({
+                            text: link.innerText.trim(), 
+                            href: link.href
+                        }))
+                        .filter(link => {
+                        const href = link.href.toLowerCase();
+                        return fileExtensions.some(ext => href.endsWith(ext));
+                        });
+                    }''')
+                    # link_data_str = json.dumps(all_links)
+                    print('quiz content:',quiz_content_text)
+                    print('link data:',all_links)
+
+                except Exception as e:
+                    print(f"Navigation/Scraping failed: {e}")
+                    
+
+                
+
+                # Download files
+                print('all_links: ',all_links)
+                if all_links !=[]:
+                    print('calling download')
+                    download= self._download_file(all_links)
+                else:
+                    download=None
+
+                print('download finished')
+
+                print('Starting generate code function')
+
+                # 2. LLM Analysis and Code Generation
+                llm_plan = self._llm_analyze_and_generate_code(quiz_content_text,download)
+                if not llm_plan:
+                    print("Could not generate a valid execution plan from LLM.")
+                    
+                submission_url = llm_plan['submit_url']
+
+                final_answer = self._execute_generated_code(
+                    llm_plan['python_code'],llm_plan['dependencies']
+                )
+
+                if final_answer is None:
+                    print("Failed to calculate a final answer from code execution.")
+                    break
+                
+                print('Received result of python code: ', final_answer)
+
+                print('Sending answer to submit function')
+
+                # 5. Submit the Answer
+
+                if submission_url.find("https://")==-1:
+                    parsed = urlparse(self.current_url)
+                    base_url = urlunparse((parsed.scheme, parsed.netloc, "", "", "", ""))
+                    submission_url=base_url+submission_url
+
+                submit_response = self._solve_and_submit(submission_url, final_answer)
+
+                self.temp_dir.cleanup()
+
+                self.temp_dir = tempfile.TemporaryDirectory()
+
+                if submit_response.correct:
+                    if submit_response.url:
+                        self.current_url = submit_response.url
+                        self.start_time= datetime.now()
+                        print(f"Correct! Proceeding to new quiz: {self.current_url}")
+                        repeats=0
+                        
+                    else:
+                        print("Quiz sequence complete!")
+                        return "Success: Quiz sequence completed."
+                else:
+                    print(f"Incorrect. Reason: {submit_response.reason}")
+                    if submit_response.url:
+                        if self._get_time_remaining() <= 10:
+                            self.current_url = submit_response.url
+                            self.start_time= datetime.now()
+                            print(f"Skipping to new quiz because no time to redo: {self.current_url}")
+                            repeats=0
+                        else:
+                            repeats+=1
+                            if repeats<=2:
+                                print("Repeating question")
+                                continue
+                            else:
+                                if submit_response.url:
+                                    self.current_url = submit_response.url
+                                    self.start_time= datetime.now()
+                                    print(f"Skipping to new quiz after repeating: {self.current_url}")
+                                    repeats=0
+                                else:
+                                    return "Done"
+
+                            
+                    else:
+                        repeats+=1
+                        if repeats<=2:
+                            print("Repeating question")
+                            continue
+                        else:
+                            if submit_response.url:
+                                self.current_url = submit_response.url
+                                self.start_time= datetime.now()
+                                print(f"Skipping to new quiz after repeating: {self.current_url}")
+                                repeats=0
+                            else:
+                                return "Done"
+                                
+
+                    # Else: Loop continues for re-submission on the same URL if time remains.
+
+                browser.close()
+                
+                # if self._get_time_remaining() <= 10:
+                #     return "Timeout: Did not complete quiz within 3 minutes."
+                
+                # return "Failed to complete quiz sequence."