przechwytywanie stdout w czasie rzeczywistym z podprocesu

Chcę subprocess.Popen()rsync.exe w systemie Windows i wydrukować standardowe wyjście w Pythonie.

Mój kod działa, ale nie rejestruje postępu, dopóki nie zakończy się przesyłanie pliku! Chcę wydrukować postęp dla każdego pliku w czasie rzeczywistym.

Używając Pythona 3.1 teraz, ponieważ słyszałem, powinno być lepsze w obsłudze 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()

Kilka praktycznych zasad subprocess.

• Nigdy nie używaj shell=True. Niepotrzebnie wywołuje dodatkowy proces powłoki, aby wywołać program.
• Podczas wywoływania procesów argumenty są przekazywane jako listy. sys.argvw Pythonie jest lista, a więc jest argvw C. Więc przekazać listę do Popen, aby zadzwonić do podprocesów, a nie ciąg.
• Nie przekierowuj stderrdo a, PIPEgdy go nie czytasz.
• Nie przekierowuj, stdinkiedy do niego nie piszesz.

Przykład:

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

To powiedziawszy, jest prawdopodobne, że rsync buforuje swoje dane wyjściowe, gdy wykryje, że jest podłączony do potoku zamiast terminala. Jest to zachowanie domyślne - po podłączeniu do potoku programy muszą jawnie opróżniać standardowe wyjście, aby uzyskać wyniki w czasie rzeczywistym, w przeciwnym razie standardowa biblioteka C będzie buforować.

Aby to sprawdzić, spróbuj zamiast tego uruchomić:

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

i utwórz test_out.pyplik z zawartością:

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

Wykonanie tego podprocesu powinno dać ci „Hello” i odczekać 10 sekund przed podaniem „World”. Jeśli tak się stanie z powyższym kodem Pythona, a nie z rsync, oznacza to, że rsyncsam buforuje dane wyjściowe, więc nie masz szczęścia.

Rozwiązaniem byłoby podłączenie się bezpośrednio do pty, używając czegoś takiego jak pexpect.

Wiem, że to stary temat, ale teraz jest rozwiązanie. Wywołaj rsync z opcją --outbuf = L. Przykład:

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

W Linuksie miałem ten sam problem z pozbyciem się buforowania. W końcu użyłem "stdbuf -o0" (lub unbuffer z oczekiwania), aby pozbyć się buforowania PIPE.

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

Mógłbym wtedy użyć select.select na stdout.

Zobacz też /unix/25372/

W zależności od przypadku użycia możesz również chcieć wyłączyć buforowanie w samym podprocesie.

Jeśli podproces będzie procesem w Pythonie, możesz to zrobić przed wywołaniem:

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

Lub alternatywnie przekaż to w envargumencie do Popen.

W przeciwnym razie, jeśli korzystasz z systemu Linux / Unix, możesz użyć stdbufnarzędzia. Np. Jak:

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

Zobacz również tutaj o stdbuflub inne opcje.

for line in p.stdout:
  ...

zawsze blokuje do następnego wysunięcia wiersza.

Aby zachować zachowanie w czasie rzeczywistym, musisz zrobić coś takiego:

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

Pętla while jest pozostawiana, gdy proces potomny zamyka swoje standardowe wyjście lub kończy pracę. read()/read(-1)będzie blokować, dopóki proces potomny nie zamknie swojego wyjścia standardowego lub nie zakończy działania.

Twój problem to:

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

sam iterator ma dodatkowe buforowanie.

Spróbuj zrobić tak:

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

Nie możesz zmusić stdout do drukowania niebuforowanego do potoku (chyba że możesz przepisać program, który drukuje na stdout), więc oto moje rozwiązanie:

Przekieruj standardowe wyjście do sterr, które nie jest buforowane. '<cmd> 1>&2'powinien to zrobić. Otwórz proces w następujący sposób: myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Nie możesz odróżnić od stdout lub stderr, ale wszystkie dane wyjściowe otrzymasz natychmiast.

Mam nadzieję, że pomoże to każdemu rozwiązującemu ten problem.

Zmień standardowe wyjście z procesu rsync na niebuforowane.

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)

Aby uniknąć buforowania wyjścia, możesz spróbować pexpect,

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

PS : Wiem, że to pytanie jest dość stare, wciąż dostarcza rozwiązania, które działało dla mnie.

PPS : otrzymałem tę odpowiedź z innego pytania

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

Piszę GUI dla rsync w Pythonie i mam te same problemy. Ten problem niepokoi mnie od kilku dni, dopóki nie znajdę go w pyDoc.

Jeśli universal_newlines ma wartość True, obiekty pliku stdout i stderr są otwierane jako pliki tekstowe w trybie uniwersalnych znaków nowej linii. Linie mogą być zakończone dowolną z „\ n”, uniksowej konwencji końca linii, „\ r”, starej konwencji Macintosha lub „\ r \ n”, konwencji Windows. Wszystkie te zewnętrzne reprezentacje są postrzegane jako „\ n” przez program w języku Python.

Wygląda na to, że rsync wyświetli '\ r', gdy trwa translacja.

Zauważyłem, że nie ma wzmianki o używaniu pliku tymczasowego jako pośredniego. Poniższe informacje omijają problemy z buforowaniem, przesyłając dane do pliku tymczasowego i umożliwiają analizowanie danych pochodzących z rsync bez łączenia się z pty. Przetestowałem następujące elementy na Linuksie, a dane wyjściowe rsync różnią się na różnych platformach, więc wyrażenia regularne do analizowania danych wyjściowych mogą się różnić:

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...

jeśli uruchomisz coś takiego w wątku i zapiszesz właściwość ffmpeg_time we właściwości metody, aby uzyskać do niej dostęp, działałoby bardzo dobrze, otrzymuję takie wyniki: wyjście będzie takie, jak gdybyś używał wątków w 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)

W Pythonie 3 jest rozwiązanie, które usuwa polecenie z wiersza poleceń i dostarcza ładnie dekodowane ciągi w czasie rzeczywistym, gdy są odbierane.

Odbiornik ( 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")))

Przykładowy prosty program, który może generować dane wyjściowe w czasie rzeczywistym ( dummy_out.py):

import time
import sys

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

Wynik:

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