从子进程中实时捕获标准输出

Question

我想在 Windows 中 subprocess.Popen()rsync.exe，并在 Python 中打印标准输出。

我的代码可以工作，但在文件传输完成之前它无法捕捉进度！我想实时打印每个文件的进度。

现在使用 Python 3.1，因为我听说它应该更好地处理 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()

Answer 1

subprocess 的一些经验法则。

• 从不使用shell=True。它不必要地调用一个额外的 shell 进程来调用您的程序。
• 调用进程时，参数作为列表传递。 sys.argv 在 python 中是一个列表，argv 在 C 中也是一个列表。所以你将 list 传递给 Popen 来调用子进程，而不是字符串。
• 不阅读时不要将stderr 重定向到PIPE。
• 不写信时不要重定向stdin。

例子：

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

也就是说，当 rsync 检测到它连接到管道而不是终端时，它可能会缓冲其输出。这是默认行为 - 当连接到管道时，程序必须显式刷新标准输出以获得实时结果，否则标准 C 库将缓冲。

要对此进行测试，请尝试运行它：

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

并创建一个包含内容的test_out.py 文件：

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

执行该子进程应该会给您“Hello”并等待 10 秒，然后再给出“World”。如果上面的 python 代码而不是rsync 发生这种情况，这意味着rsync 本身正在缓冲输出，所以你不走运。

一种解决方案是直接连接到pty，使用pexpect 之类的东西。

Answer 2

我知道这是一个老话题，但现在有一个解决方案。使用选项 --outbuf=L 调用 rsync。示例：

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

Answer 3

根据用例，您可能还希望禁用子进程本身的缓冲。

如果子进程是 Python 进程，您可以在调用之前执行此操作：

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

或者在env 参数中将其传递给Popen。

否则，如果您使用的是 Linux/Unix，则可以使用 stdbuf 工具。例如。喜欢：

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

另请参阅 here 关于 stdbuf 或其他选项。

Answer 4

在 Linux 上，我遇到了摆脱缓冲的同样问题。我终于使用了“stdbuf -o0”（或者，unbuffer from expect）来摆脱 PIPE 缓冲。

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

然后我可以在标准输出上使用 select.select。

另见https://unix.stackexchange.com/questions/25372/

Answer 5

for line in p.stdout:
  ...

在下一个换行之前一直阻塞。

对于“实时”行为，您必须执行以下操作：

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 循环将被保留。 read()/read(-1) 将阻塞直到子进程关闭其标准输出或退出。

Answer 6

你的问题是：

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

迭代器本身有额外的缓冲。

尝试这样做：

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

Answer 7

你不能让标准输出无缓冲地打印到管道（除非你可以重写打印到标准输出的程序），所以这是我的解决方案：

将标准输出重定向到未缓冲的 sterr。 '<cmd> 1>&2' 应该这样做。打开进程如下：myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
您无法区分 stdout 或 stderr，但您会立即获得所有输出。

希望这可以帮助任何人解决这个问题。

Answer 8

为避免缓存输出，您可能想尝试 pexpect，

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

PS ：我知道这个问题已经很老了，仍然提供对我有用的解决方案。

PPS：从另一个问题得到这个答案

Answer 9

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

我正在为 python 中的 rsync 编写一个 GUI，并且有相同的问题。这个问题困扰了我好几天，直到我在 pyDoc 中找到它。

如果universal_newlines 为True，文件对象stdout 和stderr 将作为文本文件以通用换行符模式打开。行可以由 '\n'（Unix 行尾约定）、'\r'（旧 Macintosh 约定）或 '\r\n'（Windows 约定）中的任何一个终止。所有这些外部表示都被 Python 程序视为“\n”。

翻译进行时rsync似乎会输出'\r'。

Answer 10

将 rsync 进程的标准输出更改为无缓冲。

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)

Answer 11

我注意到没有提到使用临时文件作为中间文件。下面通过输出到一个临时文件来解决缓冲问题，并允许您在不连接到 pty 的情况下解析来自 rsync 的数据。我在linux机器上测试了以下，rsync的输出往往会因平台而异，所以解析输出的正则表达式可能会有所不同：

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

Answer 12

如果你在一个线程中运行这样的东西并将 ffmpeg_time 属性保存在一个方法的属性中以便你可以访问它，它会非常好用 我得到这样的输出： output be like if you use threading in 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)

Answer 13

在 Python 3 中，有一个解决方案，它从命令行中取出一个命令，并在接收到它们时提供实时解码良好的字符串。

接收者 (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")))

可以生成实时输出的简单程序示例 (dummy_out.py)：

import time
import sys

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

输出：

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