Mendapatkan output realtime menggunakan subproses

Saya mencoba menulis skrip wrapper untuk program baris perintah (svnadmin memverifikasi) yang akan menampilkan indikator kemajuan yang bagus untuk operasi. Ini mengharuskan saya untuk dapat melihat setiap baris output dari program yang dibungkus segera setelah itu adalah output.

Saya pikir saya hanya akan menjalankan program menggunakan subprocess.Popen, menggunakan stdout=PIPE, kemudian membaca setiap baris ketika masuk dan bertindak sesuai. Namun, ketika saya menjalankan kode berikut, output tampaknya buffer di suatu tempat, menyebabkannya muncul dalam dua potongan, baris 1 hingga 332, kemudian 333 hingga 439 (baris terakhir output)

from subprocess import Popen, PIPE, STDOUT

p = Popen('svnadmin verify /var/svn/repos/config', stdout = PIPE, 
        stderr = STDOUT, shell = True)
for line in p.stdout:
    print line.replace('\n', '')

Setelah melihat dokumentasi pada subproses sedikit, saya menemukan bufsizeparameter untuk Popen, jadi saya mencoba menetapkan bufsize ke 1 (buffer setiap baris) dan 0 (tidak ada buffer), tetapi tidak ada nilai yang tampaknya mengubah cara jalur dikirim.

Pada titik ini saya mulai memahami sedotan, jadi saya menulis loop keluaran berikut:

while True:
    try:
        print p.stdout.next().replace('\n', '')
    except StopIteration:
        break

tetapi mendapat hasil yang sama.

Apakah mungkin untuk mendapatkan output program 'realtime' dari suatu program yang dieksekusi menggunakan subproses? Apakah ada opsi lain di Python yang kompatibel dengan maju (tidak exec*)?

Saya mencoba ini, dan untuk beberapa alasan sementara kode

for line in p.stdout:
  ...

buffer secara agresif, varian

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

tidak. Rupanya ini adalah bug yang dikenal: http://bugs.python.org/issue3907 (Masalahnya sekarang "Ditutup" pada 29 Agustus 2018)

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, bufsize=1)
for line in iter(p.stdout.readline, b''):
    print line,
p.stdout.close()
p.wait()

Anda dapat mengarahkan output subproses ke stream secara langsung. Contoh sederhana:

subprocess.run(['ls'], stderr=sys.stderr, stdout=sys.stdout)

Anda dapat mencoba ini:

import subprocess
import sys

process = subprocess.Popen(
    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)

while True:
    out = process.stdout.read(1)
    if out == '' and process.poll() != None:
        break
    if out != '':
        sys.stdout.write(out)
        sys.stdout.flush()

Jika Anda menggunakan readline sebagai ganti read, akan ada beberapa kasus di mana pesan input tidak dicetak. Cobalah dengan perintah yang memerlukan input inline dan lihat sendiri.

The Streaming subproses stdin dan stdout dengan asyncio di Python posting blog oleh Kevin McCarthy menunjukkan bagaimana melakukannya dengan asyncio:

import asyncio
from asyncio.subprocess import PIPE
from asyncio import create_subprocess_exec


async def _read_stream(stream, callback):
    while True:
        line = await stream.readline()
        if line:
            callback(line)
        else:
            break


async def run(command):
    process = await create_subprocess_exec(
        *command, stdout=PIPE, stderr=PIPE
    )

    await asyncio.wait(
        [
            _read_stream(
                process.stdout,
                lambda x: print(
                    "STDOUT: {}".format(x.decode("UTF8"))
                ),
            ),
            _read_stream(
                process.stderr,
                lambda x: print(
                    "STDERR: {}".format(x.decode("UTF8"))
                ),
            ),
        ]
    )

    await process.wait()


async def main():
    await run("docker build -t my-docker-image:latest .")


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Masalah Output Real Time diselesaikan: Saya memang mengalami masalah serupa di Python, sambil menangkap output real time dari program c. Saya menambahkan " fflush (stdout) ;" dalam kode C saya. Ini berhasil untuk saya. Ini adalah snip kodenya

<< Program C >>

#include <stdio.h>
void main()
{
    int count = 1;
    while (1)
    {
        printf(" Count  %d\n", count++);
        fflush(stdout);
        sleep(1);
    }
}

<< Program Python >>

#!/usr/bin/python

import os, sys
import subprocess


procExe = subprocess.Popen(".//count", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)

while procExe.poll() is None:
    line = procExe.stdout.readline()
    print("Print:" + line)

<< OUTPUT >> Cetak: Hitungan 1 Cetak: Hitungan 2 Cetak: Hitungan 3

Semoga ini bisa membantu.

~ sairam

Saya mengalami masalah yang sama beberapa waktu lalu. Solusi saya adalah membuang iterasi untuk readmetode ini, yang akan segera kembali walaupun subproses Anda belum selesai dieksekusi, dll.

Tergantung pada kasus penggunaan, Anda mungkin juga ingin menonaktifkan buffering dalam subproses itu sendiri.

Jika subproses akan menjadi proses Python, Anda bisa melakukan ini sebelum panggilan:

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

Atau sebagai alternatif, berikan envargumen ini pada Popen.

Jika tidak, jika Anda menggunakan Linux / Unix, Anda dapat menggunakan stdbufalat ini. Misalnya suka:

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

Lihat juga di sini tentang stdbufatau opsi lain.

(Lihat juga di sini untuk jawaban yang sama.)

Saya menggunakan solusi ini untuk mendapatkan output realtime pada suatu subproses. Loop ini akan berhenti segera setelah proses selesai tanpa meninggalkan kebutuhan untuk pernyataan break atau loop tak terbatas yang mungkin.

sub_process = subprocess.Popen(my_command, close_fds=True, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

while sub_process.poll() is None:
    out = sub_process.stdout.read(1)
    sys.stdout.write(out)
    sys.stdout.flush()

Menemukan fungsi "plug-and-play" ini di sini . Bekerja seperti pesona!

import subprocess

def myrun(cmd):
    """from http://blog.kagesenshi.org/2008/02/teeing-python-subprocesspopen-output.html
    """
    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    stdout = []
    while True:
        line = p.stdout.readline()
        stdout.append(line)
        print line,
        if line == '' and p.poll() != None:
            break
    return ''.join(stdout)

Anda dapat menggunakan iterator pada setiap byte dalam output dari subproses. Ini memungkinkan pembaruan inline (baris yang diakhiri dengan '\ r' menimpa jalur output sebelumnya) dari subproses:

from subprocess import PIPE, Popen

command = ["my_command", "-my_arg"]

# Open pipe to subprocess
subprocess = Popen(command, stdout=PIPE, stderr=PIPE)


# read each byte of subprocess
while subprocess.poll() is None:
    for c in iter(lambda: subprocess.stdout.read(1) if subprocess.poll() is None else {}, b''):
        c = c.decode('ascii')
        sys.stdout.write(c)
sys.stdout.flush()

if subprocess.returncode != 0:
    raise Exception("The subprocess did not terminate correctly.")

Dalam Python 3.x proses mungkin hang karena outputnya adalah array byte, bukan string. Pastikan Anda mendekodekannya menjadi string.

Mulai dari Python 3.6 Anda bisa melakukannya menggunakan parameter encodingdi Popen Constructor . Contoh lengkap:

process = subprocess.Popen(
    'my_command',
    stdout=subprocess.PIPE,
    stderr=subprocess.STDOUT,
    shell=True,
    encoding='utf-8',
    errors='replace'
)

while True:
    realtime_output = process.stdout.readline()

    if realtime_output == '' and process.poll() is not None:
        break

    if realtime_output:
        print(realtime_output.strip(), flush=True)

Perhatikan bahwa kode ini mengalihkan stderr ke stdoutdan menangani kesalahan output .

Menggunakan pexpect [ http://www.noah.org/wiki/Pexpect ] dengan readlines non-blocking akan menyelesaikan masalah ini. Ini berasal dari fakta bahwa pipa di-buffer, dan output aplikasi Anda semakin di-buffer oleh pipa, oleh karena itu Anda tidak bisa mencapai output itu sampai buffer mengisi atau proses mati.

Solusi lengkap:

import contextlib
import subprocess

# Unix, Windows and old Macintosh end-of-line
newlines = ['\n', '\r\n', '\r']
def unbuffered(proc, stream='stdout'):
    stream = getattr(proc, stream)
    with contextlib.closing(stream):
        while True:
            out = []
            last = stream.read(1)
            # Don't loop forever
            if last == '' and proc.poll() is not None:
                break
            while last not in newlines:
                # Don't loop forever
                if last == '' and proc.poll() is not None:
                    break
                out.append(last)
                last = stream.read(1)
            out = ''.join(out)
            yield out

def example():
    cmd = ['ls', '-l', '/']
    proc = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        # Make all end-of-lines '\n'
        universal_newlines=True,
    )
    for line in unbuffered(proc):
        print line

example()

Ini adalah kerangka dasar yang selalu saya gunakan untuk ini. Ini membuatnya mudah untuk menerapkan batas waktu dan mampu menangani proses gantung yang tidak terhindarkan.

import subprocess
import threading
import Queue

def t_read_stdout(process, queue):
    """Read from stdout"""

    for output in iter(process.stdout.readline, b''):
        queue.put(output)

    return

process = subprocess.Popen(['dir'],
                           stdout=subprocess.PIPE,
                           stderr=subprocess.STDOUT,
                           bufsize=1,
                           cwd='C:\\',
                           shell=True)

queue = Queue.Queue()
t_stdout = threading.Thread(target=t_read_stdout, args=(process, queue))
t_stdout.daemon = True
t_stdout.start()

while process.poll() is None or not queue.empty():
    try:
        output = queue.get(timeout=.5)

    except Queue.Empty:
        continue

    if not output:
        continue

    print(output),

t_stdout.join()

(Solusi ini telah diuji dengan Python 2.7.15)
Anda hanya perlu sys.stdout.flush () setelah setiap baris membaca / menulis:

while proc.poll() is None:
    line = proc.stdout.readline()
    sys.stdout.write(line)
    # or print(line.strip()), you still need to force the flush.
    sys.stdout.flush()

Beberapa jawaban menyarankan python 3.x atau pthon 2.x, kode di bawah ini akan berfungsi untuk keduanya.

 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,)
    stdout = []
    while True:
        line = p.stdout.readline()
        if not isinstance(line, (str)):
            line = line.decode('utf-8')
        stdout.append(line)
        print (line)
        if (line == '' and p.poll() != None):
            break