ловити stdout в реальному часі з підпроцесу

Я хочу subprocess.Popen()rsync.exe у Windows та надрукувати stdout у 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()

Деякі емпіричні правила для subprocess.

• Ніколи не використовуйте shell=True. Він без потреби викликає додатковий процес оболонки для виклику вашої програми.
• При виклику процесів аргументи передаються у вигляді списків. sys.argvв Python список, і тому argvв С. Таким чином , ви передаєте список , щоб 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 буферизує свій вихід, коли виявляє, що він підключений до труби замість терміналу. Це поведінка за замовчуванням - при підключенні до каналу програми повинні явно змивати stdout для отримання результатів у реальному часі, інакше стандартна бібліотека C буде буферизуватися.

Щоб перевірити це, спробуйте замість цього запустити:

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

і створити test_out.pyфайл із вмістом:

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

Виконання цього підпроцесу має дати вам "Привіт" і зачекати 10 секунд, перш ніж дати "Світ". Якщо це трапляється з наведеним вище кодом python, а не з rsync, це означає, що rsyncсаме воно буферизує вихід, тому вам не пощастило.

Рішенням може бути пряме підключення до pty, використовуючи щось на зразок pexpect.

Я знаю, що це стара тема, але зараз є рішення. Викличте rsync з опцією --outbuf = L. Приклад:

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

У Linux у мене була та ж проблема позбутися буферизації. Нарешті я використав "stdbuf -o0" (або, скасуйте буфер від очікуваного), щоб позбутися буферизації PIPE.

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

Потім я міг би використовувати select.select на stdout.

Див. Також /unix/25372/

Залежно від випадку використання, можливо, ви також захочете відключити буферизацію в самому підпроцесі.

Якщо підпроцес буде процесом Python, ви можете зробити це перед викликом:

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

Або ж передайте це в envаргументі на Popen.

В іншому випадку, якщо ви працюєте на Linux / Unix, ви можете скористатися цим stdbufінструментом. Наприклад, як:

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

Дивіться також тут про stdbufабо інші варіанти.

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 залишається, коли дочірній процес закриває свій stdout або виходить. read()/read(-1)буде блокувати, поки дочірній процес не закриє свій stdout або не завершить роботу.

Ваша проблема:

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

сам ітератор має додаткову буферизацію.

Спробуйте зробити так:

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

Ви не можете отримати stdout для друку без буфера в конвеєрі (якщо ви не можете переписати програму, яка друкує в stdout), тому ось моє рішення:

Перенаправити stdout на sterr, який не буферизується. '<cmd> 1>&2'повинен це зробити. Відкрийте процес наступним чином:myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Ви не можете відрізнити від stdout або stderr, але всі результати ви отримуєте негайно.

Сподіваюся, це допомагає кожному, хто вирішує цю проблему.

Змініть stdout із процесу 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)

Щоб уникнути кешування вихідних даних, ви можете спробувати pexpect,

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

PS : Я знаю, що це питання досить старе, і все ще надає рішення, яке працювало для мене.

PPS : отримав цю відповідь з іншого питання

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

Я пишу графічний інтерфейс для rsync на python і маю однакові проблеми. Ця проблема турбує мене кілька днів, поки я не знайду це в pyDoc.

Якщо Universal_newlines має значення True, файлові об'єкти stdout і stderr відкриваються як текстові файли в режимі універсальних нових рядків. Рядки можуть бути припинені будь-яким із '\ n', конвенцією про кінець рядка Unix, '\ r', старою конвенцією Macintosh або '\ r \ n', конвенцією Windows. Усі ці зовнішні подання розглядаються програмою Python як '\ n'.

Здається, rsync виведе '\ r', коли відбувається переклад.

Я помітив, що немає жодної згадки про використання тимчасового файлу як проміжного. Наведене нижче вирішує проблеми буферизації шляхом виведення у тимчасовий файл і дозволяє аналізувати дані, що надходять з rsync, без підключення до pty. Я протестував наступне на коробці 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...

якщо ви запустите щось подібне в потоці і збережете властивість ffmpeg_time у властивості методу, щоб ви могли отримати до нього доступ, це було б дуже приємно. Я отримую такі результати: вивід буде подібним, якщо ви використовуєте різьбу в 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)

У 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