Prompt for user input using python asyncio.create_server instance

by

You can use loop.add_reader schedule a callback to run when data is available on sys.stdin, and then use an asyncio.Queue to pass the stdin data received to your data_received method:

import sys
import asyncio


def got_stdin_data(q):
    asyncio.ensure_future(q.put(sys.stdin.readline()))

class EchoServerClientProtocol(asyncio.Protocol):
   def connection_made(self, transport):
       peername = transport.get_extra_info('peername')
       print('Connection from {}'.format(peername))
       self.transport = transport

   def data_received(self, data):
       message = data.decode()
       print('Data received: {!r}'.format(message))
       fut = asyncio.ensure_future(q.get())
       fut.add_done_callback(self.write_reply)

   def write_reply(self, fut):
       reply = fut.result()
       print('Send: {!r}'.format(reply))
       self.transport.write(reply.encode())

       #print('Close the client socket')
       #self.transport.close()

q = asyncio.Queue()
loop = asyncio.get_event_loop()
loop.add_reader(sys.stdin, got_stdin_data, q)
# Each client connection will create a new protocol instance
coro = loop.create_server(EchoServerClientProtocol, '127.0.0.1', 8888)
server = loop.run_until_complete(coro)

# Serve requests until CTRL+c is pressed
print('Serving on {}'.format(server.sockets[0].getsockname()))
try:
    loop.run_forever()
except KeyboardInterrupt:
    pass

# Close the server
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()

The only tricky bit is how we call the Queue.put/Queue.get methods; both of them are coroutines, which can’t be called using yield from in the callback or the Protocol instance methods. Instead, we just schedule them with the event loop using asyncio.ensure_future, and then use the add_done_callback method to handle the reply we retrieve from the get() call.

Note: asyncio.ensure_future was introduced in Python 3.4.4. Prior to that, the method was called asyncio.async. Additionally, Python 3.7 introduced asyncio.create_task, which is now the preferred method.

More Related Contents:

  1. When to use and when not to use Python 3.5 `await` ?
  2. “Fire and forget” python async/await
  3. Asynchronous method call in Python?
  4. How to limit concurrency with Python asyncio?
  5. asyncio.sleep() vs time.sleep()
  6. multiprocessing vs multithreading vs asyncio in Python 3
  7. Asyncio.gather vs asyncio.wait
  8. Timeout for python coroutines
  9. “Asyncio Event Loop is Closed” when getting loop
  10. Can an asyncio event loop run in the background without suspending the Python interpreter?
  11. How do I run Python asyncio code in a Jupyter notebook?
  12. Combine awaitables like Promise.all
  13. What kind of problems (if any) would there be combining asyncio with multiprocessing?
  14. How to test Python 3.4 asyncio code?
  15. How to use ‘yield’ inside async function?
  16. asyncio: Is it possible to cancel a future been run by an Executor?
  17. Mocking async call in python 3.5
  18. Why can I only use the await keyword inside of async function?
  19. How to do multiprocessing in FastAPI
  20. How to set class attribute with await in __init__
  21. What’s the correct way to clean up after an interrupted event loop?
  22. aiohttp: set maximum number of requests per second
  23. How can I await inside future-like object’s __await__?
  24. Make a Python asyncio call from a Flask route
  25. Why am I getting NotImplementedError with async and await on Windows?
  26. Create generator that yields coroutine results as the coroutines finish
  27. Is it possible to run only a single step of the asyncio event loop
  28. Handling Timeouts with asyncio
  29. how to add a coroutine to a running asyncio loop?
  30. How to combine Celery with asyncio?

Leave a Comment