Постійно друкувати вихід підпроцесу під час запуску процесу

Для запуску програм з моїх Python-скриптів я використовую наступний метод:

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Тож коли я запускаю такий процес Process.execute("mvn clean install"), моя програма чекає, поки процес закінчиться, і тільки тоді я отримую повний результат своєї програми. Це дратує, якщо я запускаю процес, який потребує певного часу.

Чи можу я дозволити моїй програмі записувати вихідний процес за рядком, опитуючи висновок процесу, перш ніж він закінчується в циклі чи щось таке?

** [EDIT] Вибачте, що я не дуже добре шукав, перш ніж розміщувати це питання. Нитка - це насправді ключ. Тут знайдено приклад, який показує, як це зробити: ** Підпроцес Python. Відкрийте з потоку

Ви можете використовувати ITER для обробки рядків , як тільки команда виводить їх: lines = iter(fd.readline, ""). Ось повний приклад, який показує типовий випадок використання (завдяки @jfs за допомогу):

from __future__ import print_function # Only Python 2.x
import subprocess

def execute(cmd):
    popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True)
    for stdout_line in iter(popen.stdout.readline, ""):
        yield stdout_line 
    popen.stdout.close()
    return_code = popen.wait()
    if return_code:
        raise subprocess.CalledProcessError(return_code, cmd)

# Example
for path in execute(["locate", "a"]):
    print(path, end="")

Гаразд, мені вдалося вирішити це без потоків (будь-які пропозиції, чому краще використовувати теми, оцінюються), використовуючи фрагмент із цього питання Перехоплення строки підпроцесу під час його запуску.

def execute(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    # Poll process for new output until finished
    while True:
        nextline = process.stdout.readline()
        if nextline == '' and process.poll() is not None:
            break
        sys.stdout.write(nextline)
        sys.stdout.flush()

    output = process.communicate()[0]
    exitCode = process.returncode

    if (exitCode == 0):
        return output
    else:
        raise ProcessException(command, exitCode, output)

Щоб надрукувати вихідний підпроцес по рядку, як тільки його буфер stdout буде спущено на Python 3:

from subprocess import Popen, PIPE, CalledProcessError

with Popen(cmd, stdout=PIPE, bufsize=1, universal_newlines=True) as p:
    for line in p.stdout:
        print(line, end='') # process line here

if p.returncode != 0:
    raise CalledProcessError(p.returncode, p.args)

Зверніть увагу: вам не потрібно p.poll()- петля закінчується, коли буде досягнуто eof. І вам не потрібноiter(p.stdout.readline, '') - помилка, що читається вперед, виправлена ​​в Python 3.

Дивіться також, Python: читайте потоковий вхід з subprocess.communicate () .

Насправді це дійсно простий спосіб зробити це, коли ви просто хочете надрукувати вихід:

import subprocess
import sys

def execute(command):
    subprocess.check_call(command, stdout=sys.stdout, stderr=subprocess.STDOUT)

Тут ми просто вказуємо на підпроцес до власної версії та використовуючи існуючий api успіх чи виняток.

@tokland

спробував ваш код і виправив його для 3,4 та windows dir.cmd - це проста команда dir, збережена як cmd-файл

import subprocess
c = "dir.cmd"

def execute(command):
    popen = subprocess.Popen(command, stdout=subprocess.PIPE,bufsize=1)
    lines_iterator = iter(popen.stdout.readline, b"")
    while popen.poll() is None:
        for line in lines_iterator:
            nline = line.rstrip()
            print(nline.decode("latin"), end = "\r\n",flush =True) # yield line

execute(c)

Якщо хтось хоче читати з обох stdoutі stderrодночасно за допомогою ниток, ось що я придумав:

import threading
import subprocess
import Queue

class AsyncLineReader(threading.Thread):
    def __init__(self, fd, outputQueue):
        threading.Thread.__init__(self)

        assert isinstance(outputQueue, Queue.Queue)
        assert callable(fd.readline)

        self.fd = fd
        self.outputQueue = outputQueue

    def run(self):
        map(self.outputQueue.put, iter(self.fd.readline, ''))

    def eof(self):
        return not self.is_alive() and self.outputQueue.empty()

    @classmethod
    def getForFd(cls, fd, start=True):
        queue = Queue.Queue()
        reader = cls(fd, queue)

        if start:
            reader.start()

        return reader, queue


process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdoutReader, stdoutQueue) = AsyncLineReader.getForFd(process.stdout)
(stderrReader, stderrQueue) = AsyncLineReader.getForFd(process.stderr)

# Keep checking queues until there is no more output.
while not stdoutReader.eof() or not stderrReader.eof():
   # Process all available lines from the stdout Queue.
   while not stdoutQueue.empty():
       line = stdoutQueue.get()
       print 'Received stdout: ' + repr(line)

       # Do stuff with stdout line.

   # Process all available lines from the stderr Queue.
   while not stderrQueue.empty():
       line = stderrQueue.get()
       print 'Received stderr: ' + repr(line)

       # Do stuff with stderr line.

   # Sleep for a short time to avoid excessive CPU use while waiting for data.
   sleep(0.05)

print "Waiting for async readers to finish..."
stdoutReader.join()
stderrReader.join()

# Close subprocess' file descriptors.
process.stdout.close()
process.stderr.close()

print "Waiting for process to exit..."
returnCode = process.wait()

if returnCode != 0:
   raise subprocess.CalledProcessError(returnCode, command)

Мені просто хотілося поділитися цим, оскільки я закінчився цим питанням, намагаючись зробити щось подібне, але жодна з відповідей не вирішила моєї проблеми. Сподіваємось, це комусь допомагає!

Зауважте, що в моєму випадку використання зовнішній процес вбиває процес, який ми Popen().

Для тих, хто намагається відповісти на це питання, щоб отримати stdout із сценарію Python, зауважте, що Python буферизує свій stdout, і тому, можливо, знадобиться деякий час, щоб побачити stdout.

Це можна усунути, додавши наступне після кожного написання stdout у цільовому сценарії:

sys.stdout.flush()

У Python> = 3.5 використовуючи subprocess.runдля мене роботи:

import subprocess

cmd = 'echo foo; sleep 1; echo foo; sleep 2; echo foo'
subprocess.run(cmd, shell=True)

(отримання результату під час виконання також працює без shell=True) https://docs.python.org/3/library/subprocess.html#subprocess.run

Щоб відповісти на початкове запитання, найкращим способом IMO є просто перенаправлення підпроцесу stdoutбезпосередньо до програми вашої програми stdout(необов'язково, те саме можна зробити stderr, як у прикладі нижче)

p = Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.communicate()

Цей PoC постійно зчитує результати з процесу та може отримати доступ до нього за потреби. Зберігається лише останній результат, весь інший вихід відкидається, отже, запобігає зростанню пам’яті PIPE:

import subprocess
import time
import threading
import Queue


class FlushPipe(object):
    def __init__(self):
        self.command = ['python', './print_date.py']
        self.process = None
        self.process_output = Queue.LifoQueue(0)
        self.capture_output = threading.Thread(target=self.output_reader)

    def output_reader(self):
        for line in iter(self.process.stdout.readline, b''):
            self.process_output.put_nowait(line)

    def start_process(self):
        self.process = subprocess.Popen(self.command,
                                        stdout=subprocess.PIPE)
        self.capture_output.start()

    def get_output_for_processing(self):
        line = self.process_output.get()
        print ">>>" + line


if __name__ == "__main__":
    flush_pipe = FlushPipe()
    flush_pipe.start_process()

    now = time.time()
    while time.time() - now < 10:
        flush_pipe.get_output_for_processing()
        time.sleep(2.5)

    flush_pipe.capture_output.join(timeout=0.001)
    flush_pipe.process.kill()

print_date.py

#!/usr/bin/env python
import time

if __name__ == "__main__":
    while True:
        print str(time.time())
        time.sleep(0.01)

висновок: Ви чітко бачите, що між інтервалом ~ 2,5s виходить тільки нічого між ними.

>>>1520535158.51
>>>1520535161.01
>>>1520535163.51
>>>1520535166.01

Це працює принаймні в Python3.4

import subprocess

process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
for line in process.stdout:
    print(line.decode().strip())

Жодна з відповідей тут не відповідала всім моїм потребам.

1. Немає потоків для stdout (немає черг тощо)
2. Не блокуючи, як мені потрібно перевірити, чи не відбувається інше
3. Використовуйте PIPE так, як мені потрібно було робити декілька речей, наприклад, потоковий вихід, записувати у файл журналу та повертати рядкову копію результату.

Невеликий фон: я використовую ThreadPoolExecutor для управління пулом ниток, кожен запускаючи підпроцес і виконуючи їх одночасність. (У Python2.7, але це також має працювати в новіших 3.x). Я не хочу використовувати нитки тільки для збору результатів, оскільки я хочу, щоб якомога більше доступних для інших речей (пул з 20 процесів використовував би 40 потоків просто для запуску; 1 для потокового процесу та 1 для stdout ... і більше, якщо ви хочете, що більш жорсткий, я думаю)

Я знімаю багато винятків, і таке тут, тому це засноване на коді, який працює у виробництві. Сподіваюся, я не зіпсував це в копії та вставці. Також відгуки дуже вітаємо!

import time
import fcntl
import subprocess
import time

proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

# Make stdout non-blocking when using read/readline
proc_stdout = proc.stdout
fl = fcntl.fcntl(proc_stdout, fcntl.F_GETFL)
fcntl.fcntl(proc_stdout, fcntl.F_SETFL, fl | os.O_NONBLOCK)

def handle_stdout(proc_stream, my_buffer, echo_streams=True, log_file=None):
    """A little inline function to handle the stdout business. """
    # fcntl makes readline non-blocking so it raises an IOError when empty
    try:
        for s in iter(proc_stream.readline, ''):   # replace '' with b'' for Python 3
            my_buffer.append(s)

            if echo_streams:
                sys.stdout.write(s)

            if log_file:
                log_file.write(s)
    except IOError:
        pass

# The main loop while subprocess is running
stdout_parts = []
while proc.poll() is None:
    handle_stdout(proc_stdout, stdout_parts)

    # ...Check for other things here...
    # For example, check a multiprocessor.Value('b') to proc.kill()

    time.sleep(0.01)

# Not sure if this is needed, but run it again just to be sure we got it all?
handle_stdout(proc_stdout, stdout_parts)

stdout_str = "".join(stdout_parts)  # Just to demo

Я впевнений, що тут додаються накладні витрати, але це не викликає занепокоєння в моєму випадку. Функціонально він робить те, що мені потрібно. Єдине, що я не вирішив, це те, що це ідеально підходить для повідомлень журналу, але я бачу, що деякі printповідомлення з’являються пізніше і все відразу.

У Python 3.6 я використав це:

import subprocess

cmd = "command"
output = subprocess.call(cmd, shell=True)
print(process)