Mencetak output Subprocess secara konstan saat proses sedang berjalan

Untuk meluncurkan program dari skrip Python saya, saya menggunakan metode berikut:

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Jadi ketika saya meluncurkan proses seperti Process.execute("mvn clean install"), program saya menunggu sampai proses selesai, dan hanya kemudian saya mendapatkan hasil lengkap dari program saya. Ini menjengkelkan jika saya menjalankan proses yang membutuhkan beberapa saat untuk menyelesaikannya.

Bisakah saya membiarkan program saya menulis garis keluaran proses per baris, dengan mem-polling output proses sebelum selesai dalam satu lingkaran atau sesuatu?

** [EDIT] Maaf saya tidak mencari dengan baik sebelum memposting pertanyaan ini. Threading sebenarnya kuncinya. Temukan contoh di sini yang menunjukkan cara melakukannya: ** Python Subprocess.Popen dari utas

Anda dapat menggunakan iter untuk memproses garis secepat output perintah mereka: lines = iter(fd.readline, ""). Berikut adalah contoh lengkap yang menunjukkan kasus penggunaan umum (terima kasih kepada @jfs untuk membantu):

from __future__ import print_function # Only Python 2.x
import subprocess

def execute(cmd):
    popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True)
    for stdout_line in iter(popen.stdout.readline, ""):
        yield stdout_line 
    popen.stdout.close()
    return_code = popen.wait()
    if return_code:
        raise subprocess.CalledProcessError(return_code, cmd)

# Example
for path in execute(["locate", "a"]):
    print(path, end="")

Oke, saya berhasil menyelesaikannya tanpa utas (saran mengapa menggunakan utas lebih baik dihargai) dengan menggunakan cuplikan dari pertanyaan ini Mencegat stdout dari suatu subproses saat sedang berjalan

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    # Poll process for new output until finished
    while True:
        nextline = process.stdout.readline()
        if nextline == '' and process.poll() is not None:
            break
        sys.stdout.write(nextline)
        sys.stdout.flush()

    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Untuk mencetak output baris demi baris segera setelah buffer stdout-nya memerah dengan Python 3:

from subprocess import Popen, PIPE, CalledProcessError

with Popen(cmd, stdout=PIPE, bufsize=1, universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='') # process line here

if p.returncode != 0:
    raise CalledProcessError(p.returncode, p.args)

Perhatikan: Anda tidak perlu p.poll()- loop berakhir saat eof tercapai. Dan Anda tidak perlu iter(p.stdout.readline, '')- bug read-ahead diperbaiki dalam Python 3.

Lihat juga, Python: baca input streaming dari subprocess.communicate () .

Sebenarnya ada cara yang sangat sederhana untuk melakukan ini ketika Anda hanya ingin mencetak hasilnya:

import subprocess
import sys

def execute(command):
    subprocess.check_call(command, stdout=sys.stdout, stderr=subprocess.STDOUT)

Di sini kita hanya mengarahkan subproses ke stdout kita sendiri, dan menggunakan api yang berhasil atau pengecualian.

@tokland

mencoba kode Anda dan memperbaikinya untuk 3.4 dan windows dir.cmd adalah perintah dir sederhana, disimpan sebagai file cmd

import subprocess
c = "dir.cmd"

def execute(command):
    popen = subprocess.Popen(command, stdout=subprocess.PIPE,bufsize=1)
    lines_iterator = iter(popen.stdout.readline, b"")
    while popen.poll() is None:
        for line in lines_iterator:
            nline = line.rstrip()
            print(nline.decode("latin"), end = "\r\n",flush =True) # yield line

execute(c)

Jika seseorang ingin membaca dari keduanya stdoutdan stderrpada saat yang sama menggunakan utas, inilah yang saya buat:

import threading
import subprocess
import Queue

class AsyncLineReader(threading.Thread):
    def __init__(self, fd, outputQueue):
        threading.Thread.__init__(self)

        assert isinstance(outputQueue, Queue.Queue)
        assert callable(fd.readline)

        self.fd = fd
        self.outputQueue = outputQueue

    def run(self):
        map(self.outputQueue.put, iter(self.fd.readline, ''))

    def eof(self):
        return not self.is_alive() and self.outputQueue.empty()

    @classmethod
    def getForFd(cls, fd, start=True):
        queue = Queue.Queue()
        reader = cls(fd, queue)

        if start:
            reader.start()

        return reader, queue


process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdoutReader, stdoutQueue) = AsyncLineReader.getForFd(process.stdout)
(stderrReader, stderrQueue) = AsyncLineReader.getForFd(process.stderr)

# Keep checking queues until there is no more output.
while not stdoutReader.eof() or not stderrReader.eof():
   # Process all available lines from the stdout Queue.
   while not stdoutQueue.empty():
       line = stdoutQueue.get()
       print 'Received stdout: ' + repr(line)

       # Do stuff with stdout line.

   # Process all available lines from the stderr Queue.
   while not stderrQueue.empty():
       line = stderrQueue.get()
       print 'Received stderr: ' + repr(line)

       # Do stuff with stderr line.

   # Sleep for a short time to avoid excessive CPU use while waiting for data.
   sleep(0.05)

print "Waiting for async readers to finish..."
stdoutReader.join()
stderrReader.join()

# Close subprocess' file descriptors.
process.stdout.close()
process.stderr.close()

print "Waiting for process to exit..."
returnCode = process.wait()

if returnCode != 0:
   raise subprocess.CalledProcessError(returnCode, command)

Saya hanya ingin membagikan ini, karena saya akhirnya pada pertanyaan ini mencoba melakukan sesuatu yang serupa, tetapi tidak ada jawaban yang memecahkan masalah saya. Semoga ini membantu seseorang!

Perhatikan bahwa dalam kasus penggunaan saya, proses eksternal membunuh proses yang kita Popen().

Bagi siapa pun yang mencoba jawaban atas pertanyaan ini untuk mendapatkan stdout dari skrip Python perhatikan bahwa Python mendukung stdout-nya, dan oleh karena itu mungkin perlu beberapa saat untuk melihat stdout.

Ini dapat diperbaiki dengan menambahkan berikut ini setelah setiap stdout menulis dalam skrip target:

sys.stdout.flush()

Dalam Python> = 3.5 menggunakan subprocess.runkarya untuk saya:

import subprocess

cmd = 'echo foo; sleep 1; echo foo; sleep 2; echo foo'
subprocess.run(cmd, shell=True)

(mendapatkan output selama eksekusi juga berfungsi tanpa shell=True) https://docs.python.org/3/library/subprocess.html#subprocess.run

Untuk menjawab pertanyaan awal, cara terbaik IMO adalah mengarahkan ulang subproses stdoutlangsung ke program Anda stdout(secara opsional, hal yang sama dapat dilakukan untuk stderr, seperti dalam contoh di bawah)

p = Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.communicate()

PoC ini secara konstan membaca output dari suatu proses dan dapat diakses ketika dibutuhkan. Hanya hasil terakhir yang disimpan, semua output lainnya dibuang, karenanya mencegah PIPE dari kehabisan memori:

import subprocess
import time
import threading
import Queue


class FlushPipe(object):
    def __init__(self):
        self.command = ['python', './print_date.py']
        self.process = None
        self.process_output = Queue.LifoQueue(0)
        self.capture_output = threading.Thread(target=self.output_reader)

    def output_reader(self):
        for line in iter(self.process.stdout.readline, b''):
            self.process_output.put_nowait(line)

    def start_process(self):
        self.process = subprocess.Popen(self.command,
                                        stdout=subprocess.PIPE)
        self.capture_output.start()

    def get_output_for_processing(self):
        line = self.process_output.get()
        print ">>>" + line


if __name__ == "__main__":
    flush_pipe = FlushPipe()
    flush_pipe.start_process()

    now = time.time()
    while time.time() - now < 10:
        flush_pipe.get_output_for_processing()
        time.sleep(2.5)

    flush_pipe.capture_output.join(timeout=0.001)
    flush_pipe.process.kill()

print_date.py

#!/usr/bin/env python
import time

if __name__ == "__main__":
    while True:
        print str(time.time())
        time.sleep(0.01)

output: Anda dapat dengan jelas melihat bahwa hanya ada output dari interval ~ 2.5s tidak ada di antaranya.

>>>1520535158.51
>>>1520535161.01
>>>1520535163.51
>>>1520535166.01

Ini berfungsi setidaknya di Python3.4

import subprocess

process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
for line in process.stdout:
    print(line.decode().strip())

Tidak ada jawaban di sini yang menjawab semua kebutuhan saya.

1. Tidak ada utas untuk stdout (tidak ada Antrian, dll, juga)
2. Non-blocking karena saya perlu memeriksa hal-hal lain yang terjadi
3. Gunakan PIPE seperti yang saya perlukan untuk melakukan banyak hal, misalnya stream output, menulis ke file log dan mengembalikan salinan string dari output.

Sedikit latar belakang: Saya menggunakan ThreadPoolExecutor untuk mengelola kumpulan utas, masing-masing meluncurkan subproses dan menjalankannya bersamaan. (Dalam Python2.7, tetapi ini harus bekerja di 3.x yang lebih baru juga). Saya tidak ingin menggunakan utas hanya untuk pengumpulan keluaran karena saya ingin sebanyak mungkin tersedia untuk hal-hal lain (kumpulan 20 proses akan menggunakan 40 utas hanya untuk menjalankan; 1 untuk utas proses dan 1 untuk stdout ... dan lebih banyak jika Anda ingin stderr kurasa)

Saya menelanjangi banyak pengecualian dan semacamnya di sini jadi ini didasarkan pada kode yang bekerja di produksi. Semoga saya tidak merusaknya di copy dan paste. Juga, umpan balik sangat disambut!

import time
import fcntl
import subprocess
import time

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

# Make stdout non-blocking when using read/readline
proc_stdout = proc.stdout
fl = fcntl.fcntl(proc_stdout, fcntl.F_GETFL)
fcntl.fcntl(proc_stdout, fcntl.F_SETFL, fl | os.O_NONBLOCK)

def handle_stdout(proc_stream, my_buffer, echo_streams=True, log_file=None):
    """A little inline function to handle the stdout business. """
    # fcntl makes readline non-blocking so it raises an IOError when empty
    try:
        for s in iter(proc_stream.readline, ''):   # replace '' with b'' for Python 3
            my_buffer.append(s)

            if echo_streams:
                sys.stdout.write(s)

            if log_file:
                log_file.write(s)
    except IOError:
        pass

# The main loop while subprocess is running
stdout_parts = []
while proc.poll() is None:
    handle_stdout(proc_stdout, stdout_parts)

    # ...Check for other things here...
    # For example, check a multiprocessor.Value('b') to proc.kill()

    time.sleep(0.01)

# Not sure if this is needed, but run it again just to be sure we got it all?
handle_stdout(proc_stdout, stdout_parts)

stdout_str = "".join(stdout_parts)  # Just to demo

Saya yakin ada overhead yang ditambahkan di sini tapi itu bukan masalah dalam kasus saya. Secara fungsional itu melakukan apa yang saya butuhkan. Satu-satunya hal yang belum saya pecahkan adalah mengapa ini bekerja dengan sempurna untuk pesan log tetapi saya melihat beberapa printpesan muncul kemudian dan sekaligus.

Dalam Python 3.6 saya menggunakan ini:

import subprocess

cmd = "command"
output = subprocess.call(cmd, shell=True)
print(process)