I've been using Python for a lot of projects at work, and one problem I've had is dealing with the keyboard. Typically I just want to be able to read a key and trigger some event when that happens. Just reading a single key press isn't trivial. There are plenty of write ups about how to change the terminal into single character mode, and that does work. But what if you don't want the read to block so you can do an event driven system?
In the past I have simply made a thread that puts the terminal into non-blocking single character mode. The body of the thread reads the key. If there isn't one, the thread sleeps. If there is one, the key is read and dispatched. The problem with this approach is the sleep time because it limits how fast keys respond.
I tried a different implementation the other day I'm sharing here. For Linux machines it is more efficient because it is still blocking. However, rather than block by just waiting on the terminal (stdin) it waits for either the terminal or a temporary file. This is accomplished through the use of select which can block until an event occurs on one or more files. That eliminates the need for an arbitrary sleep.
#!/usr/bin/env python3 #------------------------------------------------------------------------------ # Uses: Thread for reading the keyboard and placing characters in a queue. # Date: 2020-02-09 # Author: Andrew Que <https://www.DrQue.net/> # # (C) Copyright 2020 #------------------------------------------------------------------------------ # For reading key in non-blocking mode. import sys import os import select import tempfile # For thread. import threading import time import queue class KeyboardThread( threading.Thread ) : """ Thread for handling single character keyboard input. Input: shutdown - Instance of `threading.Event` used to signal the thread to shutdown. keyQueue - Instance of `queue.Queue` where keys that have been pressed are placed. Queue: New keys are placed in the queue as they arrive. When the thread shuts down `None` is placed in the queue. This will unblock queue and there is no other way for `None` to be enter the queue, thus safe to assume `None` is a shutdown event. """ #----------------------------------------------------------------------------- def __init__( self, shutdown : threading.Event, keyQueue : queue.Queue, start=False, *args, **kwargs ) : super().__init__( *args, **kwargs ) self._shutdown = shutdown self._keyQueue = keyQueue # We use a temporary file (a pipe) to shutdown the thread. # Writes to the temporary file unblock the thread. So to end the thread # we simply write something to the temp file. self._shutdownFile = os.pipe() threading.Thread( target=self._stopBody ).start() if start : self.start() #----------------------------------------------------------------------------- def _stopBody( self ) : """ This function simply waits for the shutdown even and then unblocks the keyboard thread by writing something to the shutdown file. """ # Wait for shutdown. self._shutdown.wait() # Signal the keyboard task by writing dummy data to the shutdown file. os.write( self._shutdownFile[ 1 ], b"\0" ) #----------------------------------------------------------------------------- def run( self ) : try : self.runLinux() except ModuleNotFoundError : self.runWindows() #----------------------------------------------------------------------------- def runLinux( self ) : import tty import termios # File descriptor of stdin. # (Likely this will always be 0.) fileDescriptor = sys.stdin.fileno() # Set terminal in raw mode. savedAttributes = termios.tcgetattr( fileDescriptor ) tty.setcbreak( fileDescriptor ) try : # Wait for data from either `stdin` or the shutdown file. readDescriptors = [ fileDescriptor, self._shutdownFile[ 0 ] ] while not self._shutdown.is_set() : # Wait for a data. [ reading, writing, exceptional ] = select.select( readDescriptors, [], [] ) # If this was a key press... if fileDescriptor in reading : # Read and queue the new key. # (Could be more than one character for the case of special keys) character = os.read( fileDescriptor, 8 ).decode() self._keyQueue.put( character ) finally : # Restore terminal settings. termios.tcsetattr( fileDescriptor, termios.TCSANOW, savedAttributes ) # Unblock queue by adding `None`. self._keyQueue.put( None ) #----------------------------------------------------------------------------- def runWindows( self ) : import msvcrt while not self._shutdown.is_set() : if msvcrt.kbhit() : # Read and queue the new key. character = msvcrt.getch().decode() if "\0" == character : secondCharacter = msvcrt.getch().decode() character += secondCharacter self._keyQueue.put( character ) else: # Come back latter. # 100ms is rather arbitrary. self._shutdown.wait( 0.1 ) # Unblock queue by adding `None`. self._keyQueue.put( None ) #------------------------------------------------------------------------------- if __name__ == '__main__': import string # Escape key value. ESC_KEY = chr( 27 ) # Event to signal shutdown. shutdown = threading.Event() # Queue to hold keys. keyQueue = queue.Queue() class KeyUnload( threading.Thread ) : def __init__( self, shutdown : threading.Event, keyQueue : queue.Queue ) : super().__init__() self._shutdown = shutdown self._keyQueue = keyQueue def run( self ) : while not self._shutdown.is_set() : key = self._keyQueue.get() if ESC_KEY == key : print( "Shutdown key pressed" ) self._shutdown.set() elif key is not None : if key[ 0 ] == chr( 27 ) : print( "Special key code '" + key[ 1: ] + "' pressed" ) elif "\n" == key : print( "Enter key was pressed" ) elif key.isprintable() : print( "The '" + key + "' key was pressed" ) elif len( key ) > 1 : print( key ) else: print( "Character", ord( key ), "received." ) # Thread to unload key presses. keyUnload = KeyUnload( shutdown, keyQueue ) keyUnload.start() # Keyboard thread. keyboardThread = KeyboardThread( shutdown, keyQueue ) keyboardThread.start() # Timer to shutdown the example after 3 seconds. timer = threading.Timer( 3.0, lambda: shutdown.set() ) #timer.start() # Wait for shutdown. print( "Hit ESC to stop, or wait 3 seconds." ) shutdown.wait() print( "Shutdown" ) # Stop timer. timer.cancel() # Wait for keyboard thread to finish. keyUnload.join() keyboardThread.join() print( "Done" )
What we have is a thread that takes an Event as a parameter. The event is used to signal the thread to shutdown, typically when the program ends. We create a pipe which is just a temporary file for which we can use select. The body of the thread setups up the terminal for blocking single character mode. Then it enters a loop that waits for a character from either the terminal or the shutdown file. If there was a character from the terminal, it is placed in a queue for consumption by some other process. A second thread is spun up that simply waits for the event to be set, and writes something to the shutdown pipe. That will cause the main thread to unblock and see that it is time to shutdown.
This efficient process only works for POSIX system. The class has a Windows version but it uses the less efficient timed out block method. The whole things seems overly complected, but is completely functional. Maybe it will help someone else having the same issue.