leggere lo sottoprocesso stdout riga per riga

Il mio script Python utilizza un sottoprocesso per chiamare un'utilità linux molto rumorosa. Voglio archiviare tutto l'output in un file di registro e mostrarne un po 'all'utente. Ho pensato che avrebbe funzionato quanto segue, ma l'output non viene visualizzato nella mia applicazione fino a quando l'utilità non ha prodotto una quantità significativa di output.

#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()

Il comportamento che desidero davvero è che lo script del filtro stampi ogni riga man mano che viene ricevuto dal sottoprocesso. Sorta piace quello che teefa ma con il codice Python.

Cosa mi sto perdendo? È possibile?

Aggiornare:

Se un sys.stdout.flush()viene aggiunto a fake_utility.py, il codice ha il comportamento desiderato in python 3.1. Sto usando Python 2.6. proc.stdout.xreadlines()Penseresti che usare funzionerebbe allo stesso modo di py3k, ma non lo fa.

Aggiornamento 2:

Ecco il codice di lavoro minimo.

#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()

È passato molto tempo dall'ultima volta che ho lavorato con Python, ma penso che il problema sia con l'affermazione for line in proc.stdout, che legge l'intero input prima di iterare su di esso. La soluzione è utilizzare readline()invece:

#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()

Ovviamente devi ancora fare i conti con il buffering del sottoprocesso.

Nota: secondo la documentazione, la soluzione con un iteratore dovrebbe essere equivalente all'utilizzo readline(), ad eccezione del buffer read-ahead, ma (o proprio per questo) la modifica proposta ha prodotto risultati diversi per me (Python 2.5 su Windows XP).

Un po 'tardi alla festa, ma sono stato sorpreso di non vedere quella che penso sia la soluzione più semplice qui:

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

(Ciò richiede Python 3.)

Infatti, se hai risolto l'iteratore, il buffering potrebbe ora essere il tuo problema. Si potrebbe dire a Python nel processo secondario di non bufferizzare il suo output.

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

diventa

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

Ne ho avuto bisogno quando ho chiamato Python da Python.

Vuoi passare questi parametri extra a subprocess.Popen:

bufsize=1, universal_newlines=True

Quindi puoi iterare come nel tuo esempio. (Testato con Python 3.5)

Una funzione che consente di scorrere su entrambe stdoute stderrcontemporaneamente, in tempo reale, riga per riga

Nel caso in cui sia necessario ottenere il flusso di output per entrambi stdoute stderrallo stesso tempo, è possibile utilizzare la seguente funzione.

La funzione utilizza Code per unire entrambe le pipe Popen in un singolo iteratore.

Qui creiamo la funzione 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() in 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

Puoi anche leggere le righe senza loop. Funziona in python3.6.

import os
import subprocess

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

L'ho provato con python3 e ha funzionato, fonte

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 seguente modifica della risposta di Rômulo funziona per me su Python 2 e 3 (2.7.12 e 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

Non so quando questo è stato aggiunto al modulo di sottoprocesso, ma con Python 3 dovresti andare bene usando proc.stdout.splitlines():

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