Imprimer constamment la sortie du sous-processus pendant que le processus est en cours d'exécution

Pour lancer des programmes à partir de mes scripts Python, j'utilise la méthode suivante:

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)

Ainsi, lorsque je lance un processus comme Process.execute("mvn clean install"), mon programme attend que le processus soit terminé et ce n'est qu'alors que j'obtiens la sortie complète de mon programme. C'est ennuyeux si j'exécute un processus qui prend du temps pour se terminer.

Puis-je laisser mon programme écrire la sortie de processus ligne par ligne, en interrogeant la sortie de processus avant qu'elle ne se termine en boucle ou quelque chose?

** [EDIT] Désolé, je n'ai pas bien cherché avant de poster cette question. L'enfilage est en fait la clé. Trouvé un exemple ici qui montre comment le faire: ** Sous-processus Python.Ouvrir à partir d'un thread

Vous pouvez utiliser iter pour traiter les lignes dès que les sorties de commande: eux lines = iter(fd.readline, ""). Voici un exemple complet montrant un cas d'utilisation typique (merci à @jfs pour son aide):

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

Ok, j'ai réussi à le résoudre sans threads (toute suggestion pourquoi l'utilisation de threads serait mieux appréciée) en utilisant un extrait de cette question Interception de la sortie standard d'un sous-processus pendant son exécution

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)

Pour imprimer la sortie ligne du sous-processus ligne par ligne dès que son tampon stdout est vidé en 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)

Remarque: vous n'avez pas besoin p.poll()- la boucle se termine lorsque eof est atteint. Et vous n'avez pas besoin iter(p.stdout.readline, '')- le bogue de lecture anticipée est corrigé dans Python 3.

Voir aussi, Python: lire l'entrée de streaming depuis subprocess.communicate () .

Il existe en fait un moyen très simple de le faire lorsque vous souhaitez simplement imprimer la sortie:

import subprocess
import sys

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

Ici, nous pointons simplement le sous-processus vers notre propre sortie standard et utilisons l'api de réussite ou d'exception existante.

@tokland

essayé votre code et corrigé pour 3.4 et windows dir.cmd est une simple commande dir, enregistrée en tant que fichier 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)

Dans le cas où quelqu'un veut lire les deux stdoutet stderren même temps en utilisant des threads, voici ce que j'ai trouvé:

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)

Je voulais juste partager cela, car je me suis retrouvé sur cette question en essayant de faire quelque chose de similaire, mais aucune des réponses n'a résolu mon problème. Espérons que cela aide quelqu'un!

Notez que dans mon cas d'utilisation, un processus externe tue le processus que nous Popen().

Pour quiconque essaie de répondre à cette question pour obtenir la sortie standard à partir d'un script Python, notez que Python met en mémoire tampon sa sortie standard, et donc cela peut prendre un certain temps pour voir la sortie standard.

Cela peut être corrigé en ajoutant les éléments suivants après chaque écriture stdout dans le script cible:

sys.stdout.flush()

En Python> = 3.5 en utilisant des subprocess.runœuvres pour moi:

import subprocess

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

(obtenir la sortie pendant l'exécution fonctionne également sans shell=True) https://docs.python.org/3/library/subprocess.html#subprocess.run

Pour répondre à la question d'origine, la meilleure façon pour IMO est simplement de rediriger le sous-processus stdoutdirectement vers votre programme stdout(en option, la même chose peut être faite pour stderr, comme dans l'exemple ci-dessous)

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

Ce PoC lit en permanence la sortie d'un processus et est accessible en cas de besoin. Seul le dernier résultat est conservé, toutes les autres sorties sont ignorées, ce qui empêche le PIPE de se développer hors de la mémoire:

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)

sortie: Vous pouvez clairement voir qu'il n'y a qu'une sortie de ~ 2,5 s d'intervalle rien entre les deux.

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

Cela fonctionne au moins en Python3.4

import subprocess

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

Aucune des réponses ici ne répond à tous mes besoins.

1. Pas de threads pour stdout (pas de files d'attente, etc.)
2. Non bloquant car je dois vérifier que d'autres choses se passent
3. Utilisez PIPE car j'avais besoin de faire plusieurs choses, par exemple la sortie de flux, écrire dans un fichier journal et renvoyer une copie de chaîne de la sortie.

Un peu de contexte: j'utilise un ThreadPoolExecutor pour gérer un pool de threads, chacun lançant un sous-processus et les exécutant simultanément. (En Python2.7, mais cela devrait également fonctionner dans la version 3.x plus récente). Je ne veux pas utiliser de threads uniquement pour la collecte de sortie car je veux autant de disponibles que possible pour d'autres choses (un pool de 20 processus utiliserait 40 threads juste pour s'exécuter; 1 pour le thread de processus et 1 pour stdout ... et plus si vous voulez stderr je suppose)

Je retire beaucoup d'exceptions et telles ici, donc cela est basé sur du code qui fonctionne en production. J'espère que je ne l'ai pas gâché dans le copier-coller. De plus, les commentaires sont les bienvenus!

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

Je suis sûr que des frais généraux sont ajoutés ici, mais ce n'est pas un problème dans mon cas. Fonctionnellement, il fait ce dont j'ai besoin. La seule chose que je n'ai pas résolue est la raison pour laquelle cela fonctionne parfaitement pour les messages de journal, mais je vois certains printmessages apparaître plus tard et en même temps.

En Python 3.6, j'ai utilisé ceci:

import subprocess

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