하위 프로세스를 사용하여 실시간 출력 얻기

작업에 대한 진행률 표시기가 표시되는 명령 줄 프로그램 (svnadmin verify)에 대한 래퍼 스크립트를 작성하려고합니다. 이렇게하면 랩핑 된 프로그램의 출력 라인이 출력되는 즉시 볼 수 있어야합니다.

나는을 사용하여 프로그램을 실행하고 사용 subprocess.Popen하고 stdout=PIPE각 줄을 읽은 다음 그에 따라 행동한다고 ​​생각했다. 그러나 다음 코드를 실행하면 출력이 어딘가에 버퍼링되어 1 ~ 332 줄, 333 ~ 439 (마지막 출력 줄)의 두 덩어리로 나타납니다.

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

하위 프로세스에 대한 문서를 약간 살펴본 후 bufsize매개 변수를로 찾았 Popen으므로 bufsize를 1 (각 행 버퍼) 및 0 (버퍼 없음)으로 설정하려고 시도했지만 값이 행 전달 방식을 변경하지 않는 것 같습니다.

이 시점에서 나는 빨대를 파악하기 시작했으며 다음과 같은 출력 루프를 작성했습니다.

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

그러나 같은 결과를 얻었습니다.

하위 프로세스를 사용하여 실행 된 프로그램의 '실시간'프로그램 출력을 얻을 수 있습니까? 파이썬에서 순방향 호환 (아닌 exec*) 다른 옵션이 있습니까?

나는 이것을 시도했고 어떤 이유로 코드가있는 동안

for line in p.stdout:
  ...

적극적으로 버퍼를 변형

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

하지 않습니다. : 분명히 이것은 알려진 버그 http://bugs.python.org/issue3907 (이 문제는 이제 2018 년 8 월 29로 "닫기"는)

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, bufsize=1)
for line in iter(p.stdout.readline, b''):
    print line,
p.stdout.close()
p.wait()

서브 프로세스 출력을 스트림으로 직접 지정할 수 있습니다. 단순화 된 예 :

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

당신은 이것을 시도 할 수 있습니다 :

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

읽기 대신 readline을 사용하면 입력 메시지가 인쇄되지 않는 경우가 있습니다. 인라인 입력이 필요한 명령으로 시도해보십시오.

스트리밍 서브 프로세스의 표준 입력과 표준 출력과 asyncio 파이썬에 의한 블로그 포스트 케빈 맥카시의 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())

실시간 출력 문제 해결 : 파이썬에서 비슷한 문제가 발생하여 c 프로그램에서 실시간 출력을 캡처합니다. " fflush (stdout) ;"를 추가했습니다 . 내 C 코드에서. 그것은 나를 위해 일했다. 다음은 코드 스니핑입니다.

《C 프로그램》

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

<< 파이썬 프로그램 >>

#!/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)

<< 출력 >> 인쇄 : 카운트 1 인쇄 : 카운트 2 인쇄 : 카운트 3

도움이 되길 바랍니다.

~ 사이 람

나는 다시 같은 문제에 부딪쳤다. 내 솔루션은 read메서드에 대한 반복을 제거하는 것이 었습니다. 하위 프로세스가 실행을 마치지 않아도 즉시 반환됩니다.

유스 케이스에 따라 서브 프로세스 자체에서 버퍼링을 사용하지 않을 수도 있습니다.

하위 프로세스가 Python 프로세스 인 경우 호출 전에이를 수행 할 수 있습니다.

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

또는 대안으로 이것을 env인수에 전달하십시오.Popen .

그렇지 않으면 Linux / Unix에있는 경우 stdbuf도구를 사용할 수 있습니다 . 예 :

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

참조 여기 에 대한stdbuf 다른 옵션을 제공합니다.

( 동일한 답변 은 여기 를 참조하십시오 .)

이 솔루션을 사용하여 하위 프로세스에서 실시간 출력을 얻었습니다. 이 루프는 프로세스가 완료 되 자마자 break 문이나 무한 루프가 필요하지 않게되면 중지됩니다.

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

이 "플러그 앤 플레이"기능을 여기서 찾으 십시오 . 매력처럼 일했다!

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)

서브 프로세스의 출력에서 ​​각 바이트에 대해 반복자를 사용할 수 있습니다. 서브 프로세스에서 인라인 업데이트 ( '\ r'로 끝나는 라인이 이전 출력 라인을 덮어 씁니다)를 허용합니다.

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

Python 3.x에서는 출력이 문자열 대신 바이트 배열이므로 프로세스가 중단 될 수 있습니다. 문자열로 디코딩해야합니다.

Python 3.6부터 Popen Constructor 의 매개 변수 encoding를 사용하여이를 수행 할 수 있습니다 . 완전한 예 :

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)

참고이 코드가 리디렉션 stderr 에 stdout와 핸들 출력 오류 .

비 차단 readlines와 함께 pexpect [ http://www.noah.org/wiki/Pexpect ]를 사용하면 이 문제가 해결됩니다. 파이프가 버퍼링되어 파이프에 의해 앱의 출력이 버퍼링되기 때문에 버퍼가 채워지거나 프로세스가 종료 될 때까지 해당 출력에 도달 할 수 없습니다.

완벽한 솔루션 :

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

이것은 항상 이것을 위해 사용하는 기본 골격입니다. 시간 초과를 쉽게 구현할 수 있으며 불가피한 중단 프로세스를 처리 할 수 ​​있습니다.

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

(이 솔루션은 Python 2.7.15에서 테스트되었습니다.
) 각 줄 읽기 / 쓰기 후에 sys.stdout.flush ()를 실행하면됩니다.

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

python 3.x 또는 pthon 2.x를 제안하는 답변은 거의 없으며 아래 코드는 둘 다 작동합니다.

 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