capturando stdout em tempo real do subprocesso

Quero subprocess.Popen()rsync.exe no Windows e imprimir o stdout em Python.

Meu código funciona, mas não detecta o progresso até que uma transferência de arquivo seja concluída! Quero imprimir o progresso de cada arquivo em tempo real.

Usando Python 3.1 agora, desde que ouvi dizer que deve ser melhor para lidar com 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()

Algumas regras básicas para subprocess.

• Nunca use shell=True. Ele invoca desnecessariamente um processo shell extra para chamar seu programa.
• Ao chamar processos, os argumentos são transmitidos como listas. sys.argvem python é uma lista, e também argvem C. Então, você passa uma lista para Popenpara chamar subprocessos, não uma string.
• Não redirecione stderrpara um PIPEquando não estiver lendo.
• Não redirecione stdinquando você não estiver escrevendo.

Exemplo:

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

Dito isso, é provável que o rsync armazene sua saída ao detectar que está conectado a um pipe em vez de um terminal. Este é o comportamento padrão - quando conectado a um pipe, os programas devem limpar explicitamente o stdout para resultados em tempo real, caso contrário, a biblioteca C padrão irá armazenar em buffer.

Para testar isso, tente executar o seguinte:

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

e crie um test_out.pyarquivo com o conteúdo:

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

A execução desse subprocesso deve dar a você "Hello" e esperar 10 segundos antes de dar "World". Se isso acontecer com o código Python acima e não com rsync, isso significa que rsyncele próprio está armazenando a saída em buffer, então você está sem sorte.

Uma solução seria conectar-se diretamente a um pty, usando algo parecido pexpect.

Eu sei que este é um assunto antigo, mas agora há uma solução. Chame o rsync com a opção --outbuf = L. Exemplo:

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

No Linux, tive o mesmo problema para me livrar do buffer. Finalmente usei "stdbuf -o0" (ou, sem buffer de expect) para me livrar do buffer PIPE.

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

Eu poderia então usar select.select em stdout.

Veja também /unix/25372/

Dependendo do caso de uso, você também pode desabilitar o armazenamento em buffer no próprio subprocesso.

Se o subprocesso for um processo Python, você pode fazer isso antes da chamada:

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

Ou, alternativamente, passe isso no envargumento para Popen.

Caso contrário, se você estiver no Linux / Unix, pode usar a stdbufferramenta. Por exemplo, como:

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

Veja também aqui sobre stdbufou outras opções.

for line in p.stdout:
  ...

sempre bloqueia até o próximo avanço de linha.

Para comportamento em "tempo real", você deve fazer algo assim:

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

O loop while é deixado quando o processo filho fecha seu stdout ou sai. read()/read(-1)bloquearia até que o processo filho fechasse seu stdout ou saísse.

Seu problema é:

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

o próprio iterador tem buffer extra.

Tente fazer assim:

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

Você não pode fazer com que o stdout imprima sem buffer em um pipe (a menos que você possa reescrever o programa que imprime no stdout), então aqui está minha solução:

Redirecione stdout para sterr, que não é armazenado em buffer. '<cmd> 1>&2'deve fazer isso. Abra o processo da seguinte maneira: myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Você não pode distinguir de stdout ou stderr, mas obtém todas as saídas imediatamente.

Espero que isso ajude alguém a lidar com este problema.

Altere o stdout do processo rsync para sem buffer.

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)

Para evitar o cache de saída, você pode tentar o pexpect,

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

PS : Eu sei que essa questão é bem antiga, ainda fornecendo a solução que funcionou para mim.

PPS : obtive esta resposta de outra pergunta

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

Estou escrevendo uma GUI para rsync em python e tenho os mesmos problemas. Esse problema me incomodou por vários dias, até que eu encontrei isso no pyDoc.

Se universal_newlines for True, os objetos de arquivo stdout e stderr são abertos como arquivos de texto no modo de nova linha universal. As linhas podem ser encerradas por qualquer uma das '\ n', convenção de fim de linha do Unix, '\ r', a antiga convenção do Macintosh ou '\ r \ n', a convenção do Windows. Todas essas representações externas são vistas como '\ n' pelo programa Python.

Parece que o rsync irá imprimir '\ r' quando a tradução estiver acontecendo.

Percebi que não há menção ao uso de um arquivo temporário como intermediário. A seguir, contorna os problemas de buffer, gerando um arquivo temporário e permite que você analise os dados vindos do rsync sem conectar a um pty. Testei o seguinte em uma máquina Linux, e a saída do rsync tende a ser diferente entre as plataformas, portanto, as expressões regulares para analisar a saída podem variar:

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

se você executar algo assim em um thread e salvar a propriedade ffmpeg_time em uma propriedade de um método para que você possa acessá-lo, funcionaria muito bem, eu recebo saídas como esta: a saída será como se você usar threading no 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)

No Python 3, aqui está uma solução, que tira um comando da linha de comando e entrega strings decodificadas em tempo real à medida que são recebidas.

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

Exemplo de programa simples que pode gerar saída em tempo real ( dummy_out.py):

import time
import sys

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

Resultado:

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