menangkap stdout secara realtime dari subprocess

Saya ingin subprocess.Popen()rsync.exe di Windows, dan mencetak stdout dengan Python.

Kode saya berfungsi, tetapi tidak menangkap kemajuan sampai transfer file selesai! Saya ingin mencetak kemajuan untuk setiap file secara real time.

Menggunakan Python 3.1 sekarang karena saya mendengarnya seharusnya lebih baik dalam menangani 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()

Beberapa aturan praktis untuk subprocess.

• Jangan pernah gunakan shell=True. Itu tidak perlu memanggil proses shell ekstra untuk memanggil program Anda.
• Saat memanggil proses, argumen diteruskan sebagai daftar. sys.argvdi python adalah daftar, dan begitu juga argvdi C. Jadi Anda lulus daftar untuk Popenmemanggil subproses, bukan string.
• Jangan mengalihkan stderrke PIPEsaat Anda tidak membacanya.
• Jangan mengalihkan stdinketika Anda tidak sedang menulis untuk itu.

Contoh:

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

Meskipun demikian, kemungkinan besar rsync menyangga keluarannya ketika ia mendeteksi bahwa ia terhubung ke pipa dan bukan ke terminal. Ini adalah perilaku default - ketika terhubung ke pipa, program harus secara eksplisit membersihkan stdout untuk hasil realtime, jika tidak, library C standar akan buffer.

Untuk mengujinya, coba jalankan ini sebagai gantinya:

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

dan buat test_out.pyfile dengan isinya:

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

Menjalankan subproses itu akan memberi Anda "Halo" dan menunggu 10 detik sebelum memberikan "Dunia". Jika itu terjadi dengan kode python di atas dan bukan dengan rsync, itu berarti rsyncoutput buffering, jadi Anda kurang beruntung.

Solusinya adalah menghubungkan langsung ke pty, menggunakan sesuatu seperti pexpect.

Saya tahu ini adalah topik lama, tetapi sekarang ada solusinya. Panggil rsync dengan opsi --outbuf = L. Contoh:

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

Di Linux, saya memiliki masalah yang sama dalam menghilangkan buffering. Saya akhirnya menggunakan "stdbuf -o0" (atau, unbuffer from expect) untuk menghilangkan buffering PIPE.

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

Saya kemudian dapat menggunakan select.select di stdout.

Lihat juga /unix/25372/

Bergantung pada kasus penggunaan, Anda mungkin juga ingin menonaktifkan buffering di subproses itu sendiri.

Jika subproses adalah proses Python, Anda dapat melakukan ini sebelum panggilan:

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

Atau sebagai alternatif, berikan ini dalam envargumen ke Popen.

Jika tidak, jika Anda menggunakan Linux / Unix, Anda dapat menggunakan stdbufalat tersebut. Misalnya seperti:

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

Lihat juga di sini tentang stdbufatau opsi lain.

for line in p.stdout:
  ...

selalu memblokir sampai feed baris berikutnya.

Untuk perilaku "waktu nyata", Anda harus melakukan sesuatu seperti ini:

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

While-loop ditinggalkan saat proses anak menutup stdout atau keluarnya. read()/read(-1)akan memblokir sampai proses anak menutup stdout atau keluarnya.

Masalah Anda adalah:

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

iterator itu sendiri memiliki buffering ekstra.

Coba lakukan seperti ini:

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

Anda tidak bisa mendapatkan stdout untuk mencetak unbuffered ke pipa (kecuali jika Anda dapat menulis ulang program yang mencetak ke stdout), jadi inilah solusi saya:

Alihkan stdout ke sterr, yang tidak di-buffer. '<cmd> 1>&2'harus melakukannya. Buka prosesnya sebagai berikut: myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Anda tidak dapat membedakan dari stdout atau stderr, tetapi Anda langsung mendapatkan semua output.

Semoga ini bisa membantu siapa pun yang menangani masalah ini.

Ubah stdout dari proses rsync menjadi unbuffered.

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)

Untuk menghindari caching output Anda mungkin ingin mencoba pexpect,

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

PS : Saya tahu pertanyaan ini cukup lama, masih memberikan solusi yang berhasil untuk saya.

PPS : dapatkan jawaban ini dari pertanyaan lain

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

Saya menulis GUI untuk rsync dengan python, dan memiliki masalah yang sama. Masalah ini mengganggu saya selama beberapa hari hingga saya menemukan ini di pyDoc.

Jika universal_newlines True, file objek stdout dan stderr dibuka sebagai file teks dalam mode baris baru universal. Baris dapat diakhiri oleh salah satu '\ n', konvensi akhir baris Unix, '\ r', konvensi Macintosh lama atau '\ r \ n', konvensi Windows. Semua representasi eksternal ini dilihat sebagai '\ n' oleh program Python.

Tampaknya rsync akan mengeluarkan '\ r' saat terjemahan sedang berlangsung.

Saya perhatikan bahwa tidak disebutkan menggunakan file sementara sebagai perantara. Berikut ini adalah mengatasi masalah buffering dengan mengeluarkan ke file sementara dan memungkinkan Anda untuk mengurai data yang berasal dari rsync tanpa menghubungkan ke pty. Saya menguji yang berikut ini di kotak linux, dan keluaran rsync cenderung berbeda di seluruh platform, sehingga ekspresi reguler untuk mengurai keluaran dapat bervariasi:

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

jika Anda menjalankan sesuatu seperti ini di utas dan menyimpan properti ffmpeg_time dalam properti metode sehingga Anda dapat mengaksesnya, itu akan bekerja dengan sangat baik Saya mendapatkan output seperti ini: output seperti jika Anda menggunakan threading di 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)

Di Python 3, inilah solusinya, yang mengambil perintah dari baris perintah dan memberikan string yang didekodekan secara real-time dengan baik saat diterima.

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

Contoh program sederhana yang dapat menghasilkan keluaran waktu nyata ( dummy_out.py):

import time
import sys

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

Keluaran:

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