Popen read error

Execute a child program in a new process. On POSIX, the class uses
os.execvp()-like behavior to execute the child program. On Windows,
the class uses the Windows CreateProcess() function. The arguments to
Popen are as follows.

args should be a sequence of program arguments or else a single string.
By default, the program to execute is the first item in args if args is
a sequence. If args is a string, the interpretation is
platform-dependent and described below. See the shell and executable
arguments for additional differences from the default behavior. Unless
otherwise stated, it is recommended to pass args as a sequence.

On POSIX, if args is a string, the string is interpreted as the name or
path of the program to execute. However, this can only be done if not
passing arguments to the program.

>>> import shlex, subprocess
>>> command_line = input()
/bin/vikings -input eggs.txt -output "spam spam.txt" -cmd "echo '$MONEY'"
>>> args = shlex.split(command_line)
>>> print(args)
['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "echo '$MONEY'"]
>>> p = subprocess.Popen(args) # Success!

On Windows, if args is a sequence, it will be converted to a string in a
manner described in Converting an argument sequence to a string on Windows. This is because
the underlying CreateProcess() operates on strings.

The shell argument (which defaults to False) specifies whether to use
the shell as the program to execute. If shell is True, it is
recommended to pass args as a string rather than as a sequence.

On POSIX with shell=True, the shell defaults to /bin/sh. If
args is a string, the string specifies the command
to execute through the shell. This means that the string must be
formatted exactly as it would be when typed at the shell prompt. This
includes, for example, quoting or backslash escaping filenames with spaces in
them. If args is a sequence, the first item specifies the command string, and
any additional items will be treated as additional arguments to the shell
itself. That is to say, Popen does the equivalent of:

Popen(['/bin/sh', '-c', args[0], args[1], ...])

On Windows with shell=True, the COMSPEC environment variable
specifies the default shell. The only time you need to specify
shell=True on Windows is when the command you wish to execute is built
into the shell (e.g. dir or copy). You do not need
shell=True to run a batch file or console-based executable.

bufsize will be supplied as the corresponding argument to the
open() function when creating the stdin/stdout/stderr pipe
file objects:

• 0 means unbuffered (read and write are one
  system call and can return short)
• 1 means line buffered
  (only usable if universal_newlines=True i.e., in a text mode)
• any other positive value means use a buffer of approximately that
  size
• negative bufsize (the default) means the system default of
  io.DEFAULT_BUFFER_SIZE will be used.

Changed in version 3.3.1: bufsize now defaults to -1 to enable buffering by default to match the
behavior that most code expects. In versions prior to Python 3.2.4 and
3.3.1 it incorrectly defaulted to 0 which was unbuffered
and allowed short reads. This was unintentional and did not match the
behavior of Python 2 as most code expected.

The executable argument specifies a replacement program to execute. It
is very seldom needed. When shell=False, executable replaces the
program to execute specified by args. However, the original args is
still passed to the program. Most programs treat the program specified
by args as the command name, which can then be different from the program
actually executed. On POSIX, the args name
becomes the display name for the executable in utilities such as
ps. If shell=True, on POSIX the executable argument
specifies a replacement shell for the default /bin/sh.

stdin, stdout and stderr specify the executed program’s standard input,
standard output and standard error file handles, respectively. Valid values
are PIPE, DEVNULL, an existing file descriptor (a positive
integer), an existing file object, and None. PIPE
indicates that a new pipe to the child should be created. DEVNULL
indicates that the special file os.devnull will be used. With the
default settings of None, no redirection will occur; the child’s file
handles will be inherited from the parent. Additionally, stderr can be
STDOUT, which indicates that the stderr data from the applications
should be captured into the same file handle as for stdout.

If preexec_fn is set to a callable object, this object will be called in the
child process just before the child is executed.
(POSIX only)

If close_fds is true, all file descriptors except 0, 1 and
2 will be closed before the child process is executed. (POSIX only).
The default varies by platform: Always true on POSIX. On Windows it is
true when stdin/stdout/stderr are None, false otherwise.
On Windows, if close_fds is true then no handles will be inherited by the
child process. Note that on Windows, you cannot set close_fds to true and
also redirect the standard handles by setting stdin, stdout or stderr.

Changed in version 3.2: The default for close_fds was changed from False to
what is described above.

pass_fds is an optional sequence of file descriptors to keep open
between the parent and child. Providing any pass_fds forces
close_fds to be True. (POSIX only)

New in version 3.2: The pass_fds parameter was added.

If cwd is not None, the function changes the working directory to
cwd before executing the child. cwd can be a str and
path-like object. In particular, the function
looks for executable (or for the first item in args) relative to cwd
if the executable path is a relative path.

Changed in version 3.6: cwd parameter accepts a path-like object.

If restore_signals is true (the default) all signals that Python has set to
SIG_IGN are restored to SIG_DFL in the child process before the exec.
Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals.
(POSIX only)

Changed in version 3.2: restore_signals was added.

If start_new_session is true the setsid() system call will be made in the
child process prior to the execution of the subprocess. (POSIX only)

Changed in version 3.2: start_new_session was added.

If env is not None, it must be a mapping that defines the environment
variables for the new process; these are used instead of the default
behavior of inheriting the current process’ environment.

If encoding or errors are specified, the file objects stdin, stdout
and stderr are opened in text mode with the specified encoding and
errors, as described above in Frequently Used Arguments. If
universal_newlines is True, they are opened in text mode with default
encoding. Otherwise, they are opened as binary streams.

New in version 3.6: encoding and errors were added.

If given, startupinfo will be a STARTUPINFO object, which is
passed to the underlying CreateProcess function.
creationflags, if given, can be one or more of the following flags:

• CREATE_NEW_CONSOLE
• CREATE_NEW_PROCESS_GROUP
• ABOVE_NORMAL_PRIORITY_CLASS
• BELOW_NORMAL_PRIORITY_CLASS
• HIGH_PRIORITY_CLASS
• IDLE_PRIORITY_CLASS
• NORMAL_PRIORITY_CLASS
• REALTIME_PRIORITY_CLASS
• CREATE_NO_WINDOW
• DETACHED_PROCESS
• CREATE_DEFAULT_ERROR_MODE
• CREATE_BREAKAWAY_FROM_JOB

Popen objects are supported as context managers via the with statement:
on exit, standard file descriptors are closed, and the process is waited for.

with Popen(["ifconfig"], stdout=PIPE) as proc:
    log.write(proc.stdout.read())

Changed in version 3.2: Added context manager support.

Changed in version 3.6: Popen destructor now emits a ResourceWarning warning if the child
process is still running.

Содержание:

• Проверка на завершение процесса Popen.poll(),
• Ожидание завершения процесса Popen.wait(),
• Взаимодействие с процессом Popen.communicate(),
• Послать сигнал процессу Popen.send_signal(),
• Остановить процесс Popen.terminate(),
• Убить процесс Popen.kill(),
• Вернуть имя программы со всеми параметрами Popen.args(),
• Передать данные процессу Popen.stdin(),
• Извлечь генерируемые данные процессом Popen.stdout(),
• Извлечь ошибки процесса Popen.stderr(),
• Посмотреть pid процесса Popen.pid(),
• Посмотреть код, с которым завершился процесс Popen.returncode().

Методы объекта Popen.

Popen.poll():

Метод Popen.poll() проверяет, завершен ли дочерний процесс. Возвращает атрибут кода возврата Popen.returncode. В противном случае возвращает None.

>>> import time, subprocess
>>> proc = subprocess.Popen(['sleep', '30'])
>>> print(proc.poll())
# None

# после 30 секунд
>>> print(proc.poll())
# 0
>>> proc.returncode
# 0

Popen.wait(timeout=None):

Метод Popen.wait() ждет завершения дочернего процесса. Возвращает атрибут кода возврата Popen.returncode.

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '10'])
>>> proc.wait()
# 0
>>> proc = subprocess.Popen(['sleep', '10'])
>>> proc.wait(5)
# Traceback (most recent call last):
#     raise TimeoutExpired(self.args, timeout)
# subprocess.TimeoutExpired: Command '['sleep', '10']' timed out after 5 seconds

Примечание:

• Метод Popen.wait() приведет к взаимоблокировке при использовании stdout=subprocess.PIPE или stderr=subprocess.PIPE если дочерний процесс генерирует достаточно данных для канала. Метод блокирует ожидание буфера канала ОС для приема большего количества данных. Используйте метод Popen.communicate() при использовании каналов, чтобы избежать этого.
• Метод реализован с использованием цикла занятости (неблокирующий вызов и короткие спящие режимы). Используйте модуль asyncio для асинхронного ожидания.

Popen.communicate(input=None, timeout=None):

Метод Popen.communicate() взаимодействует с процессом, отправляя данные в stdin и читает данные из stdout и stderr, пока не будет достигнут конец файла. Необязательным входным аргументом должны быть данные input, которые будут отправлены дочернему процессу или None, если никакие данные отправлять не требуется.

Метод Popen.communicate() возвращает кортеж (stdout_data, stderr_data). Данные будут строками, если потоки были открыты в текстовом режиме, в противном случае байты.

>>> from subprocess import Popen, PIPE
>>> cmd = ['ls', '-Rla', '/tmp']
>>> proc = Popen(cmd, stdout=PIPE, stderr=PIPE, encoding='utf-8')
>>> stdout, stderr = proc.communicate()
>>> print(stdout)
# /tmp:
# итого 76
# drwxrwxrwt 17 root   root   4096 мая 13 15:06 .
# drwxr-xr-x 26 root   root   4096 апр 30 09:18 ..
# drwxrwxrwt  2 root   root   4096 мая 13 07:35 .font-unix
# drwxrwxrwt  2 root   root   4096 мая 13 07:35 .ICE-unix
# ...
# ...
>>> print(stderr)
# ls: невозможно открыть каталог ... Отказано в доступе
# ls: невозможно открыть каталог ... Отказано в доступе
# ...
# ...

Если истекает время ожидания timeout, то дочерний процесс не уничтожается, поэтому для правильной очистки, приложение с хорошим поведением должно завершить дочерний процесс и завершить соединение:

# псевдокод
proc = subprocess.Popen(...)
try:
    outs, errs = proc.communicate(timeout=15)
except TimeoutExpired:
    proc.kill()
    outs, errs = proc.communicate()

Примечание:

• Считываемые данные буферизируются в памяти, поэтому не используйте этот метод, если размер данных большой или неограниченный. В этом случае пишите данные в лог-файл, пример смотрите в разделе «Часто используемые параметры модуля subprocess«.

Popen.send_signal(signal):

Метод Popen.send_signal() посылает сигнал signal дочернему процессу.

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '60'])
>>> proc.send_signal(9)
>>> proc.poll()
# -9

Примечание:

• В Windows SIGTERM является псевдонимом Popen.terminate(). CTRL_C_EVENT и CTRL_BREAK_EVENT можно отправлять процессам, запущенным с параметром creationflags, который включает CREATE_NEW_PROCESS_GROUP.

Popen.terminate():

Метод Popen.terminate() останавливает дочерний процесс.

• В ОС Unix метод отправляет SIGTERM дочернему процессу.
• В Windows вызывается Win32 API-функция TerminateProcess().

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '60'])
>>> proc.terminate()
>>> proc.poll()
# -15

Popen.kill():

Метод Popen.kill() убивает дочерний процесс.

• В ОС Unix функция отправляет SIGKILL ребенку.
• В Windows метод Popen.kill() является псевдонимом Popen.terminate().

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '60'])
>>> proc.kill()
>>> proc.poll()
-9

Атрибуты объекта Popen.

Popen.args:

Атрибут Popen.args() возвращает аргумент args в том виде, как он был передан в subprocess.Popen(). Представляет из себя список аргументов программы или отдельная строка.

Popen.stdin:

Если аргумент stdin=subprocess.PIPE, то атрибут Popen.stdin() является записываемым объектом потока, возвращаемым функцией open().

Если были заданы аргументы encoding или errors, или text=True (также известный как universal_newlines), то Popen.stdin() является текстовым потоком, в противном случае это поток байтов.

Если аргумент stdin не был равен subprocess.PIPE, то этот атрибут будет возвращать None.

Предупреждение:

• Используйте метод Popen.communicate() вместо методов Popen.stdin.write(), чтобы избежать взаимных блокировок из-за того, что другие буферы конвейера ОС заполняют и блокируют дочерний процесс.

Popen.stdout:

Если аргумент stdout=subprocess.PIPE, то атрибут Popen.stdout() является читаемым объектом потока, возвращаемым функцией open(). Чтение из потока stdout обеспечивает вывод генерируемых данных от дочернего процесса.

Если были заданы аргументы encoding или errors, или text=True (также известный как universal_newlines), то Popen.stdout() является текстовым потоком, в противном случае это поток байтов.

Если аргумент stdout не был равен subprocess.PIPE, то этот атрибут будет возвращать None.

Предупреждение:

• Используйте метод Popen.communicate() вместо метода Popen.stdout.read(), чтобы избежать взаимных блокировок из-за того, что другие буферы конвейера ОС заполняют и блокируют дочерний процесс.

Popen.stderr:

Если аргумент stderr=subprocess.PIPE, то атрибут Popen.stderr() является читаемым объектом потока, возвращаемым open (). Чтение из потока stderr обеспечивает вывод ошибок от дочернего процесса.

Если были заданы аргументы encoding или errors, или text=True (также известный как universal_newlines), то Popen.stderr() является текстовым потоком, в противном случае это поток байтов.

Если аргумент stderr не был равен subprocess.PIPE, то этот атрибут будет возвращать None.

Предупреждение:

• Используйте метод Popen.communicate() вместо методаPopen.stderr.read(), чтобы избежать взаимных блокировок из-за того, что другие буферы конвейера ОС заполняют и блокируют дочерний процесс.

Popen.pid:

Атрибут Popen.pid() возвращает идентификатор ID процесса дочернего процесса.

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '10'])
>>> proc.pid
# 6016

Popen.returncode:

Атрибут Popen.returncode() это код возврата дочернего процесса, установленный Popen.poll() и Popen.wait() и косвенно — Popen.communicate(). Значение None указывает, что процесс еще не завершен.

Отрицательное значение -N указывает на то, что дочерний элемент был прерван сигналом N. Справедливо только для Unix.

>>> import subprocess
>>> proc = subprocess.Popen(['sleep', '20'])
>>> print(proc.returncode)
# None
>>> proc.terminate()
>>> proc.poll()
# -15
>>> proc.returncode
# -15

The subprocess module provides a consistent interface to
creating and working with additional processes. It offers a
higher-level interface than some of the other available modules, and
is intended to replace functions such as os.system(),
os.spawn*(), os.popen*(), popen2.*() and
commands.*(). To make it easier to compare subprocess
with those other modules, many of the examples here re-create the ones
used for os and popen.

The subprocess module defines one class, Popen and a
few wrapper functions that use that class. The constructor for
Popen takes arguments to set up the new process so the parent
can communicate with it via pipes. It provides all of the
functionality of the other modules and functions it replaces, and
more. The API is consistent for all uses, and many of the extra steps
of overhead needed (such as closing extra file descriptors and
ensuring the pipes are closed) are “built in” instead of being handled
by the application code separately.

import subprocess

# Simple command
subprocess.call(['ls', '-1'], shell=True)

$ python subprocess_os_system.py

__init__.py
index.rst
interaction.py
repeater.py
signal_child.py
signal_parent.py
subprocess_check_call.py
subprocess_check_output.py
subprocess_check_output_error.py
subprocess_check_output_error_trap_output.py
subprocess_os_system.py
subprocess_pipes.py
subprocess_popen2.py
subprocess_popen3.py
subprocess_popen4.py
subprocess_popen_read.py
subprocess_popen_write.py
subprocess_shell_variables.py
subprocess_signal_parent_shell.py
subprocess_signal_setsid.py

import subprocess

# Command with shell expansion
subprocess.call('echo $HOME', shell=True)

$ python subprocess_shell_variables.py

/Users/dhellmann

import subprocess

subprocess.check_call(['false'])

$ python subprocess_check_call.py

Traceback (most recent call last):
  File "subprocess_check_call.py", line 11, in <module>
    subprocess.check_call(['false'])
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", line 511, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command '['false']' returned non-zero e
xit status 1

import subprocess

output = subprocess.check_output(['ls', '-1'])
print 'Have %d bytes in output' % len(output)
print output

                                  

$ python subprocess_check_output.py

Have 462 bytes in output
__init__.py
index.rst
interaction.py
repeater.py
signal_child.py
signal_parent.py
subprocess_check_call.py
subprocess_check_output.py
subprocess_check_output_error.py
subprocess_check_output_error_trap_output.py
subprocess_os_system.py
subprocess_pipes.py
subprocess_popen2.py
subprocess_popen3.py
subprocess_popen4.py
subprocess_popen_read.py
subprocess_popen_write.py
subprocess_shell_variables.py
subprocess_signal_parent_shell.py
subprocess_signal_setsid.py

import subprocess

output = subprocess.check_output(
    'echo to stdout; echo to stderr 1>&2; exit 1',
    shell=True,
    )
print 'Have %d bytes in output' % len(output)
print output

                                  

$ python subprocess_check_output_error.py

to stderr
Traceback (most recent call last):
  File "subprocess_check_output_error.py", line 14, in <module>
    shell=True,
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", line 544, in check_output
    raise CalledProcessError(retcode, cmd, output=output)
subprocess.CalledProcessError: Command 'echo to stdout; echo to stderr
 1>&2; exit 1' returned non-zero exit status 1

import subprocess

output = subprocess.check_output(
    'echo to stdout; echo to stderr 1>&2; exit 1',
    shell=True,
    stderr=subprocess.STDOUT,
    )
print 'Have %d bytes in output' % len(output)
print output

                                  

$ python subprocess_check_output_error_trap_output.py

Traceback (most recent call last):
  File "subprocess_check_output_error_trap_output.py", line 15, in <mo
dule>
    stderr=subprocess.STDOUT,
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", line 544, in check_output
    raise CalledProcessError(retcode, cmd, output=output)
subprocess.CalledProcessError: Command 'echo to stdout; echo to stderr
 1>&2; exit 1' returned non-zero exit status 1

import subprocess

print 'nread:'
proc = subprocess.Popen(['echo', '"to stdout"'], 
                        stdout=subprocess.PIPE,
                        )
stdout_value = proc.communicate()[0]
print 'tstdout:', repr(stdout_value)

$ python subprocess_popen_read.py


read:
        stdout: '"to stdout"n'

import subprocess

print 'nwrite:'
proc = subprocess.Popen(['cat', '-'],
                        stdin=subprocess.PIPE,
                        )
proc.communicate('tstdin: to stdinn')

$ python -u subprocess_popen_write.py


write:
        stdin: to stdin

import subprocess

print 'npopen2:'

proc = subprocess.Popen(['cat', '-'],
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        )
stdout_value = proc.communicate('through stdin to stdout')[0]
print 'tpass through:', repr(stdout_value)

$ python -u subprocess_popen2.py


popen2:
        pass through: 'through stdin to stdout'

import subprocess

print 'npopen3:'
proc = subprocess.Popen('cat -; echo "to stderr" 1>&2',
                        shell=True,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE,
                        )
stdout_value, stderr_value = proc.communicate('through stdin to stdout')
print 'tpass through:', repr(stdout_value)
print 'tstderr      :', repr(stderr_value)

$ python -u subprocess_popen3.py


popen3:
        pass through: 'through stdin to stdout'
        stderr      : 'to stderrn'

import subprocess

print 'npopen4:'
proc = subprocess.Popen('cat -; echo "to stderr" 1>&2',
                        shell=True,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        )
stdout_value, stderr_value = proc.communicate('through stdin to stdoutn')
print 'tcombined output:', repr(stdout_value)
print 'tstderr value   :', repr(stderr_value)

$ python -u subprocess_popen4.py


popen4:
        combined output: 'through stdin to stdoutnto stderrn'
        stderr value   : None

import subprocess

cat = subprocess.Popen(['cat', 'index.rst'], 
                        stdout=subprocess.PIPE,
                        )

grep = subprocess.Popen(['grep', '.. include::'],
                        stdin=cat.stdout,
                        stdout=subprocess.PIPE,
                        )

cut = subprocess.Popen(['cut', '-f', '3', '-d:'],
                        stdin=grep.stdout,
                        stdout=subprocess.PIPE,
                        )

end_of_pipe = cut.stdout

print 'Included files:'
for line in end_of_pipe:
    print 't', line.strip()

$ python -u subprocess_pipes.py

Included files:
        subprocess_os_system.py
        subprocess_shell_variables.py
        subprocess_check_call.py
        subprocess_check_output.py
        subprocess_check_output_error.py
        subprocess_check_output_error_trap_output.py
        subprocess_popen_read.py
        subprocess_popen_write.py
        subprocess_popen2.py
        subprocess_popen3.py
        subprocess_popen4.py
        subprocess_pipes.py
        repeater.py
        interaction.py
        signal_child.py
        signal_parent.py
        subprocess_signal_parent_shell.py
        subprocess_signal_setsid.py

import sys

sys.stderr.write('repeater.py: startingn')
sys.stderr.flush()

while True:
    next_line = sys.stdin.readline()
    if not next_line:
        break
    sys.stdout.write(next_line)
    sys.stdout.flush()

sys.stderr.write('repeater.py: exitingn')
sys.stderr.flush()

import subprocess

print 'One line at a time:'
proc = subprocess.Popen('python repeater.py', 
                        shell=True,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        )
for i in range(10):
    proc.stdin.write('%dn' % i)
    output = proc.stdout.readline()
    print output.rstrip()
remainder = proc.communicate()[0]
print remainder

print
print 'All output at once:'
proc = subprocess.Popen('python repeater.py', 
                        shell=True,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        )
for i in range(10):
    proc.stdin.write('%dn' % i)

output = proc.communicate()[0]
print output

$ python -u interaction.py

One line at a time:
repeater.py: starting
0
1
2
3
4
5
6
7
8
9
repeater.py: exiting


All output at once:
repeater.py: starting
repeater.py: exiting
0
1
2
3
4
5
6
7
8
9

import os
import signal
import time
import sys

pid = os.getpid()
received = False

def signal_usr1(signum, frame):
    "Callback invoked when a signal is received"
    global received
    received = True
    print 'CHILD %6s: Received USR1' % pid
    sys.stdout.flush()

print 'CHILD %6s: Setting up signal handler' % pid
sys.stdout.flush()
signal.signal(signal.SIGUSR1, signal_usr1)
print 'CHILD %6s: Pausing to wait for signal' % pid
sys.stdout.flush()
time.sleep(3)

if not received:
    print 'CHILD %6s: Never received signal' % pid

import os
import signal
import subprocess
import time
import sys

proc = subprocess.Popen(['python', 'signal_child.py'])
print 'PARENT      : Pausing before sending signal...'
sys.stdout.flush()
time.sleep(1)
print 'PARENT      : Signaling child'
sys.stdout.flush()
os.kill(proc.pid, signal.SIGUSR1)

$ python signal_parent.py

PARENT      : Pausing before sending signal...
CHILD  14756: Setting up signal handler
CHILD  14756: Pausing to wait for signal
PARENT      : Signaling child
CHILD  14756: Received USR1

import os
import signal
import subprocess
import tempfile
import time
import sys

script = '''#!/bin/sh
echo "Shell script in process $$"
set -x
python signal_child.py
'''
script_file = tempfile.NamedTemporaryFile('wt')
script_file.write(script)
script_file.flush()

proc = subprocess.Popen(['sh', script_file.name], close_fds=True)
print 'PARENT      : Pausing before sending signal to child %s...' % proc.pid
sys.stdout.flush()
time.sleep(1)
print 'PARENT      : Signaling child %s' % proc.pid
sys.stdout.flush()
os.kill(proc.pid, signal.SIGUSR1)
time.sleep(3)

$ python subprocess_signal_parent_shell.py

PARENT      : Pausing before sending signal to child 14759...
Shell script in process 14759
+ python signal_child.py
CHILD  14760: Setting up signal handler
CHILD  14760: Pausing to wait for signal
PARENT      : Signaling child 14759
CHILD  14760: Never received signal

import os
import signal
import subprocess
import tempfile
import time
import sys

script = '''#!/bin/sh
echo "Shell script in process $$"
set -x
python signal_child.py
'''
script_file = tempfile.NamedTemporaryFile('wt')
script_file.write(script)
script_file.flush()

proc = subprocess.Popen(['sh', script_file.name], 
                        close_fds=True,
                        preexec_fn=os.setsid,
                        )
print 'PARENT      : Pausing before sending signal to child %s...' % proc.pid
sys.stdout.flush()
time.sleep(1)
print 'PARENT      : Signaling process group %s' % proc.pid
sys.stdout.flush()
os.killpg(proc.pid, signal.SIGUSR1)
time.sleep(3)

$ python subprocess_signal_setsid.py

PARENT      : Pausing before sending signal to child 14763...
Shell script in process 14763
+ python signal_child.py
CHILD  14764: Setting up signal handler
CHILD  14764: Pausing to wait for signal
PARENT      : Signaling process group 14763
CHILD  14764: Received USR1

Exceptions raised in the child process, before the new program has started to execute, will be re-raised in the parent.

The most common exception raised is OSError. This occurs, for example, when trying to execute a non-existent file. Applications should prepare for OSError exceptions. Note that, when shell=True, OSError will be raised by the child only if the selected shell itself was not found. To determine if the shell failed to find the requested application, it is necessary to check the return code or output from the subprocess.

A ValueError will be raised if Popen is called with invalid arguments.

check_call() and check_output() will raise CalledProcessError if the called process returns a non-zero return code.

All of the functions and methods that accept a timeout parameter, such as call() and Popen.communicate() will raise TimeoutExpired if the timeout expires before the process exits.

Exceptions defined in this module all inherit from SubprocessError.

New in version 3.3: The SubprocessError base class was added.

Python

3.11

• subprocess — Subprocess management

  Source code: Lib/subprocess.py The subprocess module allows you to spawn new processes, connect their input/output/error pipes, and obtain return codes.

• Popen Constructor

  The underlying process creation and management this module handled by Popen class.

• Older high-level API

  Prior to Python 3.5, these three functions comprised high level API subprocess.

• symtable — Access to the compiler’s symbol tables

  Source code: Lib/symtable.py Symbol tables are generated by the compiler from AST just before bytecode is Return the toplevel SymbolTable for Python source

I am a beginner at python coding.

I wrote a simple code that lists a number of programs and asks the user to choose one of the programs. It will then open a website with the version history of that program, and, where it exists, run the updater of the program.

Initially I wrote the program manually writing out the list of programs (20) and then manually write out the url and, where relevant, the path and file name to the updater. Something like:

if choice == 1
   url = 'https://blablabla'
   prg = 'C:\Program Files\blablabla'

After manually defining the URL and prg variables for all 20 options, I run:

webbrowser.open_new_tab(url)
subprocess.Popen(prg)

This works fine.

Then I tried to write the code where the list of programs and the url and file paths are listed in a .csv file. The values for the url and prg variables are read from the .csv file (using numpy load.txt)

webbrowser.open_new_tab(url)

works fine

However:

subprocess.Popen(prg)

gives an error message if the file path has a blank space in it (which is in 19 out of the 20 options). The error message is:

Error:
Traceback (most recent call last):
 File "test.py", line 32, in <module>
   mainmenu()
 File "test.py", line 30, in mainmenu
   subprocess.Popen(prg)
 File "C:UserszorinAppDataLocalProgramsPythonPython38libsubprocess.py", line 858, in _init__
   self._execute_child(args, executable, preexec_fn, close_fds,
 File "C:UserszorinAppDataLocalProgramsPythonPython38libsubprocess.py", line 1311, in _execute_child
    hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
FileNotFoundError: [WinError 2] The system cannot find the file specified

One example:

In the original (long-winded)code I manually set the full file name for Chrome:

prg = 'C:\Program Files\Google\Chrome\Application\chrome.exe'

and

subprocess.Popen(prg)

runs Chrome without a problem.

In the updated code the same full file name is read into prg, but this time

subprocess.Popen(prg)

gives the above-mentioned error code (if the file path has a black space it).

In the new code

print(prg)

will give:

Output:
C:\Program Files\Google\Chrome\Application\chrome.exe

so the correct value is read into the variable.

Any suggestions what I am doing wrong?

I use Windows