Alt işlem kullanarak gerçek zamanlı çıktı alma

İşlem için güzel bir ilerleme göstergesi gösterecek bir komut satırı programı (svnadmin doğrulaması) için bir sarmalayıcı komut dosyası yazmaya çalışıyorum. Bu, çıktı alınır alınmaz sarmalanmış programdan her çıktı satırını görebilmemi gerektiriyor.

Programı kullanarak çalıştıracağımı subprocess.Popen, kullanacağımı stdout=PIPE, sonra gelen her satırı okuyup ona göre hareket edeceğimi düşündüm . Bununla birlikte, aşağıdaki kodu çalıştırdığımda, çıktı bir yerde arabelleğe alınmış gibi görünüyordu, bu da iki parça halinde görünmesine neden oldu: 1'den 332'ye, sonra 333'ten 439'a (son çıktı satırı)

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

Alt süreçle ilgili belgelere biraz baktıktan sonra, bufsizeparametresini keşfettim Popen, bu yüzden bufsize'yi 1 (her satırı tampon) ve 0 (tampon yok) olarak ayarlamayı denedim, ancak her iki değer de satırların teslim edilme şeklini değiştirmedi.

Bu noktada pipetleri kavramaya başladım, bu yüzden aşağıdaki çıktı döngüsünü yazdım:

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

ama aynı sonucu aldı.

Alt süreç kullanılarak çalıştırılan bir programın 'gerçek zamanlı' program çıktısını almak mümkün müdür? Python'da ileriye uyumlu (olmayan exec*) başka bir seçenek var mı ?

Bunu denedim ve bazı nedenlerden dolayı kod

for line in p.stdout:
  ...

tamponlar agresif bir şekilde, varyant

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

değil. Görünüşe göre bu bilinen bir hatadır: http://bugs.python.org/issue3907 (Sorun 29 Ağustos 2018 itibariyle artık "Kapalı")

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

Alt işlem çıktısını doğrudan akışlara yönlendirebilirsiniz. Basitleştirilmiş örnek:

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

Bunu deneyebilirsiniz:

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

Okuma yerine okuma satırı kullanırsanız, giriş mesajının yazdırılmadığı bazı durumlar olacaktır. Satır içi giriş gerektiren bir komutla deneyin ve kendiniz görün.

Akış altişlem Stdin ve stdout'u ile asyncio Python içinde tarafından blog post Kevin McCarthy asyncio ile bunu nasıl gösterir:

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

Gerçek Zamanlı Çıktı Sorunu çözüldü: Python'da c programından gerçek zamanlı çıktıyı yakalarken benzer bir sorunla karşılaştım. " Fflush (stdout) " ekledim ; benim C kodumda. Benim için çalıştı. İşte kodun kırılması

<< C Programı >>

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

<< Python Programı >>

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

<< ÇIKTI >> Yazdır: 1 Sayım Yazdır: 2 Sayım Yazdır: 3 Sayım

Umarım yardımcı olur.

~ Sairam

Bir süre önce aynı problemle karşılaştım. Benim çözümüm, readyöntem için yinelemekten vazgeçmekti; bu , alt işleminizin yürütülmesi bitmemiş olsa bile hemen geri dönecektir.

Kullanım durumuna bağlı olarak, alt işlemin kendisinde de arabelleğe almayı devre dışı bırakmak isteyebilirsiniz.

Alt süreç bir Python süreci olacaksa, bunu aramadan önce yapabilirsiniz:

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

Veya alternatif olarak bunu envargümanda iletin Popen.

Aksi takdirde, Linux / Unix üzerindeyseniz, stdbufaracı kullanabilirsiniz . Örneğin:

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

Ayrıca bkz burada yaklaşık stdbufveya diğer seçenekler.

( Aynı cevap için buraya da bakınız .)

Bu çözümü bir alt işlemde gerçek zamanlı çıktı elde etmek için kullandım. Bu döngü, bir break ifadesine veya olası sonsuz döngüye ihtiyaç duymadan, işlem tamamlanır tamamlanmaz duracaktır.

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

Bu "tak ve çalıştır" işlevini burada buldum . Büyü gibi çalıştı!

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)

Alt işlemin çıktısında her bayt üzerinde bir yineleyici kullanabilirsiniz. Bu, alt işlemden satır içi güncellemeye ('\ r' ile biten satırlar önceki çıktı satırının üzerine yazılır) izin verir:

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'te, çıktı bir dize yerine bir bayt dizisi olduğu için işlem askıda kalabilir. Bir dizeye dönüştürdüğünüzden emin olun.

Python 3.6 başlayarak parametresini kullanarak bunu yapabilirsiniz encodingyılında POPEN Oluşturucu . Tam örnek:

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)

Not bu kod o yönlendirmeleri stderr için stdoutve kolları çıktı hataları .

Pexpect [ http://www.noah.org/wiki/Pexpect ] 'i engellemeyen okuma hatları ile kullanmak bu sorunu çözecektir. Bu, kanalların arabelleğe alınmasından ve dolayısıyla uygulamanızın çıktısının boru tarafından arabelleğe alınmasından kaynaklanır, bu nedenle, arabellek dolana veya işlem ölene kadar bu çıktıya ulaşamazsınız.

Tam çözüm:

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

Bunun için her zaman kullandığım temel iskelet budur. Zaman aşımlarının uygulanmasını kolaylaştırır ve kaçınılmaz asılı süreçlerle başa çıkabilir.

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

(Bu çözüm Python 2.7.15 ile test edilmiştir
) Her satır okuma / yazma sonrasında sys.stdout.flush () yapmanız yeterlidir:

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 veya pthon 2.x'i öneren az sayıda yanıt, Aşağıdaki kod her ikisi için de işe yarayacaktır.

 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