mcy98's picture
Upload folder using huggingface_hub
d7ff85b verified
Raw History Blame Contribute Delete
19 kB
# 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