Imprime constantemente a saída do subprocesso enquanto o processo está em execução

Para iniciar programas dos meus scripts Python, estou usando o seguinte método:

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Então, quando inicio um processo como Process.execute("mvn clean install"), meu programa aguarda até que o processo termine e só então recebo a saída completa do meu programa. Isso é chato se eu estiver executando um processo que demora um pouco para terminar.

Posso deixar meu programa escrever a saída do processo linha por linha, pesquisando a saída do processo antes que ela termine em um loop ou algo assim?

** [EDIT] Desculpe, não pesquisei muito bem antes de postar esta pergunta. Rosquear é realmente a chave. Encontrei um exemplo aqui que mostra como fazê-lo: ** Python Subprocess.Popen from a thread

Você pode usar o iter para processar linhas assim que as saídas de comandá-los: lines = iter(fd.readline, ""). Aqui está um exemplo completo mostrando um caso de uso típico (obrigado a @jfs por ajudar):

from __future__ import print_function # Only Python 2.x
import subprocess

def execute(cmd):
    popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True)
    for stdout_line in iter(popen.stdout.readline, ""):
        yield stdout_line 
    popen.stdout.close()
    return_code = popen.wait()
    if return_code:
        raise subprocess.CalledProcessError(return_code, cmd)

# Example
for path in execute(["locate", "a"]):
    print(path, end="")

Ok, eu consegui resolvê-lo sem threads (qualquer sugestão de por que usar threads seria melhor é apreciada) usando um trecho desta pergunta Interceptando o stdout de um subprocesso enquanto ele está sendo executado

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    # Poll process for new output until finished
    while True:
        nextline = process.stdout.readline()
        if nextline == '' and process.poll() is not None:
            break
        sys.stdout.write(nextline)
        sys.stdout.flush()

    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Para imprimir a saída do subprocesso linha por linha assim que seu buffer stdout for liberado no Python 3:

from subprocess import Popen, PIPE, CalledProcessError

with Popen(cmd, stdout=PIPE, bufsize=1, universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='') # process line here

if p.returncode != 0:
    raise CalledProcessError(p.returncode, p.args)

Aviso: você não precisa p.poll()- o loop termina quando eof é atingido. E você não precisaiter(p.stdout.readline, '') - o bug de leitura antecipada foi corrigido no Python 3.

Veja também, Python: leia a entrada de streaming de subprocess.communicate () .

Na verdade, existe uma maneira muito simples de fazer isso quando você deseja imprimir a saída:

import subprocess
import sys

def execute(command):
    subprocess.check_call(command, stdout=sys.stdout, stderr=subprocess.STDOUT)

Aqui, estamos simplesmente apontando o subprocesso para nosso próprio stdout e usando a API de êxito ou exceção existente.

@tokland

tentei seu código e o corrigi para 3,4 e o Windows dir.cmd é um comando dir simples, salvo como arquivo cmd

import subprocess
c = "dir.cmd"

def execute(command):
    popen = subprocess.Popen(command, stdout=subprocess.PIPE,bufsize=1)
    lines_iterator = iter(popen.stdout.readline, b"")
    while popen.poll() is None:
        for line in lines_iterator:
            nline = line.rstrip()
            print(nline.decode("latin"), end = "\r\n",flush =True) # yield line

execute(c)

Caso alguém queira ler ambos stdoute stderrao mesmo tempo usando threads, é isso que eu criei:

import threading
import subprocess
import Queue

class AsyncLineReader(threading.Thread):
    def __init__(self, fd, outputQueue):
        threading.Thread.__init__(self)

        assert isinstance(outputQueue, Queue.Queue)
        assert callable(fd.readline)

        self.fd = fd
        self.outputQueue = outputQueue

    def run(self):
        map(self.outputQueue.put, iter(self.fd.readline, ''))

    def eof(self):
        return not self.is_alive() and self.outputQueue.empty()

    @classmethod
    def getForFd(cls, fd, start=True):
        queue = Queue.Queue()
        reader = cls(fd, queue)

        if start:
            reader.start()

        return reader, queue


process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdoutReader, stdoutQueue) = AsyncLineReader.getForFd(process.stdout)
(stderrReader, stderrQueue) = AsyncLineReader.getForFd(process.stderr)

# Keep checking queues until there is no more output.
while not stdoutReader.eof() or not stderrReader.eof():
   # Process all available lines from the stdout Queue.
   while not stdoutQueue.empty():
       line = stdoutQueue.get()
       print 'Received stdout: ' + repr(line)

       # Do stuff with stdout line.

   # Process all available lines from the stderr Queue.
   while not stderrQueue.empty():
       line = stderrQueue.get()
       print 'Received stderr: ' + repr(line)

       # Do stuff with stderr line.

   # Sleep for a short time to avoid excessive CPU use while waiting for data.
   sleep(0.05)

print "Waiting for async readers to finish..."
stdoutReader.join()
stderrReader.join()

# Close subprocess' file descriptors.
process.stdout.close()
process.stderr.close()

print "Waiting for process to exit..."
returnCode = process.wait()

if returnCode != 0:
   raise subprocess.CalledProcessError(returnCode, command)

Eu só queria compartilhar isso, pois acabei tentando fazer algo semelhante, mas nenhuma das respostas resolveu meu problema. Espero que ajude alguém!

Observe que, no meu caso de uso, um processo externo mata o processo que nós Popen().

Para quem tenta as respostas a esta pergunta para obter o stdout de um script Python, observe que o Python armazena em buffer seu stdout e, portanto, pode demorar um pouco para vê-lo.

Isso pode ser corrigido adicionando o seguinte após cada gravação stdout no script de destino:

sys.stdout.flush()

Em Python> = 3.5, o subprocess.runWorks funciona para mim:

import subprocess

cmd = 'echo foo; sleep 1; echo foo; sleep 2; echo foo'
subprocess.run(cmd, shell=True)

(obter a saída durante a execução também funciona sem shell=True) https://docs.python.org/3/library/subprocess.html#subprocess.run

Para responder à pergunta original, a melhor maneira de o IMO é apenas redirecionar o subprocesso stdoutdiretamente para o programa stdout(opcionalmente, o mesmo pode ser feito stderr, como no exemplo abaixo)

p = Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.communicate()

Esse PoC lê constantemente a saída de um processo e pode ser acessado quando necessário. Somente o último resultado é mantido, todas as outras saídas são descartadas, impedindo o PIPE de ficar sem memória:

import subprocess
import time
import threading
import Queue


class FlushPipe(object):
    def __init__(self):
        self.command = ['python', './print_date.py']
        self.process = None
        self.process_output = Queue.LifoQueue(0)
        self.capture_output = threading.Thread(target=self.output_reader)

    def output_reader(self):
        for line in iter(self.process.stdout.readline, b''):
            self.process_output.put_nowait(line)

    def start_process(self):
        self.process = subprocess.Popen(self.command,
                                        stdout=subprocess.PIPE)
        self.capture_output.start()

    def get_output_for_processing(self):
        line = self.process_output.get()
        print ">>>" + line


if __name__ == "__main__":
    flush_pipe = FlushPipe()
    flush_pipe.start_process()

    now = time.time()
    while time.time() - now < 10:
        flush_pipe.get_output_for_processing()
        time.sleep(2.5)

    flush_pipe.capture_output.join(timeout=0.001)
    flush_pipe.process.kill()

print_date.py

#!/usr/bin/env python
import time

if __name__ == "__main__":
    while True:
        print str(time.time())
        time.sleep(0.01)

saída: Você pode ver claramente que só há saída a partir do intervalo ~ 2,5s, nada entre elas.

>>>1520535158.51
>>>1520535161.01
>>>1520535163.51
>>>1520535166.01

Isso funciona pelo menos em Python3.4

import subprocess

process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
for line in process.stdout:
    print(line.decode().strip())

Nenhuma das respostas aqui abordou todas as minhas necessidades.

1. Sem threads para stdout (sem filas etc.)
2. Sem bloqueio, pois preciso verificar se há outras coisas acontecendo
3. Use o PIPE conforme necessário para fazer várias coisas, por exemplo, saída de fluxo, gravação em um arquivo de log e retorno de uma cópia em seqüência da saída.

Um pouco de experiência: estou usando um ThreadPoolExecutor para gerenciar um pool de threads, cada um iniciando um subprocesso e executando-os simultaneamente. (No Python2.7, mas isso também deve funcionar na versão 3.x mais recente). Eu não quero usar threads apenas para reunir a saída, pois quero o maior número possível de outras coisas (um pool de 20 processos usaria 40 threads apenas para executar; 1 para o processo e 1 para stdout ... e mais se você quiser stderr eu acho)

Estou retirando muitas exceções e outras aqui, então isso se baseia no código que funciona na produção. Espero que não estraguei tudo na cópia e colar. Além disso, feedback muito bem-vindo!

import time
import fcntl
import subprocess
import time

proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

# Make stdout non-blocking when using read/readline
proc_stdout = proc.stdout
fl = fcntl.fcntl(proc_stdout, fcntl.F_GETFL)
fcntl.fcntl(proc_stdout, fcntl.F_SETFL, fl | os.O_NONBLOCK)

def handle_stdout(proc_stream, my_buffer, echo_streams=True, log_file=None):
    """A little inline function to handle the stdout business. """
    # fcntl makes readline non-blocking so it raises an IOError when empty
    try:
        for s in iter(proc_stream.readline, ''):   # replace '' with b'' for Python 3
            my_buffer.append(s)

            if echo_streams:
                sys.stdout.write(s)

            if log_file:
                log_file.write(s)
    except IOError:
        pass

# The main loop while subprocess is running
stdout_parts = []
while proc.poll() is None:
    handle_stdout(proc_stdout, stdout_parts)

    # ...Check for other things here...
    # For example, check a multiprocessor.Value('b') to proc.kill()

    time.sleep(0.01)

# Not sure if this is needed, but run it again just to be sure we got it all?
handle_stdout(proc_stdout, stdout_parts)

stdout_str = "".join(stdout_parts)  # Just to demo

Tenho certeza de que há custos adicionais sendo adicionados aqui, mas isso não é uma preocupação no meu caso. Funcionalmente, ele faz o que eu preciso. A única coisa que não resolvi é por que isso funciona perfeitamente para mensagens de log, mas vejo algumas printmensagens aparecerem mais tarde e de uma só vez.

No Python 3.6, usei isso:

import subprocess

cmd = "command"
output = subprocess.call(cmd, shell=True)
print(process)