code: def check_correctness(
      problem: Dict,
      completion: str,
      timeout: float,
      completion_id: Optional[int] = None,
  ) -> Dict:
      """
      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.
      """
  
      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 = (
                  problem["prompt"]
                  + "    "
                  + completion
                  + "\n"
                  + problem["test"]
                  + "\n"
                  + f"check({problem['entry_point']})"
              )
  
              try:
                  exec_globals = {}
                  with swallow_io():
                      with time_limit(timeout):
                          # WARNING
                          # This program exists to execute untrusted model-generated code. Although
                          # it is highly unlikely that model-generated code will do something overtly
                          # malicious in response to this test suite, model-generated code may act
                          # destructively due to a lack of model capability or alignment.
                          # Users are strongly encouraged to sandbox this evaluation suite so that it
                          # does not perform destructive actions on their host or network. For more
                          # information on how OpenAI sandboxes its code, see the accompanying paper.
                          # Once you have read this disclaimer and taken appropriate precautions,
                          # uncomment the following line and proceed at your own risk:
                          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: List[str] = 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=problem["task_id"],
          passed=result[0] == "passed",
          result=result[0],
          completion_id=completion_id,
      )
  
imports: import contextlib
  import gc
  from enum import Enum
  import faulthandler
  import io
  from io import StringIO
  import json
  import multiprocessing
  import os
  import platform
  import signal
  import sys
  import tempfile
  from typing import List, Union, Dict, Optional
  from unittest.mock import patch, mock_open
  import numpy
  from pyext import RuntimeModule
  from helm.common.hierarchical_logger import hlog
label_desc: Use image node_id 6 for calling a global function with example usage: check_correctness(problem, completion, timeout, completion_id) and returns: dict