cattura stdout in tempo reale da sottoprocesso

voglio subprocess.Popen() rsync.exe in Windows e stampare lo stdout in Python.

Il mio codice funziona, ma non rileva lo stato di avanzamento finché non viene completato il trasferimento di un file! Voglio stampare l'avanzamento di ogni file in tempo reale.

Usando Python 3.1 ora da quando ho sentito che dovrebbe essere migliore nella gestione dell'IO.

import subprocess, time, os, sys

cmd = "rsync.exe -vaz -P source/ dest/"
p, line = True, 'start'


p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=64,
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

Alcune regole pratiche per subprocess.

• Non usare maishell=True . Invoca inutilmente un processo di shell aggiuntivo per chiamare il programma.
• Quando si chiamano processi, gli argomenti vengono passati come elenchi. sys.argvin python è una lista, e così è argvin C. Quindi passi una lista aPopen per chiamare sottoprocessi, non una stringa.
• Non reindirizzare stderra un filePIPE quando non lo stai leggendo.
• Non reindirizzare stdinquando non ci scrivi.

Esempio:

import subprocess, time, os, sys
cmd = ["rsync.exe", "-vaz", "-P", "source/" ,"dest/"]

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

for line in iter(p.stdout.readline, b''):
    print(">>> " + line.rstrip())

Detto questo, è probabile che rsync bufferizzi il suo output quando rileva che è connesso a una pipe invece che a un terminale. Questo è il comportamento predefinito: quando si è connessi a una pipe, i programmi devono svuotare esplicitamente lo stdout per ottenere risultati in tempo reale, altrimenti la libreria C standard verrà bufferizzata.

Per verificarlo, prova a eseguire questo invece:

cmd = [sys.executable, 'test_out.py']

e crea un test_out.pyfile con il contenuto:

import sys
import time
print ("Hello")
sys.stdout.flush()
time.sleep(10)
print ("World")

L'esecuzione di quel sottoprocesso dovrebbe darti "Hello" e attendere 10 secondi prima di dare "World". Se ciò accade con il codice python sopra e non con rsync, significa che esso rsyncstesso esegue il buffering dell'output, quindi sei sfortunato.

Una soluzione sarebbe connettersi direttamente a un pty, usando qualcosa di simile pexpect.

So che questo è un vecchio argomento, ma ora c'è una soluzione. Chiama rsync con l'opzione --outbuf = L. Esempio:

cmd=['rsync', '-arzv','--backup','--outbuf=L','source/','dest']
p = subprocess.Popen(cmd,
                     stdout=subprocess.PIPE)
for line in iter(p.stdout.readline, b''):
    print '>>> {}'.format(line.rstrip())

Su Linux, ho avuto lo stesso problema di sbarazzarmi del buffering. Alla fine ho usato "stdbuf -o0" (o, unbuffer da aspettarmi) per sbarazzarmi del buffering PIPE.

proc = Popen(['stdbuf', '-o0'] + cmd, stdout=PIPE, stderr=PIPE)
stdout = proc.stdout

Potrei quindi usare select.select su stdout.

Vedi anche /unix/25372/

A seconda del caso d'uso, potresti anche voler disabilitare il buffering nel sottoprocesso stesso.

Se il sottoprocesso sarà un processo Python, potresti farlo prima della chiamata:

os.environ["PYTHONUNBUFFERED"] = "1"

Oppure, in alternativa, passalo envnell'argomento aPopen .

Altrimenti, se sei su Linux / Unix, puoi usare lo stdbufstrumento. Ad esempio come:

cmd = ["stdbuf", "-oL"] + cmd

Vedi anche qui su stdbufo altre opzioni.

for line in p.stdout:
  ...

si blocca sempre fino al successivo avanzamento riga.

Per un comportamento "in tempo reale" devi fare qualcosa del genere:

while True:
  inchar = p.stdout.read(1)
  if inchar: #neither empty string nor None
    print(str(inchar), end='') #or end=None to flush immediately
  else:
    print('') #flush for implicit line-buffering
    break

Il ciclo while viene lasciato quando il processo figlio chiude lo stdout o esce. read()/read(-1)si bloccherebbe fino a quando il processo figlio non chiudesse lo stdout o uscisse.

Il tuo problema è:

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

l'iteratore stesso ha un buffer aggiuntivo.

Prova a fare così:

while True:
  line = p.stdout.readline()
  if not line:
     break
  print line

Non è possibile ottenere stdout per stampare senza buffer su una pipe (a meno che non sia possibile riscrivere il programma che stampa su stdout), quindi ecco la mia soluzione:

Reindirizza lo stdout a sterr, che non è bufferizzato. '<cmd> 1>&2'dovrebbe farlo. Apri il processo come segue:myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Non puoi distinguere da stdout o stderr, ma ottieni immediatamente tutto l'output.

Spero che questo aiuti chiunque ad affrontare questo problema.

Modificare lo stdout dal processo rsync in modo che non sia bufferizzato.

p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=0,  # 0=unbuffered, 1=line-buffered, else buffer-size
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

Per evitare la memorizzazione nella cache dell'output potresti provare pexpect,

child = pexpect.spawn(launchcmd,args,timeout=None)
while True:
    try:
        child.expect('\n')
        print(child.before)
    except pexpect.EOF:
        break

PS : So che questa domanda è piuttosto vecchia, ma fornisce ancora la soluzione che ha funzionato per me.

PPS : ho ottenuto questa risposta da un'altra domanda

    p = subprocess.Popen(command,
                                bufsize=0,
                                universal_newlines=True)

Sto scrivendo una GUI per rsync in Python e ho gli stessi problemi. Questo problema mi ha turbato per diversi giorni fino a quando non l'ho trovato in pyDoc.

Se universal_newlines è True, gli oggetti file stdout e stderr vengono aperti come file di testo in modalità newline universale. Le righe possono essere terminate da "\ n", la convenzione di fine riga di Unix, "\ r", la vecchia convenzione Macintosh o "\ r \ n", la convenzione di Windows. Tutte queste rappresentazioni esterne sono viste come "\ n" dal programma Python.

Sembra che rsync restituisca '\ r' quando la traduzione è in corso.

Ho notato che non si fa menzione dell'utilizzo di un file temporaneo come intermedio. Quanto segue aggira i problemi di buffering eseguendo l'output in un file temporaneo e consente di analizzare i dati provenienti da rsync senza connettersi a un pty. Ho testato quanto segue su una macchina Linux e l'output di rsync tende a differire tra le piattaforme, quindi le espressioni regolari per analizzare l'output possono variare:

import subprocess, time, tempfile, re

pipe_output, file_name = tempfile.TemporaryFile()
cmd = ["rsync", "-vaz", "-P", "/src/" ,"/dest"]

p = subprocess.Popen(cmd, stdout=pipe_output, 
                     stderr=subprocess.STDOUT)
while p.poll() is None:
    # p.poll() returns None while the program is still running
    # sleep for 1 second
    time.sleep(1)
    last_line =  open(file_name).readlines()
    # it's possible that it hasn't output yet, so continue
    if len(last_line) == 0: continue
    last_line = last_line[-1]
    # Matching to "[bytes downloaded]  number%  [speed] number:number:number"
    match_it = re.match(".* ([0-9]*)%.* ([0-9]*:[0-9]*:[0-9]*).*", last_line)
    if not match_it: continue
    # in this case, the percentage is stored in match_it.group(1), 
    # time in match_it.group(2).  We could do something with it here...

se esegui qualcosa di simile in un thread e salvi la proprietà ffmpeg_time in una proprietà di un metodo in modo da potervi accedere, funzionerebbe molto bene ottengo output come questo: l' output è come se usi il threading in tkinter

input = 'path/input_file.mp4'
output = 'path/input_file.mp4'
command = "ffmpeg -y -v quiet -stats -i \"" + str(input) + "\" -metadata title=\"@alaa_sanatisharif\" -preset ultrafast -vcodec copy -r 50 -vsync 1 -async 1 \"" + output + "\""
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, shell=True)
for line in self.process.stdout:
    reg = re.search('\d\d:\d\d:\d\d', line)
    ffmpeg_time = reg.group(0) if reg else ''
    print(ffmpeg_time)

In Python 3, ecco una soluzione, che elimina un comando dalla riga di comando e fornisce stringhe ben decodificate in tempo reale non appena vengono ricevute.

Ricevitore ( receiver.py):

import subprocess
import sys

cmd = sys.argv[1:]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
for line in p.stdout:
    print("received: {}".format(line.rstrip().decode("utf-8")))

Esempio di programma semplice che potrebbe generare output in tempo reale ( dummy_out.py):

import time
import sys

for i in range(5):
    print("hello {}".format(i))
    sys.stdout.flush()  
    time.sleep(1)

Produzione:

$python receiver.py python dummy_out.py
received: hello 0
received: hello 1
received: hello 2
received: hello 3
received: hello 4