utils.py

import pexpect
import json_stream
import json

MACOS = 'MacOS'
LINUX = 'Linux'
OS = LINUX #MACOS
LEAN_REPL_CMD = 'lake env ../repl/.lake/build/bin/repl'
SHELL_CMD = '/bin/sh' if OS == MACOS else '/bin/bash'  #zsh doesn't play well with non-canonical input: https://github.com/samapriya/geeup/issues/41
BASE_PATH = 'LeanSrc/LeanSrc'

def make_lean_repl(repl_type='zsh'):
    # there are maximum line lengths that can be sent over tty, this will cause some things we send to 
    # lean repl to be cut off at e.g. 1024 characters for MacOS unless we use this workaround.
    # See https://pexpect.readthedocs.io/en/stable/api/pexpect.html#pexpect.spawn.send
    print('making repl')
    if repl_type == 'icanon':
        lean_repl = pexpect.spawn(SHELL_CMD, cwd='LeanSrc', maxread=5000, timeout=20, echo=False)
        lean_repl.sendline('stty -icanon') # this is the magic that allows a bunch of chars to be sent
        lean_repl.sendline(LEAN_REPL_CMD)
        if OS == MACOS:
            print(lean_repl.readline()) # my mac prints out some garbage when I run /bin/sh
            print(lean_repl.readline())
    elif repl_type == 'zsh':
        lean_repl = pexpect.spawn(LEAN_REPL_CMD,cwd='LeanSrc', maxread=1025, timeout=5)

    return lean_repl

# To reliably read multiple json objects from a single byte string where the objects are 
# separated by newlines but the content also contains newlines, we treat the byte string
# as a stream using the json-stream python library, and consume from the stream repeatedly until
# we reach the end of the byte array. 
#
# The simplest thing to do is just feed json-stream the byte array one byte at a time, but this
# produces errors due to multi-byte unicode characters being split. So, we solve this in another
# simple way: produce chunks up to and including the next '}' byte. This makes sure weird byte sequences
# get sent together and thus decoded correctly.
def json_stream_itr(bstr):
    start = 0
    for end in range(len(bstr)):
        #print(bstr[end:end+1], b'}')
        if bstr[end:end+1] == b'}':
            yield bstr[start: end + 1]
            start = end + 1

def load_mult_json(jsons):
    #NOTE: when using the non-canonical input mode and /bin/sh to spawn lean repl,
    # sometimes multiple json lines get output! I collect them all into a single 
    # dictionary to return.
    itr = json_stream_itr(jsons)
    ps_out = {'messages': []}
    while True:
        try:
            data = json_stream.load(itr, persistent=True)
        except StopIteration:
            break
        data.read_all()
        data = json_stream.to_standard_types(data)
        for k in data:
            # special case: for some reason when their is a single message the key is not plural, and 
            # is just a string, which is a problem for later when I try to look at the error severity.
            if k == 'message': 
                if data[k].strip().startswith('Lean error:'):
                    dct = {'severity': 'error', 'data': data[k].replace('Lean error:', '')}
                else:
                    dct = {'severity': 'warning', 'data': data[k]}
                    print('got unexpected non-error message', dct) #TODO: if these don't occur in practice we can delete this
                    exit()
                ps_out['messages'].append(dct)
            elif isinstance(data[k], list) and k in ps_out:
                ps_out[k].extend(data[k])
            else:
                assert k not in ps_out, k +',' +str(ps_out[k])
                ps_out[k] = data[k]
        #ps_out = json_stream.to_standard_types(ps_out)
        #print('yo', ps_out)

    #ps_out = json.loads(output)
    assert ps_out is not None, 'parsing failed: ' + jsons.decode()
    #print('parsed output:', ps_out)
    return ps_out

def make_repl_command(def_str, env=None):
    jsn = {'cmd': def_str}
    if env is not None:
        jsn['env'] = env
    return json.dumps(jsn)

# This is the standard way to send commands to lean repl using most normal shells in canonical input mode.
# unfortunately, in canonical input mode there is a maximum character limit that can be sent over terminal:
# see https://pexpect.readthedocs.io/en/stable/api/pexpect.html#pexpect.spawn.send for more details.
# unfortunately this can't be solved by just chunking up the message to send; we're not sure why, but 
# lean repl stubbornly insists it has only received the first 1024 (on Mac) characters. 
#
# you can use send_command_icanon to handle sending longer strings, although we have found that the messages
# lean repl sends change for some reason, causing some inconsistencies in how we parse successful or failed proofs.
def send_command_zsh(repl, command, env=None, timeout=5, first=False):
    rpl_comm = make_repl_command(command, env=env)
    #print(rpl_comm)
    """
    num_splits = len(rpl_comm)//1024 + 1
    for split in range(num_splits):
    #print(rpl_comm) # NOTE: uncomment to see everything being sent to lean repl
        spl_comm = rpl_comm[split*1024:(split+1)*1024]
        print(spl_comm)
        
        #print('sent and expecting:')
        #print(len(rpl_comm), rpl_comm)
        if split < num_splits - 1:
            repl.sendline(spl_comm)
        else:
            repl.sendline(spl_comm)
            repl.expect_exact(rpl_comm+'\r\n')
    """
    #print(repl.readline())
    #repl.sendline()
    #repl.expect_exact('\r\n')
    #print('sup', repl.readline())
    repl.sendline(rpl_comm)
    repl.expect_exact(rpl_comm + '\r\n')

    repl.sendline()
    repl.expect_exact('\r\n')

    _index = repl.expect('env": \d+\}', timeout=timeout)
    env_str = repl.match.group().decode()
    new_env = int(env_str.split(':')[1].strip()[:-1])
    output = repl.before + repl.match.group()
    #print('js outp', output)
    return load_mult_json(output), new_env


def send_command_icanon(repl, command, env=None, timeout=20, first=False):
    #print('sending command:', command)
    rpl_comm = make_repl_command(command, env=env)
        
    repl.sendline(rpl_comm + '\n')
    if OS == MACOS:
        if first:
            repl.expect_exact('~>')
            first = False
        else:
            try:
                repl.expect_exact('\r\n\r\n')
            except pexpect.exceptions.TIMEOUT as e:
                print('did not find newlines')
    elif OS == LINUX and first:
        repl.expect_exact('\r{')
    try:
        _index = repl.expect('env": \d+\}', timeout=60)
        command_sent = True
    except pexpect.exceptions.TIMEOUT as e:
        raise(e)
        print('did not find env in output')
        return None, None
        
    env_str = repl.match.group().decode()
    new_env = int(env_str.split(':')[1].strip()[:-1])
    output = repl.before + repl.match.group()
    if OS == LINUX and first:
        output = '{'.encode() + output
    return load_mult_json(output), new_env

def make_repl_tactic(tac, proofState):
    return json.dumps({'tactic': tac, 'proofState': proofState})

def send_tactic(repl, tactic, proofState):
    rpl_comm = make_repl_tactic(tactic, proofState)

    #repl.sendline(rpl_comm)
    #repl.expect_exact(rpl_comm + "\r\n")
    #repl.sendline()
    #repl.expect_exact("\r\n")
    repl.sendline(rpl_comm+'\n')
    
    # the icanon mode sometimes sends a single dict with just one field: 'message'.
    # when we get that with a lean error, the tactic failed so we return None
    _index = repl.expect('(]})|(\"}\r\n\r\n)', timeout=60)


    #ps_str = repl.match.group().decode()
    #new_ps = int(ps_str.split(':')[1].strip()[:-1])
    output = repl.before + repl.match.group()
    #if verbose: 
    #print('js outp 2', output)
    ps_out = load_mult_json(output)
    #print('ps out', ps_out)
    if 'proofState' not in ps_out:
        return None, None
    return ps_out, ps_out['proofState']
    #except pexpect.exceptions.TIMEOUT:
    #    print("FAILED DUE TO TIMEOUT")
    #    return None, None

def get_errs(outp):
    return [m for m in outp.get('messages', []) if m.get('severity', 'error') == 'error']