Nifty scroll script still not fast enough

Question

I started writing this python script because I wanted to have a scrolling, fixed-width mpc status line in my dwm top bar:
#!/usr/bin/python3
from time import time
from subprocess import getstatusoutput
import sys
_ERROR_MSG = "Usage: scrollout [-l (int)] (cmd)"
def input_cmd(cmd,l):
if cmd == "":
s = sys.stdin.read()
else:
e,s = getstatusoutput(cmd)
if e: sys.exit(1)
s = s.replace("\n"," ")
s += (" " * int(l/3))
k = len(s)
t = int(k*(time()/k-int(time()/k)))
if k <= l: # static
return s
else: # scrolling
while len(s[t:]) < l: s += s
return s[t:t+l]
def run():
_arg = -1
length = 20
cmd = ""
enter_cmd = False
flags = ("-l")
for arg in sys.argv[1:]:
if enter_cmd or (arg not in flags and _arg not in flags):
cmd += arg + " "
enter_cmd = True
elif _arg == "-l":
try:
length = int(arg)
except:
print(_ERROR_MSG)
exit(1)
_arg = arg
output=input_cmd(cmd,length)
print(output)
run()
Since it uses time since Epoch to determine how much to scroll the text at any given moment it doesn't have to have any internal loops or run any longer than it takes to compute the output. You can simply call it like so:
scrollout -l 20 mpc current
alternatively
mpc current | scrollout -l 20
For example, in my statusbar script I have the following line:
mpc_status="|$(scrollout -l 20 mpc current) ($(mpc | grep -Eo '[0-9]*\:[0-9]*\/[0-9]*\:[0-9]*')) "
I find it works nicely, but is a bit slow. Not surprisingly, since it has to re-import all of it's libraries every time it gets launched. To be a truly useful script I imagine it would have to be able to finish it's task in less than one second. Right now it's just above that, ofcourse somewhat depending on what command is being piped through it. The big timestealer, however, is the module imports (according to the python profiler). Having a pretty limited experience of programming, I would like to know if anyone knows of a good workaround for this. Perhaps some way to speed up the module imports or to mimic some of the functionality of these modules without having to import them?
Cheers,
Mach

Answer 1

Thanks a lot guys! Glad to see such enthusiasm. :-)
juster: But I don't know C! :-) Oh well, I'm working nights, so I have time to learn.
Rewrote the script in python based on juster's algorithm:
#!/usr/bin/python3
from time import time
import sys
w = 20
if len(sys.argv) > 1: w = sys.argv[1]
s = sys.stdin.read().replace("\n","") + (" " * int(w/3))
if len(s) > w:
i = int(time() % w)
while len(s[i:]) < w: s += s
s = s[i:i+w]
print(s)
Then wrote a small bash script to run each of the different variants a hundred times and output their average execution time. Brace yourselves...
The script originally posted:
# mpc current | runtime10 scrollout.py | grep nanoseconds
Average run time: 0 seconds (205726798 nanoseconds)
Roughly the same script, frozen with cx_freeze:
# mpc current | runtime10 scrollout | grep nanoseconds
Average run time: 0 seconds (166651145 nanoseconds)
The perl script submitted by juster:
# mpc current | runtime10 ./perlscrollout | grep nanoseconds
Average run time: 0 seconds (24679770 nanoseconds)
The python script from this post:
# mpc current | runtime10 ./pythonscrollout | grep nanoseconds
Average run time: 0 seconds (190167249 nanoseconds)
So, the perl script still clearly stands out. Also, the new python script doesn't stand a chance compared to the old frozen executable, even though the script itself is proven faster than the original one. A frozen version of the new script will only get me so far in optimization - obviously, this is not a job for python.
Anyone care to prove me wrong?