Pfthb

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')

Here is a portable and simple Python 3 solution using threads.
This is the only one that worked for me while being cross-platform.

Other things I tried all had problems:

• Using signal.SIGALRM: not working on Windows


• Using select call: not working on Windows


• Using force-terminate of a process (instead of thread): stdin cannot be used in new process (stdin is auto-closed)


• Redirection stdin to StringIO and writing directly to stdin: will still write to previous stdin if input() has already been called (see https://stackoverflow.com/a/15055639/9624704)

 from threading import Thread
 class myClass:
 _input = None

 def __init__(self):
 get_input_thread = Thread(target=self.get_input)
 get_input_thread.daemon = True # Otherwise the thread won't be terminated when the main program terminates.
 get_input_thread.start()
 get_input_thread.join(timeout=20)

 if myClass._input is None:
 print("No input was given within 20 seconds")
 else:
 print("Input given was: ".format(myClass._input))


 @classmethod
 def get_input(cls):
 cls._input = input("")
 return

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

Features

• Platform 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.