Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,165 @@
+logs/
+cache/
+output/
+!output/pass_at_k_results.json
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

ERRATA.md

@@ -0,0 +1,32 @@
+# Livecodebench Errata
+While we have tries to ensure the correctness of the benchmark in terms of test cases and problems, we have received feedback on issues regarding erroneous tests and problems not amenable to autograding. Here, we document the known issues and are also constantly using this feedback to improve our problem selection heuristics as we update LiveCodeBench.
+
+## Multiple Solutions Accepted
+7 problems have been identified with test case issues. Particularly, these problems accept multiple possible outputs, while the benchmark grades for only one specific output. Thus some correct solutions may be marked as incorrect and can add noise to the benchmark results.
+
+1. abc311_c - Multiple solutions accepted
+2. abc326_d - Multiple solutions accepted
+3. abc327_b - Multiple solutions accepted
+4. abc333_e - Multiple solutions accepted
+5. abc343_e - Multiple solutions accepted
+6. abc362_c - Multiple solutions accepted
+7. find-words-containing-character - Multiple solutions accepted
+8. find-the-peaks - Multiple solutions accepted
+10. generate-binary-strings-without-adjacent-zeros - Multiple solutions accepted
+11. arc185_c - Multiple solutions accepted
+12. abc343_a - Multiple solutions accepted
+
+
+## Interactive Problems
+2 problems have been identified as interactive problems. These problems require the submission to interact with the judge to get the final answer. The benchmark evaluation suite does not support interactive problems and thus these problems cannot be solved correctly. Note that these problems will not affect model comparison results since no model can solve these problems.
+
+1. abc337_e - Interactive problem
+2. abc355_e - Interactive problem
+
+## Erroneous Test Cases
+1 problem has been identified with erroneous test cases during scraping. This problem cannot be solved correctly with the current test cases. Note that these problems will not affect model comparison results since no model can solve these problems.
+
+1. abc350_c - Erroneous test cases
+2. apply-operations-to-make-string-empty - Erroneous test case of empty string
+3. most-frequent-ids - Adversarian input not following constraints
+4. arc189_a - Single erroneous test case with incorrect output

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LiveCodeBench
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,217 @@
+# LiveCodeBench
+Official repository for the paper "LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code"
+
+<p align="center">
+    <a href="https://livecodebench.github.io/">🏠 Home Page</a> •
+    <a href="https://huggingface.co/livecodebench/">💻 Data </a> •
+    <a href="https://livecodebench.github.io/leaderboard.html">🏆 Leaderboard</a> •
+    <a href="https://huggingface.co/spaces/livecodebench/code_generation_samples">🔍 Explorer</a> 
+</p>
+
+## Introduction
+LiveCodeBench provides holistic and contamination-free evaluation of coding capabilities of LLMs.  Particularly, LiveCodeBench continuously collects new problems over time from contests across three competition platforms -- LeetCode, AtCoder, and CodeForces. Next, LiveCodeBench also focuses on a broader range of code-related capabilities, such as self-repair, code execution, and test output prediction, beyond just code generation. Currently, LiveCodeBench hosts four hundred high-quality coding problems that were published between May 2023 and March 2024.
+
+
+## Installation
+You can clone the repository using the following command:
+
+```bash
+git clone https://github.com/LiveCodeBench/LiveCodeBench.git
+cd LiveCodeBench
+```
+
+We recommend using [uv](https://github.com/astral-sh/uv)
+for managing dependencies, which can be installed a [number of ways](https://github.com/astral-sh/uv?tab=readme-ov-file#installation).
+
+Verify that `uv` is installed on your system by running:
+
+```bash
+uv --version
+```
+
+Once `uv` has been installed, use it to create a virtual environment for
+LiveCodeBench and install its dependencies with the following commands:
+
+```bash
+uv venv --python 3.11
+source .venv/bin/activate
+
+uv pip install -e .
+```
+
+## Data
+We provide a benchmark for different code capability scenarios
+- [Code Generation](https://huggingface.co/datasets/livecodebench/code_generation_lite)
+- [Code Execution](https://huggingface.co/datasets/livecodebench/execution)
+- [Test Output Prediction](https://huggingface.co/datasets/livecodebench/test_generation)
+
+## Inference and Evaluation
+
+### Dataset Versions
+Since LiveCodeBench is a continuously updated benchmark, we provide different versions of the dataset. Particularly, we provide the following versions of the dataset:
+- `release_v1`: The initial release of the dataset with problems released between May 2023 and Mar 2024 containing 400 problems.
+- `release_v2`: The updated release of the dataset with problems released between May 2023 and May 2024 containing 511 problems.
+- `release_v3`: The updated release of the dataset with problems released between May 2023 and Jul 2024 containing 612 problems.
+- `release_v4`: The updated release of the dataset with problems released between May 2023 and Sep 2024 containing 713 problems.
+- `release_v5`: The updated release of the dataset with problems released between May 2023 and Jan 2025 containing 880 problems.
+- `release_v6`: The updated release of the dataset with problems released between May 2023 and Apr 2025 containing 1055 problems.
+
+You can use the `--release_version` flag to specify the dataset version you wish to use. Particularly, you can use the following command to run the evaluation on the `release_v2` dataset. Release version defaults to `release_latest`. Additionally, we have introduced fine-grained release versions such as `v1`, `v2`, `v1_v3`, `v4_v5` for specific versions of the dataset.
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario codegeneration --evaluate --release_version release_v2
+```
+
+### Code Generation
+
+We use `vllm` for inference using open models. By default, we use  `tensor_parallel_size=${num_gpus}` to parallelize inference across all available GPUs. It can be configured using the  `--tensor_parallel_size` flag as required. 
+
+For running the inference, please provide the `model_name` based on the [./lcb_runner/lm_styles.py](./lcb_runner/lm_styles.py) file.
+The scenario (here `codegeneration`) can be used to specify the scenario for the model.
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario codegeneration
+```
+
+Additionally, `--use_cache` flag can be used to cache the generated outputs and `--continue_existing` flag can be used to use the existing dumped results. In case you wish to use model from a local path, you can additionally provide `--local_model_path` flag with the path to the model. We use `n=10` and `temperature=0.2` for generation. Please check the [./lcb_runner/runner/parser.py](./lcb_runner/runner/parser.py) file for more details on the flags.
+
+For closed API models,  `--multiprocess` flag can be used to parallelize queries to API servers (adjustable according to rate limits).
+
+
+#### Evaluation
+We compute `pass@1` and `pass@5` metrics for model evaluations.
+We use a modified version of the checker released with the [`apps` benchmark](https://github.com/hendrycks/apps/blob/main/eval/testing_util.py) to compute the metrics. Particularly, we identified some unhandled edge cases in the original checker and fixed them and additionally simplified the checker based on our collected dataset. To run the evaluation, you can add the `--evaluate` flag:
+
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario codegeneration --evaluate
+```
+
+Note that time limits can cause slight (`< 0.5`) points of variation in the computation of the `pass@1` and `pass@5` metrics.
+If you observe a significant variation in performance, adjust the `--num_process_evaluate` flag to a lower value or increase the `--timeout` flag. Please report particular issues caused by improper timeouts here. 
+
+Finally, to get scores over different time windows, you can use [./lcb_runner/evaluation/compute_scores.py](./lcb_runner/evaluation/compute_scores.py) file. 
+Particularly, you can provide `--start_date` and `--end_date` flags (using the `YYYY-MM-DD` format) to get scores over the specified time window. In our paper, to counter contamination in the DeepSeek models, we only report results on problems released after August 2023. You can replicate those evaluations using:
+
+```bash
+python -m lcb_runner.evaluation.compute_scores --eval_all_file {saved_eval_all_file} --start_date 2023-09-01
+```
+
+**NOTE: We have pruned a large number of test cases from the original benchmark and created `code_generation_lite` which is set as the default benchmark offering similar performance estimation much faster. If you wish to use the original benchmark, please use the `--not_fast` flag. We are in the process of updating the leaderboard scores with this updated setting.** 
+
+**NOTE: V2 Update: to run the update LiveCodeBench please use `--release_version release_v2`. In addition, if you have existing results from `release_v1` you can add `--continue_existing` or better `--continue_existing_with_eval` flags to reuse the old completions or evaluations respectively.**
+
+
+### Self Repair
+For running self repair, you need to provide an additional `--codegen_n` flag that maps to the number of codes that were generated during code generation. Additionally, the `--temperature` flag is used to resolve the old code generation eval file which must be present in the `output` directory. 
+
+```bash
+python -m lcb_runner.runner.main --model {model_name --scenario selfrepair --codegen_n {num_codes_codegen} --n 1 # only n=1 supported
+```
+
+In case you have results on a smaller subset or version of the benchmark, you can use `--continue_existing` and `--continue_existing_with_eval` flags to reuse the old computations. Particularly, you can run the following command to continue from existing generated solutions.
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario selfrepair --evaluate --continue_existing
+```
+
+Note that this will only reuse the generated samples and rerun evaluations. To reuse the old evaluations, you can add the `--continue_existing_with_eval` flag.
+
+### Test Output Prediction
+For running the test output prediction scenario you can simply run
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario testoutputprediction --evaluate
+```
+
+### Code Execution
+For running the test output prediction scenario you can simply run
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario codeexecution --evaluate
+```
+
+Additionally, we support the COT setting with
+
+```bash
+python -m lcb_runner.runner.main --model {model_name} --scenario codeexecution --cot_code_execution --evaluate
+```
+
+## Custom Evaluation
+Alternatively, you can using [`lcb_runner/runner/custom_evaluator.py`](./lcb_runner/runner/custom_evaluator.py) to directly evaluated model generations in a custom file. The file should contain a list of model outputs, appropriately formatted for evaluation in the order of benchmark problems. 
+
+```bash
+python -m lcb_runner.runner.custom_evaluator --custom_output_file {path_to_custom_outputs}
+```
+
+Particularly, arrange the outputs in the following format
+
+```json
+[
+    {"question_id": "id1", "code_list": ["code1", "code2"]},
+    {"question_id": "id2", "code_list": ["code1", "code2"]}
+]
+```
+
+
+## Adding Support for New Models
+
+To add support for new models, we have implemented an extensible framework to add new models and customize prompts appropriately. 
+
+Step 1: Add a new model to the [./lcb_runner/lm_styles.py](./lcb_runner/lm_styles.py) file. Particularly, extend the `LMStyle` class to add a new model family and extend the model to the `LanguageModelList` array.
+
+Step 2: Since we use instruction tuned models, we allow configuring the instruction for each model. Modify the [./lcb_runner/prompts/generation.py](./lcb_runner/prompts/generation.py) file to add a new prompt for the model in the `format_prompt_generation` function. 
+For example, the prompt for `DeepSeekCodeInstruct` family of models looks as follows
+
+```python
+# ./lcb_runner/prompts/generation.py
+if LanguageModelStyle == LMStyle.DeepSeekCodeInstruct:
+    prompt = f"{PromptConstants.SYSTEM_MESSAGE_DEEPSEEK}\n\n"
+    prompt += f"{get_deepseekcode_question_template_answer(question)}"
+    return prompt
+```
+
+## Submit Models to Leaderboard
+We are currently only accepting submissions for only the code generation scenario. To submit models you can create a pull request on our [submissions](https://github.com/LiveCodeBench/submissions). Particularly, you can copy your model generations folder from `output` to the `submissions` folder and create a pull request. We will review the submission and add the model to the leaderboard accordingly. 
+
+## ERRATA
+We maintain a list of known issues and updates in the [ERRATA.md](./ERRATA.md) file. Particularly, we document issues regarding erroneous tests and problems not amenable to autograding. We are constantly using this feedback to improve our problem selection heuristics as we update LiveCodeBench.
+
+## Results
+LiveCodeBench can be used to evaluate performance of LLMs on different time-windows (using problem release date to filter the models). 
+Thus we can detect and prevent potential contamination in the evaluation process and evaluate LLMs on _new_ problems.
+
+<div style="text-align: center;">
+    <img src="./assets/images/contamination1.png" alt="Code Generation Live Evaluation" class="teaser-image"
+    width="40%" />
+    <img src="./assets/images/contamination2.png" alt="Test Output Prediction Live Evaluation" class="teaser-image"
+    width="40%" />
+</div>
+
+Next, we evaluate models on different code capabilities and find that relative performances of models do change over tasks (left). 
+Thus, it highlights the need for holistic evaluation of LLMs for code.
+
+<div style="text-align: center;">
+    <img src="./assets/images/tasks_radar.png" alt="Holistic Tasks Evaluation" class="teaser-image"
+    width="36.1%" />
+    <img src="./assets/images/lcb_vs_he.png" alt="Comparing LCB vs HumanEval" class="teaser-image"
+    width="46%" />
+</div>
+
+We also find evidence of possible overfitting on HumanEval (right). 
+Particularly, models that perform well on HumanEval do not necessarily perform well on LiveCodeBench. 
+In the scatterplot above, we find the models get clustered into two groups, shaded in red and green. 
+The red group contains models that perform well on HumanEval but poorly on LiveCodeBench, while the green group contains models that perform well on both.
+
+For more details, please refer to our website at [livecodebench.github.io](https://livecodebench.github.io).
+
+## Citation
+
+```bibtex
+@article{jain2024livecodebench,
+  author    = {Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, Ion Stoica},
+  title     = {LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code},
+  year      = {2024},
+  journal   = {arXiv preprint},
+}
+```

eval_ckpts.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+BASE="/data/repos/agentica-rllm/scripts/train/deepcoder/checkpoints/deepcoder-1.7b"
+
+run_eval() {
+    local model_path="$1"
+    local nickname="$2"
+    echo "Running eval: $nickname"
+    CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python -m lcb_runner.runner.main \
+        --model "$model_path" \
+        --nickname "$nickname" \
+        --scenario codegeneration \
+        --evaluate \
+        --release_version v4_v6 \
+        --n 256 \
+        --temperature 0.6 \
+        --top_p 0.95 \
+        --tensor_parallel_size 8 \
+        --num_process_evaluate 60
+}
+
+
+
+# run_eval "$BASE/adv:maxrl-cont:false/global_step_100/actor/checkpoint"  maxrl_binary_100
+# run_eval "$BASE/adv:tailrl-cont:true/global_step_100/actor/checkpoint"  tailrl_cont_100
+# run_eval "$BASE/adv:maxrl-cont:false/global_step_200/actor/checkpoint"  maxrl_binary_200
+# run_eval "$BASE/adv:tailrl-cont:true/global_step_200/actor/checkpoint"  tailrl_cont_200
+# run_eval "$BASE/adv:maxrl-cont:false/global_step_300/actor/checkpoint"  maxrl_binary_300
+# run_eval "$BASE/adv:tailrl-cont:true/global_step_300/actor/checkpoint"  tailrl_cont_300
+run_eval "$BASE/adv:maxrl-cont:false/global_step_400/actor/checkpoint"  maxrl_binary_400
+run_eval "$BASE/adv:tailrl-cont:true/global_step_400/actor/checkpoint"  tailrl_cont_400

lcb_runner/benchmarks/__init__.py

@@ -0,0 +1,13 @@
+from lcb_runner.benchmarks.code_generation import (
+    CodeGenerationProblem,
+    load_code_generation_dataset,
+    load_code_generation_dataset_not_fast,
+)
+from lcb_runner.benchmarks.test_output_prediction import (
+    TestOutputPredictionProblem,
+    load_test_prediction_dataset,
+)
+from lcb_runner.benchmarks.code_execution import (
+    CodeExecutionProblem,
+    load_code_execution_dataset,
+)

lcb_runner/benchmarks/code_execution.py

@@ -0,0 +1,67 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class CodeExecutionProblem:
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    function_name: str
+    code: str
+    input: str
+    output: str
+    id: str
+    problem_id: str
+    numsteps: int
+
+    def __post_init__(self):
+        pass
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "function_name": self.function_name,
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+            "id": self.id,
+            "problem_id": self.problem_id,
+            "numsteps": self.numsteps,
+            "output_list": output_list,
+            "pred_list": pred_list,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+        }
+
+
+def load_code_execution_dataset(release_version="release_v1") -> list[CodeExecutionProblem]:
+    dataset = load_dataset("livecodebench/execution-v2", split="test")
+    dataset = [CodeExecutionProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_execution_dataset()

lcb_runner/benchmarks/code_generation.py

@@ -0,0 +1,147 @@
+import json
+import zlib
+import pickle
+import base64
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+class Platform(Enum):
+    LEETCODE = "leetcode"
+    CODEFORCES = "codeforces"
+    ATCODER = "atcoder"
+
+
+class Difficulty(Enum):
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+
+
+class TestType(Enum):
+    STDIN = "stdin"
+    FUNCTIONAL = "functional"
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: TestType
+
+    def __post_init__(self):
+        self.testtype = TestType(self.testtype)
+        # if self.testtype == TestType.FUNCTIONAL:
+        #     self.input = json.loads(self.input)
+        #     self.output = json.loads(self.output)
+
+
+@dataclass
+class CodeGenerationProblem:
+    question_title: str
+    question_content: str
+    platform: Platform
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    starter_code: str
+    difficulty: Difficulty
+    public_test_cases: list[Test]
+    private_test_cases: list[Test]
+    metadata: dict
+
+    def __post_init__(self):
+        self.platform = Platform(self.platform)
+        self.difficulty = Difficulty(self.difficulty)
+        self.contest_date = datetime.fromisoformat(self.contest_date)
+
+        self.public_test_cases = json.loads(self.public_test_cases)  # type: ignore
+        self.public_test_cases = [Test(**t) for t in self.public_test_cases]
+
+        try:
+            self.private_test_cases = json.loads(self.private_test_cases)  # type: ignore
+        except:
+            self.private_test_cases = json.loads(
+                pickle.loads(
+                    zlib.decompress(
+                        base64.b64decode(self.private_test_cases.encode("utf-8"))  # type: ignore
+                    )
+                )
+            )  # type: ignore
+        self.private_test_cases = [Test(**t) for t in self.private_test_cases]
+
+        self.metadata = json.loads(self.metadata)  # type: ignore
+
+    def insert_output(self, output_list: list[str], code_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "platform": self.platform.value,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "starter_code": self.starter_code,
+            "difficulty": self.difficulty.value,
+            "output_list": output_list,
+            "code_list": code_list,
+        }
+
+    def insert_output_evaluation(
+        self,
+        output_list: list[str],
+        code_list: list[str],
+        graded_list: list[bool],
+        **kwargs,
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        for k, v in kwargs.items():
+            output[k] = v
+        return output
+
+    def get_evaluation_sample(self):
+        return {
+            "input_output": json.dumps(
+                {
+                    "inputs": [
+                        t.input
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "outputs": [
+                        t.output
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "fn_name": self.metadata.get("func_name", None),
+                }
+            ),
+        }
+
+
+def load_code_generation_dataset(release_version="release_v1", start_date=None, end_date=None) -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation_lite", split="test", version_tag=release_version, trust_remote_code=True)
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    if start_date is not None:
+        p_start_date = datetime.strptime(start_date, "%Y-%m-%d")
+        dataset = [e for e in dataset if p_start_date <= e.contest_date]
+
+    if end_date is not None:
+        p_end_date = datetime.strptime(end_date, "%Y-%m-%d")
+        dataset = [e for e in dataset if e.contest_date <= p_end_date]
+
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+def load_code_generation_dataset_not_fast(release_version="release_v1") -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation", split="test")
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_generation_dataset()

lcb_runner/benchmarks/test_output_prediction.py

@@ -0,0 +1,70 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: str
+
+
+@dataclass
+class TestOutputPredictionProblem:
+    question_title: str
+    question_content: str
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    test: list[Test]
+    starter_code: str
+    function_name: str
+    test_id: int
+
+    def __post_init__(self):
+        self.test = [Test(**t) for t in json.loads(self.test)]  # type: ignore
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "output_list": output_list,
+            "pred_list": pred_list,
+            "test_id": self.test_id,
+            "function_name": self.function_name,
+            "starter_code": self.starter_code,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "input": self.question_content,
+            "output": self.test[0].output,
+        }
+
+
+def load_test_prediction_dataset(release_version="release_v1") -> list[TestOutputPredictionProblem]:
+    dataset = load_dataset("livecodebench/test_generation", split="test")  # type: ignore
+    dataset = [TestOutputPredictionProblem(**d) for d in dataset]
+    print(f"Loaded {len(dataset)} prediction problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_test_prediction_dataset()

lcb_runner/evaluation/__init__.py

@@ -0,0 +1,6 @@
+from lcb_runner.evaluation.compute_code_generation_metrics import codegen_metrics
+from lcb_runner.evaluation.compute_code_execution_metrics import code_execution_metrics
+from lcb_runner.evaluation.compute_test_output_prediction_metrics import (
+    test_output_metrics,
+)
+from lcb_runner.evaluation.pass_k_utils import extract_instance_results

lcb_runner/evaluation/compute_code_execution_metrics.py

@@ -0,0 +1,56 @@
+import numpy as np
+from concurrent.futures import ProcessPoolExecutor
+import tqdm
+
+from lcb_runner.evaluation.utils_execute import BASE_IMPORTS, check_correctness
+
+def evaluate_score(args) -> list[bool]:
+    gs, (c, i, o) = args
+
+    execution_results = []
+    for g in gs:
+        if i in g:
+            pass
+        else:
+            code_to_execute = f"{BASE_IMPORTS}\n{c}\nassert {o} == {g}"
+            execution_results.append(check_correctness(code_to_execute, 3))
+    if len(execution_results) == 0:
+        execution_results = [False] * len(gs)
+    return execution_results
+
+def pass_at_k(n, c, k):
+    if n - c < k: return 1.0
+    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+
+def code_execution_metrics(
+    samples,
+    generations,
+):
+    # execute the code
+    references = [(doc["code"], doc["input"], doc["output"]) for doc in samples]
+    with ProcessPoolExecutor() as executor:
+        args_list = zip(generations, references)
+        results = executor.map(evaluate_score, args_list)
+    all_results = list(results)
+
+    # serial version
+    # all_results = []
+    # for i in range(len(generations)):
+    #     generation = generations[i]
+    #     result = evaluate_score([generation, references[i]])
+    #     all_results.append(result)
+
+    # compute pass@1
+    pass_at_1s = []
+    for execution_result in all_results:
+        c, n = execution_result.count(True), len(execution_result)
+        pass_at_1s.append(pass_at_k(n, c, 1))
+    metrics = {"pass@1": sum(pass_at_1s) / len(pass_at_1s) * 100}
+
+    results = {}
+    for i, r in enumerate(all_results):
+        r_new = []
+        for _r in r:
+            r_new.append([_r])
+        results[i] = r_new
+    return [metrics, results]

lcb_runner/evaluation/compute_code_generation_metrics.py

@@ -0,0 +1,255 @@
+# borrowed and extended from
+# https://github.com/Naman-ntc/codescratch/blob/main/evaluation/bigcode-evaluation-harness/lm_eval/tasks/custom_metrics/apps_custom_metrics/utils.py
+
+import os
+import sys
+
+sys.set_int_max_str_digits(50000)
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+import json
+import multiprocessing
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+
+import numpy as np
+from tqdm import tqdm
+
+from lcb_runner.evaluation.testing_util import run_test
+from lcb_runner.evaluation.pass_k_utils import compute_metrics_from_results
+
+
+def _temp_run(sample, generation, debug, result, metadata_list, timeout):
+    res, metadata = run_test(sample, test=generation, debug=debug, timeout=timeout)
+    result.append(res)
+    metadata_list.append(metadata)
+
+
+def check_correctness(sample, generation, timeout, debug=True):
+    """Check correctness of code generation with a global timeout.
+    The global timeout is to catch some extreme/rare cases not handled by the timeouts
+    inside `run_test`"""
+
+    manager = multiprocessing.Manager()
+    result = manager.list()
+    metadata_list = manager.list()
+    p = multiprocessing.Process(
+        target=_temp_run,
+        args=(sample, generation, debug, result, metadata_list, timeout),
+    )
+    p.start()
+    p.join(
+        timeout=(timeout + 1) * len(json.loads(sample["input_output"])["inputs"]) + 5
+    )
+    try:
+        os.kill(p.pid, 9) # Force to kill the process by PID for safety
+    except:
+        None
+    if p.is_alive():
+        p.kill()
+    if not result:
+        in_outs = json.loads(sample["input_output"])
+        # consider that all tests failed
+        result = [[-1 for i in range(len(in_outs["inputs"]))]]
+        if debug:
+            print(f"global timeout")
+    return result[0], metadata_list[0]
+
+
+def evaluate_generations_by_problem(args):
+    problem_generations: list[str] = args[0]
+    sample = args[1]
+    debug: bool = args[2]
+    timeout: int = args[3]
+
+    res = []
+    metadata = []
+    for o_idx, o in enumerate(problem_generations):
+        curr_res = [-2]
+        try:
+            curr_res, curr_metadata = check_correctness(
+                sample, o, timeout=timeout, debug=debug
+            )
+            if debug:
+                print(f"\nSuccessful compilation of task {o_idx}!")
+            fixed = []
+            for e in curr_res:
+                if isinstance(e, np.ndarray):
+                    e = e.item(0)
+                if isinstance(e, np.bool_):
+                    e = bool(e)
+                fixed.append(e)
+            curr_res = fixed
+            if not np.all(curr_res):
+                if debug:
+                    print(f"Results were not True for all test cases {curr_res=}\n")
+        except Exception as e:
+            if debug:
+                print(f"Compilation failed, test framework exception = {repr(e)}{e}\n")
+            # break
+            curr_metadata = {
+                "error": repr(e),
+                "error_code": -5,
+                "error_message": "TestRunnerError",
+            }
+        finally:
+            assert isinstance(curr_res, list), curr_res
+            assert isinstance(curr_metadata, dict), curr_metadata
+            res.append(curr_res)
+            metadata.append(curr_metadata)
+    if debug:
+        for i, r in enumerate(problem_generations):
+            print("Sample\n")
+            print(r)
+            print("\n")
+            print("Result\n")
+            print(res[i])
+            print("*" * 30 + "\n\n")
+    return res, metadata
+
+
+def evaluate_generations(
+    samples_list: list,
+    generations_list: list[list[str]],
+    debug: bool = False,
+    num_process_evaluate: int = 16,
+    timeout=6,
+):
+    """We take the list of code generations and try to compile them
+     and the run their corresponding unit tests which are retrieved from the APPS dataset.
+
+    Args:
+        generations: list of code generations (same order as samples in APPS dataset)
+        level: difficulty level used in the generation, can be "all", "introductory", "interview" or "competition"
+
+    Returns:
+        results: dictionary of results, key is the problem index, value is a list of results for each generation
+    """
+
+    # generations are code generations in the same order of the dataset
+
+    inputs = [
+        [(generations_list[index], samples_list[index], debug, timeout), index]
+        for index in range(len(generations_list))
+    ]
+
+    with tqdm(total=len(inputs)) as pbar:
+        with ProcessPoolExecutor(
+            max_workers=1 if debug else num_process_evaluate
+        ) as executor:
+            futures = {
+                executor.submit(evaluate_generations_by_problem, arg): index
+                for arg, index in inputs
+            }
+
+            results = {}
+            metadata = {}
+            for future in as_completed(futures):
+                index = futures[future]
+                results[index], metadata[index] = future.result()
+                pbar.update(1)
+
+    assert len(results) == len(
+        inputs
+    ), f"results = {len(results)} inputs = {len(inputs)} {results=}"
+    # results = {i: r for r, (_, i) in zip(results, inputs)}
+
+    return results, metadata
+
+
+def codegen_metrics(
+    samples_list,
+    generations_list,
+    k_list=[1, 5, 10, 20, 40, 50, 75, 100, 125, 150, 200, 500, 1000],
+    num_process_evaluate=16,
+    timeout=6,
+    debug=False,
+):
+
+    samples_linear = []
+    generations_linear = []
+    remap_index = []
+    results = defaultdict(list)
+    metadatas = defaultdict(list)
+    for idx, (sample, generation_list) in enumerate(
+        zip(samples_list, generations_list)
+    ):
+        assert isinstance(generation_list, list), generations_list[0]
+        for generation in generation_list:
+            assert isinstance(generation, str), generations_list[0]
+            samples_linear.append(sample)
+            generations_linear.append([generation])
+            remap_index.append(idx)
+
+    print(f"Evaluating {len(samples_linear)}...")
+
+    results_linear, metadatas_linear = evaluate_generations(
+        samples_linear,
+        generations_linear,
+        debug=debug,
+        num_process_evaluate=num_process_evaluate,
+        timeout=timeout,
+    )
+
+    for idx, sub_results in sorted(results_linear.items(), key=lambda x: x[0]):
+        results[remap_index[idx]].append(sub_results[0])
+
+    for idx, sub_metadatas in sorted(metadatas_linear.items(), key=lambda x: x[0]):
+        metadatas[remap_index[idx]].append(sub_metadatas[0])
+
+    metrics = compute_metrics_from_results(results, k_list=k_list)
+
+    final_metadata = []
+    for key in sorted(list(metadatas.keys())):
+        final_metadata.append(metadatas[key])
+    for i in range(len(final_metadata)):
+        if type(final_metadata[i]) is not list:
+            final_metadata[i] = [json.dumps(final_metadata[i])]
+        else:
+            final_metadata[i] = [json.dumps(x) for x in final_metadata[i]]
+
+        assert len(final_metadata[i]) == len(
+            generations_list[0]
+        ), f"{len(final_metadata[i])=}"
+
+    return [metrics, results, final_metadata]
+
+
+if __name__ == "__main__":
+    # print(
+    #     check_correctness(
+    #         {
+    #             "input_output": json.dumps(
+    #                 {
+    #                     "inputs": [
+    #                         json.dumps([1] * 100000)
+    #                         + "\n"
+    #                         + json.dumps([100000, -100000] * (100000 // 2))
+    #                     ],
+    #                     "outputs": [json.dumps([100000, 0] * (100000 // 2))],
+    #                     "fn_name": "mostFrequentIDs",
+    #                 }
+    #             )
+    #         },
+    #         "class Solution:\n    def mostFrequentIDs(self, nums: List[int], freq: List[int]) -> List[int]:\n        from collections import defaultdict\n        \n        # Count of each ID\n        count = defaultdict(int)\n        # How many IDs exist for a given frequency\n        freq_of_count = defaultdict(int)\n        \n        max_freq = 0\n        ans = []\n        \n        for i in range(len(nums)):\n            x = nums[i]\n            change = freq[i]\n            \n            old_freq = count[x]\n            new_freq = old_freq + change\n            \n            # If there was an old frequency, decrease its usage\n            if old_freq > 0:\n                freq_of_count[old_freq] -= 1\n                if freq_of_count[old_freq] == 0:\n                    del freq_of_count[old_freq]\n            \n            # Update with the new frequency\n            count[x] = new_freq\n            freq_of_count[new_freq] += 1\n            \n            # Update max_freq if needed\n            if new_freq > max_freq:\n                max_freq = new_freq\n            \n            # If the collection at max_freq is empty, reduce max_freq until we find a non-empty bin\n            while max_freq > 0 and max_freq not in freq_of_count:\n                max_freq -= 1\n            \n            # If the collection is empty, max_freq will be 0\n            ans.append(max_freq)\n        \n        return ans",
+    #         6,
+    #         debug=True,
+    #     )
+    # )
+
+    print(
+        check_correctness(
+            {
+                "input_output": json.dumps(
+                    {
+                        "inputs": ")))))",
+                        "outputs": "0",
+                    },
+                )
+            },
+            "\nMOD = 998244353\n\nS = input().strip()\nn = len(S)\n\nif n % 2 != 0:\n    print(0)\n    exit()\n\n# Initialize DP table\ndp = [[0] * (n + 2) for _ in range(n + 1)]\ndp[0][0] = 1\n\nfor i in range(1, n + 1):\n    c = S[i-1]\n    for b in range(n + 1):\n        if dp[i-1][b] == 0:\n            continue\n        if c == '(':\n            new_b = b + 1\n            if new_b <= n:\n                dp[i][new_b] = (dp[i][new_b] + dp[i-1][b]) % MOD\n        elif c == ')':\n            if b > 0:\n                new_b = b - 1\n                dp[i][new_b] = (dp[i][new_b] + dp[i-1][b]) % MOD\n        else:  # '?'\n            # Replace with '('\n            new_b = b + 1\n            if new_b <= n:\n                dp[i][new_b] = (dp[i][new_b] + dp[i-1][b]) % MOD\n            # Replace with ')'\n            if b > 0:\n                new_b = b - 1\n                dp[i][new_b] = (dp[i][new_b] + dp[i-1][b]) % MOD\n\nprint(dp[n][0] % MOD)\n",
+            6,
+            debug=True,
+        )
+    )

lcb_runner/evaluation/compute_scores.py

@@ -0,0 +1,155 @@
+import json
+import argparse
+import numpy as np
+from datetime import datetime
+
+from lcb_runner.lm_styles import LanguageModelStore
+from lcb_runner.evaluation.pass_k_utils import (
+    estimate_pass_at_k,
+    compute_metrics_from_results,
+)
+from lcb_runner.utils.scenarios import Scenario
+from lcb_runner.utils.path_utils import get_eval_all_output_path
+
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="gpt-3.5-turbo-0301",
+        help="Name of the model to use matching `lm_styles.py`",
+    )
+    parser.add_argument(
+        "--scenario",
+        type=Scenario,
+        default=Scenario.codegeneration,
+        help="Type of scenario to run",
+    )
+    parser.add_argument(
+        "--n", type=int, default=10, help="Number of samples to generate"
+    )
+    parser.add_argument(
+        "--temperature", type=float, default=0.2, help="Temperature for sampling"
+    )
+
+    parser.add_argument(
+        "--eval_all_file",
+        type=str,
+        default=None,
+        help="Alternative way to provide the evaluation file",
+    )
+
+    parser.add_argument(
+        "--start_date",
+        type=str,
+        default=None,
+        help="Start date for the contest to filter the evaluation file (format - YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--end_date",
+        type=str,
+        default=None,
+        help="End date for the contest to filter the evaluation file (format - YYYY-MM-DD)",
+    )
+
+    parser.add_argument(
+        "--platform",
+        type=str,
+        default=None,
+        help="Platform to filter the evaluation file",
+    )
+
+    args = parser.parse_args()
+
+    if args.eval_all_file is None:
+        model = LanguageModelStore[args.model]
+        args.eval_all_file = get_eval_all_output_path(model, args)
+
+    return args
+
+
+def compute_scores(args):
+    with open(args.eval_all_file, "r") as f:
+        results = json.load(f)
+
+    for res in results:
+        res["contest_date"] = datetime.fromisoformat(res["contest_date"])
+
+    if args.start_date is not None:
+        args.start_date = datetime.strptime(args.start_date, "%Y-%m-%d")
+        results = [
+            result for result in results if args.start_date <= result["contest_date"]
+        ]
+
+    if args.end_date is not None:
+        args.end_date = datetime.strptime(args.end_date, "%Y-%m-%d")
+        results = [
+            result for result in results if result["contest_date"] <= args.end_date
+        ]
+
+    if args.platform is not None:
+        results = [result for result in results if result["platform"] == args.platform]
+
+    print(len(results))
+    totals = [len(x["graded_list"]) for x in results]
+    corrects = [sum(x["graded_list"]) for x in results]
+
+    easy_totals = [len(x["graded_list"]) for x in results if x["difficulty"] == "easy"]
+    med_totals = [len(x["graded_list"]) for x in results if x["difficulty"] == "medium"]
+    hard_totals = [len(x["graded_list"]) for x in results if x["difficulty"] == "hard"]
+    easy_corrects = [sum(x["graded_list"]) for x in results if x["difficulty"] == "easy"]
+    med_corrects = [sum(x["graded_list"]) for x in results if x["difficulty"] == "medium"]
+    hard_corrects = [sum(x["graded_list"]) for x in results if x["difficulty"] == "hard"]
+    for k in [1, 5, 10, 25, 50, 100, 150, 200]:
+        print(
+            f"Pass@{k} = ",
+            estimate_pass_at_k(totals, corrects, k).mean(),
+            # np.array(
+            #     [estimate_pass_at_k(t, c, k) for t, c in zip(totals, corrects)]
+            # ).mean(),
+        )
+        print(
+            f"Easy Pass@{k} = ",
+            estimate_pass_at_k(easy_totals, easy_corrects, k).mean(),
+        )
+        print(
+            f"Medium Pass@{k} = ",
+            estimate_pass_at_k(med_totals, med_corrects, k).mean(),
+        )
+        print(
+            f"Hard Pass@{k} = ",
+            estimate_pass_at_k(hard_totals, hard_corrects, k).mean(),
+        )
+
+
+    pass_1_list = [result["pass@1"] for result in results]
+    print(f"Pass@1: {sum(pass_1_list) / len(pass_1_list)}")
+
+    easy_pass_1_list = [
+        result["pass@1"]
+        for result in results
+        if "difficulty" in result and result["difficulty"] == "easy"
+    ]
+    if len(easy_pass_1_list) > 0:
+        print(f"Easy Pass@1: {sum(easy_pass_1_list) / len(easy_pass_1_list)}")
+
+    medium_pass_1_list = [
+        result["pass@1"]
+        for result in results
+        if "difficulty" in result and result["difficulty"] == "medium"
+    ]
+    if len(medium_pass_1_list) > 0:
+        print(f"Medium Pass@1: {sum(medium_pass_1_list) / len(medium_pass_1_list)}")
+
+    hard_pass_1_list = [
+        result["pass@1"]
+        for result in results
+        if "difficulty" in result and result["difficulty"] == "hard"
+    ]
+    if len(hard_pass_1_list) > 0:
+        print(f"Hard Pass@1: {sum(hard_pass_1_list) / len(hard_pass_1_list)}")
+
+
+if __name__ == "__main__":
+    compute_scores(get_parser())

lcb_runner/evaluation/compute_test_output_prediction_metrics.py

@@ -0,0 +1,100 @@
+import ast
+import json
+
+import tqdm
+
+from lcb_runner.evaluation.pass_k_utils import compute_metrics_from_results
+
+
+def parse_assert_statement(statement):
+    """
+    Parse a Python assert statement and extract the expected output
+    from the right side of the '==' operator as a string.
+
+    :param statement: A string containing the assert statement.
+    :return: The expected output from the assert statement as a string.
+    """
+    try:
+        parsed = ast.parse(statement, mode="exec")
+    except SyntaxError:
+        return "Invalid syntax"
+
+    if len(parsed.body) == 0:
+        return "Empty statement"
+
+    if not isinstance(parsed.body[0], ast.Assert):
+        return "Not an assert statement"
+
+    comparison = parsed.body[0].test
+
+    if not isinstance(comparison, ast.Compare) or not isinstance(
+        comparison.ops[0], ast.Eq
+    ):
+        return "Not an equality assertion"
+
+    # Extract and return the right side of the '==' operator as a string
+    return ast.get_source_segment(statement, comparison.comparators[0])
+
+
+def check_testcase_output(testcase_str, expected_output):
+
+    if len(testcase_str.splitlines()) > 1:
+        for line in testcase_str.splitlines():
+            if line.startswith("#"):
+                continue
+            if "assert" in line:
+                testcase_str = line
+                break
+
+    testcase_str = testcase_str.strip()
+
+    if "assert" in testcase_str:
+        testcase_output_str = str(parse_assert_statement(testcase_str))
+
+    else:
+        testcase_output_str = testcase_str
+
+    global_result = None
+
+    try:
+        testcase_output_eval = eval(testcase_output_str)
+    except:
+        global_result = False
+        # print("Failed to eval testcase output", testcase_output_str)
+        # breakpoint()
+
+    try:
+        expected_output_eval = json.loads(expected_output)
+    except:
+        global_result = False
+        print("Failed to eval expected testcase output", expected_output)
+
+    if global_result is None:
+        global_result = testcase_output_eval == expected_output_eval
+
+    return global_result
+
+
+def test_output_metrics(
+    samples,
+    generations,
+    k_list=[1, 5],
+):
+    num_samples = len(samples)
+    results = []
+    for idx in tqdm.tqdm(list(range(num_samples))):
+        idx_results = []
+        sample = samples[idx]
+        extracted_generation_list = generations[idx]
+        for extracted_generation in extracted_generation_list:
+            global_result = check_testcase_output(
+                extracted_generation, sample["output"]
+            )
+            idx_results.append([global_result])
+        results.append(idx_results)
+
+    results = {result_idx: results[result_idx] for result_idx in range(len(results))}
+
+    metrics = compute_metrics_from_results(results, k_list=k_list)
+
+    return [metrics, results]

lcb_runner/evaluation/old_results_check.py

@@ -0,0 +1,73 @@
+import numpy as np
+import json
+from lcb_runner.benchmarks import load_generation_dataset, CodeGenerationProblem
+from lcb_runner.evaluation import codegen_metrics
+
+
+dataset = load_generation_dataset()
+
+dataset = sorted(dataset, key=lambda x: x.question_id)
+
+
+def check_model(model_key):
+    path = f"/home/naman/Repos/LiveCodeBench/run_models_outputs/{model_key}/chat_0.2_checked.json"
+    with open(path) as f:
+        old_results = json.load(f)
+    old_results = sorted(old_results, key=lambda x: x["question_id"])
+    assert old_results[0]["question_id"] == dataset[0].question_id
+
+    def debug(idx):
+        codegen_metrics(
+            [dataset[idx].get_evaluation_sample()],
+            [old_results[idx]["code_list"][:1]],
+            debug=True,
+        )
+
+    def run(idx):
+        return codegen_metrics(
+            [dataset[idx].get_evaluation_sample()],
+            [old_results[idx]["code_list"]],
+        )
+
+    debug(380)
+    exit()
+    # debug(196)
+    # debug(352)
+
+    metrics = codegen_metrics(
+        [d.get_evaluation_sample() for d in dataset],
+        [r["code_list"] for r in old_results],
+        num_process_evaluate=12,
+    )
+    old_pass1 = np.mean([np.mean(r["pass1_list"]) for r in old_results])
+
+    print(old_pass1)
+    print(metrics[0]["pass@1"])
+
+    for idx in range(400):
+        old_pass1 = np.mean(old_results[idx]["pass1_list"])
+        new_pass1 = metrics[0]["detail"]["pass@1"][idx]
+        if not abs(old_pass1 - new_pass1) < 1e-4:
+            print(idx, old_pass1, new_pass1)
+
+
+# model_key = "GPT-4-Turbo-1106"
+# check_model(model_key)
+
+model_key = "Claude-3-Opus"
+check_model(model_key)
+
+model_key = "GPT-4-0613"
+check_model(model_key)
+
+model_key = "Mistral-Large"
+check_model(model_key)
+
+model_key = "Claude-3-Sonnet"
+check_model(model_key)
+
+model_key = "GPT-3.5-Turbo-0301"
+check_model(model_key)
+
+model_key = "Gemini-Pro"
+check_model(model_key)

lcb_runner/evaluation/pass_k_utils.py

@@ -0,0 +1,66 @@
+import numpy as np
+
+
+def estimate_pass_at_k(num_samples, num_correct, k):
+    """Estimates pass@k of each problem and returns them in an array."""
+
+    def estimator(n: int, c: int, k: int) -> float:
+        """Calculates 1 - comb(n - c, k) / comb(n, k)."""
+        if n - c < k:
+            return 1.0
+        return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+
+    import itertools
+
+    if isinstance(num_samples, int):
+        num_samples_it = itertools.repeat(num_samples, len(num_correct))
+    else:
+        assert len(num_samples) == len(num_correct)
+        num_samples_it = iter(num_samples)
+
+    return np.array(
+        [estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)]
+    )
+
+
+def compute_metrics_from_results(results, k_list=[1, 5]):
+    total = []
+    correct = []
+    task_ids = []
+    for task_id, res in results.items():
+        all_correct = []
+        for generation in res:
+            gen = np.array(generation)
+            all_correct.append(np.all(gen > 0))
+        task_ids.append(task_id)
+        total.append(len(all_correct))
+        correct.append(sum(all_correct))
+    total = np.array(total)
+    correct = np.array(correct)
+    ks = k_list
+    detail_pass_at_k = {
+        f"pass@{k}": estimate_pass_at_k(total, correct, k).tolist()
+        for k in ks
+        if (total >= k).all()
+    }
+    pass_at_k = {
+        f"pass@{k}": estimate_pass_at_k(total, correct, k).mean()
+        for k in ks
+        if (total >= k).all()
+    }
+    detail_metrics = {k: dict(zip(task_ids, v)) for k, v in detail_pass_at_k.items()}
+    pass_at_k["detail"] = detail_metrics
+    return pass_at_k
+
+
+def extract_instance_results(results):
+    instance_wise_grades = {}
+    for task_id, res in results.items():
+        instance_wise_grades[task_id] = []
+        for generation in res:
+            instance_wise_grades[task_id].append(all([g > 0 for g in generation]))
+
+    instance_wise_grades = [
+        v for _, v in sorted(instance_wise_grades.items(), key=lambda item: item[0])
+    ]
+    return instance_wise_grades

lcb_runner/evaluation/testing_util.py

@@ -0,0 +1,592 @@
+import ast
+import json
+import sys
+import faulthandler
+import platform
+
+# used for debugging to time steps
+from datetime import datetime
+
+# to run the solution files we're using a timing based approach
+import signal
+
+import numpy as np
+
+from io import StringIO
+
+# used for testing the code that reads from input
+from unittest.mock import patch, mock_open
+
+# from pyext import RuntimeModule
+from types import ModuleType
+
+from enum import Enum
+from decimal import Decimal
+import time
+
+import_string = "from string import *\nfrom re import *\nfrom datetime import *\nfrom collections import *\nfrom heapq import *\nfrom bisect import *\nfrom copy import *\nfrom math import *\nfrom random import *\nfrom statistics import *\nfrom itertools import *\nfrom functools import *\nfrom operator import *\nfrom io import *\nfrom sys import *\nfrom json import *\nfrom builtins import *\nfrom typing import *\nimport string\nimport re\nimport datetime\nimport collections\nimport heapq\nimport bisect\nimport copy\nimport math\nimport random\nimport statistics\nimport itertools\nimport functools\nimport operator\nimport io\nimport sys\nimport json\nsys.setrecursionlimit(50000)\n"
+
+
+def truncatefn(s, length=300):
+    if isinstance(s, str):
+        pass
+    else:
+        s = str(s)
+    if len(s) <= length:
+        return s
+
+    return s[: length // 2] + "...(truncated) ..." + s[-length // 2 :]
+
+
+class CODE_TYPE(Enum):
+    call_based = 0
+    standard_input = 1
+
+
+# stuff for setting up signal timer
+class TimeoutException(Exception):
+    pass
+
+
+def timeout_handler(signum, frame):
+    print("timeout occured: alarm went off")
+    raise TimeoutException
+
+
+# used to capture stdout as a list
+# from https://stackoverflow.com/a/16571630/6416660
+# alternative use redirect_stdout() from contextlib
+class Capturing(list):
+    def __enter__(self):
+        self._stdout = sys.stdout
+        sys.stdout = self._stringio = StringIO()
+        # Make closing the StringIO a no-op
+        self._stringio.close = lambda x: 1
+        return self
+
+    def __exit__(self, *args):
+        self.append(self._stringio.getvalue())
+        del self._stringio  # free up some memory
+        sys.stdout = self._stdout
+
+
+# Custom mock for sys.stdin that supports buffer attribute
+class MockStdinWithBuffer:
+    def __init__(self, inputs: str):
+        self.inputs = inputs
+        self._stringio = StringIO(inputs)
+        self.buffer = MockBuffer(inputs)
+
+    def read(self, *args):
+        return self.inputs
+
+    def readline(self, *args):
+        return self._stringio.readline(*args)
+
+    def readlines(self, *args):
+        return self.inputs.split("\n")
+
+    def __getattr__(self, name):
+        # Delegate other attributes to StringIO
+        return getattr(self._stringio, name)
+
+
+class MockBuffer:
+    def __init__(self, inputs: str):
+        self.inputs = inputs.encode("utf-8")  # Convert to bytes
+
+    def read(self, *args):
+        # Return as byte strings that can be split
+        return self.inputs
+
+    def readline(self, *args):
+        return self.inputs.split(b"\n")[0] + b"\n"
+
+
+def clean_if_name(code: str) -> str:
+    try:
+        astree = ast.parse(code)
+        last_block = astree.body[-1]
+        if isinstance(last_block, ast.If):
+            condition = last_block.test
+            if ast.unparse(condition).strip() == "__name__ == '__main__'":
+                code = (
+                    ast.unparse(astree.body[:-1]) + "\n" + ast.unparse(last_block.body)  # type: ignore
+                )
+    except:
+        pass
+
+    return code
+
+
+def make_function(code: str) -> str:
+    try:
+        import_stmts = []
+        all_other_stmts = []
+        astree = ast.parse(code)
+        for stmt in astree.body:
+            if isinstance(stmt, (ast.Import, ast.ImportFrom)):
+                import_stmts.append(stmt)
+            else:
+                all_other_stmts.append(stmt)
+
+        function_ast = ast.FunctionDef(
+            name="wrapped_function",
+            args=ast.arguments(
+                posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]
+            ),
+            body=all_other_stmts,
+            decorator_list=[],
+            lineno=-1,
+        )
+        main_code = (
+            import_string
+            + "\n"
+            + ast.unparse(import_stmts)  # type: ignore
+            + "\n"
+            + ast.unparse(function_ast)  # type: ignore
+        )
+        return main_code
+    except Exception as e:
+        return code
+
+
+def call_method(method, inputs):
+
+    if isinstance(inputs, list):
+        inputs = "\n".join(inputs)
+
+    inputs_line_iterator = iter(inputs.split("\n"))
+
+    # Create custom stdin mock with buffer support
+    mock_stdin = MockStdinWithBuffer(inputs)
+
+    # sys.setrecursionlimit(10000)
+
+    # @patch('builtins.input', side_effect=inputs.split("\n"))
+    @patch("builtins.open", mock_open(read_data=inputs))
+    @patch("sys.stdin", mock_stdin)  # Use our custom mock instead of StringIO
+    @patch("sys.stdin.readline", lambda *args: next(inputs_line_iterator))
+    @patch("sys.stdin.readlines", lambda *args: inputs.split("\n"))
+    @patch("sys.stdin.read", lambda *args: inputs)
+    # @patch('sys.stdout.write', print)
+    def _inner_call_method(_method):
+        try:
+            return _method()
+        except SystemExit as e:
+            pass
+        finally:
+            pass
+
+    return _inner_call_method(method)
+
+
+def get_function(compiled_sol, fn_name: str):  # type: ignore
+    try:
+        assert hasattr(compiled_sol, fn_name)
+        return getattr(compiled_sol, fn_name)
+    except Exception as e:
+        return
+
+
+def compile_code(code: str, timeout: int):
+    signal.alarm(timeout)
+    try:
+        tmp_sol = ModuleType("tmp_sol", "")
+        exec(code, tmp_sol.__dict__)
+        if "class Solution" in code:
+            # leetcode wraps solutions in `Solution`
+            # this is a hack to check if it is leetcode solution or not
+            # currently livecodebench only supports LeetCode but
+            # else condition allows future extensibility to other platforms
+            compiled_sol = tmp_sol.Solution()
+        else:
+            # do nothing in the other case since function is accesible
+            compiled_sol = tmp_sol
+
+        assert compiled_sol is not None
+    finally:
+        signal.alarm(0)
+
+    return compiled_sol
+
+
+def convert_line_to_decimals(line: str) -> tuple[bool, list[Decimal]]:
+    try:
+        decimal_line = [Decimal(elem) for elem in line.split()]
+    except:
+        return False, []
+    return True, decimal_line
+
+
+def get_stripped_lines(val: str):
+    ## you don't want empty lines to add empty list after splitlines!
+    val = val.strip()
+
+    return [val_line.strip() for val_line in val.split("\n")]
+
+
+def grade_call_based(
+    code: str, all_inputs: list, all_outputs: list, fn_name: str, timeout: int
+):
+    # call-based clean up logic
+    # need to wrap in try-catch logic after to catch the correct errors, but for now this is fine.
+    code = import_string + "\n\n" + code
+    compiled_sol = compile_code(code, timeout)
+
+    if compiled_sol is None:
+        return
+
+    method = get_function(compiled_sol, fn_name)
+
+    if method is None:
+        return
+
+    all_inputs = [
+        [json.loads(line) for line in inputs.split("\n")] for inputs in all_inputs
+    ]
+
+    all_outputs = [json.loads(output) for output in all_outputs]
+
+    total_execution = 0
+    all_results = []
+    for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
+        signal.alarm(timeout)
+        faulthandler.enable()
+        try:
+            # can lock here so time is useful
+            start = time.time()
+            prediction = method(*gt_inp)
+            total_execution += time.time() - start
+            signal.alarm(0)
+
+            # don't penalize model if it produces tuples instead of lists
+            # ground truth sequences are not tuples
+            if isinstance(prediction, tuple):
+                prediction = list(prediction)
+
+            tmp_result = prediction == gt_out
+
+            # handle floating point comparisons
+
+            all_results.append(tmp_result)
+
+            if not tmp_result:
+                return all_results, {
+                    "output": truncatefn(prediction),
+                    "inputs": truncatefn(gt_inp),
+                    "expected": truncatefn(gt_out),
+                    "error_code": -2,
+                    "error_message": "Wrong Answer",
+                }
+        except Exception as e:
+            signal.alarm(0)
+            if "timeoutexception" in repr(e).lower():
+                all_results.append(-3)
+                return all_results, {
+                    "error": repr(e),
+                    "error_code": -3,
+                    "error_message": "Time Limit Exceeded",
+                    "inputs": truncatefn(gt_inp),
+                    "expected": truncatefn(gt_out),
+                }
+            else:
+                all_results.append(-4)
+                return all_results, {
+                    "error": repr(e),
+                    "error_code": -4,
+                    "error_message": "Runtime Error",
+                    "inputs": truncatefn(gt_inp),
+                    "expected": truncatefn(gt_out),
+                }
+
+        finally:
+            signal.alarm(0)
+            faulthandler.disable()
+
+    return all_results, {"execution time": total_execution}
+
+
+def grade_stdio(
+    code: str,
+    all_inputs: list,
+    all_outputs: list,
+    timeout: int,
+):
+    ## runtime doesn't interact well with __name__ == '__main__'
+    code = clean_if_name(code)
+
+    ## we wrap the given code inside another function
+    code = make_function(code)
+
+    compiled_sol = compile_code(code, timeout)
+    if compiled_sol is None:
+        return
+
+    method = get_function(compiled_sol, "wrapped_function")
+
+    if method is None:
+        return
+
+    all_results = []
+    total_execution_time = 0
+    for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
+        signal.alarm(timeout)
+        faulthandler.enable()
+
+        signal.alarm(timeout)
+        with Capturing() as captured_output:
+            try:
+                start = time.time()
+                call_method(method, gt_inp)
+                total_execution_time += time.time() - start
+                # reset the alarm
+                signal.alarm(0)
+            except Exception as e:
+                signal.alarm(0)
+                if "timeoutexception" in repr(e).lower():
+                    all_results.append(-3)
+                    return all_results, {
+                        "error": repr(e),
+                        "error_code": -3,
+                        "error_message": "Time Limit Exceeded",
+                        "inputs": truncatefn(gt_inp),
+                        "expected": truncatefn(gt_out),
+                    }
+                else:
+                    all_results.append(-4)
+                    return all_results, {
+                        "error": repr(e),
+                        "error_code": -4,
+                        "error_message": "Runtime Error",
+                        "inputs": truncatefn(gt_inp),
+                        "expected": truncatefn(gt_out),
+                    }
+
+            finally:
+                signal.alarm(0)
+                faulthandler.disable()
+
+        prediction = captured_output[0]
+
+        stripped_prediction_lines = get_stripped_lines(prediction)
+        stripped_gt_out_lines = get_stripped_lines(gt_out)
+
+        ## WA happens in multiple circumstances
+        ## so cache the return to make it clean!
+        WA_send_args = {
+            "output": truncatefn(prediction),
+            "inputs": truncatefn(gt_inp),
+            "expected": truncatefn(gt_out),
+            "error_code": -2,
+        }
+
+        if len(stripped_prediction_lines) != len(stripped_gt_out_lines):
+            all_results.append(-2)
+            WA_send_args["error_message"] = "Wrong answer: mismatched output length"
+            return all_results, WA_send_args
+
+        for output_line_idx, (
+            stripped_prediction_line,
+            stripped_gt_out_line,
+        ) in enumerate(zip(stripped_prediction_lines, stripped_gt_out_lines)):
+            WA_send_args["error_message"] = (
+                f"Wrong answer at {output_line_idx=}: {truncatefn(stripped_prediction_line)} != {truncatefn(stripped_gt_out_line)}"
+            )
+
+            ## CASE 1: exact match
+            if stripped_prediction_line == stripped_gt_out_line:
+                continue
+
+            ## CASE 2: element-wise comparision
+            ## if there are floating elements
+            ## use `decimal` library for good floating point comparision
+            ## otherwise gotcha: np.isclose(50000000000000000, 50000000000000001) = True
+            ## note that we should always be able to convert to decimals
+
+            success, decimal_prediction_line = convert_line_to_decimals(
+                stripped_prediction_line
+            )
+            if not success:
+                all_results.append(-2)
+                return all_results, WA_send_args
+            success, decimal_gtout_line = convert_line_to_decimals(stripped_gt_out_line)
+            if not success:
+                all_results.append(-2)
+                return all_results, WA_send_args
+
+            if decimal_prediction_line == decimal_gtout_line:
+                continue
+
+            all_results.append(-2)
+            return all_results, WA_send_args
+        all_results.append(True)
+
+    return all_results, {"execution time": total_execution_time}
+
+
+def run_test(sample, test=None, debug=False, timeout=6):
+    """
+    if test(generated_code) is not None it'll try to run the code.
+    otherwise it'll just return an input and output pair.
+    """
+    signal.signal(signal.SIGALRM, timeout_handler)
+
+    # Disable functionalities that can make destructive changes to the test.
+    # max memory is set to 4GB
+    reliability_guard(4 * 1024 * 1024 * 1024)
+
+    if debug:
+        print(f"start = {datetime.now().time()}")
+
+    try:
+        in_outs = json.loads(sample["input_output"])
+    except ValueError as e:
+        raise e
+        in_outs = None
+
+    if in_outs:
+        if in_outs.get("fn_name") is None:
+            which_type = CODE_TYPE.standard_input  # Standard input
+            method_name = None
+
+        else:
+            which_type = CODE_TYPE.call_based  # Call-based
+            method_name = in_outs["fn_name"]
+
+    if debug:
+        print(f"loaded input_output = {datetime.now().time()}")
+
+    if test is None:
+        assert False, "should not happen: test code is none"
+        return in_outs, {"error": "no test code provided"}
+    elif test is not None:
+        results = []
+        sol = import_string
+        if debug:
+            print(f"loading test code = {datetime.now().time()}")
+
+        if which_type == CODE_TYPE.call_based:
+            signal.alarm(timeout)
+            try:
+                results, metadata = grade_call_based(
+                    code=test,
+                    all_inputs=in_outs["inputs"],
+                    all_outputs=in_outs["outputs"],
+                    fn_name=method_name,
+                    timeout=timeout,
+                )
+                return results, metadata
+            except Exception as e:
+                return [-4], {
+                    "error_code": -4,
+                    "error_message": f"Error during testing: {e}",
+                }
+            finally:
+                signal.alarm(0)
+        elif which_type == CODE_TYPE.standard_input:
+            # sol
+            # if code has if __name__ == "__main__": then remove it
+
+            signal.alarm(timeout)
+            try:
+                results, metadata = grade_stdio(
+                    code=test,
+                    all_inputs=in_outs["inputs"],
+                    all_outputs=in_outs["outputs"],
+                    timeout=timeout,
+                )
+                return results, metadata
+            except Exception as e:
+                return [-4], {
+                    "error_code": -4,
+                    "error_message": f"Error during testing: {e}",
+                }
+            finally:
+                signal.alarm(0)
+
+
+def reliability_guard(maximum_memory_bytes=None):
+    """
+    This disables various destructive functions and prevents the generated code
+    from interfering with the test (e.g. fork bomb, killing other processes,
+    removing filesystem files, etc.)
+    WARNING
+    This function is NOT a security sandbox. Untrusted code, including, model-
+    generated code, should not be blindly executed outside of one. See the
+    Codex paper for more information about OpenAI's code sandbox, and proceed
+    with caution.
+    """
+
+    if maximum_memory_bytes is not None:
+        import resource
+
+        resource.setrlimit(
+            resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)
+        )
+        resource.setrlimit(
+            resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)
+        )
+        if not platform.uname().system == "Darwin":
+            resource.setrlimit(
+                resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)
+            )
+
+    faulthandler.disable()
+
+    import builtins
+
+    # builtins.exit = None
+    builtins.quit = None
+
+    import os
+
+    os.environ["OMP_NUM_THREADS"] = "1"
+
+    os.kill = None
+    os.system = None
+    os.putenv = None
+    os.remove = None
+    os.removedirs = None
+    os.rmdir = None
+    os.fchdir = None
+    os.setuid = None
+    os.fork = None
+    os.forkpty = None
+    os.killpg = None
+    os.rename = None
+    os.renames = None
+    os.truncate = None
+    os.replace = None
+    os.unlink = None
+    os.fchmod = None
+    os.fchown = None
+    os.chmod = None
+    os.chown = None
+    os.chroot = None
+    os.fchdir = None
+    os.lchflags = None
+    os.lchmod = None
+    os.lchown = None
+    os.getcwd = None
+    os.chdir = None
+
+    import shutil
+
+    shutil.rmtree = None
+    shutil.move = None
+    shutil.chown = None
+
+    import subprocess
+
+    subprocess.Popen = None  # type: ignore
+
+    __builtins__["help"] = None
+
+    import sys
+
+    sys.modules["ipdb"] = None
+    sys.modules["joblib"] = None
+    sys.modules["resource"] = None
+    sys.modules["psutil"] = None
+    sys.modules["tkinter"] = None

lcb_runner/evaluation/utils_execute.py

@@ -0,0 +1,267 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This code is adapted from OpenAI's release
+# https://github.com/openai/human-eval/blob/master/human_eval/execution.py
+
+import contextlib
+import faulthandler
+import io
+import multiprocessing
+import os
+import platform
+import signal
+import tempfile
+
+
+BASE_IMPORTS = """from itertools import accumulate, chain, combinations, count, permutations, product, groupby, islice, repeat
+from copy import deepcopy
+from string import ascii_lowercase
+from math import floor, log2, log10, sqrt, comb, gcd, ceil, inf, isqrt
+from collections import defaultdict, deque, Counter
+from bisect import bisect, bisect_left, bisect_right, insort
+from heapq import heappush, heappop, heapify, merge
+from functools import reduce, cache, lru_cache
+from random import randrange, shuffle
+from operator import itemgetter, sub
+from re import search as re_search  # Assuming 're' refers to a regex search
+from os.path import commonprefix
+from typing import List, Tuple, Dict, Set, Optional, Union, Any, Callable, Iterable, Iterator, Generator
+import copy
+import string
+import math
+import collections
+import bisect
+import heapq
+import functools
+import random
+import itertools
+import operator
+import re
+import numpy as np
+import pandas as pd
+from math import log, prod  # 'log' and 'prod' are functions in the math module
+from collections import deque, defaultdict, Counter, OrderedDict
+from itertools import accumulate, permutations, combinations, product, groupby, islice, chain, repeat, zip_longest, cycle
+from functools import lru_cache, reduce, partial
+# from sortedcontainers import SortedList, SortedDict, SortedSet
+# import sortedcontainers
+from operator import iand
+import sys
+"""
+
+def check_correctness(check_program, timeout=3):
+    """
+    Evaluates the functional correctness of a completion by running the test
+    suite provided in the problem.
+
+    :param completion_id: an optional completion ID so we can match
+        the results later even if execution finishes asynchronously.
+    """
+    manager = multiprocessing.Manager()
+    result = manager.list()
+
+    p = multiprocessing.Process(target=unsafe_execute, args=(check_program, result, timeout))
+    p.start()
+    p.join(timeout=timeout + 1)
+    if p.is_alive():
+        p.kill()
+
+    if not result:
+        result.append("timed out")
+
+    return result[0] == "passed"
+
+
+def unsafe_execute(check_program, result, timeout):
+
+    with create_tempdir():
+
+        # These system calls are needed when cleaning up tempdir.
+        import os
+        import shutil
+
+        rmtree = shutil.rmtree
+        rmdir = os.rmdir
+        chdir = os.chdir
+
+        # Disable functionalities that can make destructive changes to the test.
+        reliability_guard()
+
+        # Run program.
+        try:
+            exec_globals = {}
+            with swallow_io():
+                with time_limit(timeout):
+                    exec(check_program, exec_globals)
+            result.append("passed")
+        except TimeoutException:
+            result.append("timed out")
+        except BaseException as e:
+            result.append(f"failed: {e}")
+
+        # Needed for cleaning up.
+        shutil.rmtree = rmtree
+        os.rmdir = rmdir
+        os.chdir = chdir
+
+
+@contextlib.contextmanager
+def time_limit(seconds):
+    def signal_handler(signum, frame):
+        raise TimeoutException("Timed out!")
+
+    signal.setitimer(signal.ITIMER_REAL, seconds)
+    signal.signal(signal.SIGALRM, signal_handler)
+    try:
+        yield
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+
+
+@contextlib.contextmanager
+def swallow_io():
+    stream = WriteOnlyStringIO()
+    with contextlib.redirect_stdout(stream):
+        with contextlib.redirect_stderr(stream):
+            with redirect_stdin(stream):
+                yield
+
+
+@contextlib.contextmanager
+def create_tempdir():
+    with tempfile.TemporaryDirectory() as dirname:
+        with chdir(dirname):
+            yield dirname
+
+
+class TimeoutException(Exception):
+    pass
+
+
+class WriteOnlyStringIO(io.StringIO):
+    """StringIO that throws an exception when it's read from"""
+
+    def read(self, *args, **kwargs):
+        raise OSError
+
+    def readline(self, *args, **kwargs):
+        raise OSError
+
+    def readlines(self, *args, **kwargs):
+        raise OSError
+
+    def readable(self, *args, **kwargs):
+        """Returns True if the IO object can be read."""
+        return False
+
+
+class redirect_stdin(contextlib._RedirectStream):  # type: ignore
+    _stream = "stdin"
+
+
+@contextlib.contextmanager
+def chdir(root):
+    if root == ".":
+        yield
+        return
+    cwd = os.getcwd()
+    os.chdir(root)
+    try:
+        yield
+    except BaseException as exc:
+        raise exc
+    finally:
+        os.chdir(cwd)
+
+
+def reliability_guard(maximum_memory_bytes=None):
+    """
+    This disables various destructive functions and prevents the generated code
+    from interfering with the test (e.g. fork bomb, killing other processes,
+    removing filesystem files, etc.)
+
+    WARNING
+    This function is NOT a security sandbox. Untrusted code, including, model-
+    generated code, should not be blindly executed outside of one. See the
+    Codex paper for more information about OpenAI's code sandbox, and proceed
+    with caution.
+    """
+
+    if maximum_memory_bytes is not None:
+        import resource
+
+        resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes))
+        resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes))
+        if not platform.uname().system == "Darwin":
+            resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes))
+
+    faulthandler.disable()
+
+    import builtins
+
+    builtins.exit = None
+    builtins.quit = None
+
+    import os
+
+    os.environ["OMP_NUM_THREADS"] = "1"
+
+    os.kill = None
+    os.system = None
+    os.putenv = None
+    os.remove = None
+    os.removedirs = None
+    os.rmdir = None
+    os.fchdir = None
+    os.setuid = None
+    os.fork = None
+    os.forkpty = None
+    os.killpg = None
+    os.rename = None
+    os.renames = None
+    os.truncate = None
+    os.replace = None
+    os.unlink = None
+    os.fchmod = None
+    os.fchown = None
+    os.chmod = None
+    os.chown = None
+    os.chroot = None
+    os.fchdir = None
+    os.lchflags = None
+    os.lchmod = None
+    os.lchown = None
+    os.getcwd = None
+    os.chdir = None
+
+    import shutil
+
+    shutil.rmtree = None
+    shutil.move = None
+    shutil.chown = None
+
+    import subprocess
+
+    subprocess.Popen = None  # type: ignore
+
+    __builtins__["help"] = None
+
+    import sys
+
+    sys.modules["ipdb"] = None
+    sys.modules["joblib"] = None
+    sys.modules["resource"] = None
+    sys.modules["psutil"] = None
+    sys.modules["tkinter"] = None

lcb_runner/lm_styles.py

@@ -0,0 +1,920 @@
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+
+
+class LMStyle(Enum):
+    OpenAIChat = "OpenAIChat"
+    OpenAIReasonPreview = "OpenAIReasonPreview"
+    OpenAIReason = "OpenAIReason"
+
+    Claude = "Claude"  # Claude 1 and Claude 2
+    Claude3 = "Claude3"
+    Claude3Thinking = "Claude3Thinking"
+
+    Gemini = "Gemini"
+    GeminiThinking = "GeminiThinking"
+    Grok = "Grok"
+
+    MistralWeb = "MistralWeb"
+    CohereCommand = "CohereCommand"
+
+    DataBricks = "DataBricks"
+    DeepSeekAPI = "DeepSeekAPI"
+
+    GenericBase = "GenericBase"
+
+    DeepSeekCodeInstruct = "DeepSeekCodeInstruct"
+    CodeLLaMaInstruct = "CodeLLaMaInstruct"
+    StarCoderInstruct = "StarCoderInstruct"
+    CodeQwenInstruct = "CodeQwenInstruct"
+    QwQ = "QwQ"
+    LLaMa3 = "LLaMa3"
+    DeepSeekR1 = "DeepSeekR1"
+
+    TogetherAI = "TogetherAI"
+
+
+@dataclass
+class LanguageModel:
+    model_name: str
+    model_repr: str
+    model_style: LMStyle
+    release_date: datetime | None  # XXX Should we use timezone.utc?
+    link: str | None = None
+
+    def __hash__(self) -> int:
+        return hash(self.model_name)
+
+    def to_dict(self) -> dict:
+        return {
+            "model_name": self.model_name,
+            "model_repr": self.model_repr,
+            "model_style": self.model_style.value,
+            "release_date": int(self.release_date.timestamp() * 1000),
+            "link": self.link,
+        }
+
+
+LanguageModelList: list[LanguageModel] = [
+    ## LLama3 Base (8B and 70B)
+    LanguageModel(
+        "meta-llama/Meta-Llama-3-8B",
+        "LLama3-8b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Meta-Llama-3-8B",
+    ),
+    LanguageModel(
+        "meta-llama/Meta-Llama-3-70B",
+        "LLama3-70b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Meta-Llama-3-70B",
+    ),
+    ## LLama3 Instruct (8B and 70B)
+    LanguageModel(
+        "meta-llama/Meta-Llama-3-8B-Instruct",
+        "LLama3-8b-Ins",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct",
+    ),
+    LanguageModel(
+        "meta-llama/Meta-Llama-3-70B-Instruct",
+        "LLama3-70b-Ins",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Meta-Llama-3-70B-Instruct",
+    ),
+    ## LLama3.1 Base (8B, 70B, 405B)
+    LanguageModel(
+        "meta-llama/Llama-3.1-8B",
+        "LLama3.1-8b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-8B",
+    ),
+    LanguageModel(
+        "meta-llama/Llama-3.1-70B",
+        "LLama3.1-70b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-70B",
+    ),
+    LanguageModel(
+        "meta-llama/Llama-3.1-405B-FP8",
+        "LLama3.1-405b-Base-FP8",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-405B-FP8",
+    ),
+    ## LLama3.1 Instruct (8B, 70B, 405B)
+    LanguageModel(
+        "meta-llama/Llama-3.1-8B-Instruct",
+        "LLama3.1-8b-Ins",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct",
+    ),
+    LanguageModel(
+        "meta-llama/Llama-3.1-70B-Instruct",
+        "LLama3.1-70b-Ins",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-70B-Instruct",
+    ),
+    LanguageModel(
+        "meta-llama/Llama-3.1-405B-Instruct-FP8",
+        "LLama3.1-405b-Ins-FP8",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.1-405B-Instruct-FP8",
+    ),
+    ## LLama3.3 Instruct (8B, 70B)
+    # LanguageModel( 
+    #     "meta-llama/Llama-3.3-8B-Instruct", # Has been removed from HuggingFace by meta-llama
+    #     "LLama3.3-8b-Ins",
+    #     LMStyle.LLaMa3,
+    #     datetime(2023, 1, 1),
+    #     link="https://huggingface.co/meta-llama/Llama-3.3-8B-Instruct",
+    # ),
+    LanguageModel(
+        "meta-llama/Llama-3.3-70B-Instruct",
+        "LLama3.3-70b-Ins",
+        LMStyle.LLaMa3,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct",
+    ),
+    ## Deepseek-Coder Base (33B, 6.7B, 1.3B)
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-33b-base",
+        "DSCoder-33b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-33b-base",
+    ),
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-6.7b-base",
+        "DSCoder-6.7b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-6.7b-base",
+    ),
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-1.3b-base",
+        "DSCoder-1.3b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-1.3b-base",
+    ),
+    ## Deepseek-Coder Instruct (33B, 6.7B, 1.3B)
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-33b-instruct",
+        "DSCoder-33b-Ins",
+        LMStyle.DeepSeekCodeInstruct,
+        datetime(2023, 9, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-33b-instruct",
+    ),
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-6.7b-instruct",
+        "DSCoder-6.7b-Ins",
+        LMStyle.DeepSeekCodeInstruct,
+        datetime(2023, 9, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-6.7b-instruct",
+    ),
+    LanguageModel(
+        "deepseek-ai/deepseek-coder-1.3b-instruct",
+        "DSCoder-1.3b-Ins",
+        LMStyle.DeepSeekCodeInstruct,
+        datetime(2023, 8, 1),
+        link="https://huggingface.co/deepseek-ai/deepseek-coder-1.3b-instruct",
+    ),
+    ##
+    LanguageModel(
+        "01-ai/Yi-Coder-9B-Chat",
+        "Yi-Coder-9B-Chat",
+        LMStyle.DeepSeekAPI,
+        datetime(2023, 8, 1),
+        link="https://huggingface.co/01-ai/Yi-Coder-9B-Chat",
+    ),
+    ## Deepseek-Chat Latest API (currently DeepSeek-V3)
+    LanguageModel(
+        "deepseek-r1-preview",
+        "DeepSeek-R1-Preview",
+        LMStyle.DeepSeekAPI,
+        datetime(2024, 6, 30),
+        link="https://api-docs.deepseek.com/news/news1120",
+    ),
+    LanguageModel(
+        "deepseek-r1-lite-preview",
+        "DeepSeek-R1-Lite-Preview",
+        LMStyle.DeepSeekAPI,
+        datetime(2024, 6, 30),
+        link="https://api-docs.deepseek.com/news/news1120",
+    ),
+    LanguageModel(
+        "deepseek-chat",
+        "DeepSeek-V3",
+        LMStyle.DeepSeekAPI,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-V3",
+    ),
+    ## Deepseek-Coder Latest API (currently DeepSeekCoder-V2.5)
+    LanguageModel(
+        "deepseek-coder",
+        "DeepSeekCoder-V2.5",
+        LMStyle.DeepSeekAPI,
+        datetime(2023, 8, 1),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-V2",
+    ),
+    ## OpenAI GPT-3.5-Turbo
+    LanguageModel(
+        "gpt-3.5-turbo-0301",
+        "GPT-3.5-Turbo-0301",
+        LMStyle.OpenAIChat,
+        datetime(2021, 10, 1),
+        link="https://openai.com/blog/new-models-and-developer-products-announced-at-devday",
+    ),
+    LanguageModel(
+        "gpt-3.5-turbo-0125",
+        "GPT-3.5-Turbo-0125",
+        LMStyle.OpenAIChat,
+        datetime(2021, 10, 1),
+        link="https://openai.com/blog/new-embedding-models-and-api-updates#:~:text=Other%20new%20models%20and%20lower%20pricing",
+    ),
+    ## OpenAI GPT-4, GPT-4-Turbo
+    LanguageModel(
+        "gpt-4-0613",
+        "GPT-4-0613",
+        LMStyle.OpenAIChat,
+        datetime(2021, 10, 1),
+        link="https://platform.openai.com/docs/models/gpt-4-turbo-and-gpt-4",
+    ),
+    LanguageModel(
+        "gpt-4-1106-preview",
+        "GPT-4-Turbo-1106",
+        LMStyle.OpenAIChat,
+        datetime(2023, 4, 30),
+        link="https://openai.com/blog/new-models-and-developer-products-announced-at-devday",
+    ),
+    LanguageModel(
+        "gpt-4-turbo-2024-04-09",
+        "GPT-4-Turbo-2024-04-09",
+        LMStyle.OpenAIChat,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/models/gpt-4-turbo-and-gpt-4",
+    ),
+    ## OpenAI GPT-4O (and Mini)
+    LanguageModel(
+        "gpt-4o-2024-05-13",
+        "GPT-4O-2024-05-13",
+        LMStyle.OpenAIChat,
+        datetime(2023, 4, 30),
+        link="https://openai.com/index/spring-update",
+    ),
+    LanguageModel(
+        "gpt-4o-2024-08-06",
+        "GPT-4O-2024-08-06",
+        LMStyle.OpenAIChat,
+        datetime(2023, 4, 30),
+        link="https://openai.com/index/spring-update",
+    ),
+    LanguageModel(
+        "gpt-4o-mini-2024-07-18",
+        "GPT-4O-mini-2024-07-18",
+        LMStyle.OpenAIChat,
+        datetime(2023, 4, 30),
+        link="https://openai.com/index/spring-update",
+    ),
+    ## O1-Mini and O1-Preview
+    LanguageModel(
+        "o1-preview-2024-09-12",
+        "O1-Preview-2024-09-12",
+        LMStyle.OpenAIReasonPreview,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/guides/reasoning",
+    ),
+    LanguageModel(
+        "o1-mini-2024-09-12",
+        "O1-Mini-2024-09-12",
+        LMStyle.OpenAIReasonPreview,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/guides/reasoning",
+    ),
+    ## O1 (reasoning models)
+    LanguageModel(
+        "o1-2024-12-17__low",
+        "O1-2024-12-17 (Low)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o1-2024-12-17__medium",
+        "O1-2024-12-17 (Med)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="htthttps://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o1-2024-12-17__high",
+        "O1-2024-12-17 (High)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    ## O3-Mini
+    LanguageModel(
+        "o3-mini-2025-01-31__low",
+        "O3-Mini-2025-01-31 (Low)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o3-mini-2025-01-31__medium",
+        "O3-Mini-2025-01-31 (Med)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o3-mini-2025-01-31__high",
+        "O3-Mini-2025-01-31 (High)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o4-mini__high",
+        "O4-Mini (High)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o4-mini__medium",
+        "O4-Mini (Medium)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o4-mini__low",
+        "O4-Mini (Low)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    LanguageModel(
+        "o3__high",
+        "O3 (High)",
+        LMStyle.OpenAIReason,
+        datetime(2023, 4, 30),
+        link="https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort",
+    ),
+    ## Claude and Claude 2
+    LanguageModel(
+        "claude-instant-1",
+        "Claude-Instant-1",
+        LMStyle.Claude,
+        datetime(2022, 12, 31),
+        link="https://www.anthropic.com/index/introducing-claude",
+    ),
+    LanguageModel(
+        "claude-2",
+        "Claude-2",
+        LMStyle.Claude,
+        datetime(2022, 12, 31),
+        link="https://www.anthropic.com/index/claude-2",
+    ),
+    ## Claude 3 and Claude 3.5
+    LanguageModel(
+        "claude-3-opus-20240229",
+        "Claude-3-Opus",
+        LMStyle.Claude3,
+        datetime(2023, 9, 1),
+        link="https://www.anthropic.com/index/claude-3",
+    ),
+    LanguageModel(
+        "claude-3-sonnet-20240229",
+        "Claude-3-Sonnet",
+        LMStyle.Claude3,
+        datetime(2023, 9, 1),
+        link="https://www.anthropic.com/index/claude-3",
+    ),
+    LanguageModel(
+        "claude-3-5-sonnet-20240620",
+        "Claude-3.5-Sonnet-20240620",
+        LMStyle.Claude3,
+        datetime(2024, 3, 31),
+        link="https://www.anthropic.com/news/claude-3-5-sonnet",
+    ),
+    LanguageModel(
+        "claude-3-5-sonnet-20241022",
+        "Claude-3.5-Sonnet-20241022",
+        LMStyle.Claude3,
+        datetime(2024, 3, 31),
+        link="https://www.anthropic.com/news/claude-3-5-sonnet",
+    ),
+    LanguageModel(
+        "claude-3-7-sonnet-20250219",
+        "Claude-3.7-Sonnet (Thinking)",
+        LMStyle.Claude3Thinking,
+        datetime(2024, 3, 31),
+        link="https://www.anthropic.com/news/claude-3-7-sonnet",
+    ),
+    LanguageModel(
+        "claude-3-haiku-20240307",
+        "Claude-3-Haiku",
+        LMStyle.Claude3,
+        datetime(2023, 4, 30),
+        link="https://www.anthropic.com/index/claude-3",
+    ),
+    LanguageModel(
+        "claude-sonnet-4-20250514",
+        "Claude-Sonnet-4 (Thinking)",
+        LMStyle.Claude3Thinking,
+        datetime(2023, 4, 30),
+        link="https://www.anthropic.com/claude/sonnet",
+    ),
+    LanguageModel(
+        "claude-opus-4-20250514",
+        "Claude-Opus-4 (Thinking)",
+        LMStyle.Claude3Thinking,
+        datetime(2023, 4, 30),
+        link="https://www.anthropic.com/claude/sonnet",
+    ),
+    LanguageModel(
+        "claude-opus-4-20250514_nothink",
+        "Claude-Opus-4",
+        LMStyle.Claude3Thinking,
+        datetime(2023, 4, 30),
+        link="https://www.anthropic.com/claude/sonnet",
+    ),
+    LanguageModel(
+        "claude-sonnet-4-20250514_nothink",
+        "Claude-Sonnet-4",
+        LMStyle.Claude3,
+        datetime(2023, 4, 30),
+        link="https://www.anthropic.com/claude/sonnet",
+    ),
+    ## Gemini
+    LanguageModel(
+        "gemini-1.5-pro-002",
+        "Gemini-Pro-1.5-002",
+        LMStyle.Gemini,
+        datetime(2023, 4, 30),
+        link="https://blog.google/technology/ai/gemini-api-developers-cloud",
+    ),
+    LanguageModel(
+        "gemini-1.5-flash-002",
+        "Gemini-Flash-1.5-002",
+        LMStyle.Gemini,
+        datetime(2023, 4, 30),
+        link="https://blog.google/technology/ai/gemini-api-developers-cloud",
+    ),
+    # LanguageModel(
+    #     "gemini-exp-1206",
+    #     "Gemini-Exp-1206",
+    #     LMStyle.Gemini,
+    #     datetime(2023, 4, 30),
+    #     link="https://ai.google.dev/gemini-api/docs/models/experimental-models",
+    # ),
+    # LanguageModel(
+    #     "gemini-2.0-flash-thinking-exp-1219",
+    #     "Gemini-Flash-2.0-Thinking-12-19",
+    #     LMStyle.GeminiThinking,
+    #     datetime(2023, 4, 30),
+    #     link="https://ai.google.dev/gemini-api/docs/models/experimental-models",
+    # ),
+    # LanguageModel(
+    #     "gemini-2.0-flash-thinking-exp-01-21",
+    #     "Gemini-Flash-2.0-Thinking-01-21",
+    #     LMStyle.GeminiThinking,
+    #     datetime(2023, 4, 30),
+    #     link="https://ai.google.dev/gemini-api/docs/models/experimental-models",
+    # ),
+    # LanguageModel(
+    #     "gemini-2.0-flash-exp",
+    #     "Gemini-Flash-2.0-Exp",
+    #     LMStyle.Gemini,
+    #     datetime(2023, 4, 30),
+    #     link="https://ai.google.dev/gemini-api/docs/models/experimental-models",
+    # ),
+    LanguageModel(
+        "gemini-2.5-pro",
+        "Gemini-2.5-Pro-06-17",
+        LMStyle.GeminiThinking,
+        datetime(2023, 4, 30),
+        link="https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/#advanced-coding",
+    ),
+    LanguageModel(
+        "gemini-2.5-pro-preview-06-05",
+        "Gemini-2.5-Pro-06-05",
+        LMStyle.GeminiThinking,
+        datetime(2023, 4, 30),
+        link="https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/#advanced-coding",
+    ),
+    LanguageModel(
+        "gemini-2.5-pro-preview-05-06",
+        "Gemini-2.5-Pro-05-06",
+        LMStyle.GeminiThinking,
+        datetime(2023, 4, 30),
+        link="https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/#advanced-coding",
+    ),
+    # LanguageModel(
+    #     "gemini-2.5-pro-exp-03-25",
+    #     "Gemini-2.5-Pro-03-25",
+    #     LMStyle.GeminiThinking,
+    #     datetime(2023, 4, 30),
+    #     link="https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/#advanced-coding",
+    # ),
+    LanguageModel(
+        "gemini-2.5-flash-preview-04-17",
+        "Gemini-2.5-Flash-04-17",
+        LMStyle.GeminiThinking,
+        datetime(2023, 4, 30),
+        link="https://developers.googleblog.com/en/start-building-with-gemini-25-flash/",
+    ),
+    LanguageModel(
+        "gemini-2.5-flash-preview-05-20",
+        "Gemini-2.5-Flash-05-20",
+        LMStyle.GeminiThinking,
+        datetime(2023, 4, 30),
+        link="https://developers.googleblog.com/en/start-building-with-gemini-25-flash/",
+    ),
+    ## Generic Base Models
+    LanguageModel(
+        "bigcode/starcoder2-3b",
+        "StarCoder2-3b",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/bigcode/starcoder2-7b-magicoder-instruct/tree/main",
+    ),
+    LanguageModel(
+        "bigcode/starcoder2-7b",
+        "StarCoder2-7b",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/bigcode/starcoder2-7b-magicoder-instruct/tree/main",
+    ),
+    LanguageModel(
+        "bigcode/starcoder2-15b",
+        "StarCoder2-15b",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/bigcode/starcoder2-7b-magicoder-instruct/tree/main",
+    ),
+    LanguageModel(
+        "google/codegemma-7b",
+        "CodeGemma-7b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/google/codegemma-7b",
+    ),
+    LanguageModel(
+        "google/codegemma-2b",
+        "CodeGemma-2b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/google/codegemma-2b",
+    ),
+    LanguageModel(
+        "google/gemma-7b",
+        "Gemma-7b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/google/gemma-7b",
+    ),
+    LanguageModel(
+        "google/gemma-2b",
+        "Gemma-2b-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 1, 1),
+        link="https://huggingface.co/google/gemma-2b",
+    ),
+    ## Mistral Web
+    LanguageModel(
+        "mistral-large-latest",
+        "Mistral-Large",
+        LMStyle.MistralWeb,
+        datetime(2023, 1, 1),
+        link="https://mistral.ai/news/mistral-large/",
+    ),
+    ## Mistral OSS
+    LanguageModel(
+        "open-mixtral-8x22b",
+        "Mixtral-8x22B-Ins",
+        LMStyle.MistralWeb,
+        datetime(2023, 1, 1),
+        link="https://mistral.ai/news/mixtral-8x22b/",
+    ),
+    LanguageModel(
+        "open-mixtral-8x7b",
+        "Mixtral-8x7B-Ins",
+        LMStyle.MistralWeb,
+        datetime(2023, 1, 1),
+        link="https://mistral.ai/news/mixtral-8x7b/",
+    ),
+    LanguageModel(
+        "codestral-latest",
+        "Codestral-Latest",
+        LMStyle.MistralWeb,
+        datetime(2023, 1, 1),
+        link="https://mistral.ai/news/codestral/",
+    ),
+    ## QwQ
+    LanguageModel(
+        "Qwen/QwQ-32B-Preview",
+        "QwQ-32B-Preview",
+        LMStyle.QwQ,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/QwQ-32B-Preview",
+    ),
+    LanguageModel(
+        "Qwen/QwQ-32B",
+        "QwQ-32B",
+        LMStyle.QwQ,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/QwQ-32B",
+    ),
+    ## Qwen 2
+    LanguageModel(
+        "Qwen/Qwen2-72B-Instruct",
+        "Qwen2-Ins-72B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2-72B-Instruct",
+    ),
+    ## Qwen 2.5
+    LanguageModel(
+        "Qwen/Qwen2.5-7B-Instruct",
+        "Qwen2.5-Ins-7B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-7B-Instruct",
+    ),
+    LanguageModel(
+        "Qwen/Qwen3-4B-Base",
+        "Qwen3-4B-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen3-4B-Base",
+    ),
+    LanguageModel(
+        "Qwen/Qwen3-1.7B-Base",
+        "Qwen3-1.7B-Base",
+        LMStyle.GenericBase,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen3-1.7B-Base",
+    ),
+    LanguageModel(
+        "ftajwar/qwen3_4B_Base_MaxRL_Polaris_1000_steps",
+        "ftajwar/qwen3_4B_Base_MaxRL_Polaris_1000_steps",
+        LMStyle.GenericBase,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/ftajwar/qwen3_4B_Base_MaxRL_Polaris_1000_steps",
+    ),
+    LanguageModel(
+        "ftajwar/qwen3_4B_Base_GRPO_Polaris_1000_steps",
+        "ftajwar/qwen3_4B_Base_GRPO_Polaris_1000_steps",
+        LMStyle.GenericBase,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/ftajwar/qwen3_4B_Base_GRPO_Polaris_1000_steps",
+    ),
+    LanguageModel(
+        "/data/models/Qwen2.5-1.5B-Instruct/",
+        "/data/models/Qwen2.5-1.5B-Instruct/",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct",
+    ),
+    LanguageModel(
+        "/data/repos/agentica-rllm/scripts/train/deepcoder/checkpoints/deepcoder-1.5b/grpo-lcb-prompt/global_step_900/actor/checkpoint",
+        "grpo_900",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct",
+    ),
+    LanguageModel(
+        "/data/repos/agentica-rllm/scripts/train/deepcoder/checkpoints/deepcoder-1.5b/tailrl-lcb-prompt/global_step_900/actor/checkpoint",
+        "tailrl_900",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct",
+    ),
+    LanguageModel(
+        "Qwen/Qwen2.5-32B-Instruct",
+        "Qwen2.5-Ins-32B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-32B-Instruct",
+    ),
+    LanguageModel(
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen2.5-Ins-72B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2023, 8, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-72B-Instruct",
+    ),
+    ## Qwen 2.5-Coder
+    LanguageModel(
+        "Qwen/Qwen2.5-Coder-7B-Instruct",
+        "Qwen2.5-Coder-Ins-7B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct",
+    ),
+    LanguageModel(
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen2.5-Coder-Ins-32B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct",
+    ),
+    LanguageModel(
+        "Qwen/Qwen3-235B-A22B",
+        "Qwen3-235B-A22B",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/Qwen3-235B-A22B",
+    ),
+    LanguageModel(
+        "azerogpt",
+        "AzeroGPT-64b",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 3, 1),
+        "https://azerogpt.soundai.com",
+    ),
+    LanguageModel(
+        "Kimi-k1.6-IOI-high",
+        "Kimi-k1.6-IOI-high",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 7, 30),
+        "https://kimi.moonshot.cn/",
+    ),
+    LanguageModel(
+        "Kimi-k1.6-IOI",
+        "Kimi-k1.6-IOI",
+        LMStyle.CodeQwenInstruct,
+        datetime(2024, 7, 30),
+        "https://kimi.moonshot.cn/",
+    ),
+    LanguageModel(
+        "Qwen/QwQ-Max-Preview",
+        "QwQ-Max-Preview",
+        LMStyle.QwQ,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/Qwen/QwQ-Max-Preview",
+    ),
+    LanguageModel(
+        "accounts/fireworks/models/deepseek-r1",
+        "DeepSeek-R1",
+        LMStyle.DeepSeekR1,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1",
+    ),
+    LanguageModel(
+        "deepseek-reasoner",
+        "DeepSeek-R1-0528",
+        LMStyle.DeepSeekR1,
+        datetime(2024, 6, 30),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-0528",
+    ),
+    ## DeepSeek R1 distilled of Qwen/Llama models
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+        "DeepSeek-R1-Distill-Qwen-1.5B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+    ),
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+        "DeepSeek-R1-Distill-Qwen-7B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+    ),
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+        "DeepSeek-R1-Distill-Qwen-14B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+    ),
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+        "DeepSeek-R1-Distill-Qwen-32B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+    ),
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+        "DeepSeek-R1-Distill-Llama-8B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
+    ),
+    LanguageModel(
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "DeepSeek-R1-Distill-Llama-70B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 1, 20),
+        link="https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+    ),
+    LanguageModel(
+        model_name="command-r-plus-08-2024",
+        model_repr="command-r-plus-08-2024",
+        model_style=LMStyle.CohereCommand,
+        release_date=datetime(2024, 8, 1),
+        link="https://docs.cohere.com/docs/command-r-plus",
+    ),
+    LanguageModel(
+        model_name="command-r-08-2024",
+        model_repr="command-r-08-2024",
+        model_style=LMStyle.CohereCommand,
+        release_date=datetime(2024, 8, 1),
+        link="https://docs.cohere.com/docs/command-r",
+    ),
+    LanguageModel(
+        model_name="command-r7b-12-2024",
+        model_repr="command-r7b-12-2024",
+        model_style=LMStyle.CohereCommand,
+        release_date=datetime(2024, 12, 13),
+        link="https://docs.cohere.com/docs/command-r7b",
+    ),
+    LanguageModel(
+        model_name="command-a-03-2025",
+        model_repr="command-a-03-2025",
+        model_style=LMStyle.CohereCommand,
+        release_date=datetime(2025, 3, 13),
+        link="https://docs.cohere.com/docs/command-a",
+    ),
+    LanguageModel(
+        model_name="Qwen/Qwen2.5-72B-Instruct-Turbo",
+        model_repr="Qwen2.5-72B-Instruct-Turbo",
+        model_style=LMStyle.TogetherAI,
+        release_date=datetime(2024, 9, 19),
+        link="https://docs.together.ai/docs/serverless-models",
+    ),
+    # LanguageModel(
+    #     model_name="deepseek-ai/DeepSeek-V3",
+    #     model_repr="DeepSeek-V3",
+    #     model_style=LMStyle.TogetherAI,
+    #     release_date=datetime(2024, 12, 26),
+    #     link="https://docs.together.ai/docs/serverless-models",
+    # ),
+    LanguageModel(
+        "MetaStone-L1-7B",
+        "MetaStone-L1-7B",
+        LMStyle.DeepSeekR1,
+        datetime(2025, 3, 12),
+        "https://www.wenxiaobai.com/",
+    ),
+    LanguageModel(
+        "grok-3-mini-beta",
+        "Grok-3-Mini",
+        LMStyle.Grok,
+        datetime(2024, 3, 1),
+        "https://x.com/i/grok",
+    ),
+    LanguageModel(
+        "grok-3-mini-beta_high",
+        "Grok-3-Mini (High)",
+        LMStyle.Grok,
+        datetime(2024, 3, 1),
+        "https://x.com/i/grok",
+    ),
+    LanguageModel(
+        "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+        "Llama-3_1-Nemotron-Ultra-253B-v1",
+        LMStyle.DeepSeekR1,
+        datetime(2024, 4, 1),
+        "https://huggingface.co/nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+    ),
+    LanguageModel(
+        "nvidia/Llama-3_1-Nemotron-Nano-8B-v1",
+        "Llama-3_1-Nemotron-Nano-8B-v1",
+        LMStyle.DeepSeekR1,
+        datetime(2024, 4, 1),
+        "https://huggingface.co/nvidia/Llama-3_1-Nemotron-Nano-8B-v1/",
+    ),
+    LanguageModel(
+        "agentica-org/DeepCoder-14B-Preview",
+        "DeepCoder-14B-Preview",
+        LMStyle.DeepSeekR1,
+        datetime(2024, 4, 1),
+        "https://huggingface.co/agentica-org/DeepCoder-14B-Preview",
+    ),
+]
+
+LanguageModelStore: dict[str, LanguageModel] = {
+    lm.model_name: lm for lm in LanguageModelList
+}
+
+if __name__ == "__main__":
+    print(list(LanguageModelStore.keys()))

lcb_runner/prompts/__init__.py

@@ -0,0 +1,4 @@
+from lcb_runner.prompts.code_execution import format_prompt_execution, format_prompt_execution_cot
+from lcb_runner.prompts.code_generation import format_prompt_generation
+from lcb_runner.prompts.test_output_prediction import format_prompt_test_output
+from lcb_runner.prompts.self_repair import format_prompt_self_repair

lcb_runner/prompts/code_execution.py

@@ -0,0 +1,183 @@
+import json
+
+from lcb_runner.lm_styles import LMStyle
+from lcb_runner.benchmarks import CodeExecutionProblem
+
+
+def make_cot_output_prompt(s):
+    code, input = s
+    return f"""You are given a Python function and an assertion containing an input to the function. Complete the assertion with a literal (no unsimplified expressions, no function calls) containing the output when executing the provided code on the given input, even if the function is incorrect or incomplete. Do NOT output any extra information. Execute the program step by step before arriving at an answer, and provide the full assertion with the correct output in [ANSWER] and [/ANSWER] tags, following the examples.
+
+[PYTHON]
+def performOperation(s):
+    s = s + s
+    return "b" + s + "a"
+assert performOperation(s = "hi") == ??
+[/PYTHON]
+[THOUGHT]
+Let's execute the code step by step:
+
+1. The function performOperation is defined, which takes a single argument s.
+2. The function is called with the argument "hi", so within the function, s is initially "hi".
+3. Inside the function, s is concatenated with itself, so s becomes "hihi".
+4. The function then returns a new string that starts with "b", followed by the value of s (which is now "hihi"), and ends with "a".
+5. The return value of the function is therefore "bhihia".
+[/THOUGHT]
+[ANSWER]
+assert performOperation(s = "hi") == "bhihia"
+[/ANSWER]
+
+[PYTHON]
+{code}
+assert {input} == ??
+[/PYTHON]
+[THOUGHT]
+"""
+
+
+def make_direct_output_prompt(s):
+    code, input = s
+    return f"""You are given a Python function and an assertion containing an input to the function. Complete the assertion with a literal (no unsimplified expressions, no function calls) containing the output when executing the provided code on the given input, even if the function is incorrect or incomplete. Do NOT output any extra information. Provide the full assertion with the correct output in [ANSWER] and [/ANSWER] tags, following the examples.
+
+[PYTHON]
+def repeatNumber(number : int) -> int:
+    return number
+assert repeatNumber(number = 17) == ??
+[/PYTHON]
+[ANSWER]
+assert repeatNumber(number = 17) == 17
+[/ANSWER]
+
+[PYTHON]
+def addCharacterA(string : str) -> str:
+    return string + "a"
+assert addCharacterA(string = "x9j") == ??
+[/PYTHON]
+[ANSWER]
+assert addCharacterA(string = "x9j") == "x9ja"
+[/ANSWER]
+
+[PYTHON]
+{code}
+assert {input} == ??
+[/PYTHON]
+[ANSWER]
+"""
+
+
+def format_prompt_execution(question, LanguageModelStyle):
+    return format_prompt_execution_base(question, LanguageModelStyle, False)
+
+
+def format_prompt_execution_cot(question, LanguageModelStyle):
+    return format_prompt_execution_base(question, LanguageModelStyle, True)
+
+
+def format_prompt_execution_base(
+    question: CodeExecutionProblem, LanguageModelStyle: LMStyle, cot: bool
+) -> str:
+    code = question.code
+    input = question.input
+    system_message = "You are an expert at Python programming, code execution, test case generation, and fuzzing."
+    if cot:
+        prompt = make_cot_output_prompt((code, input))
+    else:
+        prompt = make_direct_output_prompt((code, input))
+
+    if LanguageModelStyle == LMStyle.OpenAIChat:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": system_message,
+            },
+        ]
+        chat_messages += [
+            {"role": "user", "content": prompt},
+        ]
+        return chat_messages
+    if LanguageModelStyle == LMStyle.LLaMa3:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": system_message,
+            },
+        ]
+        chat_messages += [
+            {"role": "user", "content": prompt},
+        ]
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "meta-llama/Meta-Llama-3-8B-Instruct", padding_side="left", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+
+    elif LanguageModelStyle == LMStyle.Claude:
+        return prompt
+    elif LanguageModelStyle == LMStyle.Claude3:
+        prompt = [
+            {
+                "role": "user",
+                "content": prompt,
+            }
+        ]
+        return system_message, prompt
+    elif LanguageModelStyle == LMStyle.Gemini:
+        return prompt
+    elif LanguageModelStyle == LMStyle.StarCoderInstruct:
+        return prompt
+    elif LanguageModelStyle == LMStyle.DeepSeekCodeInstruct:
+        return prompt
+    elif LanguageModelStyle == LMStyle.CodeLLaMaInstruct:
+        return prompt
+    elif LanguageModelStyle == LMStyle.MagiCoder:
+        return prompt
+    elif LanguageModelStyle == LMStyle.WizardCoder:
+        return prompt
+    elif LanguageModelStyle == LMStyle.Phind:
+        return prompt
+    elif LanguageModelStyle == LMStyle.OC:
+        return prompt
+    elif LanguageModelStyle == LMStyle.MistralWeb:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": system_message,
+            },
+            {"role": "user", "content": prompt},
+        ]
+        return chat_messages
+    elif LanguageModelStyle == LMStyle.DracarysLlama:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": system_message,
+            },
+        ]
+        chat_messages += [
+            {"role": "user", "content": prompt},
+        ]
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "abacusai/Dracarys-Llama-3.1-70B-Instruct", padding_side="right", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+    elif LanguageModelStyle == LMStyle.DracarysQwen:
+        return prompt
+    else:
+        raise NotImplementedError(
+            f"LanguageModelStyle {LanguageModelStyle} not implemented"
+        )

lcb_runner/prompts/code_generation.py

@@ -0,0 +1,384 @@
+import json
+
+try:
+    from anthropic import HUMAN_PROMPT, AI_PROMPT
+except ImportError:
+    HUMAN_PROMPT = None
+    AI_PROMPT = None
+
+from lcb_runner.lm_styles import LMStyle
+from lcb_runner.benchmarks.code_generation import CodeGenerationProblem
+
+
+class PromptConstants:
+    SYSTEM_MESSAGE_GENERIC = f"You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests."
+
+    SYSTEM_MESSAGE_GEMINI = f"You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. Do NOT use system calls like `exit` in the generated program. Ensure that the first code block contains the solution."
+
+    SYSTEM_MESSAGE_GEMINITHINK = f"You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests."
+
+    SYSTEM_MESSAGE_DEEPSEEK = f"You are an AI programming assistant, utilizing the DeepSeek Coder model, developed by DeepSeek Company, and you answer questions related to computer science."
+
+    SYSTEM_MESSAGE_CODEQWEN = (
+        f"<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user"
+    )
+
+    SYSTEM_MESSAGE_QWEN_QWQ = f"<|im_start|>system\nYou are a helpful and harmless assistant. You are Qwen developed by Alibaba. You should think step-by-step.<|im_end|>\n<|im_start|>user"
+
+    SYSTEM_MESSAGE_DEEPSEEK_R1 = (
+        "<｜begin▁of▁sentence｜>A conversation between User and Assistant. "
+        "The user asks a question, and the Assistant solves it. "
+        "The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. "
+        "The reasoning process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>.<｜User｜>"
+    )
+
+    FORMATTING_MESSAGE_WITH_STARTER_CODE = "You will use the following starter code to write the solution to the problem and enclose your code within delimiters."
+
+    FORMATTING_WITHOUT_STARTER_CODE = "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT."
+
+
+def get_generic_question_template_answer(question: CodeGenerationProblem):
+    prompt = f"### Question:\n{question.question_content}\n\n"
+    if question.starter_code:
+        prompt += (
+            f"### Format: {PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        )
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_oaireason_question_template_answer(question: CodeGenerationProblem):
+    prompt = f"### Question:\n{question.question_content}\n\n"
+    if question.starter_code:
+        prompt += (
+            f"### Format: {PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        )
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += f"### Format: Implement a function called `main()` which orchastrates the solution by reading inputs from stdin and writing the answer to stdout. Feel free to use additional functions as necessary. Next do NOT forget to call `main` function at the end of the program otherwise you will not be awarded any points.\n"
+        prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_geminithinking_question_template_answer(question: CodeGenerationProblem):
+    prompt = f"### Question:\n{question.question_content}\n\n"
+    if question.starter_code:
+        prompt += (
+            f"### Format: {PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        )
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_deepseekcode_question_template_answer(question: CodeGenerationProblem):
+    prompt = f"### Instruction: You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt += f"Question:\n{question.question_content}\n\n"
+    if question.starter_code:
+        prompt += (
+            f"### Instruction: {PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        )
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += (
+            f"### Instruction: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        )
+        prompt += f"```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Response:\n\n"
+    return prompt
+
+
+def get_qwen_question_template_answer(question: CodeGenerationProblem):
+    from transformers import AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        "/abacus/models/Qwen1.5-72B-Chat/", padding_side="left", use_fast=False
+    )
+    prompt = "You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt += f"Question:\n{question.question_content}\n\n"
+    if question.starter_code:
+        prompt += f"{PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += f"{PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n\n"
+        prompt += f"```python\n# YOUR CODE HERE\n```\n\n"
+
+    messages = [
+        {"role": "system", "content": PromptConstants.SYSTEM_MESSAGE_GENERIC},
+        {"role": "user", "content": prompt},
+    ]
+
+    prompt = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        truncation=False,
+        padding=False,
+    )
+    return prompt
+
+
+def get_codeqwen_question_template_answer(question: CodeGenerationProblem):
+    prompt = "You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt += f"Question: {question.question_content}\n\n"
+    if question.starter_code:
+        prompt += f"{PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        prompt += f"```python\n{question.starter_code}\n```\n\n<|im_end|>\n"
+    else:
+        prompt += f"{PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += f"```python\n# YOUR CODE HERE\n```\n\n<|im_end|>\n"
+    prompt += f"<|im_start|>assistant\n"
+    return prompt
+
+
+def get_qwen_qwq_question_template_answer(question: CodeGenerationProblem):
+    prompt = "You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n"
+    prompt += f"Question: {question.question_content}\n\n"
+    if question.starter_code:
+        prompt += f"{PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        prompt += f"```python\n{question.starter_code}\n```\n\n<|im_end|>\n"
+    else:
+        prompt += f"{PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += f"```python\n# YOUR CODE HERE\n```\n\n<|im_end|>\n"
+    prompt += f"<|im_start|>assistant\n"
+    return prompt
+
+
+def get_deepseek_r1_question_template_answer(question: CodeGenerationProblem):
+    # Following modifications from: https://github.com/fanqiwan/FuseAI/blob/main/FuseO1-Preview/code_evaluation/lcb_runner_cq/prompts/code_generation.py
+    prompt = "You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n"
+    prompt += f"Question: {question.question_content}\n\n"
+    if question.starter_code:
+        prompt += f"{PromptConstants.FORMATTING_MESSAGE_WITH_STARTER_CODE}\n"
+        prompt += f"```python\n{question.starter_code}\n```\n\n"
+    else:
+        prompt += f"{PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+        prompt += f"```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"<｜Assistant｜>"
+    return prompt
+
+
+with open("lcb_runner/prompts/few_shot_examples/generation/func.json") as f:
+    func = json.load(f)
+
+with open("lcb_runner/prompts/few_shot_examples/generation/stdin.json") as f:
+    stdin = json.load(f)
+
+
+def get_base_model_question_template_answer(question: CodeGenerationProblem):
+    if question.starter_code:
+        examples_json = func
+    else:
+        examples_json = stdin
+
+    def get_example_prompt(example):
+        prompt = ""
+        prompt += "### Question\n"
+        prompt += example["question"]
+        prompt += "\n\n"
+        if question.starter_code:
+            prompt += "### Starter Code\n"
+            prompt += example["sample_code"]
+            prompt += "\n\n"
+        prompt += "### Answer\n\n"
+        prompt += example["answer"]
+        if example["answer"]:
+            prompt += "\n\n"
+        return prompt
+
+    prompt = ""
+    prompt += get_example_prompt(examples_json[0])
+    prompt += get_example_prompt(
+        {
+            "question": question.question_content,
+            "sample_code": question.starter_code,
+            "answer": "",
+        }
+    )
+    return prompt
+
+
+def format_prompt_generation(
+    question: CodeGenerationProblem, LanguageModelStyle: LMStyle
+) -> str:
+    if LanguageModelStyle in [
+        LMStyle.OpenAIChat,
+        LMStyle.DeepSeekAPI,
+        LMStyle.TogetherAI,
+        LMStyle.CohereCommand,
+    ]:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(question),
+            },
+        ]
+        return chat_messages
+    elif LanguageModelStyle in [LMStyle.OpenAIReasonPreview, LMStyle.Grok]:
+        chat_messages = [
+            {
+                "role": "user",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC
+                + "\n\n"
+                + get_generic_question_template_answer(question),
+            },
+        ]
+        return chat_messages
+    elif LanguageModelStyle == LMStyle.OpenAIReason:
+        chat_messages = [
+            {
+                "role": "user",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC
+                + "\n\n"
+                + get_oaireason_question_template_answer(question),
+            },
+        ]
+        return chat_messages
+
+    if LanguageModelStyle == LMStyle.LLaMa3:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(question),
+            },
+        ]
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "meta-llama/Meta-Llama-3-8B-Instruct", padding_side="left", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+
+    if LanguageModelStyle == LMStyle.Claude:
+        prompt = f"{HUMAN_PROMPT}\n"
+        prompt += f"{PromptConstants.SYSTEM_MESSAGE_GENERIC}\n\n"
+        prompt += f"{get_generic_question_template_answer(question).rstrip()}\n"
+        prompt += f"{AI_PROMPT}"
+        return prompt
+
+    if LanguageModelStyle in [LMStyle.Claude3, LMStyle.Claude3Thinking]:
+        system = PromptConstants.SYSTEM_MESSAGE_GENERIC
+        prompt = [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(question).rstrip(),
+            }
+        ]
+        return system, prompt
+
+    if LanguageModelStyle == LMStyle.Gemini:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_GEMINI}\n"
+        prompt += f"{get_generic_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.GeminiThinking:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_GEMINITHINK}\n"
+        prompt += f"{get_geminithinking_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.MistralWeb:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC,
+            },
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(question),
+            },
+        ]
+        return chat_messages
+
+    if LanguageModelStyle == LMStyle.DeepSeekCodeInstruct:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_DEEPSEEK}\n\n"
+        prompt += f"{get_deepseekcode_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.CodeQwenInstruct:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_CODEQWEN}\n\n"
+        prompt += f"{get_codeqwen_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.QwQ:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_QWEN_QWQ}\n\n"
+        prompt += f"{get_qwen_qwq_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.DeepSeekR1:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_DEEPSEEK_R1}"
+        prompt += f"{get_deepseek_r1_question_template_answer(question)}"
+        return prompt
+
+    if LanguageModelStyle == LMStyle.GenericBase:
+        prompt = get_base_model_question_template_answer(question)
+        return prompt
+
+    raise NotImplementedError(
+        f"LanguageModelStyle {LanguageModelStyle} not implemented"
+    )
+
+
+def test():
+    import pathlib
+
+    base_dir = "logs/example_prompts/generation"
+    pathlib.Path(base_dir).mkdir(parents=True, exist_ok=True)
+
+    for lmstyle in LMStyle:
+        generation_problem = CodeGenerationProblem(
+            "title",
+            "question-content",
+            "leetcode",
+            "question_id",
+            "contest_id",
+            "contest_date",
+            "",
+            "easy",
+            "[]",
+            "[]",
+            "{}",
+        )
+        prompt1 = format_prompt_generation(generation_problem, lmstyle)
+        with open(f"{base_dir}/{lmstyle}_1.txt", "w") as f:
+            try:
+                f.write(prompt1)
+            except TypeError:
+                f.write(json.dumps(prompt1))
+
+        generation_problem.starter_code = "starter code"
+        prompt2 = format_prompt_generation(generation_problem, lmstyle)
+        with open(f"{base_dir}/{lmstyle}_2.txt", "w") as f:
+            try:
+                f.write(prompt2)
+            except TypeError:
+                f.write(json.dumps(prompt2))
+
+
+if __name__ == "__main__":
+    test()

lcb_runner/prompts/few_shot_examples/generation/func.json

@@ -0,0 +1,12 @@
+[
+    {
+        "question": "You are given a 0-indexed array of positive integers nums. Find the number of triplets (i, j, k) that meet the following conditions:\n\n0 <= i < j < k < nums.length\nnums[i], nums[j], and nums[k] are pairwise distinct.\n\t\nIn other words, nums[i] != nums[j], nums[i] != nums[k], and nums[j] != nums[k].\n\n\n\nReturn the number of triplets that meet the conditions.\n \nExample 1:\n\nInput: nums = [4,4,2,4,3]\nOutput: 3\nExplanation: The following triplets meet the conditions:\n- (0, 2, 4) because 4 != 2 != 3\n- (1, 2, 4) because 4 != 2 != 3\n- (2, 3, 4) because 2 != 4 != 3\nSince there are 3 triplets, we return 3.\nNote that (2, 0, 4) is not a valid triplet because 2 > 0.\n\nExample 2:\n\nInput: nums = [1,1,1,1,1]\nOutput: 0\nExplanation: No triplets meet the conditions so we return 0.\n\n \nConstraints:\n\n3 <= nums.length <= 100\n1 <= nums[i] <= 1000\n\n",
+        "sample_code": "class Solution:\n    def unequalTriplets(self, nums: List[int]) -> int:\n        ",
+        "answer": "class Solution:\n    def unequalTriplets(self, a: List[int]) -> int:\n        ans = 0\n        n = len(a)\n        for i in range(n):\n            for j in range(i + 1, n):\n                for k in range(j + 1, n):\n                    ans += len({a[i], a[j], a[k]}) == 3\n        return ans"
+    },
+    {
+        "question": "You are given two strings s and t consisting of only lowercase English letters.\nReturn the minimum number of characters that need to be appended to the end of s so that t becomes a subsequence of s.\nA subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.\n \nExample 1:\n\nInput: s = \"coaching\", t = \"coding\"\nOutput: 4\nExplanation: Append the characters \"ding\" to the end of s so that s = \"coachingding\".\nNow, t is a subsequence of s (\"coachingding\").\nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.\n\nExample 2:\n\nInput: s = \"abcde\", t = \"a\"\nOutput: 0\nExplanation: t is already a subsequence of s (\"abcde\").\n\nExample 3:\n\nInput: s = \"z\", t = \"abcde\"\nOutput: 5\nExplanation: Append the characters \"abcde\" to the end of s so that s = \"zabcde\".\nNow, t is a subsequence of s (\"zabcde\").\nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.\n\n \nConstraints:\n\n1 <= s.length, t.length <= 10^5\ns and t consist only of lowercase English letters.\n\n",
+        "sample_code": "class Solution:\n    def appendCharacters(self, s: str, t: str) -> int:\n        ",
+        "answer": "class Solution:\n    def appendCharacters(self, s: str, t: str) -> int:\n        i = 0\n        for char in s:\n            if i < len(t) and char == t[i]:\n                i += 1\n        return len(t) - i"
+    }
+]

lcb_runner/prompts/few_shot_examples/generation/stdin.json

@@ -0,0 +1,10 @@
+[
+    {
+        "question": "You have $n$ gifts and you want to give all of them to children. Of course, you don't want to offend anyone, so all gifts should be equal between each other. The $i$-th gift consists of $a_i$ candies and $b_i$ oranges.\n\nDuring one move, you can choose some gift $1 \\le i \\le n$ and do one of the following operations:\n\n  eat exactly one candy from this gift (decrease $a_i$ by one);  eat exactly one orange from this gift (decrease $b_i$ by one);  eat exactly one candy and exactly one orange from this gift (decrease both $a_i$ and $b_i$ by one). \n\nOf course, you can not eat a candy or orange if it's not present in the gift (so neither $a_i$ nor $b_i$ can become less than zero).\n\nAs said above, all gifts should be equal. This means that after some sequence of moves the following two conditions should be satisfied: $a_1 = a_2 = \\dots = a_n$ and $b_1 = b_2 = \\dots = b_n$ (and $a_i$ equals $b_i$ is not necessary).\n\nYour task is to find the minimum number of moves required to equalize all the given gifts.\n\nYou have to answer $t$ independent test cases.\n\n\n-----Input-----\n\nThe first line of the input contains one integer $t$ ($1 \\le t \\le 1000$) \u2014 the number of test cases. Then $t$ test cases follow.\n\nThe first line of the test case contains one integer $n$ ($1 \\le n \\le 50$) \u2014 the number of gifts. The second line of the test case contains $n$ integers $a_1, a_2, \\dots, a_n$ ($1 \\le a_i \\le 10^9$), where $a_i$ is the number of candies in the $i$-th gift. The third line of the test case contains $n$ integers $b_1, b_2, \\dots, b_n$ ($1 \\le b_i \\le 10^9$), where $b_i$ is the number of oranges in the $i$-th gift.\n\n\n-----Output-----\n\nFor each test case, print one integer: the minimum number of moves required to equalize all the given gifts.\n\n\n-----Example-----\nInput\n5\n3\n3 5 6\n3 2 3\n5\n1 2 3 4 5\n5 4 3 2 1\n3\n1 1 1\n2 2 2\n6\n1 1000000000 1000000000 1000000000 1000000000 1000000000\n1 1 1 1 1 1\n3\n10 12 8\n7 5 4\n\nOutput\n6\n16\n0\n4999999995\n7\n\n\n\n-----Note-----\n\nIn the first test case of the example, we can perform the following sequence of moves:\n\n  choose the first gift and eat one orange from it, so $a = [3, 5, 6]$ and $b = [2, 2, 3]$;  choose the second gift and eat one candy from it, so $a = [3, 4, 6]$ and $b = [2, 2, 3]$;  choose the second gift and eat one candy from it, so $a = [3, 3, 6]$ and $b = [2, 2, 3]$;  choose the third gift and eat one candy and one orange from it, so $a = [3, 3, 5]$ and $b = [2, 2, 2]$;  choose the third gift and eat one candy from it, so $a = [3, 3, 4]$ and $b = [2, 2, 2]$;  choose the third gift and eat one candy from it, so $a = [3, 3, 3]$ and $b = [2, 2, 2]$.",
+        "answer": "def minimum_moves(t, test_cases):\n    for _ in range(t):\n        n = test_cases[_][0]\n        candies = test_cases[_][1]\n        oranges = test_cases[_][2]\n        min_candies = min(candies)\n        min_oranges = min(oranges)\n        ans = 0\n        for i in range(n):\n            ans += max(candies[i] - min_candies, oranges[i] - min_oranges)\n        print(ans)\n\n\ndef main():\n    t = int(input())\n    test_cases = []\n    for _ in range(t):\n        n = int(input())\n        candies = list(map(int, input().split()))\n        oranges = list(map(int, input().split()))\n        test_cases.append((n, candies, oranges))\n    minimum_moves(t, test_cases)\n\n\nmain()\n"
+    },
+    {
+        "question": "Let's call a string a phone number if it has length 11 and fits the pattern \"8xxxxxxxxxx\", where each \"x\" is replaced by a digit.\n\nFor example, \"80123456789\" and \"80000000000\" are phone numbers, while \"8012345678\" and \"79000000000\" are not.\n\nYou have n cards with digits, and you want to use them to make as many phone numbers as possible. Each card must be used in at most one phone number, and you don't have to use all cards. The phone numbers do not necessarily have to be distinct.\n\nInput\n\nThe first line contains an integer n \u2014 the number of cards with digits that you have (1 \u2264 n \u2264 100).\n\nThe second line contains a string of n digits (characters \"0\", \"1\", ..., \"9\") s_1, s_2, \u2026, s_n. The string will not contain any other characters, such as leading or trailing spaces.\n\nOutput\n\nIf at least one phone number can be made from these cards, output the maximum number of phone numbers that can be made. Otherwise, output 0.\n\nExamples\n\nInput\n\n11\n00000000008\n\n\nOutput\n\n1\n\n\nInput\n\n22\n0011223344556677889988\n\n\nOutput\n\n2\n\n\nInput\n\n11\n31415926535\n\n\nOutput\n\n0\n\nNote\n\nIn the first example, one phone number, \"8000000000\", can be made from these cards.\n\nIn the second example, you can make two phone numbers from the cards, for example, \"80123456789\" and \"80123456789\".\n\nIn the third example you can't make any phone number from the given cards.",
+        "answer": "def count_phone_numbers(num_cards, card_digits):\n    count_eights = card_digits.count(\"8\")\n    max_phone_numbers = num_cards // 11\n    max_possible = min(count_eights, max_phone_numbers)\n    return max_possible\n\ndef main():\n    num_cards = int(input())\n    card_digits = input().strip()\n    max_possible = count_phone_numbers(num_cards, card_digits)\n    print(max_possible)\n\nmain()"
+    }
+]

lcb_runner/prompts/self_repair.py

@@ -0,0 +1,352 @@
+import json
+
+from anthropic import HUMAN_PROMPT, AI_PROMPT
+
+from lcb_runner.lm_styles import LMStyle
+
+
+class PromptConstants:
+    SYSTEM_MESSAGE_GENERIC = f"You are a helpful programming assistant and an expert Python programmer. You are helping a user write a program to solve a problem. The user has written some code, but it has some errors and is not passing the tests. You will help the user by first giving a concise (at most 2-3 sentences) textual explanation of what is wrong with the code. After you have pointed out what is wrong with the code, you will then generate a fixed version of the program. You must put the entired fixed program within code delimiters only for once."
+
+    SYSTEM_MESSAGE_DEEPSEEK = f"You are an AI programming assistant, utilizing the DeepSeek Coder model, developed by DeepSeek Company, and you are helping a user correct a error program for code competition. The user has written some code, but it has some errors and is not passing the tests. You will help the user by first giving a concise (at most 2-3 sentences) textual explanation of what is wrong with the code. After you have pointed out what is wrong with the code, you will then generate a fixed version of the entire executable program. You must put the entire fixed executable program within code delimiters."
+
+    SYSTEM_MESSAGE_MAGIC = f"You are an exceptionally intelligent coding assistant that consistently delivers accurate and reliable responses to user instructions.\n\n@@ Instruction\n"
+
+    SYSTEM_MESSAGE_WIZARD = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
+
+    SYSTEM_MESSAGE_PHIND = f"""You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program. You must put the entired fixed program within code delimiters only for once., for example: 
+```python 
+# YOUR CODE HERE
+```"""
+
+    FORMATTING_REPEAT = f"First reason about the code providing a textual explanation of what is wrong with the code and then generate a fixed of the program enclosed code delimiters."
+
+    FORMATTING_MESSAGE = "You will use the following starter code to write the solution to the problem and enclose your code within delimiters."
+
+    FORMATTING_WITHOUT_STARTER_CODE = "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows."
+
+
+# def truncate_io(io):
+#     if len(str(io)) > 200:
+#         io = str(io)[:200] + "...."
+#     return io
+
+
+def get_check_prompt(question: str, result, metadata):
+    ## assumes i/o examples are already truncated!
+    ## less pressure on storing 10 MB json because on a single large input-output pair
+    # result_by_test_case = result
+    # assert len(metadata) == 1, f"metadata = {metadata}"
+    # metadata = metadata[0]
+    metadata = json.loads(metadata)
+    if "error_code" not in metadata:
+        return ""
+    if metadata["error_code"] == -1:
+        # time limit exceeded
+        message = f"The above code is incorrect and got the following compilation error.\n{metadata['error']}"
+    elif metadata["error_code"] == -2:
+        # wrong answer
+        message = f"The above code is incorrect and got a wrong answer.\nInput: {metadata['inputs']}\nGenerated Output: {metadata['output']}\nExpected: {metadata['expected']}"
+    elif metadata["error_code"] == -3:
+        # time limit exceeded
+        message = f"The above code is incorrect and got time limit exceeded.\n{metadata['error']}\nInput: {metadata['inputs']}\nExpected: {metadata['expected']}"
+        pass
+    elif metadata["error_code"] == -4:
+        # runtime error
+        message = f"The above code is incorrect and got a runtime error.\nInput: {metadata['inputs']}\nExpected: {metadata['expected']}\n{metadata['error']}"
+    else:
+        raise NotImplementedError(
+            f"metadata['error_code'] = {metadata['error_code']} not implemented || {metadata=}"
+        )
+    return message
+
+
+def get_generic_question_template_answer(question: str, code, result, metadata):
+    prompt = f"### Question:\n{question}\n\n"
+    prompt += f"### Answer:\n```python\n{code}\n```\n\n"
+    prompt += get_check_prompt(question, result, metadata) + "\n"
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_cllama_question_template_answer(question: str, code, result, metadata):
+    prompt = f"### Question\n{question}\n\n"
+    prompt += f"### Answer\n```python\n{code}\n```\n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_deepseekcode_question_template_answer(question: str, code, result, metadata):
+    prompt = f"### Instruction: You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt += f"Question:\n{question}\n\n"
+    prompt += f"### Response:\n```python\n{code}\n```\n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_magicoder_question_template_answer(question: str, code, result, metadata):
+    prompt = f"You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt += f"Question:\n{question}\n\n"
+    prompt += f"@@ Response \n```python\n{code}\n```\n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_mixtral_question_template_answer(question: str, code, result, metadata):
+    prompt = f"Question:\n"
+    prompt += f"{question}\n\n"
+    prompt += f"Answer:\n\n"
+    prompt += f"```python\n\n{code}\n``\n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_wizard_question_template_answer(question: str, code, result, metadata):
+    prompt = f"""### Instruction: You are a helpful programming assistant and an expert Python programmer. You are helping a user write a program to solve a problem. The user has written some code, but it has some errors and is not passing the tests. You will help the user by first giving a concise (at most 2-3 sentences) textual explanation of what is wrong with the code. After you have pointed out what is wrong with the code, you will then generate a fixed version of the program. You must put the entired fixed program within code delimiters only for once., for example:
+    ```python
+    # YOUR CODE HERE
+    ```
+"""
+    prompt += f"{question}\n\n"
+    prompt += f"### Response:```python\n\n{code}\n```\n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+
+def get_phind_question_template_answer(question: str, code, result, metadata):
+    prompt = f"{question}\n\n"
+    prompt += f"```python\n{code}\n``` \n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"\n\n### Assistant"
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+    return prompt
+
+def get_qwen_question_template_answer(question: str, code, result, metadata):
+    from transformers import AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        "abacusai/Dracarys-72B-Instruct", padding_side="left", use_fast=False
+    )
+    prompt = f"""### Instruction: You are a helpful programming assistant and an expert Python programmer. You are helping a user write a program to solve a problem. The user has written some code, but it has some errors and is not passing the tests. You will help the user by first giving a concise (at most 2-3 sentences) textual explanation of what is wrong with the code. After you have pointed out what is wrong with the code, you will then generate a fixed version of the program. You must put the entired fixed program within code delimiters only for once., for example:
+    ```python
+    # YOUR CODE HERE
+    ```\n\n
+"""
+    prompt += f"Question:\n{question}\n\n"
+    prompt += f"```python\n{code}\n``` \n\n"
+    prompt += get_check_prompt(question, result, metadata)
+    prompt += f"\n\n### Assistant"
+    prompt += f"### Format: {PromptConstants.FORMATTING_WITHOUT_STARTER_CODE}\n"
+    prompt += "```python\n# YOUR CODE HERE\n```\n\n"
+    prompt += f"### Answer: (use the provided format with backticks)\n\n"
+
+    messages = [
+        {"role": "user", "content": prompt},
+    ]
+
+    prompt = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        truncation=False,
+        padding=False,
+    )
+    return prompt
+
+def format_prompt_self_repair(
+    question: str, LanguageModelStyle: LMStyle, code, result, metadata
+) -> str:
+    if result:
+        # The code is accepted, no need to change anything.
+        return ""
+    if LanguageModelStyle == LMStyle.OpenAIChat:
+        chat_messages = [
+            {"role": "system", "content": PromptConstants.SYSTEM_MESSAGE_GENERIC},
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(
+                    question, code, result, metadata
+                )
+                + "\n\n"
+                + PromptConstants.FORMATTING_REPEAT,
+            },
+        ]
+        return chat_messages
+    if LanguageModelStyle == LMStyle.LLaMa3:
+        chat_messages = [
+            {"role": "system", "content": PromptConstants.SYSTEM_MESSAGE_GENERIC},
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(
+                    question, code, result, metadata
+                ),
+            },
+        ]
+
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "meta-llama/Meta-Llama-3-8B-Instruct", padding_side="left", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+    elif LanguageModelStyle == LMStyle.Claude:
+        prompt = f"{HUMAN_PROMPT}\n{PromptConstants.SYSTEM_MESSAGE_GENERIC}\n\n{get_generic_question_template_answer(question, code, result, metadata).rstrip()}\n{AI_PROMPT}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.Claude3:
+        system = PromptConstants.SYSTEM_MESSAGE_GENERIC
+        prompt = [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(
+                    question, code, result, metadata
+                ).rstrip(),
+            }
+        ]
+        return system, prompt
+    elif LanguageModelStyle == LMStyle.MistralWeb:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(question, code, result, metadata),
+            },
+        ]
+        return chat_messages
+    elif LanguageModelStyle == LMStyle.Gemini:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_GENERIC}\n{get_generic_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.StarCoderInstruct:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_GENERIC}\n{get_generic_question_template_answer(question, code, result,metadata)}"
+        return prompt
+
+    elif LanguageModelStyle == LMStyle.DeepSeekCodeInstruct:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_DEEPSEEK}\n\n{get_deepseekcode_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.CodeLLaMaInstruct:
+        prompt = f"[INST] <<SYS>>\n{PromptConstants.SYSTEM_MESSAGE_GENERIC}\n<</SYS>>\n\n{get_cllama_question_template_answer(question, code, result,metadata)}\n[/INST]"
+        return prompt
+    elif LanguageModelStyle == LMStyle.MagiCoder:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_MAGIC}\n{get_magicoder_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.WizardCoder:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_WIZARD}\n\n{get_wizard_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.Phind:
+        prompt = f"### System Prompt\n\n{PromptConstants.SYSTEM_MESSAGE_PHIND}\n\n### User Message\n\n{get_phind_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.DracarysQwen:
+        prompt = f"{get_qwen_question_template_answer(question, code, result,metadata)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.DracarysLlama:
+        chat_messages = [
+            {"role": "system", "content": PromptConstants.SYSTEM_MESSAGE_GENERIC},
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_answer(
+                    question, code, result, metadata
+                ),
+            },
+        ]
+
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "abacusai/Dracarys-Llama-3.1-70B-Instruct", padding_side="right", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+    if LanguageModelStyle == LMStyle.Eurusx:
+        prompt = "[INST] Write Python code to solve the task:\n"
+        prompt += f"{get_wizard_question_template_answer(question, code, result,metadata)}"
+        prompt += "[/INST]"
+        return prompt
+    else:
+        raise NotImplementedError(
+            f"LanguageModelStyle {LanguageModelStyle} not implemented"
+        )
+
+
+def extract_code(model_output: str, lmstyle: LMStyle):
+    outputlines = model_output.split("\n")
+    if lmstyle == LMStyle.CodeLLaMa:
+        indexlines = [i for i, line in enumerate(outputlines) if "PYTHON]" in line]
+    else:
+        indexlines = [i for i, line in enumerate(outputlines) if "```" in line]
+    if len(indexlines) < 2:
+        return ""
+    return "\n".join(outputlines[indexlines[0] + 1 : indexlines[1]])
+
+
+def test():
+    def write_str_or_json(prompt):
+        if isinstance(prompt, str):
+            fp.write(prompt)
+        else:
+            fp.write(json.dumps(prompt))
+        return
+
+    for lm_style in [LMStyle.OpenAIChat]:
+        with open(
+            "output/GPT-3.5-Turbo-0125/Scenario.codegeneration_10_0.2_eval_all.json"
+        ) as f:
+            check_metadata = json.load(f)[0]
+        checked_base_question_cotent = check_metadata["question_content"]
+        checked_base_codes = check_metadata["code_list"][0]
+        checked_base_results = check_metadata["graded_list"][0]
+        checked_base_metadata = check_metadata["metadata"][0]
+        leetcode_prompt = format_prompt_self_repair(
+            checked_base_question_cotent,
+            lm_style,
+            checked_base_codes,
+            checked_base_results,
+            checked_base_metadata,
+        )
+
+        with open(f"/tmp/leetcode_{lm_style}.txt", "w") as fp:
+            write_str_or_json(leetcode_prompt)
+    return
+
+
+if __name__ == "__main__":
+    test()

lcb_runner/prompts/test_output_prediction.py

@@ -0,0 +1,311 @@
+import json
+
+from anthropic import HUMAN_PROMPT, AI_PROMPT
+
+from lcb_runner.lm_styles import LMStyle
+from lcb_runner.benchmarks import TestOutputPredictionProblem
+
+
+class PromptConstants:
+    SYSTEM_MESSAGE_CHAT_GENERIC = f"You are a helpful programming assistant and an expert Python programmer.\
+ You are helping a user to write a test case to help to check the correctness of the function.\
+ The user has written a input for the testcase.\
+ You will calculate the output of the testcase and\
+ write the whole assertion statement in the markdown code block with the correct output."
+
+    SYSTEM_MESSAGE_COMPLETION_GENERIC = f"You are a helpful programming assistant and an expert Python programmer.\
+ You are helping a user to write a test case to help to check the correctness of the function."
+
+    SYSTEM_MESSAGE_INST_CLLAMA = f"You are a helpful programming assistant and an expert Python programmer.\
+ You are helping a user to write a test case to help to check the correctness of the function.\
+ The user has written a input for the testcase.\
+ You will calculate the output of the testcase and \
+ write out the complete assertion statement between [PYTHON] and [/PYTHON] tags."
+
+    SYSTEM_MESSAGE_WIZARD = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
+
+    SYSTEM_MESSAGE_PHIND = f"""You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program. You must put the entired fixed program within code delimiters only for once., for example: 
+```python 
+# YOUR CODE HERE
+```"""
+
+    FORMATTING_MESSAGE = "You will use the following starter code to write the solution to the problem and enclose your code within delimiters."
+
+    FORMATTING_WITHOUT_STARTER_MESSAGE = "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters as follows."
+
+
+def truncate_io(io):
+    if len(str(io)) > 1000:
+        io = str(io)[:1000] + "...."
+        print(io)
+    return io
+
+
+def format_testcase_func_name_input(function_name, testcase):
+    """
+    use the form of "assert func_name(input) == "
+    """
+    # TODO should there be a space after the == ?
+    input_str = ", ".join(testcase.split("\n"))
+    return f"assert {function_name}({input_str}) == # TODO"
+
+
+def parse_function_name_from_starter_code(starter_code):
+    """
+    starter_code : str
+    """
+    import ast
+
+    tree = ast.parse(starter_code)
+    fn = None
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            assert fn is None
+            fn = node.name
+    return fn
+
+
+def get_generic_question_template_test_completion(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = f"Problem:\n{question.question_content}"
+    prompt += f"Function:\n```\n{question.starter_code}\n```\n"
+
+    # parse function name from starter_code
+    func_name = parse_function_name_from_starter_code(question.starter_code)
+    prompt += "Please complete the following test case:\n\n"
+    prompt += (
+        f"```\n{format_testcase_func_name_input(func_name, testcase_input)}\n```\n"
+    )
+
+    return prompt
+
+
+def get_cllama_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = f"### Question\n"
+    prompt += get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"### Answer\n"
+    return prompt
+
+
+def get_deepseekcode_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = f"### Instruction: {PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n\n"
+    prompt += get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"### Response:\n\n"
+    return prompt
+
+
+def get_magicoder_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    # prompt = f"You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests. You will NOT return anything except for the program.\n\n"
+    prompt = f"Question:\n"
+    prompt += get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"@@ Response \n"
+    return prompt
+
+
+def get_mixtral_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = get_generic_question_template_test_completion(question, testcase_input)
+    return prompt
+
+
+def get_wizard_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = f"""### Instruction: {PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"""
+    prompt += get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"### Response:\n"
+    return prompt
+
+
+def get_phind_question_template_answer(
+    question: TestOutputPredictionProblem, testcase_input: str
+):
+    prompt = get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"\n\n### Assistant"
+    return prompt
+
+def get_qwen_question_template_answer(question: TestOutputPredictionProblem, testcase_input: str):
+    from transformers import AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        "abacusai/Dracarys-72B-Instruct", padding_side="left", use_fast=False
+    )
+
+    prompt = f"""### Instruction: {PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"""
+    prompt += get_generic_question_template_test_completion(question, testcase_input)
+    prompt += f"### Response:\n"
+
+    messages = [
+        {"role": "user", "content": prompt},
+    ]
+
+    prompt = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        truncation=False,
+        padding=False,
+    )
+    return prompt
+
+def format_prompt_test_output(
+    question: TestOutputPredictionProblem, LanguageModelStyle: LMStyle
+) -> str:
+    testcase_input = question.test[0].input
+    if LanguageModelStyle == LMStyle.OpenAIChat:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_test_completion(
+                    question, testcase_input
+                ),
+            },
+        ]
+        return chat_messages
+    if LanguageModelStyle == LMStyle.LLaMa3:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_test_completion(
+                    question, testcase_input
+                ),
+            },
+        ]
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "meta-llama/Meta-Llama-3-8B-Instruct", padding_side="left", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+    elif LanguageModelStyle == LMStyle.Claude:
+        prompt = f"{HUMAN_PROMPT}\n{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n\n"
+        prompt += f"{get_generic_question_template_test_completion(question, testcase_input).rstrip()}\n{AI_PROMPT}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.Claude3:
+        system = PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC
+        prompt = [
+            {
+                "role": "user",
+                "content": get_generic_question_template_test_completion(
+                    question, testcase_input
+                ).rstrip(),
+            }
+        ]
+        return system, prompt
+    elif LanguageModelStyle == LMStyle.Gemini:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"
+        prompt += (
+            f"{get_generic_question_template_test_completion(question, testcase_input)}"
+        )
+        return prompt
+
+    elif LanguageModelStyle == LMStyle.StarCoderInstruct:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"
+        prompt += (
+            f"{get_generic_question_template_test_completion(question, testcase_input)}"
+        )
+        return prompt
+
+    elif LanguageModelStyle == LMStyle.DeepSeekCodeInstruct:
+        prompt = (
+            f"{get_deepseekcode_question_template_answer(question, testcase_input)}"
+        )
+        return prompt
+    elif LanguageModelStyle == LMStyle.CodeLLaMaInstruct:
+        prompt = f"[INST] <<SYS>>\n{PromptConstants.SYSTEM_MESSAGE_INST_CLLAMA}\n<</SYS>>\n\n"
+        prompt += (
+            f"{get_cllama_question_template_answer(question, testcase_input)}\n[/INST]"
+        )
+        return prompt
+    elif LanguageModelStyle == LMStyle.MagiCoder:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"
+        prompt += f"{get_magicoder_question_template_answer(question, testcase_input)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.WizardCoder:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_WIZARD}\n\n{get_wizard_question_template_answer(question, testcase_input)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.Phind:
+        prompt = f"### System Prompt\n\n{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n\n### User Message\n\n{get_phind_question_template_answer(question, testcase_input)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.OC:
+        prompt = f"{PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC}\n"
+        prompt += (
+            f"{get_generic_question_template_test_completion(question, testcase_input)}"
+        )
+        return prompt
+    elif LanguageModelStyle == LMStyle.MistralWeb:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC,
+            },
+            {
+                "role": "user",
+                "content": get_generic_question_template_test_completion(
+                    question, testcase_input
+                ),
+            },
+        ]
+        return chat_messages
+    elif (
+        LanguageModelStyle == LMStyle.DracarysQwen
+    ):
+        prompt = f"{get_qwen_question_template_answer(question, testcase_input)}"
+        return prompt
+    elif LanguageModelStyle == LMStyle.DracarysLlama:
+        chat_messages = [
+            {
+                "role": "system",
+                "content": PromptConstants.SYSTEM_MESSAGE_CHAT_GENERIC,
+            },
+        ]
+        chat_messages += [
+            {
+                "role": "user",
+                "content": get_generic_question_template_test_completion(
+                    question, testcase_input
+                ),
+            },
+        ]
+        from transformers import AutoTokenizer
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            "abacusai/Dracarys-Llama-3.1-70B-Instruct", padding_side="right", use_fast=False
+        )
+        return tokenizer.apply_chat_template(
+            chat_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            truncation=False,
+            padding=False,
+        )
+    else:
+        raise NotImplementedError(
+            f"LanguageModelStyle {LanguageModelStyle} not implemented"
+        )

lcb_runner/runner/base_runner.py

@@ -0,0 +1,181 @@
+import os
+import json
+from abc import ABC, abstractmethod
+
+from tqdm import tqdm
+
+from lcb_runner.lm_styles import LanguageModel
+from lcb_runner.utils.path_utils import get_cache_path
+from lcb_runner.utils.multiprocess import run_tasks_in_parallel
+from lcb_runner.runner.scenario_router import Scenario
+
+
+class BaseRunner(ABC):
+    def __init__(self, args, model: LanguageModel):
+        self.args = args
+        self.model = model
+        self.client_kwargs: dict[str | str] = {}
+
+        if self.args.use_cache:
+            self.cache_path = get_cache_path(model.model_repr, args)
+            if os.path.exists(self.cache_path):
+                with open(self.cache_path) as f:
+                    self.cache: dict = json.load(f)
+            else:
+                self.cache = {}
+        else:
+            self.cache_path = None
+            self.cache = None
+
+    def save_cache(self):
+        if self.args.use_cache:
+            with open(self.cache_path, "w") as f:
+                json.dump(self.cache, f, indent=4)
+
+    # @abstractmethod
+    def _run_single(self, prompt: str | list[dict[str, str]]) -> list[str]:
+        pass
+
+    @staticmethod
+    def run_single(combined_args) -> list[str]:
+        """
+        Run the model for a single prompt and return the output
+        Static method to be used in multiprocessing
+        Calls the _run_single method with the combined arguments
+        """
+        prompt: str | list[dict[str, str]]
+        cache: dict[str, str]
+        call_method: callable
+        prompt, cache, args, call_method = combined_args
+
+        if isinstance(prompt, list):
+            prompt_cache = json.dumps(prompt)
+        elif isinstance(prompt, tuple):
+            prompt_cache = prompt[0] + json.dumps(prompt[1])
+        else:
+            prompt_cache = prompt      
+
+        if cache is not None and prompt_cache in cache:
+            if len(cache[prompt_cache]) == args.n:
+                return cache[prompt_cache]
+
+        result = call_method(prompt)
+        assert len(result) == args.n
+
+        return result
+
+    def run_batch(self, prompts: list[str | list[dict[str, str]]]) -> list[list[str]]:
+        outputs = []
+        arguments = [
+            (
+                prompt,
+                self.cache,  ## pass the cache as argument for cache check
+                self.args,  ## pass the args as argument for cache check
+                self._run_single,  ## pass the _run_single method as argument because of multiprocessing
+            )
+            for prompt in prompts
+        ]
+        if self.args.multiprocess > 1:
+            parallel_outputs = run_tasks_in_parallel(
+                self.run_single,
+                arguments,
+                self.args.multiprocess,
+                use_progress_bar=True,
+            )
+            for output in parallel_outputs:
+                if output.is_success():
+                    outputs.append(output.result)
+                else:
+                    print("Failed to run the model for some prompts")
+                    print(output.status)
+                    print(output.exception_tb)
+                    outputs.extend([""] * self.args.n)
+        else:
+            outputs = [self.run_single(argument) for argument in tqdm(arguments)]
+
+        if self.args.use_cache:
+            for prompt, output in zip(prompts, outputs):
+                if isinstance(prompt, list):
+                    prompt_cache = json.dumps(prompt)
+                elif isinstance(prompt, tuple):
+                    prompt_cache = prompt[0] + json.dumps(prompt[1])
+                else:
+                    prompt_cache = prompt
+                self.cache[prompt_cache] = output  ## save the output to cache
+
+        return outputs
+
+    def prompts_to_outputs(
+        self, prompts: list[str | list[dict[str, str]]]
+    ) -> list[list[str]]:
+        if self.args.use_cache:
+            outputs = []
+            batch_size = self.args.cache_batch_size
+            for i in range(0, len(prompts), batch_size):
+                batch = prompts[i : i + batch_size]
+                batch_outputs = self.run_batch(batch)
+                outputs.extend(batch_outputs)
+                self.save_cache()
+        else:
+            outputs = self.run_batch(prompts)
+        return outputs
+
+    def run_main_repair(self, benchmark: list, format_prompt: callable) -> list[list[str]]:
+        assert self.args.n == 1
+        with open(
+            f"output/{self.model.model_repr}/{Scenario.codegeneration}_{self.args.codegen_n}_{self.args.temperature}_eval_all.json"
+        ) as f:
+            check_metadata_list = json.load(f)
+
+        outputs = [
+            [None for _ in range(self.args.codegen_n)]
+            for _ in range(len(benchmark))
+        ]
+        prompts = []
+        prompt_index_to_question_idx = {}
+        prompt_index_to_code_idx = {}
+        count = 0
+
+        for problem_idx, problem in enumerate(benchmark):
+            for check_metadata_idx, check_metadata in enumerate(check_metadata_list):
+                if problem.question_id == check_metadata['question_id']:
+                    count += 1 
+                    question_content = check_metadata["question_content"]
+                    code_list = check_metadata["code_list"]
+                    output_list = check_metadata["output_list"]
+                    graded_list = check_metadata["graded_list"]
+                    metadata = check_metadata["metadata"]
+                    for code_idx in range(len(code_list)):
+                        prompt = format_prompt(
+                            question_content,
+                            self.model.model_style,
+                            code_list[code_idx],
+                            graded_list[code_idx],
+                            metadata[code_idx],
+                        )
+                        if prompt == "":
+                            outputs[problem_idx][code_idx] = output_list[code_idx]
+                            continue
+                        prompts.append(prompt)
+                        prompt_index_to_question_idx[len(prompts) - 1] = problem_idx
+                        prompt_index_to_code_idx[len(prompts) - 1] = code_idx
+
+        assert len(benchmark)==count, f"{len(benchmark)=}!={count=}"
+
+        prompt_outputs = self.prompts_to_outputs(prompts)
+        for prompt_idx, output in enumerate(prompt_outputs):
+            question_idx = prompt_index_to_question_idx[prompt_idx]
+            code_idx = prompt_index_to_code_idx[prompt_idx]
+            outputs[question_idx][code_idx] = output
+
+        return outputs
+
+    def run_main(self, benchmark: list, format_prompt: callable) -> list[list[str]]:
+        if self.args.scenario == Scenario.selfrepair:
+            return self.run_main_repair(benchmark, format_prompt)
+
+        prompts = [
+            format_prompt(problem, self.model.model_style) for problem in benchmark
+        ]
+        outputs = self.prompts_to_outputs(prompts)
+        return outputs

lcb_runner/runner/claude3_runner.py

@@ -0,0 +1,65 @@
+import os
+from time import sleep
+
+try:
+    from anthropic import Anthropic
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class Claude3Runner(BaseRunner):
+    client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"), timeout=1200)
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        if "Thinking" in model.model_style.value:
+            self.client_kwargs: dict[str | str] = {
+                "model": args.model,
+                "max_tokens": 32000,
+                "thinking": {"type": "enabled", "budget_tokens": 24000},
+                "stream": False,
+            }
+        else:
+            self.client_kwargs: dict[str | str] = {
+                "model": args.model,
+                "temperature": args.temperature,
+                "max_tokens": args.max_tokens,
+                "top_p": args.top_p,
+            }
+
+    def _run_single(self, prompt: tuple[str, str]) -> list[str]:
+
+        def __run_single(counter):
+            try:
+                response = self.client.messages.create(
+                    system=prompt[0],
+                    messages=prompt[1],
+                    **self.client_kwargs,
+                )
+                content = "\n".join(
+                    [
+                        getattr(x, "text", getattr(x, "thinking", "\nREDACTED\n"))
+                        for x in response.content
+                    ]
+                )
+                return content
+            except Exception as e:
+                print("Exception: ", repr(e), "Sleeping for 20 seconds...")
+                sleep(20 * (11 - counter))
+                counter = counter - 1
+                if counter == 0:
+                    print(f"Failed to run model for {prompt}!")
+                    print("Exception: ", repr(e))
+                    raise e
+                return __run_single(counter)
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+
+        return outputs

lcb_runner/runner/claude_runner.py

@@ -0,0 +1,51 @@
+import os
+from time import sleep
+
+try:
+    from anthropic import Anthropic
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class ClaudeRunner(BaseRunner):
+    client = Anthropic(api_key=os.getenv("ANTHROPIC_KEY"))
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens_to_sample": args.max_tokens,
+            "top_p": args.top_p,
+        }
+
+    def _run_single(self, prompt: str) -> list[str]:
+
+        def __run_single(counter):
+            try:
+                response = self.client.completions.create(
+                    prompt=prompt,
+                    **self.client_kwargs,
+                )                                
+                content = response.completion
+                return content
+            except Exception as e:
+                print("Exception: ", repr(e), "Sleeping for 20 seconds...")
+                sleep(20 * (11 - counter))
+                counter = counter - 1
+                if counter == 0:
+                    print(f"Failed to run model for {prompt}!")
+                    print("Exception: ", repr(e))
+                    raise e
+                return __run_single(counter)
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+
+        return outputs

lcb_runner/runner/cohere_runner.py

@@ -0,0 +1,50 @@
+import os
+from time import sleep
+
+try:
+    import cohere
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class CohereRunner(BaseRunner):
+    client = cohere.ClientV2(os.getenv("COHERE_API_KEY"))
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "p": args.top_p,
+        }
+
+    def _run_single(self, prompt: tuple[dict[str,str], str]) -> list[str]:
+        def __run_single(counter):
+            try:
+                response = self.client.chat(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.message.content[0].text
+                return content
+            except Exception as e:
+                print("Exception: ", repr(e), "Sleeping for 20 seconds...")
+                sleep(20 * (11 - counter))
+                counter = counter - 1
+                if counter == 0:
+                    print(f"Failed to run model for {prompt}!")
+                    print("Exception: ", repr(e))
+                    raise e
+                return __run_single(counter)
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+
+        return outputs

lcb_runner/runner/custom_evaluator.py

@@ -0,0 +1,114 @@
+import os
+import json
+
+from lcb_runner.runner.parser import get_args
+from lcb_runner.utils.scenarios import Scenario
+from lcb_runner.utils.path_utils import get_output_path
+from lcb_runner.evaluation import extract_instance_results
+from lcb_runner.runner.scenario_router import (
+    build_prompt_benchmark,
+    sort_and_extract_save_results,
+    get_metrics,
+)
+
+
+def main():
+    args = get_args()
+
+    benchmark, _ = build_prompt_benchmark(args)
+
+    with open(args.custom_output_file, "r") as f:
+        custom_outputs = json.load(f)
+        assert isinstance(custom_outputs, list)
+        assert len(custom_outputs) == len(benchmark), f"{len(custom_outputs)} != {len(benchmark)}"
+        if isinstance(custom_outputs[0], list):
+            ## custom outputs must list[list[str]]
+            ## list of extracted outputs per question
+            ## sorted by the benchmark question_id, test_id, id depending on the scenario
+
+            assert all(
+                isinstance(custom_output, list) for custom_output in custom_outputs
+            )
+        elif isinstance(custom_outputs[0], dict):
+            ## custom outputs must list[dict[str, Any]]
+            ## list of extracted outputs per question
+            ## for codegeneration and selfrepair scenario -- `code_list` and `question_id` are required
+            ## for testoutputprediction -- `pred_list`, `question_id`, `test_id` are required 
+            ## for codeexecution -- `pred_list`, `id` are required 
+            ## code_list/pred_list is a list of extracted answers (code or assertions) for a question
+
+            assert all(
+                isinstance(custom_output, dict) for custom_output in custom_outputs
+            )
+            if args.scenario in [Scenario.codegeneration, Scenario.selfrepair]:
+                custom_outputs = [
+                    custom_output["code_list"]
+                    for custom_output in sorted(
+                        custom_outputs, key=lambda x: str(x["question_id"])
+                    )
+                ]
+            elif args.scenario == Scenario.testoutputprediction:
+                custom_outputs = [
+                    custom_output['pred_list']
+                    for custom_output in sorted(
+                        custom_outputs, key=lambda x: (str(x["question_id"]), str(x['test_id']))
+                    )
+                ]
+            elif args.scenario == Scenario.codeexecution:
+                custom_outputs = [
+                    custom_output['pred_list']
+                    for custom_output in sorted(
+                        custom_outputs, key=lambda x: int(x.id.split("_")[1])
+                    )
+                ]
+
+    save_results = [
+        instance.insert_output(custom_output, custom_output)
+        for instance, custom_output in zip(benchmark, custom_outputs)
+    ]
+
+    save_results, combined_results = sort_and_extract_save_results(
+        args.scenario, save_results
+    )
+
+    metrics = get_metrics(args.scenario, args, benchmark, combined_results)
+    graded = extract_instance_results(metrics[1])
+
+    if args.scenario == Scenario.codegeneration:
+        metadatas = metrics[2]
+        save_eval_results = [
+            instance.insert_output_evaluation(
+                outputs_list, extracted_list, graded_list, metadata=meta
+            )
+            for instance, (outputs_list, extracted_list), graded_list, meta in zip(
+                benchmark, combined_results, graded, metadatas
+            )
+        ]
+    else:
+        save_eval_results = [
+            instance.insert_output_evaluation(
+                outputs_list, extracted_list, graded_list
+            )
+            for instance, (outputs_list, extracted_list), graded_list in zip(
+                benchmark, combined_results, graded
+            )
+        ]
+    
+
+    if args.custom_output_save_name is None:
+        output_path = args.custom_output_file[:-5] + f"_{args.scenario.value}_output.json"
+    else:
+        output_path = get_output_path(args.custom_output_save_name, args)
+
+    with open(output_path, "w") as f:
+        json.dump(save_results, f, indent=4)
+
+
+    with open(output_path.replace(".json", "_eval.json"), "w") as f:
+        json.dump(metrics, f, indent=4)
+
+    with open(output_path.replace(".json", "_eval_all.json"), "w") as f:
+        json.dump(save_eval_results, f, indent=4)
+
+if __name__ == "__main__":
+    main()

lcb_runner/runner/deepseek_runner.py

@@ -0,0 +1,70 @@
+import os
+from time import sleep
+
+try:
+    import openai
+    from openai import OpenAI
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class DeepSeekRunner(BaseRunner):
+    client = OpenAI(
+        api_key=os.getenv("DEEPSEEK_API"),
+        base_url="https://api.deepseek.com",
+    )
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "top_p": args.top_p,
+            "frequency_penalty": 0,
+            "presence_penalty": 0,
+            "n": 1,
+            "timeout": args.openai_timeout,
+            # "stop": args.stop, --> stop is only used for base models currently
+        }
+
+    def _run_single(self, prompt: list[dict[str, str]]) -> list[str]:
+        assert isinstance(prompt, list)
+
+        def __run_single(counter):
+            try:
+                response = self.client.chat.completions.create(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.choices[0].message.content
+                return content
+            except (
+                openai.APIError,
+                openai.RateLimitError,
+                openai.InternalServerError,
+                openai.OpenAIError,
+                openai.APIStatusError,
+                openai.APITimeoutError,
+                openai.InternalServerError,
+                openai.APIConnectionError,
+            ) as e:
+                print("Exception: ", repr(e))
+                print("Sleeping for 30 seconds...")
+                print("Consider reducing the number of parallel processes.")
+                sleep(30)
+                return DeepSeekRunner._run_single(prompt)
+            except Exception as e:
+                print(f"Failed to run the model for {prompt}!")
+                print("Exception: ", repr(e))
+                raise e
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+        return outputs

lcb_runner/runner/fireworks_runner.py

@@ -0,0 +1,73 @@
+import os
+from time import sleep
+
+try:
+    import openai
+    from openai import OpenAI
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class FireWorksRunner(BaseRunner):
+    client = OpenAI(
+        api_key=os.getenv("FIREWORKS_API"),
+        base_url="https://api.fireworks.ai/inference/v1",
+    )
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "top_p": args.top_p,
+            "frequency_penalty": 0,
+            "presence_penalty": 0,
+            "n": 1,
+            "timeout": args.openai_timeout,
+            # "stop": args.stop, --> stop is only used for base models currently
+        }
+
+    def _run_single(self, prompt: list[dict[str, str]]) -> list[str]:
+        if isinstance(prompt, list):
+            pass
+        else:
+            prompt = [{"role": "user", "content": prompt}]
+
+        def __run_single(counter):
+            try:
+                response = self.client.chat.completions.create(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.choices[0].message.content
+                return content
+            except (
+                openai.APIError,
+                openai.RateLimitError,
+                openai.InternalServerError,
+                openai.OpenAIError,
+                openai.APIStatusError,
+                openai.APITimeoutError,
+                openai.InternalServerError,
+                openai.APIConnectionError,
+            ) as e:
+                print("Exception: ", repr(e))
+                print("Sleeping for 30 seconds...")
+                print("Consider reducing the number of parallel processes.")
+                sleep(30)
+                return FireWorksRunner._run_single(prompt)
+            except Exception as e:
+                print(f"Failed to run the model for {prompt}!")
+                print("Exception: ", repr(e))
+                raise e
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+        return outputs

lcb_runner/runner/gemini_runner.py

@@ -0,0 +1,101 @@
+import os
+from time import sleep
+
+try:
+    from google import genai
+    from google.genai.types import GenerateContentConfigDict, ThinkingConfig
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+from lcb_runner.lm_styles import LMStyle
+
+
+class GeminiRunner(BaseRunner):
+    client = genai.Client(
+        # api_key=os.getenv("GOOGLE_API_KEY"), http_options={"api_version": "v1alpha"}
+        vertexai=True,
+        project=os.getenv("VERTEX_GEMINI_PROJECT"),
+        location=os.getenv("VERTEX_GEMINI_LOCATION"),
+    )
+    safety_settings = [
+        {
+            "category": "HARM_CATEGORY_HARASSMENT",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_HATE_SPEECH",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "threshold": "BLOCK_NONE",
+        },
+        {
+            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "threshold": "BLOCK_NONE",
+        },
+    ]
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.args = args
+        self.model = model
+        if self.model.model_style == LMStyle.GeminiThinking:
+            self.generation_config = GenerateContentConfigDict(
+                # candidate_count=args.n,
+                # temperature=0.7,
+                # top_p=0.95,
+                # top_k=64,
+                # max_output_tokens=65536,
+                safety_settings=GeminiRunner.safety_settings,
+                thinking_config=ThinkingConfig(include_thoughts=True),
+            )
+            print("GeminiThinking model")
+        else:
+            self.generation_config = GenerateContentConfigDict(
+                max_output_tokens=args.max_tokens,
+                temperature=args.temperature,
+                top_p=args.top_p,
+                safety_settings=GeminiRunner.safety_settings,
+                candidate_count=args.n,
+            )
+
+    def _run_single(self, prompt: str) -> list[str]:
+
+        try:
+            outputs = self.client.models.generate_content(
+                model=self.model.model_name,
+                contents=prompt,
+                config=self.generation_config,
+            ).candidates
+
+            if outputs is None:
+                print("No outputs from Gemini")
+                return ["" for _ in range(self.args.n)]
+        except Exception as e:
+            print("Exception: ", repr(e))
+            print("Sleeping for 30 seconds...")
+            print("Consider reducing the number of parallel processes.")
+            sleep(30)
+            return self._run_single(prompt)
+
+        new_outputs = []
+        for output in outputs:
+            try:
+                texts = [part.text for part in output.content.parts]
+                texts = [
+                    "## Part " + str(i) + "\n" + text for i, text in enumerate(texts)
+                ]
+                text = "\n\n\n".join(texts)
+                if text == "":
+                    print("Empty text for output")
+                    print(output.__dict__)
+                new_outputs.append(text)
+            except Exception as e:
+                print("Cannot extract text exception: ", repr(e))
+                print(output.__dict__)
+                new_outputs.append("")
+        outputs = new_outputs
+
+        return outputs

lcb_runner/runner/grok_runner.py

@@ -0,0 +1,72 @@
+import os
+from time import sleep
+
+try:
+    import openai
+    from openai import OpenAI
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class GrokRunner(BaseRunner):
+    client = OpenAI(
+        api_key=os.getenv("GROK_API_KEY"),
+        base_url="https://api.x.ai/v1",
+    )
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        model_name = args.model.split("_")[0]
+        self.client_kwargs: dict[str | str] = {
+            "model": model_name,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "top_p": args.top_p,
+            "n": 1,
+            # "timeout": args.openai_timeout,
+            # "stop": args.stop, --> stop is only used for base models currently
+        }
+        if "_" in args.model:
+            self.client_kwargs["reasoning_effort"] = args.model.split("_")[1]
+
+    def _run_single(self, prompt: list[dict[str, str]]) -> list[str]:
+        assert isinstance(prompt, list)
+
+        def __run_single(counter):
+            try:
+                response = self.client.chat.completions.create(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.choices[0].message.content
+                return content
+            except (
+                openai.APIError,
+                openai.RateLimitError,
+                openai.InternalServerError,
+                openai.OpenAIError,
+                openai.APIStatusError,
+                openai.APITimeoutError,
+                openai.InternalServerError,
+                openai.APIConnectionError,
+            ) as e:
+                print("Exception: ", repr(e))
+                print(prompt[0]["content"])
+                print("Sleeping for 30 seconds...")
+                print("Consider reducing the number of parallel processes.")
+                sleep(30)
+                return GrokRunner._run_single(prompt)
+            except Exception as e:
+                print(f"Failed to run the model for {prompt}!")
+                print("Exception: ", repr(e))
+                raise e
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+        return outputs

lcb_runner/runner/main.py

@@ -0,0 +1,240 @@
+import os
+import json
+
+from lcb_runner.runner.parser import get_args
+from lcb_runner.utils.scenarios import Scenario
+from lcb_runner.lm_styles import LanguageModelStore, LanguageModel, LMStyle
+from lcb_runner.runner.runner_utils import build_runner
+from lcb_runner.utils.path_utils import get_output_path
+from lcb_runner.evaluation import extract_instance_results
+from lcb_runner.runner.scenario_router import (
+    build_prompt_benchmark,
+    combine_results,
+    sort_and_extract_save_results,
+    get_metrics,
+)
+
+
+def main():
+    args = get_args()
+
+    if args.model in LanguageModelStore:
+        model = LanguageModelStore[args.model]
+    else:
+        if args.nickname is None:
+            raise ValueError(
+                f"Model '{args.model}' not found in lm_styles.py. "
+                "Provide --nickname to use it as a custom model."
+            )
+        model = LanguageModel(
+            model_name=args.model,
+            model_repr=args.nickname,
+            model_style=LMStyle[args.model_style],
+            release_date=None,
+        )
+    benchmark, format_prompt = build_prompt_benchmark(args)
+    if args.debug:
+        print(f"Running with {len(benchmark)} instances in debug mode")
+        benchmark = benchmark[:15]
+
+    output_path = get_output_path(model.model_repr, args)
+    eval_file = output_path.replace(".json", "_eval.json")
+    eval_all_file = output_path.replace(".json", "_eval_all.json")
+
+    if args.continue_existing or args.continue_existing_with_eval:
+        if os.path.exists(output_path):
+            with open(output_path, "r") as f:
+                old_save_results = json.load(f)
+        elif os.path.exists(eval_all_file):
+            with open(eval_all_file, "r") as f:
+                old_save_results = json.load(f)
+        else:
+            print(
+                f"File {output_path} does not exist in --continue_existing, starting from scratch"
+            )
+            old_save_results = []
+
+        old_save_results = [
+            instance
+            for instance in old_save_results
+            if instance["output_list"] and [x for x in instance["output_list"] if x]
+        ]
+        old_save_results_question_ids = [
+            instance["question_id"] for instance in old_save_results
+        ]
+        remaining_benchmark = [
+            instance
+            for instance in benchmark
+            if instance.question_id not in old_save_results_question_ids
+        ]
+        print(
+            f"Found {len(old_save_results)} existing generations, continuing with {len(remaining_benchmark)} remaining"
+        )
+    else:
+        old_save_results = []
+        remaining_benchmark = benchmark
+
+    if len(remaining_benchmark) > 0:
+        runner = build_runner(args, model)
+        results: list[list[str]] = runner.run_main(remaining_benchmark, format_prompt)
+    else:
+        results = []
+
+    combined_results = combine_results(
+        args.scenario, results, model, args.cot_code_execution
+    )
+
+    save_results = [
+        instance.insert_output(outputs_list, extracted_list)
+        for instance, (outputs_list, extracted_list) in zip(
+            remaining_benchmark, combined_results
+        )
+    ]
+
+    if args.continue_existing or args.continue_existing_with_eval:
+        save_results += old_save_results
+
+    save_results, combined_results = sort_and_extract_save_results(
+        args.scenario, save_results
+    )
+
+    with open(output_path, "w") as f:
+        json.dump(save_results, f, indent=4)
+
+    # for i in range(len(combined_results)):
+    #     for j in range(len(combined_results[i][1])):
+    #         if "def solve()" in combined_results[i][1][j]:
+    #             from lcb_runner.utils.extraction_utils import extract_code, LMStyle
+
+    #             combined_results[i][1][j] = extract_code(
+    #                 combined_results[i][0][j], LMStyle.Gemini
+    #             )
+    #             if "\nsolve()" not in combined_results[i][1][j]:
+    #                 combined_results[i][1][j] += "\n\nsolve()"
+
+    #                 # combined_results[i][1][j] += "\n\nsolve()"
+    #                 print(combined_results[i][1][j])
+
+    if args.evaluate:
+        if args.continue_existing_with_eval and os.path.exists(eval_all_file):
+            with open(eval_all_file) as fp:
+                old_eval_all_results = json.load(fp)
+
+            if os.path.exists(eval_file):
+                with open(eval_file) as fp:
+                    old_eval_results = json.load(fp)
+            else:
+                old_eval_results = None
+
+            old_eval_results_question_ids = [
+                instance["question_id"] for instance in old_eval_all_results
+            ]
+            remaining_indices = [
+                idx
+                for idx in range(len(benchmark))
+                if benchmark[idx].question_id not in old_eval_results_question_ids
+            ]
+            benchmark = [benchmark[idx] for idx in remaining_indices]
+            combined_results = [combined_results[idx] for idx in remaining_indices]
+
+            old_eval_size = len(old_eval_results_question_ids)
+            new_eval_size = len(benchmark)
+
+            if new_eval_size == 0:
+                return
+
+            print(f"Found {old_eval_size}, running evals for {new_eval_size} problems")
+
+            metrics = get_metrics(args.scenario, args, benchmark, combined_results)
+            graded = extract_instance_results(metrics[1])
+
+            if old_eval_results:
+                for key in metrics[0]:
+                    if key in old_eval_results[0]:
+                        if key != "detail":
+                            metrics[0][key] = (
+                                old_eval_size * old_eval_results[0][key]
+                                + new_eval_size * metrics[0][key]
+                            )
+                            metrics[0][key] /= old_eval_size + new_eval_size
+
+                for key in metrics[0]["detail"]:
+                    if key in old_eval_results[0]["detail"]:
+                        metrics[0]["detail"][key] = {
+                            **metrics[0]["detail"][key],
+                            **old_eval_results[0]["detail"][key],
+                        }
+                metrics[1] = {**metrics[1], **old_eval_results[1]}
+            else:
+                print("Old eval file not present, cannot update eval file")
+                metrics = {}
+
+        else:
+            metrics = get_metrics(args.scenario, args, benchmark, combined_results)
+            graded = extract_instance_results(metrics[1])
+            old_eval_all_results = []
+            old_eval_results = []
+
+        if args.scenario == Scenario.codegeneration:
+            if metrics:
+                metadatas = metrics[2]
+            else:
+                metadatas = [[] for _ in benchmark]
+            save_eval_results = [
+                instance.insert_output_evaluation(
+                    outputs_list, extracted_list, graded_list, metadata=meta
+                )
+                for instance, (outputs_list, extracted_list), graded_list, meta in zip(
+                    benchmark, combined_results, graded, metadatas
+                )
+            ]
+            if metrics and old_eval_results:
+                old_eval_results
+                metrics[2] = old_eval_results[2] + metrics[2]
+        elif args.scenario == Scenario.selfrepair:
+            metadatas = metrics[2]
+            with open(
+                f"output/{model.model_repr}/{Scenario.codegeneration}_{args.codegen_n}_{args.temperature}_eval_all.json"
+            ) as f:
+                code_gen_evals = json.load(f)
+            original_code_lists = [
+                code_gen_eval["code_list"] for code_gen_eval in code_gen_evals
+            ]
+
+            save_eval_results = [
+                instance.insert_output_evaluation(
+                    outputs_list,
+                    extracted_list,
+                    graded_list,
+                    metadata=meta,
+                    original_code_list=original_code_list,
+                )
+                for instance, (
+                    outputs_list,
+                    extracted_list,
+                ), graded_list, meta, original_code_list in zip(
+                    benchmark, combined_results, graded, metadatas, original_code_lists
+                )
+            ]
+
+        else:
+            save_eval_results = [
+                instance.insert_output_evaluation(
+                    outputs_list, extracted_list, graded_list
+                )
+                for instance, (outputs_list, extracted_list), graded_list in zip(
+                    benchmark, combined_results, graded
+                )
+            ]
+
+        save_eval_results = old_eval_all_results + save_eval_results
+
+        with open(eval_file, "w") as f:
+            json.dump(metrics, f, indent=4)
+
+        with open(eval_all_file, "w") as f:
+            json.dump(save_eval_results, f, indent=4)
+
+
+if __name__ == "__main__":
+    main()

lcb_runner/runner/mistral_runner.py

@@ -0,0 +1,53 @@
+import os
+from time import sleep
+
+try:
+    from mistralai.client import MistralClient
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class MistralRunner(BaseRunner):
+    client = MistralClient(
+        api_key=os.environ["MISTRAL_API_KEY"],
+    )
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "top_p": args.top_p,
+        }
+
+    def _run_single(self, prompt: list[dict[str, str]]) -> list[str]:
+
+        def __run_single(counter):
+            try:
+                response = self.client.chat(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.choices[0].message.content
+                return content
+            except Exception as e:
+                print("Exception: ", repr(e), "Sleeping for 20 seconds...")
+                sleep(20 * (11 - counter))
+                counter = counter - 1
+                if counter == 0:
+                    print(f"Failed to run model for {prompt}!")
+                    print("Exception: ", repr(e))
+                    raise e
+                return __run_single(counter)
+
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+
+        return outputs

lcb_runner/runner/oai_runner.py

@@ -0,0 +1,79 @@
+import os
+from time import sleep
+
+try:
+    import openai
+    from openai import OpenAI
+except ImportError as e:
+    pass
+
+from lcb_runner.lm_styles import LMStyle
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class OpenAIRunner(BaseRunner):
+    client = OpenAI(
+        api_key=os.getenv("OPENAI_KEY"),
+    )
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        if model.model_style == LMStyle.OpenAIReasonPreview:
+            self.client_kwargs: dict[str | str] = {
+                "model": args.model,
+                "max_completion_tokens": 25000,
+            }
+        elif model.model_style == LMStyle.OpenAIReason:
+            assert (
+                "__" in args.model
+            ), f"Model {args.model} is not a valid OpenAI Reasoning model as we require reasoning effort in model name."
+            model, reasoning_effort = args.model.split("__")
+            self.client_kwargs: dict[str | str] = {
+                "model": model,
+                "reasoning_effort": reasoning_effort,
+            }
+        else:
+            self.client_kwargs: dict[str | str] = {
+                "model": args.model,
+                "temperature": args.temperature,
+                "max_tokens": args.max_tokens,
+                "top_p": args.top_p,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "n": args.n,
+                "timeout": args.openai_timeout,
+                # "stop": args.stop, --> stop is only used for base models currently
+            }
+
+    def _run_single(self, prompt: list[dict[str, str]], n: int = 10) -> list[str]:
+        assert isinstance(prompt, list)
+
+        if n == 0:
+            print("Max retries reached. Returning empty response.")
+            return []
+
+        try:
+            response = OpenAIRunner.client.chat.completions.create(
+                messages=prompt,
+                **self.client_kwargs,
+            )
+        except (
+            openai.APIError,
+            openai.RateLimitError,
+            openai.InternalServerError,
+            openai.OpenAIError,
+            openai.APIStatusError,
+            openai.APITimeoutError,
+            openai.InternalServerError,
+            openai.APIConnectionError,
+        ) as e:
+            print("Exception: ", repr(e))
+            print("Sleeping for 30 seconds...")
+            print("Consider reducing the number of parallel processes.")
+            sleep(30)
+            return self._run_single(prompt, n=n - 1)
+        except Exception as e:
+            print(f"Failed to run the model for {prompt}!")
+            print("Exception: ", repr(e))
+            raise e
+        return [c.message.content for c in response.choices]

lcb_runner/runner/parser.py

@@ -0,0 +1,166 @@
+import os
+import torch
+import argparse
+
+from lcb_runner.utils.scenarios import Scenario
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="gpt-3.5-turbo-0301",
+        help="Name of the model to use matching `lm_styles.py`, or a path if not in the store",
+    )
+    parser.add_argument(
+        "--nickname",
+        type=str,
+        default=None,
+        help="Short name used as model_repr when --model is not present in lm_styles.py",
+    )
+    parser.add_argument(
+        "--model_style",
+        type=str,
+        default="CodeQwenInstruct",
+        help="LMStyle to use when --model is not present in lm_styles.py (default: CodeQwenInstruct)",
+    )
+    parser.add_argument(
+        "--local_model_path",
+        type=str,
+        default=None,
+        help="If you have a local model, specify it here in conjunction with --model",
+    )
+    parser.add_argument(
+        "--trust_remote_code",
+        action="store_true",
+        help="trust_remote_code option used in huggingface models",
+    )
+    parser.add_argument(
+        "--scenario",
+        type=Scenario,
+        default=Scenario.codegeneration,
+        help="Type of scenario to run",
+    )
+    parser.add_argument(
+        "--not_fast",
+        action="store_true",
+        help="whether to use full set of tests (slower and more memory intensive evaluation)",
+    )
+    parser.add_argument(
+        "--release_version",
+        type=str,
+        default="release_latest",
+        help="whether to use full set of tests (slower and more memory intensive evaluation)",
+    )
+    parser.add_argument(
+        "--cot_code_execution",
+        action="store_true",
+        help="whether to use CoT in code execution scenario",
+    )
+    parser.add_argument(
+        "--n", type=int, default=10, help="Number of samples to generate"
+    )
+    parser.add_argument(
+        "--codegen_n",
+        type=int,
+        default=10,
+        help="Number of samples for which code generation was run (used to map the code generation file during self-repair)",
+    )
+    parser.add_argument(
+        "--temperature", type=float, default=0.2, help="Temperature for sampling"
+    )
+    parser.add_argument("--top_p", type=float, default=0.95, help="Top p for sampling")
+    parser.add_argument(
+        "--max_tokens", type=int, default=2000, help="Max tokens for sampling"
+    )
+    parser.add_argument(
+        "--multiprocess",
+        default=0,
+        type=int,
+        help="Number of processes to use for generation (vllm runs do not use this)",
+    )
+    parser.add_argument(
+        "--stop",
+        default="###",
+        type=str,
+        help="Stop token (use `,` to separate multiple tokens)",
+    )
+    parser.add_argument("--continue_existing", action="store_true")
+    parser.add_argument("--continue_existing_with_eval", action="store_true")
+    parser.add_argument(
+        "--use_cache", action="store_true", help="Use cache for generation"
+    )
+    parser.add_argument(
+        "--cache_batch_size", type=int, default=100, help="Batch size for caching"
+    )
+    parser.add_argument("--debug", action="store_true", help="Debug mode")
+    parser.add_argument("--evaluate", action="store_true", help="Evaluate the results")
+    parser.add_argument(
+        "--num_process_evaluate",
+        type=int,
+        default=12,
+        help="Number of processes to use for evaluation",
+    )
+    parser.add_argument("--timeout", type=int, default=6, help="Timeout for evaluation")
+    parser.add_argument(
+        "--openai_timeout", type=int, default=90, help="Timeout for requests to OpenAI"
+    )
+    parser.add_argument(
+        "--tensor_parallel_size",
+        type=int,
+        default=-1,
+        help="Tensor parallel size for vllm",
+    )
+    parser.add_argument(
+        "--enable_prefix_caching",
+        action="store_true",
+        help="Enable prefix caching for vllm",
+    )
+    parser.add_argument(
+        "--custom_output_file",
+        type=str,
+        default=None,
+        help="Path to the custom output file used in `custom_evaluator.py`",
+    )
+    parser.add_argument(
+        "--custom_output_save_name",
+        type=str,
+        default=None,
+        help="Folder name to save the custom output results (output file folder modified if None)",
+    )
+    parser.add_argument("--dtype", type=str, default="bfloat16", help="Dtype for vllm")
+    # Added to avoid running extra generations (it's slow for reasoning models)
+    parser.add_argument(
+        "--start_date",
+        type=str,
+        default=None,
+        help="Start date for the contest to filter the evaluation file (format - YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--end_date",
+        type=str,
+        default=None,
+        help="End date for the contest to filter the evaluation file (format - YYYY-MM-DD)",
+    )
+
+    args = parser.parse_args()
+
+    args.stop = args.stop.split(",")
+
+    if args.tensor_parallel_size == -1:
+        args.tensor_parallel_size = torch.cuda.device_count()
+
+    if args.multiprocess == -1:
+        args.multiprocess = os.cpu_count()
+
+    return args
+
+
+def test():
+    args = get_args()
+    print(args)
+
+
+if __name__ == "__main__":
+    test()

lcb_runner/runner/runner_utils.py

@@ -0,0 +1,60 @@
+from lcb_runner.lm_styles import LMStyle, LanguageModel
+
+
+def build_runner(args, model: LanguageModel):
+    if model.model_style == LMStyle.OpenAIChat:
+        from lcb_runner.runner.oai_runner import OpenAIRunner
+
+        return OpenAIRunner(args, model)
+    if model.model_style in [LMStyle.OpenAIReason, LMStyle.OpenAIReasonPreview]:
+        from lcb_runner.runner.oai_runner import OpenAIRunner
+
+        return OpenAIRunner(args, model)
+    if model.model_style in [LMStyle.Gemini, LMStyle.GeminiThinking]:
+        from lcb_runner.runner.gemini_runner import GeminiRunner
+
+        return GeminiRunner(args, model)
+    if model.model_style in [LMStyle.Claude3, LMStyle.Claude3Thinking]:
+        from lcb_runner.runner.claude3_runner import Claude3Runner
+
+        return Claude3Runner(args, model)
+    if model.model_style == LMStyle.Claude:
+        from lcb_runner.runner.claude_runner import ClaudeRunner
+
+        return ClaudeRunner(args, model)
+    if model.model_style == LMStyle.MistralWeb:
+        from lcb_runner.runner.mistral_runner import MistralRunner
+
+        return MistralRunner(args, model)
+    if model.model_style == LMStyle.CohereCommand:
+        from lcb_runner.runner.cohere_runner import CohereRunner
+
+        return CohereRunner(args, model)
+    if model.model_style == LMStyle.DeepSeekAPI:
+        from lcb_runner.runner.deepseek_runner import DeepSeekRunner
+
+        return DeepSeekRunner(args, model)
+    if model.model_style == LMStyle.DeepSeekAPI:
+        from lcb_runner.runner.deepseek_runner import DeepSeekRunner
+
+        return DeepSeekRunner(args, model)
+    if model.model_style == LMStyle.Grok:
+        from lcb_runner.runner.grok_runner import GrokRunner
+
+        return GrokRunner(args, model)
+    if model.model_style == LMStyle.TogetherAI:
+        from lcb_runner.runner.together_runner import TogetherAIRunner
+
+        return TogetherAIRunner(args, model)
+    if "/fireworks/" in model.model_name:
+        from lcb_runner.runner.fireworks_runner import FireWorksRunner
+
+        return FireWorksRunner(args, model)
+    elif model.model_style in []:
+        raise NotImplementedError(
+            f"Runner for language model style {model.model_style} not implemented yet"
+        )
+    else:
+        from lcb_runner.runner.vllm_runner import VLLMRunner
+
+        return VLLMRunner(args, model)

lcb_runner/runner/scenario_router.py

@@ -0,0 +1,217 @@
+from typing import Union
+
+from lcb_runner.utils.scenarios import Scenario
+from lcb_runner.lm_styles import LanguageModel
+from lcb_runner.evaluation import (
+    codegen_metrics,
+    test_output_metrics,
+    code_execution_metrics,
+)
+
+from lcb_runner.prompts import (
+    format_prompt_generation,
+    format_prompt_test_output,
+    format_prompt_execution,
+    format_prompt_execution_cot,
+    format_prompt_self_repair,
+)
+from lcb_runner.utils.extraction_utils import (
+    extract_code,
+    extract_test_output_code,
+    extract_execution_code,
+)
+
+from lcb_runner.benchmarks import (
+    CodeGenerationProblem,
+    TestOutputPredictionProblem,
+    CodeExecutionProblem,
+    load_code_generation_dataset,
+    load_code_generation_dataset_not_fast,
+    load_test_prediction_dataset,
+    load_code_execution_dataset,
+)
+
+# BenchMarkType = list[CodeGenerationProblem | TestOutputPredictionProblem]
+BenchMarkType = list[
+    Union[CodeGenerationProblem, CodeExecutionProblem, TestOutputPredictionProblem]
+]
+
+
+def build_prompt_benchmark(
+    args,
+) -> tuple[
+    list[CodeExecutionProblem]
+    | list[CodeGenerationProblem]
+    | list[TestOutputPredictionProblem],
+    callable,
+]:
+    scenario: Scenario = args.scenario
+
+    if scenario == Scenario.codegeneration:
+        not_fast: bool = args.not_fast
+        if not_fast:
+            benchmark = load_code_generation_dataset_not_fast(args.release_version)
+        else:
+            benchmark = load_code_generation_dataset(
+                args.release_version,
+                start_date=args.start_date,
+                end_date=args.end_date
+            )
+        benchmark = sorted(benchmark, key=lambda x: x.question_id)
+        format_prompt = format_prompt_generation
+    elif scenario == Scenario.testoutputprediction:
+        benchmark = load_test_prediction_dataset(args.release_version)
+        benchmark = sorted(benchmark, key=lambda x: (x.question_id, x.test_id))
+        format_prompt = format_prompt_test_output
+    elif scenario == Scenario.selfrepair:
+        benchmark = load_code_generation_dataset(args.release_version)
+        benchmark = sorted(benchmark, key=lambda x: x.question_id)
+        format_prompt = format_prompt_self_repair
+    elif scenario == Scenario.codeexecution:
+        cot_code_execution: bool = args.cot_code_execution
+        benchmark = load_code_execution_dataset(args.release_version)
+        benchmark = sorted(benchmark, key=lambda x: int(x.id.split("_")[1]))
+        if cot_code_execution:
+            format_prompt = format_prompt_execution_cot
+        else:
+            format_prompt = format_prompt_execution
+    else:
+        raise ValueError(f"Scenario {scenario} not implemented")
+    return benchmark, format_prompt
+
+
+def combine_results(
+    scenario: Scenario,
+    results: list[list[str]],
+    model: LanguageModel,
+    cot_code_execution: bool = False,
+):
+    if scenario == Scenario.codegeneration:
+        combined_results = [
+            (
+                outputs_list,
+                [extract_code(output, model.model_style) for output in outputs_list],
+            )
+            for outputs_list in results
+        ]
+    elif scenario == Scenario.testoutputprediction:
+        combined_results = [
+            (
+                outputs_list,
+                [
+                    extract_test_output_code(output, model.model_style)
+                    for output in outputs_list
+                ],
+            )
+            for outputs_list in results
+        ]
+    elif scenario == Scenario.selfrepair:
+        combined_results = [
+            (
+                [
+                    output[0] if type(output) is list else output
+                    for output in outputs_list
+                ],
+                [
+                    (
+                        extract_code(output[0], model.model_style)
+                        if type(output) is list
+                        else extract_code(output, model.model_style)
+                    )
+                    for output in outputs_list
+                ],
+            )
+            for outputs_list in results
+        ]
+    elif scenario == Scenario.codeexecution:
+        combined_results = [
+            (
+                outputs_list,
+                [
+                    extract_execution_code(
+                        output, model.model_style, cot=cot_code_execution
+                    )
+                    for output in outputs_list
+                ],
+            )
+            for outputs_list in results
+        ]
+    else:
+        raise ValueError(f"Scenario {scenario} not implemented")
+
+    return combined_results
+
+
+def sort_and_extract_save_results(scenario: Scenario, save_results: list[dict]):
+    if scenario == Scenario.codegeneration:
+        save_results = sorted(save_results, key=lambda x: x["question_id"])
+        combined_results = [
+            (save_result_instance["output_list"], save_result_instance["code_list"])
+            for save_result_instance in save_results
+        ]
+
+    elif scenario == Scenario.testoutputprediction:
+        save_results = sorted(
+            save_results, key=lambda x: (x["question_id"], x["test_id"])
+        )
+        combined_results = [
+            (save_result_instance["output_list"], save_result_instance["pred_list"])
+            for save_result_instance in save_results
+        ]
+    elif scenario == Scenario.selfrepair:
+        save_results = sorted(save_results, key=lambda x: x["question_id"])
+        combined_results = [
+            (save_result_instance["output_list"], save_result_instance["code_list"])
+            for save_result_instance in save_results
+        ]
+    elif scenario == Scenario.codeexecution:
+        save_results = sorted(save_results, key=lambda x: int(x["id"].split("_")[1]))
+        combined_results = [
+            (save_result_instance["output_list"], save_result_instance["pred_list"])
+            for save_result_instance in save_results
+        ]
+
+    else:
+        raise ValueError(f"Scenario {scenario} not implemented")
+
+    return save_results, combined_results
+
+
+def get_metrics(
+    scenario: Scenario,
+    args,
+    benchmark: list[
+        CodeGenerationProblem | CodeExecutionProblem | TestOutputPredictionProblem
+    ],
+    combined_results,
+):
+    eval_samples = [instance.get_evaluation_sample() for instance in benchmark]
+    generations = [extracted for _, extracted in combined_results]
+
+    if scenario == Scenario.codegeneration or scenario == Scenario.selfrepair:
+        metrics = codegen_metrics(
+            eval_samples,
+            generations,
+            num_process_evaluate=args.num_process_evaluate,
+            timeout=args.timeout,
+        )
+
+    elif args.scenario == Scenario.testoutputprediction:
+        metrics = test_output_metrics(
+            eval_samples,
+            generations,
+            k_list=[1, 5],
+        )
+
+    elif args.scenario == Scenario.codeexecution:
+        metrics = code_execution_metrics(
+            eval_samples,
+            generations,
+        )
+
+    else:
+        raise ValueError(f"Scenario {scenario} not implemented")
+
+    print(metrics[0]["pass@1"])
+
+    return metrics

lcb_runner/runner/together_runner.py

@@ -0,0 +1,53 @@
+import os
+from time import sleep
+
+try:
+    from together import Together
+except ImportError as e:
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+class TogetherAIRunner(BaseRunner):
+    client = Together(api_key=os.getenv("TOGETHER_API_KEY"))
+
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        self.client_kwargs: dict[str | str] = {
+            "model": args.model,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "top_p": args.top_p,
+            "frequency_penalty": 0,
+            "presence_penalty": 0,
+            "n": 1,
+        }
+
+    def _run_single(self, prompt: tuple[dict[str,str], str]) -> list[str]:
+
+        def __run_single(counter):
+            try:
+                response = self.client.chat.completions.create(
+                    messages=prompt,
+                    **self.client_kwargs,
+                )
+                content = response.choices[0].message.content
+                return content
+            except Exception as e:
+                print("Exception: ", repr(e), "Sleeping for 20 seconds...")
+                sleep(20 * (11 - counter))
+                counter = counter - 1
+                if counter == 0:
+                    print(f"Failed to run model for {prompt}!")
+                    print("Exception: ", repr(e))
+                    raise e
+                return __run_single(counter)
+            
+        outputs = []
+        try:
+            for _ in range(self.args.n):
+                outputs.append(__run_single(10))
+        except Exception as e:
+            raise e
+
+        return outputs

lcb_runner/runner/vllm_runner.py

@@ -0,0 +1,63 @@
+try:
+    from transformers import AutoTokenizer
+    from vllm import LLM, SamplingParams
+except ImportError as e:
+    # print("Cannot import vllm")
+    pass
+
+from lcb_runner.runner.base_runner import BaseRunner
+
+
+class VLLMRunner(BaseRunner):
+    def __init__(self, args, model):
+        super().__init__(args, model)
+        model_tokenizer_path = (
+            model.model_name if args.local_model_path is None else args.local_model_path
+        )
+        self.llm = LLM(
+            model=model_tokenizer_path,
+            tokenizer=model_tokenizer_path,
+            tensor_parallel_size=args.tensor_parallel_size,
+            dtype=args.dtype,
+            enforce_eager=True,
+            disable_custom_all_reduce=True,
+            enable_prefix_caching=args.enable_prefix_caching,
+            trust_remote_code=args.trust_remote_code,
+        )
+        self.sampling_params = SamplingParams(
+            n=self.args.n,
+            max_tokens=self.args.max_tokens,
+            temperature=self.args.temperature,
+            top_p=self.args.top_p,
+            frequency_penalty=0,
+            presence_penalty=0,
+            stop=self.args.stop,
+        )
+
+    def _run_single(self, prompt: str) -> list[str]:
+        pass
+
+    def run_batch(self, prompts: list[str]) -> list[list[str]]:
+        outputs = [None for _ in prompts]
+        remaining_prompts = []
+        remaining_indices = []
+        for prompt_index, prompt in enumerate(prompts):
+            if self.args.use_cache and prompt in self.cache:
+                if len(self.cache[prompt]) == self.args.n:
+                    outputs[prompt_index] = self.cache[prompt]
+                    continue
+            remaining_prompts.append(prompt)
+            remaining_indices.append(prompt_index)
+        if remaining_prompts:
+            vllm_outputs = self.llm.generate(remaining_prompts, self.sampling_params)
+            if self.args.use_cache:
+                assert len(remaining_prompts) == len(vllm_outputs)
+                for index, remaining_prompt, vllm_output in zip(
+                    remaining_indices, remaining_prompts, vllm_outputs
+                ):
+                    self.cache[remaining_prompt] = [o.text for o in vllm_output.outputs]
+                    outputs[index] = [o.text for o in vllm_output.outputs]
+            else:
+                for index, vllm_output in zip(remaining_indices, vllm_outputs):
+                    outputs[index] = [o.text for o in vllm_output.outputs]
+        return outputs