Advanced Wrapper: Python with Input

Using a cunning trade secret, the Scratchpad can be used to run code that uses the Python input() function. You enter the response to a prompt into an entry field and type Enter to proceed. [Yeah, OK, it's actually a hack. But our students haven't noticed yet, so it's a workable hack.]

The 'cunning trade secret' is to re-run the program each time an additional input is required with an expanding list of known inputs, i.e. collect one input, rerun program with that input and all the prevouis inputs, repeat until no more inputs. The hack in more detail follows (when using the recommended "json" output display mode):

1. Set stdin to be an empty string.
   
2. Run the program as normal until stdin is required.
   
3. If stdin, exit with the error code 42.
   • Setting returncode to 42 will add an input field to the end of the output, when in the json output display mode.
     
   • When enter is pressed inside the input field the value inside will be appended to the run stdin and the program is run again..
4. Repeat steps 2-4 until the program completes without error code 42.
   

Listed below is a simplified version of the wrapper used in this question (with restrictions on output size left out).

Note: because answer_code and test_code are inserted inside a multi-line string we must escape all double-quotes (") before insertion into the wrapper. To do this we must set the UI parameter escape to true.

import sys, io, subprocess, ast, traceback, json

student_code = """
{| ANSWER_CODE |}
{| SCRATCHPAD_CODE |}
"""

subproc_code = """
import sys

__saved_input__ = input

def input(prompt=''):
    try:
        line = __saved_input__()
    except EOFError:
        print(prompt, end = '')
        sys.stderr.flush()
        sys.stdout.flush()
        sys.exit(42)
    print(prompt, end='')
    print(line)
    return line

"""

subproc_code += student_code

def check_syntax():
    try:
        ast.parse(student_code)
        return ''
    except SyntaxError:
        catcher = io.StringIO()
        traceback.print_exc(limit=0, file=catcher)
        return catcher.getvalue()

stdout = ''
stderr = check_syntax()
if stderr == '':  # No syntax errors
    program_code = subproc_code
    with open('prog.py', 'w') as outfile:
        outfile.write(program_code)
    proc = subprocess.Popen([sys.executable, 'prog.py'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    try:
        stdout, stderr = proc.communicate(timeout=3)
        returncode = proc.returncode
    except subprocess.TimeoutExpired:
        proc.kill()
        stdout, stderr = proc.communicate()
        returncode = 13
else:
    returncode = 1 # Syntax errors

output = {
    'returncode': returncode,
    'stdout' : stdout,
    'stderr' : stderr,
    'files'  : [],
}

print(json.dumps(output))

Listed below is the embedded Python code from subproc_code:

import sys
__saved_input__ = input

def input(prompt=''):
    try:
        line = __saved_input__()
    except EOFError:
        print(prompt, end = '')
        sys.stderr.flush()
        sys.stdout.flush()
        sys.exit(42)
    print(prompt, end='')
    print(line)
    return line

Question Specification

Write a function get_int(low, high) that asks the user to enter an integer in the range low to high inclusive. If an out-of-bounds answer is entered, the user is given an error message and reprompted. You may assume that only ints are entered (to simplify, so we don't have to deal with exceptions).

In this example, the answer box has been preloaded with a correct answer to the question, the scratchpad has been reloaded with the first test -- to see it in action click Run.