leer el subproceso stdout línea por línea

Mi script de Python usa un subproceso para llamar a una utilidad de Linux que es muy ruidosa. Quiero almacenar todo el resultado en un archivo de registro y mostrarlo al usuario. Pensé que lo siguiente funcionaría, pero el resultado no aparece en mi aplicación hasta que la utilidad haya producido una cantidad significativa de resultados.

#fake_utility.py, just generates lots of output over time
import time
i = 0
while True:
   print hex(i)*512
   i += 1
   time.sleep(0.5)

#filters output
import subprocess
proc = subprocess.Popen(['python','fake_utility.py'],stdout=subprocess.PIPE)
for line in proc.stdout:
   #the real code does filtering here
   print "test:", line.rstrip()

El comportamiento que realmente quiero es que el script de filtro imprima cada línea tal como se recibe del subproceso. Sorta como lo que teehace pero con código python.

¿Qué me estoy perdiendo? ¿Es esto posible?

Actualizar:

Si sys.stdout.flush()se agrega a fake_utility.py, el código tiene el comportamiento deseado en python 3.1. Estoy usando python 2.6. Se podría pensar que usar proc.stdout.xreadlines()funcionaría igual que py3k, pero no es así.

Actualización 2:

Aquí está el código de trabajo mínimo.

#fake_utility.py, just generates lots of output over time
import sys, time
for i in range(10):
   print i
   sys.stdout.flush()
   time.sleep(0.5)

#display out put line by line
import subprocess
proc = subprocess.Popen(['python','fake_utility.py'],stdout=subprocess.PIPE)
#works in python 3.0+
#for line in proc.stdout:
for line in iter(proc.stdout.readline,''):
   print line.rstrip()

Ha pasado mucho tiempo desde la última vez que trabajé con Python, pero creo que el problema es con la declaración for line in proc.stdout, que lee toda la entrada antes de repetirla. La solución es usar readline()en su lugar:

#filters output
import subprocess
proc = subprocess.Popen(['python','fake_utility.py'],stdout=subprocess.PIPE)
while True:
  line = proc.stdout.readline()
  if not line:
    break
  #the real code does filtering here
  print "test:", line.rstrip()

Por supuesto, todavía tiene que lidiar con el almacenamiento en búfer del subproceso.

Nota: de acuerdo con la documentación, la solución con un iterador debería ser equivalente a usar readline(), excepto el búfer de lectura anticipada, pero (o exactamente por esto) el cambio propuesto produjo resultados diferentes para mí (Python 2.5 en Windows XP).

Un poco tarde a la fiesta, pero me sorprendió no ver cuál es la solución más simple aquí:

import io
import subprocess

proc = subprocess.Popen(["prog", "arg"], stdout=subprocess.PIPE)
for line in io.TextIOWrapper(proc.stdout, encoding="utf-8"):  # or another encoding
    # do something with line

(Esto requiere Python 3.)

De hecho, si resolvió el iterador, el almacenamiento en búfer ahora podría ser su problema. Podrías decirle a la pitón en el subproceso que no almacene su salida.

proc = subprocess.Popen(['python','fake_utility.py'],stdout=subprocess.PIPE)

se convierte

proc = subprocess.Popen(['python','-u', 'fake_utility.py'],stdout=subprocess.PIPE)

He necesitado esto al llamar a python desde python.

Desea pasar estos parámetros adicionales a subprocess.Popen:

bufsize=1, universal_newlines=True

Entonces puedes iterar como en tu ejemplo. (Probado con Python 3.5)

Una función que permite iterar sobre ambos stdouty stderrsimultáneamente, en tiempo real, línea por línea

En caso de que necesite obtener el flujo de salida para ambos stdouty stderral mismo tiempo, puede usar la siguiente función.

La función usa Colas para fusionar ambas tuberías de Popen en un solo iterador.

Aquí creamos la función read_popen_pipes():

from queue import Queue, Empty
from concurrent.futures import ThreadPoolExecutor


def enqueue_output(file, queue):
    for line in iter(file.readline, ''):
        queue.put(line)
    file.close()


def read_popen_pipes(p):

    with ThreadPoolExecutor(2) as pool:
        q_stdout, q_stderr = Queue(), Queue()

        pool.submit(enqueue_output, p.stdout, q_stdout)
        pool.submit(enqueue_output, p.stderr, q_stderr)

        while True:

            if p.poll() is not None and q_stdout.empty() and q_stderr.empty():
                break

            out_line = err_line = ''

            try:
                out_line = q_stdout.get_nowait()
            except Empty:
                pass
            try:
                err_line = q_stderr.get_nowait()
            except Empty:
                pass

            yield (out_line, err_line)

read_popen_pipes() en uso:

import subprocess as sp


with sp.Popen(my_cmd, stdout=sp.PIPE, stderr=sp.PIPE, text=True) as p:

    for out_line, err_line in read_popen_pipes(p):

        # Do stuff with each line, e.g.:
        print(out_line, end='')
        print(err_line, end='')

    return p.poll() # return status-code

También puede leer líneas sin bucle. Funciona en python3.6.

import os
import subprocess

process = subprocess.Popen(command, stdout=subprocess.PIPE)
list_of_byte_strings = process.stdout.readlines()

Intenté esto con python3 y funcionó, fuente

def output_reader(proc):
    for line in iter(proc.stdout.readline, b''):
        print('got line: {0}'.format(line.decode('utf-8')), end='')


def main():
    proc = subprocess.Popen(['python', 'fake_utility.py'],
                            stdout=subprocess.PIPE,
                            stderr=subprocess.STDOUT)

    t = threading.Thread(target=output_reader, args=(proc,))
    t.start()

    try:
        time.sleep(0.2)
        import time
        i = 0

        while True:
        print (hex(i)*512)
        i += 1
        time.sleep(0.5)
    finally:
        proc.terminate()
        try:
            proc.wait(timeout=0.2)
            print('== subprocess exited with rc =', proc.returncode)
        except subprocess.TimeoutExpired:
            print('subprocess did not terminate in time')
    t.join()

La siguiente modificación de la respuesta de Rômulo funciona para mí en Python 2 y 3 (2.7.12 y 3.6.1):

import os
import subprocess

process = subprocess.Popen(command, stdout=subprocess.PIPE)
while True:
  line = process.stdout.readline()
  if line != '':
    os.write(1, line)
  else:
    break

No sé cuándo esto se ha agregado al módulo de subproceso, pero con Python 3 debería estar bien usando proc.stdout.splitlines():

for line in proc.stdout.splitlines():
   print "stdout:", line