views:

1863

answers:

5

Is there a simple way to run a Python script on Windows/Linux/OS X?

On the latter two, subprocess.Popen("/the/script.py") works, but on Windows I get the following error:

Traceback (most recent call last):
  File "test_functional.py", line 91, in test_functional
    log = tvnamerifiy(tmp)
  File "test_functional.py", line 49, in tvnamerifiy
    stdout = PIPE
  File "C:\Python26\lib\subprocess.py", line 595, in __init__
    errread, errwrite)
  File "C:\Python26\lib\subprocess.py", line 804, in _execute_child
    startupinfo)
WindowsError: [Error 193] %1 is not a valid Win32 application


monkut's comment: The use case isn't clear. Why use subprocess to run a python script? Is there something preventing you from importing the script and calling the necessary function?

I was writing a quick script to test the overall functionality of a Python-command-line tool (to test it on various platforms). Basically it had to create a bunch of files in a temp folder, run the script on this and check the files were renamed correctly.

I could have imported the script and called the function, but since it relies on sys.argv and uses sys.exit(), I would have needed to do something like..

import sys
import tvnamer
sys.argv.append("-b", "/the/folder")
try:
    tvnamer.main()
except BaseException, errormsg:
    print type(errormsg)

Also, I wanted to capture the stdout and stderr for debugging incase something went wrong.

Of course a better way would be to write the script in more unit-testable way, but the script is basically "done" and I'm doing a final batch of testing before doing a "1.0" release (after which I'm going to do a rewrite/restructure, which will be far tidier and more testable)

Basically, it was much easier to simply run the script as a process, after finding the sys.executable variable. I would have written it as a shell-script, but that wouldn't have been cross-platform. The final script can be found here

+7  A: 

Just found sys.executable - the full path to the current Python executable, which can be used to run the script (instead of relying on the shbang, which obviously doesn't work on Windows)

import sys
import subprocess

theproc = subprocess.Popen([sys.executable, "myscript.py"])
theproc.communicate()
dbr
That's even more handy than my solution.
Robbie
+2  A: 

When you are running a python script on windows in subprocess you should use python in front of the script name. Try:

process = subprocess.Popen("python /the/script.py")
Robbie
+1  A: 

It looks like windows tries to run the script using its own EXE framework rather than call it like

python /the/script.py

Try,

subprocess.Popen(["python", "/the/script.py"])

Edit: "python" would need to be on your path.

viksit
The python.org Windows installer doesn't seem to put the "python" command in PATH, and I think it would have the .exe suffix (which would break the other platforms)
dbr
ah, I guess the .exe would break things, yes..
viksit
Hm, it seems you can exclude the .exe on Windows as long as it's in PATH, but you have to manually add Python to it
dbr
So use "cmd /S /C" instead of "python" - it's always on the path and will run the script so long as the extension is registered.
romkyns
A: 

You are using a pathname separator which is platform dependent. Windows uses "\" and Unix uses "/".

Amit
Good point, although in the actual script that caused the error I used os.path.join() (although I should have mentioned that)
dbr
Of course the forward slash has been valid on Windows since prehistoric times and still is, so that's not a problem.
romkyns
A: 

How about this:

import sys
import subprocess

theproc = subprocess.Popen("myscript.py", shell = True)
theproc.communicate()                   # ^^^^^^^^^^^^

This tells subprocess to use the OS shell to open your script, and works on anything that you can just run in cmd.exe.

Additionally, this will search the PATH for "myscript.py" - which could be desirable.

romkyns
I think that'll function the same, if I recall right shell=True just stops subprocess from escaping any special characters (so "mycmd > somefile.txt" redirects text to somefile.txt, rather than trying to execute a file called "mycmd > somefile.txt")
dbr
Here's a situation in which the two are significantly different. Suppose "myscript.py" is in the system PATH, and not in the current directory. If you use "shell = True" the script will be found on the PATH, but if you use "sys.executable" it won't.
romkyns
Ahh I see what you mean (although the script I was trying to run was always going to be in the current directory)
dbr