bắt stdout trong thời gian thực từ quy trình con

Tôi muốn subprocess.Popen()rsync.exe trong Windows và in stdout bằng Python.

Mã của tôi hoạt động, nhưng nó không bắt được tiến trình cho đến khi quá trình chuyển tệp hoàn tất! Tôi muốn in tiến trình cho từng tệp trong thời gian thực.

Sử dụng Python 3.1 ngay bây giờ vì tôi nghe nói rằng nó sẽ xử lý IO tốt hơn.

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

Một số quy tắc ngón tay cái cho subprocess.

• Không bao giờ sử dụng shell=True. Nó không cần thiết phải gọi một quá trình shell bổ sung để gọi chương trình của bạn.
• Khi gọi các tiến trình, các đối số được chuyển xung quanh dưới dạng danh sách. sys.argvtrong python là một danh sách, và như vậy là argvtrong C. Vì vậy, bạn vượt qua một danh sách để Popengọi trình con, không phải là một chuỗi.
• Đừng chuyển hướng stderrđến a PIPEkhi bạn không đọc nó.
• Đừng chuyển hướng stdinkhi bạn không viết thư cho nó.

Thí dụ:

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

Điều đó nói rằng, có khả năng rsync đệm đầu ra của nó khi nó phát hiện ra rằng nó được kết nối với một đường ống thay vì một thiết bị đầu cuối. Đây là hành vi mặc định - khi được kết nối với một đường ống, các chương trình phải xóa rõ ràng stdout để có kết quả thời gian thực, nếu không thư viện C tiêu chuẩn sẽ đệm.

Để kiểm tra điều đó, hãy thử chạy điều này thay thế:

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

và tạo một test_out.pytệp có nội dung:

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

Việc thực thi quy trình con đó sẽ cung cấp cho bạn "Xin chào" và đợi 10 giây trước khi đưa ra "Thế giới". Nếu điều đó xảy ra với mã python ở trên mà không phải với rsync, điều đó có nghĩa là rsyncbản thân nó đang lưu đầu ra vào bộ đệm, vì vậy bạn không may mắn.

Một giải pháp sẽ là kết nối trực tiếp với a pty, sử dụng một cái gì đó như pexpect.

Tôi biết đây là một chủ đề cũ, nhưng có một giải pháp bây giờ. Gọi rsync với tùy chọn --outbuf = L. Thí dụ:

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

Trên Linux, tôi đã gặp vấn đề tương tự khi loại bỏ bộ đệm. Cuối cùng tôi đã sử dụng "stdbuf -o0" (hoặc, bỏ bộ đệm từ mong đợi) để loại bỏ bộ đệm PIPE.

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

Sau đó, tôi có thể sử dụng select.select trên stdout.

Xem thêm /unix/25372/

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

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

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

Hoặc cách khác, chuyển điều này trong envđối số sang Popen.

Ngược lại, nếu bạn đang sử 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.

for line in p.stdout:
  ...

luôn chặn cho đến dòng tiếp theo.

Đối với hành vi "thời gian thực", bạn phải làm như sau:

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

Vòng lặp while còn lại khi process con đóng stdout của nó hoặc thoát. read()/read(-1)sẽ chặn cho đến khi tiến trình con đóng lại hoặc thoát.

Vấn đề của bạn là:

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

bản thân trình lặp có thêm bộ đệm.

Hãy thử làm như sau:

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

Bạn không thể yêu cầu stdout in không có bộ đệm vào một đường ống (trừ khi bạn có thể viết lại chương trình in thành stdout), vì vậy đây là giải pháp của tôi:

Chuyển hướng stdout sang sterr, không được lưu vào bộ đệm. '<cmd> 1>&2'Hãy làm nó. Mở quá trình như sau: myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Bạn không thể phân biệt với stdout hay stderr, nhưng bạn nhận được tất cả các đầu ra ngay lập tức.

Hy vọng điều này sẽ giúp bất cứ ai giải quyết vấn đề này.

Thay đổi stdout từ quá trình rsync để được bỏ bộ đệm.

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)

Để tránh bộ nhớ đệm của đầu ra, bạn có thể muốn thử pexpect,

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

Tái bút : Tôi biết câu hỏi này khá cũ, vẫn cung cấp giải pháp phù hợp với tôi.

PPS : có câu trả lời này từ một câu hỏi khác

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

Tôi đang viết GUI cho rsync trong python và có cùng các thăm dò. Vấn đề này đã gây khó khăn cho tôi trong vài ngày cho đến khi tôi tìm thấy nó trong pyDoc.

Nếu Universal_newlines là True, các đối tượng tệp stdout và stderr được mở dưới dạng tệp văn bản trong chế độ dòng mới phổ quát. Các dòng có thể được kết thúc bởi bất kỳ '\ n', quy ước cuối dòng Unix, '\ r', quy ước Macintosh cũ hoặc '\ r \ n', quy ước Windows. Tất cả các biểu diễn bên ngoài này được chương trình Python xem là '\ n'.

Có vẻ như rsync sẽ xuất ra '\ r' khi quá trình dịch diễn ra.

Tôi nhận thấy rằng không có đề cập đến việc sử dụng tệp tạm thời làm tệp trung gian. Phần sau giải quyết các vấn đề về bộ đệm bằng cách xuất ra tệp tạm thời và cho phép bạn phân tích cú pháp dữ liệu đến từ rsync mà không cần kết nối với pty. Tôi đã thử nghiệm điều sau trên hộp linux và đầu ra của rsync có xu hướng khác nhau giữa các nền tảng, vì vậy các biểu thức chính quy để phân tích cú pháp đầu ra có thể khác nhau:

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

nếu bạn chạy một cái gì đó như thế này trong một luồng và lưu thuộc tính ffmpeg_time trong một thuộc tính của một phương thức để bạn có thể truy cập nó, nó sẽ hoạt động rất tốt, tôi nhận được kết quả đầu ra như thế này: đầu ra giống như nếu bạn sử dụng luồng trong 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)

Trong Python 3, đây là một giải pháp, loại bỏ một lệnh khỏi dòng lệnh và cung cấp các chuỗi được giải mã độc đáo theo thời gian thực khi chúng được nhận.

Người nhận (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")))

Ví dụ chương trình đơn giản có thể tạo đầu ra thời gian thực (dummy_out.py ):

import time
import sys

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

Đầu ra:

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