asyncio keyboard input that can be canceled

async def ainput():
   loop = asyncio.get_event_loop()
fut = loop.create_future()
def _run():
   line = sys.stdin.readline()
loop.call_soon_threadsafe(fut.set_result, line)
threading.Thread(target = _run, daemon = True).start()
return await fut

async def console_input_loop():
   while True:
   inp = await ainput()
print(f "[{inp.strip()}]")

# rest of the program unchanged

try:
loop.run_forever()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()

# will schedule "print("
Hello ", flush=True)"
loop.call_soon(
   functools.partial(print, "Hello", flush = True))

import asyncio
import concurrent.futures

def blocking_io():
   # File operations(such as logging) can block the
# event loop: run them in a thread pool.
with open('/dev/urandom', 'rb') as f:
   return f.read(100)

def cpu_bound():
   # CPU - bound operations will block the event loop:
   # in general it is preferable to run them in a
# process pool.
return sum(i * i
   for i in range(10 ** 7))

async def main():
   loop = asyncio.get_running_loop()

# # Options:

   # 1. Run in the
default loop 's executor:
result = await loop.run_in_executor(
   None, blocking_io)
print('default thread pool', result)

# 2. Run in a custom thread pool:
   with concurrent.futures.ThreadPoolExecutor() as pool:
   result = await loop.run_in_executor(
      pool, blocking_io)
print('custom thread pool', result)

# 3. Run in a custom process pool:
   with concurrent.futures.ProcessPoolExecutor() as pool:
   result = await loop.run_in_executor(
      pool, cpu_bound)
print('custom process pool', result)

asyncio.run(main())

srv = await loop.create_server(...)

async with srv:
   # some code

# At this point, srv is closed and no longer accepts new connections.

async def client_connected(reader, writer):
   # Communicate with the client with
# reader / writer streams.For example:
   await reader.readline()

async def main(host, port):
   srv = await asyncio.start_server(
      client_connected, host, port)
await srv.serve_forever()

asyncio.run(main('127.0.0.1', 0))

import asyncio
import selectors

selector = selectors.SelectSelector()
loop = asyncio.SelectorEventLoop(selector)
asyncio.set_event_loop(loop)

exec_count = 0
while True:
   inp = input(f "[{exec_count}] > ") # Read
ret = eval(inp) # Evaluate
print(ret) # Print
exec_count += 1 # Loop

pyplot.show(block = True)

fig, ax = plt.subplots()
ln, = ax.plot([], [])

while True:
   x, y = get_new_data()
ln.set_data(x, y)
plt.pause(1)

import time
import matplotlib.pyplot as plt
import numpy as np
plt.ion()

fig, ax = plt.subplots()
th = np.linspace(0, 2 * np.pi, 512)
ax.set_ylim(-1.5, 1.5)

ln, = ax.plot(th, np.sin(th))

def slow_loop(N, ln):
   for j in range(N):
   time.sleep(.1) # to simulate some work
ln.figure.canvas.flush_events()

slow_loop(100, ln)

def slow_loop(N, ln):
   for j in range(N):
   time.sleep(.1) # to simulate some work
if j % 10:
   ln.set_ydata(np.sin(((j // 10) % 5 * th)))
               ln.figure.canvas.draw_idle()

               ln.figure.canvas.flush_events()

               slow_loop(100, ln)

def callback(self: Artist, val: bool) - > None:
   ...

pip install pynput

from prompt_toolkit.key_binding
import KeyBindings

bindings = KeyBindings()

@bindings.add('a')
def _(event):
   " Do something if 'a' has been pressed. "
   ...

   @bindings.add('c-t')
def _(event):
   " Do something if Control-T has been pressed. "
   ...

stty - ixon

@bindings.add('a', 'b')
def _(event):
   " Do something if 'a' is pressed and then 'b' is pressed. "
   ...

@bindings.add('escape', 'f')
def _(event):
   " Do something if alt-f or meta-f have been pressed. "

@bindings.add('a', '<any>')
   def _(event):
   ...

from prompt_toolkit.filters
import Condition

@Condition
def is_active():
   " Only activate key binding on the second half of each minute. "
return datetime.datetime.now().second > 30

@bindings.add('c-t', filter = is_active)
def _(event):
   #...
   pass

def on_key_press(symbol, modifiers):
   pass

def on_key_release(symbol, modifiers):
   pass

key.A
key.B
key.C
   ...

key._1
key._2
key._3
   ...

key.ENTER or key.RETURN
key.SPACE
key.BACKSPACE
key.DELETE
key.MINUS
key.EQUAL
key.BACKSLASH

key.LEFT
key.RIGHT
key.UP
key.DOWN
key.HOME
key.END
key.PAGEUP
key.PAGEDOWN

key.F1
key.F2
   ...

key.NUM_1
key.NUM_2
   ...
   key.NUM_EQUAL
key.NUM_DIVIDE
key.NUM_MULTIPLY
key.NUM_SUBTRACT
key.NUM_ADD
key.NUM_DECIMAL
key.NUM_ENTER

key.LCTRL
key.RCTRL
key.LSHIFT
key.RSHIFT
   ...