# Copyright (c) Microsoft Corporation. # Licensed under the MIT license. # Copied from CodeT (https://github.com/microsoft/CodeT/tree/main/CodeT) from typing import Optional, Dict import contextlib import faulthandler import io import os import multiprocessing import platform import signal import tempfile def _pack_test_cases_assert(test_cases, timeout): blank_4 = ' ' * 4 blank_8 = ' ' * 8 blank_12 = ' ' * 12 result = f'def check():\n pass_result = []\n' for idx, tc in enumerate(test_cases): multi_line_assertion = tc.strip().replace('\n', f'\n{blank_12}') result += f'\n{blank_4}try:\n{blank_8}with time_limit({timeout}):\n{blank_12}{multi_line_assertion}\ \n{blank_12}pass_result.append(True)\n{blank_4}except Exception as e:\n{blank_8}pass_result.append(False)\n' result += '\n return pass_result\n' result += f'\nglobal final_result\nfinal_result = check()' return result def _pack_test_cases(test_cases, entry_point, timeout, multi_args=False): result = "test_cases = " + str(test_cases) if multi_args: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): output = {entry_point}(*eval(tc['input'])) pass_result.append(output == eval(tc['output'])) except Exception as e: pass_result.append(False) return pass_result global final_result final_result = check() """ else: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): output = {entry_point}(eval(tc['input'])) pass_result.append(output == eval(tc['output'])) except Exception as e: pass_result.append(False) return pass_result global final_result final_result = check() """ return result def _pack_test_cases_for_spec(test_cases, timeout, multi_args=False): result = "test_cases = " + str(test_cases) if multi_args: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): preconditions(*eval(tc['input'])) postconditions(*eval(tc['input']), eval(tc['output'])) pass_result.append(True) except Exception as e: pass_result.append(False) return pass_result global final_result final_result = check() """ else: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): preconditions(eval(tc['input'])) postconditions(eval(tc['input']), eval(tc['output'])) pass_result.append(True) except Exception as e: pass_result.append(False) return pass_result global final_result final_result = check() """ return result def _pack_spec_and_casual_inputs(casual_inputs, entry_point, timeout, multi_args=False): result = "casual_inputs = " + str(casual_inputs) if multi_args: result += f""" def check(): pass_result = [] for ci in casual_inputs: try: with time_limit({timeout}): output = {entry_point}(*ci) postconditions(*ci, output) pass_result.append(True) except Exception as e: pass_result.append(False) continue return pass_result global final_result final_result = check() """ else: result += f""" def check(): pass_result = [] for ci in casual_inputs: try: with time_limit({timeout}): output = {entry_point}(ci) postconditions(ci, output) pass_result.append(True) except Exception as e: pass_result.append(False) continue return pass_result global final_result final_result = check() """ return result def _pack_spec_and_test_cases(test_cases, entry_point, timeout, multi_args=False): result = "test_cases = " + str(test_cases) if multi_args: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): output = {entry_point}(*tc['input']) except Exception as e: pass_result.append(False) continue try: with time_limit({timeout}): postconditions(*tc['input'], output) pass_result.append(True) except Exception as e: pass_result.append(output == tc['output']) return pass_result global final_result final_result = check() """ else: result += f""" def check(): pass_result = [] for tc in test_cases: try: with time_limit({timeout}): output = {entry_point}(tc['input']) except Exception as e: pass_result.append(False) continue try: with time_limit({timeout}): postconditions(tc['input'], output) pass_result.append(True) except Exception as e: pass_result.append(output == tc['output']) return pass_result global final_result final_result = check() """ return result def check_correctness_with_test_cases(task_id, prompt, completion, test_cases, entry_point, timeout, multi_args, assert_format): """ Evaluates the functional correctness of a solution_content by running the test suite provided in the problem. """ extend_timeout = timeout*len(test_cases) def unsafe_execute(): 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() # Construct the check program and run it. if assert_format: check_program = ( prompt + completion + "\n" + _pack_test_cases_assert(test_cases, timeout) ) else: check_program = ( prompt + completion + "\n" + _pack_test_cases(test_cases, entry_point, timeout, multi_args) ) # print(check_program) try: exec_globals = {'time_limit': time_limit} with swallow_io(): exec(check_program, exec_globals) result.append(exec_globals['final_result']) except TimeoutException: result.append([False for _ in test_cases]) reason.append("timed out") except BaseException as e: result.append([False for _ in test_cases]) reason.append(f"failed: {e}") # Needed for cleaning up. shutil.rmtree = rmtree os.rmdir = rmdir os.chdir = chdir manager = multiprocessing.Manager() result = manager.list() reason = manager.list() # unsafe_execute() p = multiprocessing.Process(target=unsafe_execute) p.start() p.join(timeout=extend_timeout + 0.1) if p.is_alive(): p.kill() if not result: result.append([False for _ in test_cases]) reason.append("Unknown error") return dict( task_id=task_id, code=completion, result=result[0], fail_reason=reason[0] if len(reason) > 0 else None ) def check_spec_with_test_cases(task_id, prompt, spec, test_cases, timeout, multi_args=False): """ Evaluates the a spec by running the test cases. """ extend_timeout = timeout*len(test_cases) def unsafe_execute(): 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() # Construct the check program and run it. check_program = ( prompt + spec + "\n" + _pack_test_cases_for_spec(test_cases, timeout, multi_args=multi_args) ) try: exec_globals = {'time_limit': time_limit} with swallow_io(): exec(check_program, exec_globals) result.append(exec_globals['final_result']) except TimeoutException: result.append([False for _ in test_cases]) reason.append("timed out") except BaseException as e: result.append([False for _ in test_cases]) reason.append(f"failed: {e}") # Needed for cleaning up. shutil.rmtree = rmtree os.rmdir = rmdir os.chdir = chdir manager = multiprocessing.Manager() result = manager.list() reason = manager.list() # unsafe_execute() p = multiprocessing.Process(target=unsafe_execute) p.start() p.join(timeout=extend_timeout + 0.1) if p.is_alive(): p.kill() if not result: result.append([False for _ in test_cases]) reason.append("Unknown error") return dict( task_id=task_id, spec=spec, result=result[0], fail_reason=reason[0] if len(reason) > 0 else None ) def check_with_specs_and_casual_inputs(task_id, prompt, solution, spec, casual_inputs, entry_point, timeout, multi_args=False): """ Evaluates the solution by running the test cases. """ extend_timeout = timeout*len(casual_inputs) def unsafe_execute(): 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(maximum_memory_bytes=4 * 1024 * 1024 * 1024) # Construct the check program and run it. check_program = ( prompt + solution + "\n" + spec + "\n" + _pack_spec_and_casual_inputs(casual_inputs, entry_point, timeout, multi_args=multi_args) ) try: exec_globals = {'time_limit': time_limit} with swallow_io(): exec(check_program, exec_globals) result.append(exec_globals['final_result']) except TimeoutException: result.append([False for _ in casual_inputs]) reason.append("timed out") except BaseException as e: result.append([False for _ in casual_inputs]) reason.append(f"failed: {e}") # Needed for cleaning up. shutil.rmtree = rmtree os.rmdir = rmdir os.chdir = chdir manager = multiprocessing.Manager() result = manager.list() reason = manager.list() # unsafe_execute() p = multiprocessing.Process(target=unsafe_execute) p.start() p.join(timeout=extend_timeout + 0.1) if p.is_alive(): p.kill() if not result: reason.append("Unknown error") result.append([False for _ in casual_inputs]) return dict( task_id=task_id, solution=solution, spec=spec, result=result[0], fail_reason=reason[0] if len(reason) > 0 else None ) def check_with_specs_and_test_cases(task_id, prompt, solution, spec, test_cases, entry_point, timeout, multi_args=False): """ Evaluates the solution by running the test cases. """ extend_timeout = timeout*len(test_cases) def unsafe_execute(): 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(maximum_memory_bytes=4 * 1024 * 1024 * 1024) # Construct the check program and run it. check_program = ( prompt + solution + "\n" + spec + "\n" + _pack_spec_and_test_cases(test_cases, entry_point, timeout, multi_args=multi_args) ) try: exec_globals = {'time_limit': time_limit} with swallow_io(): exec(check_program, exec_globals) result.append(exec_globals['final_result']) 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 manager = multiprocessing.Manager() result = manager.list() p = multiprocessing.Process(target=unsafe_execute) p.start() p.join(timeout=extend_timeout + 0.1) if p.is_alive(): p.kill() if not result: result.append("timed out") return dict( task_id=task_id, solution=solution, spec=spec, result=result[0] ) def check_correctness(task_id: str, prompt: str, completion: str, test: str, entry_point: str, timeout: float) -> Dict: """ Evaluates the functional correctness of a completion by running the test suite provided in the problem. """ def unsafe_execute(): 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() # Construct the check program and run it. check_program = ( prompt + completion + "\n" + test + "\n" + f'check({entry_point})' ) 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 manager = multiprocessing.Manager() result = manager.list() p = multiprocessing.Process(target=unsafe_execute) p.start() p.join(timeout=timeout+1) if p.is_alive(): p.kill() if not result: result.append("timed out") return dict( task_id=task_id, passed=result[0] == "passed", result=result[0], completion=completion, ) @contextlib.contextmanager def time_limit(seconds: float): 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 IOError def readline(self, *args, **kwargs): raise IOError def readlines(self, *args, **kwargs): raise IOError 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: Optional[int] = 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