Leer la entrada de transmisión de subprocess.communicate ()

Estoy usando Python subprocess.communicate()para leer stdout de un proceso que se ejecuta durante aproximadamente un minuto.

¿Cómo puedo imprimir cada línea de ese proceso stdouten forma de transmisión, de modo que pueda ver la salida a medida que se genera, pero aún bloquear la terminación del proceso antes de continuar?

subprocess.communicate() parece dar toda la salida a la vez.

Tenga en cuenta que creo que el método de JF Sebastian (a continuación) es mejor.

Aquí hay un ejemplo simple (sin verificación de errores):

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

Si lstermina demasiado rápido, entonces el ciclo while puede terminar antes de que haya leído todos los datos.

Puede capturar el resto en stdout de esta manera:

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

Para obtener la salida del subproceso línea por línea tan pronto como el subproceso vacíe su búfer de salida estándar:

#!/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()se usa para leer líneas tan pronto como se escriben para solucionar el error de lectura anticipada en Python 2 .

Si el subproceso 'stdout usa un búfer de bloque en lugar de un búfer de línea en modo no interactivo (que conduce a un retraso en la salida hasta que el búfer del niño está lleno o vaciado explícitamente por el niño), entonces podría intentar forzar una salida sin búfer usando pexpect , ptymódulos o unbuffer, stdbuf, scriptutilidades , ver Q: ¿Por qué no sólo tiene que utilizar un tubo (popen ())?

Aquí está el código de 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 diferencia de Python 2, que genera cadenas de bytes de subprocesos tal cual; Python 3 usa el modo de texto (la salida de cmd se decodifica usando locale.getpreferredencoding(False)codificación).

Creo que la forma más sencilla de recopilar la salida de un proceso en forma de transmisión es así:

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

La función readline()o read()solo debe devolver una cadena vacía en EOF, después de que el proceso haya terminado; de lo contrario, se bloqueará si no hay nada para leer ( readline()incluye la nueva línea, por lo que en líneas vacías, devuelve "\ n"). Esto evita la necesidad de una incómoda communicate()llamada final después del ciclo.

En archivos con líneas muy largas read()puede ser preferible reducir el uso máximo de memoria; el número que se le pasa es arbitrario, pero excluirlo da como resultado la lectura de toda la salida de la tubería a la vez, lo que probablemente no sea deseable.

Si desea un enfoque sin bloqueo, no use process.communicate(). Si establece el subprocess.Popen()argumento stdouten PIPE, puede leer process.stdouty verificar si el proceso aún se ejecuta usando process.poll().

Si simplemente está tratando de pasar la salida en tiempo real, es difícil hacerlo más simple que esto:

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'])

Consulte los documentos de subprocess.check_call () .

Si necesitas procesar la salida, claro, haz un bucle. Pero si no lo hace, manténgalo simple.

Editar: JF Sebastian señala que los valores predeterminados para los parámetros stdout y stderr pasan a sys.stdout y sys.stderr, y que esto fallará si sys.stdout y sys.stderr han sido reemplazados (por ejemplo, para capturar la salida en pruebas).

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'))

Añadiendo otra solución de python3 con algunos pequeños cambios:

1. Le permite capturar el código de salida del proceso de shell (no he podido obtener el código de salida mientras usaba el with construcción)
2. También canaliza stderr en tiempo real

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)