On Windows, the default event loop is SelectorEventLoop which does not support subprocesses. ProactorEventLoop should be used instead. Example to use it on Windows:
import asyncio, sys
if sys.platform == 'win32':
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
See also
Use the BaseEventLoop.connect_read_pipe() and BaseEventLoop.connect_write_pipe() methods to connect pipes.
Run subprocesses asynchronously using the subprocess module.
See also
The BaseEventLoop.connect_read_pipe() and BaseEventLoop.connect_write_pipe() methods.
Special value that can be used as the stdin, stdout or stderr argument to create_subprocess_shell() and create_subprocess_exec() and indicates that a pipe to the standard stream should be opened.
Special value that can be used as the stderr argument to create_subprocess_shell() and create_subprocess_exec() and indicates that standard error should go into the same handle as standard output.
Special value that can be used as the stdin, stdout or stderr argument to create_subprocess_shell() and create_subprocess_exec() and indicates that the special file os.devnull will be used.
A subprocess created by the create_subprocess_exec() or the create_subprocess_shell() function.
The API of the Process class was designed to be close to the API of the subprocess.Popen class, but there are some differences:
This class is not thread safe. See also the Subprocess and threads section.
Sends the signal signal to the child process.
Note
On Windows, SIGTERM is an alias for terminate(). CTRL_C_EVENT and CTRL_BREAK_EVENT can be sent to processes started with a creationflags parameter which includes CREATE_NEW_PROCESS_GROUP.
Stop the child. On Posix OSs the method sends signal.SIGTERM to the child. On Windows the Win32 API function TerminateProcess() is called to stop the child.
Kills the child. On Posix OSs the function sends SIGKILL to the child. On Windows kill() is an alias for terminate().
Standard input stream (StreamWriter), None if the process was created with stdin=None.
Standard output stream (StreamReader), None if the process was created with stdout=None.
Standard error stream (StreamReader), None if the process was created with stderr=None.
Warning
Use the communicate() method rather than .stdin.write, .stdout.read or .stderr.read to avoid deadlocks due to streams pausing reading or writing and blocking the child process.
The identifier of the process.
Note that for processes created by the create_subprocess_shell() function, this attribute is the process identifier of the spawned shell.
Return code of the process when it exited. A None value indicates that the process has not terminated yet.
A negative value -N indicates that the child was terminated by signal N (Unix only).
asyncio supports running subprocesses from different threads, but there are limits:
The asyncio.subprocess.Process class is not thread safe.
See also
The Concurrency and multithreading in asyncio section.
Example of a subprocess protocol using to get the output of a subprocess and to wait for the subprocess exit. The subprocess is created by the BaseEventLoop.subprocess_exec() method:
import asyncio
import sys
class DateProtocol(asyncio.SubprocessProtocol):
def __init__(self, exit_future):
self.exit_future = exit_future
self.output = bytearray()
def pipe_data_received(self, fd, data):
self.output.extend(data)
def process_exited(self):
self.exit_future.set_result(True)
@asyncio.coroutine
def get_date(loop):
code = 'import datetime; print(datetime.datetime.now())'
exit_future = asyncio.Future(loop=loop)
# Create the subprocess controlled by the protocol DateProtocol,
# redirect the standard output into a pipe
create = loop.subprocess_exec(lambda: DateProtocol(exit_future),
sys.executable, '-c', code,
stdin=None, stderr=None)
transport, protocol = yield from create
# Wait for the subprocess exit using the process_exited() method
# of the protocol
yield from exit_future
# Close the stdout pipe
transport.close()
# Read the output which was collected by the pipe_data_received()
# method of the protocol
data = bytes(protocol.output)
return data.decode('ascii').rstrip()
if sys.platform == "win32":
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
date = loop.run_until_complete(get_date(loop))
print("Current date: %s" % date)
loop.close()
Example using the Process class to control the subprocess and the StreamReader class to read from the standard output. The subprocess is created by the create_subprocess_exec() function:
import asyncio.subprocess
import sys
@asyncio.coroutine
def get_date():
code = 'import datetime; print(datetime.datetime.now())'
# Create the subprocess, redirect the standard output into a pipe
create = asyncio.create_subprocess_exec(sys.executable, '-c', code,
stdout=asyncio.subprocess.PIPE)
proc = yield from create
# Read one line of output
data = yield from proc.stdout.readline()
line = data.decode('ascii').rstrip()
# Wait for the subprocess exit
yield from proc.wait()
return line
if sys.platform == "win32":
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
date = loop.run_until_complete(get_date())
print("Current date: %s" % date)
loop.close()