vimgolf_gym.vimgolf

  1"""
  2Vimgolf API wrapper
  3"""
  4
  5# TODO: convert vimgolf keys to terminal input string, and convert terminal input string to vimgolf keys
  6# TODO: figure out if the vim -w recorded things are the same as terminal input string
  7
  8# TODO: figure out the action space of all three input representations
  9
 10import argparse
 11import json
 12import logging
 13import typing
 14from vimgolf_gym._vimrc import (
 15    _CYBERGOD_VIMGOLF_VIMRC_FILEPATH,
 16    _prepare_cybergod_vimrc_with_buffer_file,
 17    _VIMGOLF_VIMRC_FILEPATH,
 18)
 19
 20from vimgolf.vimgolf import (
 21    IGNORED_KEYSTROKES,
 22    Challenge,
 23    Result,
 24    Status,
 25    VimRunner,
 26    filecmp,
 27    format_,
 28    get_challenge_url,
 29    get_keycode_repr,
 30    input_loop,
 31    logger,
 32    os,
 33    parse_keycodes,
 34    sys,
 35    tempfile,
 36    tokenize_keycode_reprs,
 37    upload_result,
 38    working_directory,
 39    write,
 40)
 41
 42
 43def parse_commandline_arguments():
 44    """
 45    Parse the command line arguments using argparse.
 46
 47    Args:
 48        None
 49
 50    Returns:
 51        A Namespace object with the parsed arguments.
 52
 53    The parsed arguments are:
 54        - --input_file: str, the path to the input file
 55        - --output_file: str, the path to the output file
 56        - --log_file: str, the path to the log file
 57        - --buffer_file: str, the path to the buffer file
 58        - --init_keys: str, the initial keys to type into Vim
 59    """
 60
 61    parser = argparse.ArgumentParser()
 62    parser.add_argument("--input_file", type=str, required=True)
 63    parser.add_argument("--output_file", type=str, required=True)
 64    parser.add_argument("--log_file", type=str, required=True)
 65    parser.add_argument("--buffer_file", type=str, default=None)
 66    parser.add_argument("--init_keys", type=str, default="")
 67    args = parser.parse_args()
 68    return args
 69
 70
 71def main():
 72    """
 73    Parse command line arguments and execute the vimgolf local challenge.
 74
 75    It sets up the logging to a file and then calls the local function to execute
 76    the challenge.
 77
 78    The local function is called with the input file, output file, buffer file and init keys.
 79
 80    """
 81    args = parse_commandline_arguments()
 82    log_file = args.log_file
 83    file_handler = logging.FileHandler(log_file)
 84    file_handler.setLevel(logging.DEBUG)
 85    logger.addHandler(file_handler)
 86    if args.buffer_file:
 87        local(
 88            infile=args.input_file,
 89            outfile=args.output_file,
 90            buffer_file=args.buffer_file,
 91            init_keys=args.init_keys,
 92        )
 93    else:
 94        local(
 95            infile=args.input_file,
 96            outfile=args.output_file,
 97            init_keys=args.init_keys,
 98        )
 99
100
101def local(
102    infile: str, outfile: str, buffer_file: typing.Optional[str] = None, init_keys=""
103):
104    """
105    Execute a local VimGolf challenge.
106
107    It reads the input file, output file, and runs the challenge. The challenge
108    is defined by the input and output text and the file extensions.
109
110    Args:
111        infile: str, the path to the input file
112        outfile: str, the path to the output file
113        init_keys: str, the initial keys to type into Vim
114        buffer_file: typing.Optional[str]: Where to write the vim editor buffer. Defaults to None.
115
116    Returns:
117        Status: The status of the challenge
118    """
119    logger.info("local(%s, %s)", infile, outfile)
120    with open(infile, "r") as f:
121        in_text = format_(f.read())
122    with open(outfile, "r") as f:
123        out_text = format_(f.read())
124    _, in_extension = os.path.splitext(infile)
125    _, out_extension = os.path.splitext(outfile)
126    challenge = Challenge(
127        in_text=in_text,
128        out_text=out_text,
129        in_extension=in_extension,
130        out_extension=out_extension,
131        id=None,
132        compliant=None,
133        api_key=None,
134        init_keys=init_keys,
135    )
136    status = play(challenge, buffer_file=buffer_file)
137    return status
138
139
140def play(challenge, results=None, buffer_file: typing.Optional[str] = None):
141    """
142    Execute a VimGolf challenge.
143
144    Args:
145        challenge: Challenge, the challenge to play
146        results: list of Result, the results of previous plays
147        buffer_file: typing.Optional[str]: Where to write the vim editor buffer. Defaults to None.
148
149    Returns:
150        Status: The status of the challenge
151    """
152    if results is None:
153        results = []
154    logger.info("play(...)")
155    with tempfile.TemporaryDirectory() as workspace, working_directory(workspace):
156        infile = "in"
157        if challenge.in_extension:
158            infile += challenge.in_extension
159        outfile = "out"
160        if challenge.out_extension:
161            outfile += challenge.out_extension
162        logfile = "log"
163        with open(outfile, "w") as f:
164            f.write(challenge.out_text)
165
166        try:
167            # If there were init keys specified, we need to convert them to a
168            # form suitable for feedkeys(). We can't use Vim's -s option since
169            # it takes escape codes, not key codes. See Vim #4041 and TODO.txt
170            # ("Bug: script written with "-W scriptout" contains Key codes,
171            # while the script read with "-s scriptin" expects escape codes").
172            # The conversion is conducted here so that we can fail fast on
173            # error (prior to playing) and to avoid repeated computation.
174            keycode_reprs = tokenize_keycode_reprs(challenge.init_keys)
175            init_feedkeys = []
176            for item in keycode_reprs:
177                if item == "\\":
178                    item = "\\\\"  # Replace '\' with '\\'
179                elif item == '"':
180                    item = '\\"'  # Replace '"' with '\"'
181                elif item.startswith("<") and item.endswith(">"):
182                    item = "\\" + item  # Escape special keys ("<left>" -> "\<left>")
183                init_feedkeys.append(item)
184            init_feedkeys = "".join(init_feedkeys)
185        except Exception:
186            logger.exception("invalid init keys")
187            write("Invalid keys: {}".format(challenge.init_keys), color="red")
188            return Status.FAILURE
189
190        write("Launching vimgolf session", color="yellow")
191        while True:
192            with open(infile, "w") as f:
193                f.write(challenge.in_text)
194            with open(outfile, "w") as f:
195                f.write(challenge.out_text)
196            if buffer_file:
197                _prepare_cybergod_vimrc_with_buffer_file(buffer_file)
198                vimrc = _CYBERGOD_VIMGOLF_VIMRC_FILEPATH
199            else:
200                vimrc = _VIMGOLF_VIMRC_FILEPATH
201            play_args = [
202                "-Z",  # restricted mode, utilities not allowed
203                "-n",  # no swap file, memory only editing
204                "--noplugin",  # no plugins
205                "-i",
206                "NONE",  # don't load .viminfo (e.g., has saved macros, etc.)
207                "+0",  # start on line 0
208                "-u",
209                vimrc,  # vimgolf .vimrc
210                "-U",
211                "NONE",  # don't load .gvimrc
212                "-W",
213                logfile,  # keylog file (overwrites existing)
214                '+call feedkeys("{}", "t")'.format(init_feedkeys),  # initial keys
215                infile,
216            ]
217            if VimRunner.run(play_args) != Status.SUCCESS:
218                return Status.FAILURE
219
220            correct = filecmp.cmp(infile, outfile, shallow=False)
221            logger.info("correct: %s", str(correct).lower())
222            with open(logfile, "rb") as _f:
223                # raw keypress representation saved by vim's -w
224                raw_keys = _f.read()
225
226            # list of parsed keycode byte strings
227            keycodes = parse_keycodes(raw_keys)
228            keycodes = [
229                keycode for keycode in keycodes if keycode not in IGNORED_KEYSTROKES
230            ]
231
232            # list of human-readable key strings
233            keycode_reprs = [get_keycode_repr(keycode) for keycode in keycodes]
234            logger.info("keys: %s", "".join(keycode_reprs))
235
236            score = len(keycodes)
237            logger.info("score: %d", score)
238
239            result = Result(correct=correct, keys="".join(keycode_reprs), score=score)
240            logger.info(
241                json.dumps(
242                    dict(
243                        event_type="vimgolf_result",
244                        event_data=dict(
245                            correct=correct, keys="".join(keycode_reprs), score=score
246                        ),
247                    )
248                )
249            )
250            results.append(result)
251
252            write("Here are your keystrokes:", color="green")
253            for keycode_repr in keycode_reprs:
254                color = "magenta" if len(keycode_repr) > 1 else None
255                write(keycode_repr, color=color, end=None)
256            write("")
257
258            if correct:
259                write("Success! Your output matches.", color="green")
260                write("Your score:", color="green")
261            else:
262                write(
263                    "Uh oh, looks like your entry does not match the desired output.",
264                    color="red",
265                )
266                write("Your score for this failed attempt:", color="red")
267            write(score)
268
269            upload_eligible = challenge.id and challenge.compliant and challenge.api_key
270
271            while True:
272                # Generate the menu items inside the loop since it can change across iterations
273                # (e.g., upload option can be removed)
274                with open(infile, "w") as f:
275                    f.write(challenge.in_text)
276                with open(outfile, "w") as f:
277                    f.write(challenge.out_text)
278                menu = []
279                if not correct:
280                    menu.append(("d", "Show diff"))
281                if upload_eligible and correct:
282                    menu.append(("w", "Upload result"))
283                menu.append(("r", "Retry the current challenge"))
284                menu.append(("q", "Quit vimgolf"))
285                valid_codes = [x[0] for x in menu]
286                for option in menu:
287                    write("[{}] {}".format(*option), color="yellow")
288                selection = input_loop("Choice> ")
289                if selection not in valid_codes:
290                    write(
291                        "Invalid selection: {}".format(selection),
292                        stream=sys.stderr,
293                        color="red",
294                    )
295                elif selection == "d":
296                    # diffsplit is used instead of 'vim -d' to avoid the "2 files to edit" message.
297                    diff_args = [
298                        "-n",
299                        outfile,
300                        "-c",
301                        "vertical diffsplit {}".format(infile),
302                    ]
303                    if VimRunner.run(diff_args) != Status.SUCCESS:
304                        return Status.FAILURE
305                elif selection == "w":
306                    upload_status = upload_result(
307                        challenge.id, challenge.api_key, raw_keys
308                    )
309                    if upload_status == Status.SUCCESS:
310                        write("Uploaded entry!", color="green")
311                        leaderboard_url = get_challenge_url(challenge.id)
312                        write(
313                            "View the leaderboard: {}".format(leaderboard_url),
314                            color="green",
315                        )
316                        upload_eligible = False
317                    else:
318                        write(
319                            "The entry upload has failed",
320                            stream=sys.stderr,
321                            color="red",
322                        )
323                        message = "Please check your API key on vimgolf.com"
324                        write(message, stream=sys.stderr, color="red")
325                else:
326                    break
327            if selection == "q":
328                break
329            write("Retrying vimgolf challenge", color="yellow")
330
331        write("Thanks for playing!", color="green")
332        return Status.SUCCESS
333
334
335if __name__ == "__main__":
336    main()