Xtykutl

Using a select call is shorter, and should be much more portable

import sys, select



print "You have ten seconds to answer!"



i, o, e = select.select( [sys.stdin], , , 10 )



if (i):

  print "You said", sys.stdin.readline().strip()

else:

  print "You said nothing!"

Not a Python solution, but...

I ran in to this problem with a script running under CentOS (Linux), and what worked for my situation was just running the Bash "read -t" command in a subprocess. Brutal disgusting hack, I know, but I feel guilty enough about how well it worked that I wanted to share it with everyone here.

import subprocess

subprocess.call('read -t 30', shell=True)

All I needed was something that waited for 30 seconds unless the ENTER key was pressed. This worked great.

And here's one that works on Windows

I haven't been able to get any of these examples to work on Windows so I've merged some different StackOverflow answers to get the following:

import threading, msvcrt

import sys



def readInput(caption, default, timeout = 5):

    class KeyboardThread(threading.Thread):

        def run(self):

            self.timedout = False

            self.input = ''

            while True:

                if msvcrt.kbhit():

                    chr = msvcrt.getche()

                    if ord(chr) == 13:

                        break

                    elif ord(chr) >= 32:

                        self.input += chr

                if len(self.input) == 0 and self.timedout:

                    break    





    sys.stdout.write('%s(%s):'%(caption, default));

    result = default

    it = KeyboardThread()

    it.start()

    it.join(timeout)

    it.timedout = True

    if len(it.input) > 0:

        # wait for rest of input

        it.join()

        result = it.input

    print ''  # needed to move to next line

    return result



# and some examples of usage

ans = readInput('Please type a name', 'john') 

print 'The name is %s' % ans

ans = readInput('Please enter a number', 10 ) 

print 'The number is %s' % ans 

Paul's answer did not quite work. Modified code below which works for me on

• windows 7 x64



• 
  

  vanilla CMD shell (eg, not git-bash or other non-M$ shell)

  
  
  

  -- nothing msvcrt works in git-bash it appears.

  
  



• python 3.6

(I'm posting a new answer, because editing Paul's answer directly would change it from python 2.x-->3.x, which seems too much for an edit (py2 is still in use)

import sys, time, msvcrt



def readInput( caption, default, timeout = 5):



    start_time = time.time()

    sys.stdout.write('%s(%s):'%(caption, default))

    sys.stdout.flush()

    input = ''

    while True:

        if msvcrt.kbhit():

            byte_arr = msvcrt.getche()

            if ord(byte_arr) == 13: # enter_key

                break

            elif ord(byte_arr) >= 32: #space_char

                input += "".join(map(chr,byte_arr))

        if len(input) == 0 and (time.time() - start_time) > timeout:

            print("timing out, using default value.")

            break



    print('')  # needed to move to next line

    if len(input) > 0:

        return input

    else:

        return default



# and some examples of usage

ans = readInput('Please type a name', 'john') 

print( 'The name is %s' % ans)

ans = readInput('Please enter a number', 10 ) 

print( 'The number is %s' % ans) 

Following code worked for me.

I used two threads one to get the raw_Input and another to wait for a specific time.
If any of the thread exits, both the thread is terminated and returned.

def _input(msg, q):

    ra = raw_input(msg)

    if ra:

        q.put(ra)

    else:

        q.put("None")

    return



def _slp(tm, q):

    time.sleep(tm)

    q.put("Timeout")

    return



def wait_for_input(msg="Press Enter to continue", time=10):

    q = Queue.Queue()

    th = threading.Thread(target=_input, args=(msg, q,))

    tt = threading.Thread(target=_slp, args=(time, q,))



    th.start()

    tt.start()

    ret = None

    while True:

        ret = q.get()

        if ret:

            th._Thread__stop()

            tt._Thread__stop()

            return ret

    return ret



print time.ctime()    

t= wait_for_input()

print "nResponse :",t 

print time.ctime()

I spent a good twenty minutes or so on this, so I thought it was worth a shot to put this up here. It is directly building off of user137673's answer, though. I found it most useful to do something like this:

#! /usr/bin/env python



import signal



timeout = None



def main():

    inp = stdinWait("You have 5 seconds to type text and press <Enter>... ", "[no text]", 5, "Aw man! You ran out of time!!")

    if not timeout:

        print "You entered", inp

    else:

        print "You didn't enter anything because I'm on a tight schedule!"



def stdinWait(text, default, time, timeoutDisplay = None, **kwargs):

    signal.signal(signal.SIGALRM, interrupt)

    signal.alarm(time) # sets timeout

    global timeout

    try:

        inp = raw_input(text)

        signal.alarm(0)

        timeout = False

    except (KeyboardInterrupt):

        printInterrupt = kwargs.get("printInterrupt", True)

        if printInterrupt:

            print "Keyboard interrupt"

        timeout = True # Do this so you don't mistakenly get input when there is none

        inp = default

    except:

        timeout = True

        if not timeoutDisplay is None:

            print timeoutDisplay

        signal.alarm(0)

        inp = default

    return inp



def interrupt(signum, frame):

    raise Exception("")



if __name__ == "__main__":

    main()

Analogous to Locane's for windows:

import subprocess  

subprocess.call('timeout /T 30')

Since this question seems to serve as a duplicate target, here the link to my accepted answer in a duplicate question.

Features

• Plattform independent (Unix / Windows).


• StdLib only, no external dependencies.


• Threads only, no Subprocesses.


• Immediate interrupt at timeout.


• Clean shutdown of prompter at timeout.


• Unlimited inputs possible during time span.


• Easy expandable PromptManager class.


• Program may resume after timeout, multiple runs of prompter instances possible without program restart.