15 Oct
2010
15 Oct
'10
12:04 a.m.
Hi,
In a bit of a time crunch. Can anyone tell me how to do this properly?
I would like to have a threaded timer to run "cmd" after 5 seconds.
However cmd is normally triggered like this:
os.system(cmd)
But there seems to be an issue with calling os.system(cmd) from
subprocess.popen.
==========================
def do_popen(self, *args):
subprocess.Popen(args[0], shell=True)
def other function
cmd = 'spd-say -t female2 "' + audioText + '"'
args = shlex.split(cmd)
# Add 5 second delay for first view to allow existing speech processes to
finish
print "do_speech: ",delay
if delay:
print "do_speech: delayed start"
t = threading.Timer(5.0, self.do_popen(cmd))
t.start()
else :
print "do_speech: immediate start"
self.do_popen(cmd)
======================
FYI, it is for an accessibility wizard that Daniel and I have been working
on.
Cheers.
--
Patrick Shirkey
Boost Hardware Ltd.
"ZPE is not about creating something from nothing: It is about using the
zero point of a wave as a means to transform other forms of potential
energy like magnetic flux, heat, or particle spin into usable energy in
such a way that entropy appears to be reversed."
15 Oct
15 Oct
1:10 a.m.
On Thu, Oct 14, 2010 at 03:04:54PM -0700, Patrick Shirkey wrote:
In a bit of a time crunch. Can anyone tell me how to
do this properly?
I would like to have a threaded timer to run "cmd" after 5 seconds.
However cmd is normally triggered like this:
os.system(cmd)
But there seems to be an issue with calling os.system(cmd) from
subprocess.popen.
==========================
def do_popen(self, *args):
subprocess.Popen(args[0], shell=True)
def other function
cmd = 'spd-say -t female2 "' + audioText + '"'
args = shlex.split(cmd)
# Add 5 second delay for first view to allow existing speech processes to
finish
print "do_speech: ",delay
if delay:
print "do_speech: delayed start"
t = threading.Timer(5.0, self.do_popen(cmd))
t.start()
else :
print "do_speech: immediate start"
self.do_popen(cmd)
======================
A bit confusing - you mention os.system() but is not used at all
(nor should it if you use subprocess.Popen().
You didn't tell what happens...
I suspect that if you do this in a function the thread 't' will be
destroyed as soon as that function returns. Making 't' global could
help. (no guarantee -- speculating).
Ciao,
--
FA
There are three of them, and Alleline.
5:33 p.m.
On Thu, October 14, 2010 4:10 pm, fons(a)kokkinizita.net wrote:
On Thu, Oct 14, 2010 at 03:04:54PM -0700, Patrick
Shirkey wrote:
I tried all three suggestions and none of them do the trick.
What happens instead is that the threaded call gets played back the next
time the non threaded call to subprocess.Popen() is called. Although not
every time. But most likely if I wait for a bit longer than the timeout.
This script is very simple it doesn't have a ringbuffer or any way of
tracking itself.
Maybe it's just not possible to create a threaded timer with such a simple
script?
I changed approach and used the priority flag in spd-say. That seems to help.
Cheers.
--
Patrick Shirkey
Boost Hardware Ltd.
"ZPE is not about creating something from nothing: It is about using the
zero point of a wave as a means to transform other forms of potential
energy like magnetic flux, heat, or particle spin into usable energy in
such a way that entropy appears to be reversed."
In a bit of a time crunch. Can anyone tell me how
to do this properly?
I would like to have a threaded timer to run "cmd" after 5 seconds.
However cmd is normally triggered like this:
os.system(cmd)
But there seems to be an issue with calling os.system(cmd) from
subprocess.popen.
==========================
def do_popen(self, *args):
subprocess.Popen(args[0], shell=True)
def other function
cmd = 'spd-say -t female2 "' + audioText + '"'
args = shlex.split(cmd)
# Add 5 second delay for first view to allow existing speech processes
to
finish
print "do_speech: ",delay
if delay:
print "do_speech: delayed start"
t = threading.Timer(5.0, self.do_popen(cmd))
t.start()
else :
print "do_speech: immediate start"
self.do_popen(cmd)
======================
A bit confusing - you mention os.system() but is not used at all
(nor should it if you use subprocess.Popen().
You didn't tell what happens...
I suspect that if you do this in a function the thread 't' will be
destroyed as soon as that function returns. Making 't' global could
help. (no guarantee -- speculating).
6:44 p.m.
Is the program you're calling from popen generating any output on
stdin/stdout or waiting for input on stdin? Then there's a good chance
it's blocked and nothing happens.... so consider redirecting
stdin/stdout/stderr to /dev/null prior to calling the program out of
popen, or read/write the needed information from the process you are
calling. In contrast, the system() call will block the program it's
executing out of, but will blast it's I/O to that of the calling
program. Popen sends that input/output specifically to a pipe,and it
needs to be read/written to complete.
Also, consider what's actually happening when calling popen or system
-- a fork/exec (vfork usually). This may not be give the expected
results with multithreaded programming unless particular care is
taken. (
http://forums13.itrc.hp.com/service/forums/questionanswer.do?admit=10944762…
)
You're probably better off doing this kind of programming entirely
event-driven, without any use of threads. Instead of fork/exec, have a
subprocess that is basically a shell. Send text to it corresponding to
the program you want to execute, and then select() for activity on the
file descriptor which is either the program waiting for input or
generating output. Parse the output to determine if the program has
completed successfully, but do all of the processing asynchronously
and without blocking. Basically this ends up being a state machine
driven by the outputs (events) of the subprocesses being executed,
without ever blocking to await program completion.
This is the sort of thing best done by
http://www.nist.gov/el/msid/expect.cfm or the equivalent functionality
in python. Or the asynchronous subprocess facilities of WINTERP (
http://nielsmayer.com/winterp/doc/winterp.txt ), etc.
Niels
http://nielsmayer.com
9:02 a.m.
On Fri, Oct 15, 2010 at 12:04 AM, Patrick Shirkey
<pshirkey(a)boosthardware.com> wrote:
In a bit of a time crunch. Can anyone tell me how to
do this properly?
I would like to have a threaded timer to run "cmd" after 5 seconds.
However cmd is normally triggered like this:
os.system(cmd)
But there seems to be an issue with calling os.system(cmd) from
subprocess.popen.
...
t = threading.Timer(5.0, self.do_popen(cmd))
This line seems to be your problem. You need to give threading.Timer
the function to be called, but instead your *calling* do_popen
immediately. After five seconds the timer then tries to call the
return value of do_popen, which is None.
One possible solution would be:
t = threading.Timer(5.0, functools.partial(self.do_popen, cmd))
Dominic
5145
days inactive
5146
days old
linux-audio-dev@lists.linuxaudio.org
4 comments
4 participants
participants (4)
-
Dominic Sacré -
fons＠kokkinizita.net -
Niels Mayer -
Patrick Shirkey