algorithmic/scripts/run_tests.py

import requests
import time
import os
import re
import json
import concurrent.futures
import argparse
import sys
import threading
from llm_interface import *

# --- Configuration ---
API_WORKERS = 16    # Max concurrent LLM generations
JUDGE_WORKERS = 8   # Max concurrent submissions to the local judge
# Get the directory where this script is currently located
script_dir = os.path.dirname(os.path.abspath(__file__))

# Set solution_dir to be a folder named 'solutions' inside that directory
solution_dir = os.path.join(script_dir, 'solutions')

# Define available models here for validation
AVAILABLE_MODELS = {
    'gemini', 'gpt', 'claude', 'claude-opus', 
    'claude-sonnet-4-5', 'gemini3', 'Grok', 'claude-opus-4-5'
}

# Semaphore to control concurrent access to the judge
judge_throttler = threading.BoundedSemaphore(JUDGE_WORKERS)

class LocalJudge:
    def __init__(self, judge_url="http://localhost:8081"):
        self.judge_url = judge_url
        self.session = requests.Session()

    def get_all_problems(self):
        try:
            response = self.session.get(f"{self.judge_url}/problems")
            response.raise_for_status()
            return [p['id'] for p in response.json().get('problems', [])]
        except requests.RequestException:
            print(f"Error connecting to the judge at {self.judge_url}. Is it running?")
            return None

    def get_problem_statement(self, pid):
        try:
            response = self.session.get(f"{self.judge_url}/problem/{pid}/statement")
            response.raise_for_status()
            return response.text
        except requests.RequestException:
            return None

    def submit_solution(self, pid, code):
        files = {'code': ('solution.cpp', code)}
        data = {'pid': pid, 'lang': 'cpp'}
        try:
            response = self.session.post(f"{self.judge_url}/submit", files=files, data=data)
            response.raise_for_status()
            return response.json().get('sid')
        except requests.RequestException:
            return None

    def get_result(self, sid, poll_interval=60):
        # Polls indefinitely until a result is returned
        while True:
            try:
                response = self.session.get(f"{self.judge_url}/result/{sid}")
                if response.status_code == 404:
                    time.sleep(poll_interval)
                    continue
                
                response.raise_for_status()
                result = response.json()
                
                if result.get('status') in ['done', 'error']:
                    return result
                
                time.sleep(poll_interval)
                
            except requests.RequestException:
                time.sleep(poll_interval)

def extract_cpp_code(response_text):
    match = re.search(r'```cpp\n(.*?)```', response_text, re.DOTALL)
    if match:
        return match.group(1).strip()
    return response_text

def get_llm_instance(model_name):
    """Factory function to instantiate the correct LLM class."""
    if model_name == 'gemini':
        return Gemini()
    elif model_name == 'gpt':
        return GPT()
    elif model_name == 'claude':
        return Claude()
    elif model_name == 'claude-opus':
        return Claude_Opus()
    elif model_name == 'claude-sonnet-4-5':
        return Claude_Sonnet_4_5()
    elif model_name == 'gemini3':
        return Gemini3()
    elif model_name == 'Grok':
        return Grok()
    elif model_name == 'claude-opus-4-5':
        return Claude_Opus_4_5()
    else:
        raise ValueError(f"Unknown model: {model_name}")

def process_single_attempt(pid, model_name):
    """
    Generates one solution, judges it, and saves the results.
    Returns the score (float/int) for the attempt. 
    Returns 0 if a critical error occurs before grading.
    """
    run_id = f"{pid}_{model_name}"
    result_filename = f"{solution_dir}/{run_id}_result.json"
    solution_filename = f"{solution_dir}/{run_id}_solution.cpp"

    print(f"[Processing {pid}] Starting attempt using {model_name}")
    
    judge = LocalJudge()
    
    try:
        llm = get_llm_instance(model_name)
    except ValueError as e:
        print(e)
        return 0

    try:
        # 1. Get Statement
        statement = judge.get_problem_statement(pid)
        if not statement: 
            print(f"[Processing {pid}] Failed to get statement.")
            return 0

        # 2. Generate Solution
        llm_response, _ = llm.generate_solution(statement)
        if not llm_response:
            print(f"[Processing {pid}] LLM failed.")
            final_result = {"status": "error", "error": "LLM_TIMEOUT_OR_FAILURE", "score": 0}
            with open(result_filename, 'w', encoding='utf-8') as f:
                json.dump(final_result, f, indent=4)
            return 0

        llm_text_content = str(llm_response)
        solution_code = extract_cpp_code(llm_text_content)
        
        with open(solution_filename, 'w', encoding='utf-8') as f:
            f.write(solution_code)

        # 3. Submit and Grade
        with judge_throttler:
            submission_id = judge.submit_solution(pid, solution_code)
            if not submission_id:
                final_result = {"status": "error", "error": "SUBMISSION_FAILED", "score": 0}
                with open(result_filename, 'w', encoding='utf-8') as f:
                    json.dump(final_result, f, indent=4)
                return 0

            final_result = judge.get_result(submission_id)
        
        # 4. Save Result
        new_score = final_result.get('score', -1)
        with open(result_filename, 'w', encoding='utf-8') as f:
            json.dump(final_result, f, indent=4)
            
        print(f"[Processing {pid}] Finished. Score: {new_score}")
        
        return new_score

    except Exception as e:
        print(f"[Processing {pid}] A critical error occurred: {e}")
        error_result = {"status": "error", "error": str(e), "score": 0}
        try:
            with open(result_filename, 'w', encoding='utf-8') as f:
                json.dump(error_result, f, indent=4)
        except Exception as e_file:
            print(f"  ...Additionally, FAILED to write error log: {e_file}")
        return 0


if __name__ == "__main__":
    # --- Argument Parsing ---
    parser = argparse.ArgumentParser(description="Run LLM Judge Benchmarks")
    parser.add_argument(
        "model", 
        type=str, 
        help=f"The model to run. Options: {', '.join(AVAILABLE_MODELS)}"
    )
    args = parser.parse_args()
    
    selected_model = args.model

    if selected_model not in AVAILABLE_MODELS:
        print(f"Error: '{selected_model}' is not a valid model.")
        print(f"Available options: {', '.join(AVAILABLE_MODELS)}")
        sys.exit(1)

    if not os.path.exists(solution_dir):
        os.makedirs(solution_dir)

    judge = LocalJudge()
    print("Fetching list of problems...")
    problem_ids = judge.get_all_problems()
    if not problem_ids:
        print("No problems found on the judge.")
        sys.exit(0)
    
    print(f"Found {len(problem_ids)} problems. Starting single run for each using model: {selected_model}")

    collected_scores = []

    with concurrent.futures.ThreadPoolExecutor(max_workers=API_WORKERS) as executor:
        futures = [executor.submit(process_single_attempt, pid, selected_model) for pid in problem_ids]
        
        for future in concurrent.futures.as_completed(futures):
            try:
                # Retrieve the return value from the function (the score)
                raw_score = future.result()
                
                # Treat -1 (error/missing) as 0 for the average
                if raw_score == -1:
                    effective_score = 0
                else:
                    effective_score = raw_score
                
                collected_scores.append(effective_score)
                
            except Exception as e:
                print(f"A job failed in the thread pool: {e}")
                collected_scores.append(0) # Treat exceptions as 0 score

    print("\nAll problems have been processed.")
    
    # Calculate Average
    if collected_scores:
        avg_score = sum(collected_scores) / len(collected_scores)
        print("-" * 30)
        print(f"Final Average Score: {avg_score:.2f}")
        print("-" * 30)
    else:
        print("No scores collected.")