prompt with async_ doesn't clean up if cancelled

[bmerry]

I'm having some trouble with porting a REPL app (ntsh to prompt-toolkit 2.0. Mostly the new API is making things much simpler (thanks!), and instead of using an Application I'm now trying to use just PromptSession plus asyncio. Sometimes I want to terminate the app in response to a network event rather than user input. However, it seems that if the prompt future is cancelled, it doesn't restore normal terminal settings, and after exit characters aren't echoed.

Here's a minimal example case (tested with Ubuntu 18.04, Python 3.6, prompt-toolkit 2.0.7; also requires async_timeout). Just run it and wait 5 seconds for it to exit on its own, then observe that terminal echo is off.

#!/usr/bin/env python

import asyncio

import async_timeout
from prompt_toolkit.eventloop import use_asyncio_event_loop
from prompt_toolkit.shortcuts import prompt

async def main():
    try:
        with async_timeout.timeout(5):
            text = await prompt('> ', async_=True)
        print('You entered:', text)
    except asyncio.TimeoutError:
        print('Timed out')

use_asyncio_event_loop()
asyncio.get_event_loop().run_until_complete(main())

[jonathanslenders]

Hi @bmerry,

Thanks for pointing out this issue! I haven't had time yet to dig into this.
Cancellation is a difficult thing to get right. This is also one of the reasons I'd like to move to asyncio natively when dropping Python 2 support.

Thanks for the example as well! This is great for reproducing.

[jonathanslenders]

If I can suggest you one workaround. Instead of cancelling the coroutine/future like this, you can start a timer, and run
prompt_toolkit.application.get_app().set_exception(asyncio.TimeoutError) after the timeout.

[bmerry]

Thanks for the suggestion. I'm actually cancelling as part of exiting the app due to an external event rather than a timeout - using async_timeout was just the simplest way I could think of to write a minimal example - so I'd presumably set_result rather than set_exception. But I'd already written a workaround that uses asyncio.shield to prevent prompt() itself from being cancelled, and then called this to shut it down:

session.app.exit(result='', style='class:exiting')

Would you recommend your workaround over this, or should they both work?

[derekbrokeit]

I had a similar behavior as described by @bmerry. I attempted to force the application to exit as a fix, but this did not seem to work around the issues that I observed. The following test application demonstrates what I saw in a posix shell:

import asyncio
from prompt_toolkit import Application
from prompt_toolkit.buffer import Buffer
from prompt_toolkit.layout.containers import Window
from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
from prompt_toolkit.layout.layout import Layout
from prompt_toolkit.eventloop import use_asyncio_event_loop

# set up event loop
use_asyncio_event_loop()

async def main():
    layout = Layout(Window(content=BufferControl(buffer=Buffer())))
    app = Application(layout=layout, full_screen=True)

    try:
        # timeout the application after 2 seconds
        await asyncio.wait_for(app.run_async().to_asyncio_future(), 2)
    finally:
        app.exit()

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

The difference before and after included the following changes: ICRNL --> -ICRNL, ISIG --> -ISIG, and IEXTEN --> -IEXTEN. Right now, I have to run stty sane to fix the terminal after running an application. It would be better if the application set up an atexit or acted as a context manager for resetting sane terminal interface settings.

[derekbrokeit]

I should note that the only way I could get a complete fix on my machine required the following:

async def main():
    layout = Layout(Window(content=BufferControl(buffer=Buffer())))
    app = Application(layout=layout, full_screen=True)

    # temporary patch
    import termios, sys
    old_attrs = termios.tcgetattr(sys.stdin)

    try:
        # timeout the application after 2 seconds
        await asyncio.wait_for(app.run_async().to_asyncio_future(), 2)
    finally:
        app.exit()
        termios.tcsetattr(sys.stdin, termios.TCSANOW, old_attrs)