«

Hi - I'm writing a *very* simple program for my kids. It asks the user
to give it the answer to a maths question and says "right" or "wrong"

They now want a timed version where they would only get so long to
respond to the question.

I'm thinking of some logic where a raw_input call is executed and then
if more than X seconds elapses before the prompt is replied to the
process writes a message "Sorry too slow" (or similar).

I can't see the wood for the trees here - what's the best way to do
this given the rather simple environment it's needed within.

Regards

richard.

On Dec 5, 12:52*pm, northof40 <shearich...@gmail.com> wrote:
> Hi - I'm writing a *very* simple program for my kids. It asks the user
> to give it the answer to a maths question and says "right" or "wrong"
>
> They now want a timed version where they would only get so long to
> respond to the question.
>
> I'm thinking of some logic where a raw_input call is executed and then
> if more than X seconds elapses before the prompt is replied to the
> process writes a message "Sorry too slow" (or similar).
>
> I can't see the wood for the trees here - what's the best way to do
> this given the rather simple environment it's needed within.
>
> Regards
>
> richard.

Sorry I should said that based upon other answers I've seen to similar
questions this needs to run on a windows machine (other answers
suggest this is more difficult than running on *nix)

On Fri, Dec 4, 2009 at 6:55 PM, northof40 <> wrote:
> On Dec 5, 12:52Â*pm, northof40 <shearich...@gmail.com> wrote:
>> Hi - I'm writing a *very* simple program for my kids. It asks the user
>> to give it the answer to a maths question and says "right" or "wrong"
>>
>> They now want a timed version where they would only get so long to
>> respond to the question.
>>
>> I'm thinking of some logic where a raw_input call is executed and then
>> if more than X seconds elapses before the prompt is replied to the
>> process writes a message "Sorry too slow" (or similar).
>>
>> I can't see the wood for the trees here - what's the best way to do
>> this given the rather simple environment it's needed within.
>>
>> Regards
>>
>> richard.
>
> Sorry I should said that based upon other answers I've seen to similar
> questions this needs to run on a windows machine (other answers
> suggest this is more difficult than running on *nix)
>

Simplest solution I could come up with. This is indeed much easier on
*nix (just use select.select on sys.stdin with a timeout).

---
from msvcrt import getch, kbhit, putch
from time import sleep, time

ans = ''
end = time() + 5

print('2 + 2 = ?')

while True:
while time() < end:
if kbhit():
break
else:
sleep(0.001)
else:
ans = None
break

char = getch()
if char == '\r':
print('')
break
ans += char
putch(char)

if ans is None:
print('\nSorry too slow')
else:
try:
print('right' if int(ans) == 4 else 'wrong')
except:
print('not a number')
---

- Max

northof40 <> writes:
> I'm thinking of some logic where a raw_input call is executed and then
> if more than X seconds elapses before the prompt is replied to the
> process writes a message "Sorry too slow" (or similar).

The simplest way to do this is with the alarm function and a signal
handler. See the docs for the signal module.

On Dec 5, 2:44*pm, Maxim Khitrov <mkhit...@gmail.com> wrote:
> On Fri, Dec 4, 2009 at 6:55 PM, northof40 <shearich...@gmail.com> wrote:
> > On Dec 5, 12:52*pm, northof40 <shearich...@gmail.com> wrote:
> >> Hi - I'm writing a *very* simple program for my kids. It asks the user
> >> to give it the answer to a maths question and says "right" or "wrong"
>
> >> They now want a timed version where they would only get so long to
> >> respond to the question.
>
> >> I'm thinking of some logic where a raw_input call is executed and then
> >> if more than X seconds elapses before the prompt is replied to the
> >> process writes a message "Sorry too slow" (or similar).
>
> >> I can't see the wood for the trees here - what's the best way to do
> >> this given the rather simple environment it's needed within.
>
> >> Regards
>
> >> richard.
>
> > Sorry I should said that based upon other answers I've seen to similar
> > questions this needs to run on a windows machine (other answers
> > suggest this is more difficult than running on *nix)
>
> Simplest solution I could come up with. This is indeed much easier on
> *nix (just use select.select on sys.stdin with a timeout).
>
> ---
> from msvcrt import getch, kbhit, putch
> from time import sleep, time
>
> ans = ''
> end = time() + 5
>
> print('2 + 2 = ?')
>
> while True:
> * * * * while time() < end:
> * * * * * * * * if kbhit():
> * * * * * * * * * * * * break
> * * * * * * * * else:
> * * * * * * * * * * * * sleep(0.001)
> * * * * else:
> * * * * * * * * ans = None
> * * * * * * * * break
>
> * * * * char = getch()
> * * * * if char == '\r':
> * * * * * * * * print('')
> * * * * * * * * break
> * * * * ans += char
> * * * * putch(char)
>
> if ans is None:
> * * * * print('\nSorry too slow')
> else:
> * * * * try:
> * * * * * * * * print('right' if int(ans) == 4 else 'wrong')
> * * * * except:
> * * * * * * * * print('not a number')
> ---
>
> - Max

That's really great - thanks. I've never looked at the whole msvcrt
module before - it looks like it could be useful ... at least for
windows programmes.

Thanks again.

R.

On Dec 5, 6:23*pm, Paul Rubin <no.em...@nospam.invalid> wrote:
> northof40 <shearich...@gmail.com> writes:
> > I'm thinking of some logic where a raw_input call is executed and then
> > if more than X seconds elapses before the prompt is replied to the
> > process writes a message "Sorry too slow" (or similar).
>
> The simplest way to do this is with the alarm function and a signal
> handler. *See the docs for the signal module.

Hi Paul - Thanks for your reply. Unfortunately it seems like the bit
of the signal module I would need for this is not implemented for
windows (AttributeError: 'module' object has no attribute 'SIGALRM').
Still no matter when I asked the question I couldn't even figure out
what module might provide this functionality for any platform so it
was useful knowledge for the future. Thanks again.

regards

Richard.

The easiest wasy is to use the Timer object in the threading module.


from threading import Timer

On Sat, Dec 5, 2009 at 9:01 AM, Rune Strand <> wrote:
> The easiest wasy is to use the Timer object in the threading module.
>
>
> from threading import Timer

Doesn't work on Windows.

- Max

On Dec 5, 3:07*pm, Maxim Khitrov <mkhit...@gmail.com> wrote:
>
> Doesn't work on Windows.
>
> - Max

Yes, it does. I've used it a lot, also in Py2Exe apps. Try the
documentation example yourself

def hello():
print "hello, world"

t = Timer(30.0, hello)
t.start() # after 30 seconds, "hello, world" will be printed

On Sat, Dec 5, 2009 at 9:11 AM, Rune Strand <> wrote:
> On Dec 5, 3:07Â*pm, Maxim Khitrov <mkhit...@gmail.com> wrote:
>>
>> Doesn't work on Windows.
>>
>> - Max
>
> Yes, it does. I've used it a lot, also in Py2Exe apps. Â*Try the
> documentation example yourself
>
> def hello():
> Â* Â*print "hello, world"
>
> t = Timer(30.0, hello)
> t.start() # after 30 seconds, "hello, world" will be printed

I'm not talking about the Timer, I'm talking about the original
question. There's nothing (that I know of) you can do with a Timer on
Windows to interrupt a raw_input call.

- Max