Nhận đầu ra thời gian thực bằng cách sử dụng quy trình con

Tôi đang cố gắng viết một kịch bản trình bao bọc cho một chương trình dòng lệnh (svnadmin xác minh) sẽ hiển thị một chỉ báo tiến trình tốt đẹp cho hoạt động. Điều này đòi hỏi tôi phải có thể nhìn thấy từng dòng đầu ra từ chương trình được gói ngay khi nó là đầu ra.

Tôi hình dung rằng tôi chỉ thực hiện chương trình bằng cách sử dụng subprocess.Popen, sử dụng stdout=PIPE, sau đó đọc từng dòng khi nó đến và hành động theo nó. Tuy nhiên, khi tôi chạy đoạn mã sau, đầu ra dường như được đệm ở đâu đó, khiến nó xuất hiện thành hai đoạn, dòng 1 đến 332, sau đó là 333 đến 439 (dòng đầu ra cuối cùng)

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', '')

Sau khi xem tài liệu về quy trình con một chút, tôi phát hiện ra bufsizetham sốPopen , vì vậy tôi đã thử đặt bufsize thành 1 (đệm mỗi dòng) và 0 (không có bộ đệm), nhưng dường như không có giá trị nào thay đổi cách phân phối các dòng.

Tại thời điểm này tôi đã bắt đầu nắm bắt được ống hút, vì vậy tôi đã viết vòng lặp đầu ra sau:

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

nhưng nhận được kết quả tương tự.

Có thể lấy đầu ra chương trình 'thời gian thực' của chương trình được thực hiện bằng quy trình con không? Có một số tùy chọn khác trong Python tương thích về phía trước (không exec*) không?

Tôi đã thử điều này, và vì một số lý do trong khi mã

for line in p.stdout:
  ...

Bộ đệm tích cực, các biến thể

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

không làm. Rõ ràng đây là một lỗi đã biết: http://bugs.python.org/su3907 (Vấn đề hiện đã được "Đóng" kể từ ngày 29 tháng 8 năm 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()

Bạn có thể hướng đầu ra của quy trình con đến các luồng trực tiếp. Ví dụ đơn giản:

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

Bạn có thể thử điều này:

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

Nếu bạn sử dụng readline thay vì đọc, sẽ có một số trường hợp thông báo đầu vào không được in. Hãy thử nó với một lệnh yêu cầu một đầu vào nội tuyến và tự mình xem.

Quá trình phát trực tuyến stdin và stdout với asyncio trong bài đăng trên blog Python của Kevin McCarthy chỉ ra cách thực hiện với 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())

Vấn đề đầu ra thời gian thực đã được giải quyết: Tôi đã gặp phải vấn đề tương tự trong Python, trong khi nắm bắt đầu ra thời gian thực từ chương trình c. Tôi đã thêm " fflush (stdout) ;" trong mã C của tôi. Nó làm việc cho tôi. Đây là đoạn mã

<< Chương trình C >>

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

<< Chương trình 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 >> In: Đếm 1 In: Đếm 2 In: Đếm 3

Hy vọng nó giúp.

~ sairam

Tôi gặp vấn đề tương tự một lúc sau. Giải pháp của tôi là bỏ đi lặp lại readphương thức, nó sẽ trả về ngay lập tức ngay cả khi quy trình con của bạn chưa thực hiện xong, v.v.

Tùy thuộc vào trường hợp sử dụng, bạn cũng có thể muốn tắt bộ đệm trong chính quy trình con.

Nếu quy trình con sẽ là một quy trình Python, bạn có thể thực hiện việc này trước cuộc gọi:

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

Hoặc thay thế vượt qua điều này trong envđối số để Popen.

Mặt khác, nếu bạn đang dùng Linux / Unix, bạn có thể sử dụng stdbufcông cụ này. Ví dụ như:

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

Xem thêm ở đây về stdbufhoặc các tùy chọn khác.

(Xem thêm ở đây để có câu trả lời tương tự.)

Tôi đã sử dụng giải pháp này để có được đầu ra thời gian thực trên một quy trình con. Vòng lặp này sẽ dừng lại ngay khi quá trình hoàn thành không cần phải có câu lệnh break hoặc vòng lặp vô hạn có thể.

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

Tìm thấy chức năng "plug-and-play" này tại đây . Làm việc như người ở!

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)

Bạn có thể sử dụng một trình vòng lặp trên mỗi byte trong đầu ra của quy trình con. Điều này cho phép cập nhật nội tuyến (các dòng kết thúc bằng '\ r' ghi đè lên dòng đầu ra trước đó) từ quy trình con:

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

Trong Python 3.x, quá trình có thể bị treo vì đầu ra là một mảng byte thay vì một chuỗi. Hãy chắc chắn rằng bạn giải mã nó thành một chuỗi.

Bắt đầu từ Python 3.6, bạn có thể thực hiện bằng tham số encodingtrong Trình tạo Popen . Ví dụ đầy đủ:

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)

Lưu ý rằng mã này chuyển hướng stderr đến stdoutvà xử lý các lỗi đầu ra .

Sử dụng pexect [ http://www.noah.org/wiki/Pevelopect ] với các đường dẫn không chặn sẽ giải quyết vấn đề này. Nó xuất phát từ thực tế là các đường ống được đệm, và do đó, đầu ra của ứng dụng của bạn bị đệm bởi đường ống, do đó bạn không thể có được đầu ra đó cho đến khi bộ đệm lấp đầy hoặc quá trình chết.

Giải pháp hoàn chỉnh:

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

Đây là bộ xương cơ bản mà tôi luôn sử dụng cho việc này. Nó giúp bạn dễ dàng thực hiện thời gian chờ và có thể xử lý các quy trình treo không thể tránh khỏi.

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

(Giải pháp này đã được thử nghiệm với Python 2.7.15)
Bạn chỉ cần sys.stdout.flush () sau mỗi dòng đọc / ghi:

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

Rất ít câu trả lời gợi ý python 3.x hoặc pthon 2.x, Dưới đây mã sẽ hoạt động cho cả hai.

 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