The documentation for asyncio gives two examples for how to print "Hello World" every two seconds: https://docs.python.org/3/library/asyncio-eventloop.html#asyncio-hello-world-callback https://docs.python.org/3/library/asyncio-task.html#asyncio-hello-world-coroutine
I can run those from the interpreter, but if I do I lose access to the interpreter. Can an asyncio event loop be run in the background, so that I can keep typing commands at the interpreter?
Edit:
If using Python 3.8 or above, you should use the asyncio repl, as explained in zeronone's answer. If using 3.7 or lower, you can use this answer.
You can run the event loop inside a background thread:
import asyncio
@asyncio.coroutine
def greet_every_two_seconds():
while True:
print('Hello World')
yield from asyncio.sleep(2)
def loop_in_thread(loop):
asyncio.set_event_loop(loop)
loop.run_until_complete(greet_every_two_seconds())
loop = asyncio.get_event_loop()
import threading
t = threading.Thread(target=loop_in_thread, args=(loop,))
t.start()
# Hello World
# 2 second later
# Hello World
Note that you must call asyncio.set_event_loop on the loop, otherwise you'll get an error saying that the current thread doesn't have an event loop.
If you want to interact with the event loop from the main thread, you'll need to stick to loop.call_soon_threadsafe calls.
While this kind of thing is an ok way to experiment in the interpreter, in actual programs, you'll probably want all your code running inside the event loop, rather than introducing threads.
asyncio is to avoid using threads. If you're always going to run this code inside an interactive interpreter, then I guess it makes sense. But normally I would say you should implement an asyncio Procotol or Stream that handles incoming network connections, and then tell it what signals to send via network requests.
asyncio (such as scheduled background operations)? It seems running an event loop in a background thread would fit perfectly in this scenario, but I may be missing some hidden complications.asyncio eventloop thread and whatever other threads you have running.With Python 3.8, you can use the new asyncio REPL.
$ python -m asyncio
>>> async def greet_every_two_seconds():
... while True:
... print('Hello World')
... await asyncio.sleep(2)
...
>>> # run in main thread (Ctrl+C to cancel)
>>> await greet_every_two_seconds()
...
>>> # run in background
>>> asyncio.create_task(greet_every_two_seconds())
from after await
ipython as well?@raisyn
From ipython, this is working:
import asyncio
from traitlets.config.application import Application
async def greet_every_two_seconds():
while True:
print('Hello World')
await asyncio.sleep(2)
# Create coroutine
coro = greet_every_two_seconds()
# Create and get an adequate asyncio event loop
Application.instance().shell.enable_gui('asyncio')
loop = asyncio.get_event_loop()
loop.create_task(coro)
