Leggi l'input di streaming da subprocess.communicate ()

Sto usando Python subprocess.communicate()per leggere lo stdout da un processo che viene eseguito per circa un minuto.

Come posso stampare ogni riga di quel processo stdoutin streaming, in modo da poter vedere l'output mentre viene generato, ma comunque bloccare il processo che termina prima di continuare?

subprocess.communicate() sembra dare tutto l'output in una volta.

Nota, penso che il metodo di JF Sebastian (sotto) sia migliore.

Ecco un semplice esempio (senza controllo degli errori):

import subprocess
proc = subprocess.Popen('ls',
                       shell=True,
                       stdout=subprocess.PIPE,
                       )
while proc.poll() is None:
    output = proc.stdout.readline()
    print output,

Se lsfinisce troppo velocemente, il ciclo while potrebbe terminare prima che tu abbia letto tutti i dati.

Puoi catturare il resto in stdout in questo modo:

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

Per ottenere l'output del sottoprocesso riga per riga non appena il sottoprocesso svuota il suo buffer stdout:

#!/usr/bin/env python2
from subprocess import Popen, PIPE

p = Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1)
with p.stdout:
    for line in iter(p.stdout.readline, b''):
        print line,
p.wait() # wait for the subprocess to exit

iter()viene utilizzato per leggere le righe non appena vengono scritte per aggirare il bug della lettura anticipata in Python 2 .

Se lo stdout del sottoprocesso utilizza un buffer di blocco invece di un buffer di riga in modalità non interattiva (che porta a un ritardo nell'output fino a quando il buffer del bambino non è pieno o scaricato esplicitamente dal figlio) allora potresti provare a forzare un output senza buffer usando pexpect, ptymoduli o unbuffer, stdbuf, scriptutilità , vedere D: Perché non basta usare un tubo (popen ())?

Ecco il codice Python 3:

#!/usr/bin/env python3
from subprocess import Popen, PIPE

with Popen(["cmd", "arg1"], stdout=PIPE, bufsize=1,
           universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='')

Nota: a differenza di Python 2 che restituisce le stringhe di sottoprocesso così come sono; Python 3 utilizza la modalità testo (l'output di cmd viene decodificato utilizzando la locale.getpreferredencoding(False)codifica).

Credo che il modo più semplice per raccogliere l'output di un processo in streaming sia questo:

import sys
from subprocess import *
proc = Popen('ls', shell=True, stdout=PIPE)
while True:
    data = proc.stdout.readline()   # Alternatively proc.stdout.read(1024)
    if len(data) == 0:
        break
    sys.stdout.write(data)   # sys.stdout.buffer.write(data) on Python 3.x

Il readline()read() funzione o dovrebbe restituire solo una stringa vuota su EOF, dopo che il processo è terminato - altrimenti si bloccherà se non c'è niente da leggere ( readline()include il ritorno a capo, quindi su righe vuote, restituisce "\ n"). Questo evita la necessità di un finale imbarazzantecommunicate() chiamata dopo il ciclo.

Su file con righe molto lunghe read()può essere preferibile ridurre l'utilizzo massimo della memoria: il numero passato ad esso è arbitrario, ma escludendolo si ottiene la lettura dell'intero output della pipe in una volta, cosa probabilmente non desiderabile.

Se desideri un approccio non bloccante, non utilizzare process.communicate(). Se si imposta l' subprocess.Popen()argomento stdoutsu PIPE, è possibile leggere da process.stdoute verificare se il processo viene ancora eseguito utilizzando process.poll().

Se stai semplicemente cercando di trasmettere l'output in tempo reale, è difficile diventare più semplice di questo:

import subprocess

# This will raise a CalledProcessError if the program return a nonzero code.
# You can use call() instead if you don't care about that case.
subprocess.check_call(['ls', '-l'])

Vedere la documentazione per subprocess.check_call () .

Se hai bisogno di elaborare l'output, certo, eseguilo in loop. Ma se non lo fai, mantienilo semplice.

Modifica: JF Sebastian sottolinea sia che i valori predefiniti per i parametri stdout e stderr passano a sys.stdout e sys.stderr, e che questo fallirà se sys.stdout e sys.stderr sono stati sostituiti (ad esempio, per catturare l'output in test).

myCommand="ls -l"
cmd=myCommand.split()
# "universal newline support" This will cause to interpret \n, \r\n and \r     equally, each as a newline.
p = subprocess.Popen(cmd, stderr=subprocess.PIPE, universal_newlines=True)
while True:    
    print(p.stderr.readline().rstrip('\r\n'))

Aggiunta di un'altra soluzione python3 con alcune piccole modifiche:

1. Ti consente di catturare il codice di uscita del processo di shell (non sono stato in grado di ottenere il codice di uscita durante l'utilizzo del withcostrutto)
2. Inoltre convoglia lo stderr in tempo reale

import subprocess
import sys
def subcall_stream(cmd, fail_on_error=True):
    # Run a shell command, streaming output to STDOUT in real time
    # Expects a list style command, e.g. `["docker", "pull", "ubuntu"]`
    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=1, universal_newlines=True)
    for line in p.stdout:
        sys.stdout.write(line)
    p.wait()
    exit_code = p.returncode
    if exit_code != 0 and fail_on_error:
        raise RuntimeError(f"Shell command failed with exit code {exit_code}. Command: `{cmd}`")
    return(exit_code)