Datasets:

FrontierCS
/

Frontier-CS

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.")

	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.")