Using Python, how can I implement running a loop in the foreground while waiting in the background for a key-press?

It's nothing complicated, and nothing requiring any packages.

Its only problem is that it requires restoring terminal back to normal on program exit.

I.e. If program crashes the terminal will not be restored and user won't see what he is typing.

But if user knows what he is doing, he can force restart the shell and everything will be back to normal.

Of corse, you can use this code in easier manner and use raw_input() to do the stuff.

from thread import start_new_thread as thread
from time import sleep
# Get only one character from stdin without echoing it to stdout
import termios
import fcntl
import sys
import os
fd = sys.stdin.fileno()
oldterm, oldflags = None, None

def prepareterm ():
    """Turn off echoing"""
    global oldterm, oldflags
    if oldterm!=None and oldflags!=None: return
    oldterm = termios.tcgetattr(fd)
    newattr = oldterm[:] # Copy of attributes to change
    newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
    termios.tcsetattr(fd, termios.TCSANOW, newattr)
    oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)

def restoreterm ():
    """Restore terminal to its previous state"""
    global oldterm, oldflags
    if oldterm==None and oldflags==None: return
    termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
    oldterm, oldflags = None, None

def getchar():
    """Get character from stdin"""
    prepareterm()
    while 1:
        try:
            c = sys.stdin.read(1)
            break
        except IOError:
            try: sleep(0.001)
            except: restoreterm(); raise KeyboardInterrupt
    restoreterm()
    return c

def control ():
    """Waits for keypress"""
    global running, done
    while running:
        c = getchar().lower()
        print "Keypress:", c
        if c=="q": print "Quitting!"; running = 0; break
    done += 1

def work ():
    """Does the server-client part"""
    global done
    while running:
        # Do your stuff here!!!
        # Just to illustrate:
        print "I am protending to work!\nPress Q to kill me!"
        sleep(1)
    print "I am done!\nExiting . . ."
    done += 1

# Just to feel better
import atexit
atexit.register(restoreterm)

# Start the program
running = 1
done = 0
thread(work, ())
thread(control, ())
# Block the program not to close when threads detach from the main one:
while running:
    try: sleep(0.2)
    except: running = 0
# Wait for both threads to finish:
while done!=2:
    try: sleep(0.001)
    except: pass # Ignore KeyboardInterrupt
restoreterm() # Just in case!

In practice program should never be able to exit without restoring the terminal to normal, but shit happens.

Now, you can simplify things by using only one thread and your work loop put in the main thread, and use raw_input to acquire commands from user. Or maybe even better, put your server-client code in the background and wait for input in main thread.

It will also probably be safer to use threading module instead of raw threads.

If you use asyncore module, you will get each client running for its own, and your main thread will be occupied with the asyncore.loop(). You can override it, I.e. rewrite it to check for input and other things you wish to do, while keeping asyncore checks synchronized. Also, heavy loads require to override some nasty functions inside it, because its buffer is fixed to 512 bytes, if I am not mistaken. Otherwise, it may be a nice solution for your problem.

And, lastly, just to be clear, code for no echoing user input is taken and adapted from getpass module. Just a little bit there is mine.