Wie man nicht-blockierend/real-time-Verhalten von Python-logging-Modul? (Ausgabe PyQt QTextBrowser)

Hier das eigentliche problem ist, dass Sie die Blockierung der gesamten GUI für 5 Sekunden vom Schlaf-in den Haupt-thread. Das kannst du nicht tun, oder keine updates erscheinen, wird der Benutzer nicht in der Lage sein, um die Interaktion mit Ihrer app, etc. Das logging-Problem ist nur ein kleines sub-Folge, dass große problem.

Und wenn Ihr echtes Programm ist, aufrufen von code von einer Drittanbieter-Modul, das dauert 5 Sekunden, oder tut etwas blockieren, wird es genau das gleiche problem.

Im Allgemeinen, es gibt zwei Möglichkeiten, das zu tun langsam, blockieren Dinge, ohne zu blockieren eine GUI (oder andere event-loop-basierte) app:

1. Tun der Arbeit in einem hintergrund-thread. Je nach GUI-framework, aus einem hintergrund-thread, Sie können in der Regel nicht die Funktionen aufrufen, die direkt auf die GUI, oder ändern Sie die Objekte, die Sie stattdessen verwenden Sie einen Mechanismus, um Nachrichten zu posten, um die Ereignis-Schleife. In Qt, die Sie in der Regel tun dies durch das signal-slot-Mechanismus. Sehen diese Frage für details.

2. Brechen den job in non-blocking oder garantiert-nur-sehr-kurzfristig-blockiert Arbeitsplätze, schnell zurück, jede Planung, die nächste rechts vor der Rückkehr. (Mit einigen GUI-frameworks, die Sie tun können, den Gegenwert in-line " durch den Aufruf etwas wie safeYield oder der Aufruf der event-Schleife rekursiv, aber Sie tun das nicht mit Qt.)

Gegeben, dass someProcess ist einigen externen code, die Sie nicht ändern können, die entweder von Sekunden zu beenden, oder tut etwas blockieren, können Sie nicht verwenden Sie option 2. Also, option 1: führen Sie es in einem hintergrund-thread.

Glücklicherweise ist dies einfach. Qt hat Möglichkeiten, dies zu tun, aber Python ' s Wege sind auch einfacher:

t = threading.Thread(target=someProcess)
t.start()

Nun, Sie brauchen, um zu ändern ConsoleWindowLogHandler.emit so, dass, statt direkt ändern textBox sendet es ein signal zu bekommen, dass getan in den Haupt-thread. Sehen Threads und QObjects für alle details, und einige gute Beispiele.

Konkret: Die Mandelbrot-Beispiel verwendet eine RenderThread dass tatsächlich nicht alles zeichnen, sondern sendet stattdessen eine renderedImage signal; die MandelbrotWidget dann eine updatePixmap slot, verbindet es sich mit der renderedImage signal. In der gleichen Weise, Ihre log-handler nicht wirklich update-text-box, sondern senden Sie eine gotLogMessage signal; dann hätten Sie eine LogTextWidget mit einem updateLog Steckplatz verbindet auf dieses signal. Natürlich auch für Ihre einfachen Fall, Sie können halten Sie zusammen in einer einzigen Klasse, nur so lange, wie Sie eine Verbindung zwischen beiden Seiten eine signal-slot-Verbindung, anstatt einen direkten Aufruf der Methode.

Werden Sie wahrscheinlich wollen, um entweder zu halten t irgendwo Rum und join es beim Herunterfahren oder einstellen t.daemon = True.

Entweder Weg, wenn Sie wissen wollen, Wann someProcess geschehen ist, müssen Sie andere Mittel der Kommunikation zurück zu Ihrem Haupt-thread, wenn es fertig ist—wieder, mit Qt, ist die übliche Antwort ist, um ein signal zu senden. Und diese können Sie auch bekommen ein Ergebnis zurück aus someProcess. Und Sie müssen Sie nicht ändern someProcess um dies zu tun, definieren eine wrapper-Funktion, die Anrufe someProcess Signale und deren Ergebnis, und rufen Sie die wrapper-Funktion aus dem hintergrund-thread.

Hier ist eine weitere Methode. In diesem Beispiel füge ich ein StreamHandler zu dem logger, schreibt in einen Puffer, durch Erben von beiden QObject und StringIO: Wenn die Prozedur auf ein nicht-leerer string, der bufferMessage signal und erfasst in der on_bufferMessage slot.

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import logging, StringIO, time

from PyQt4 import QtCore, QtGui

class logBuffer(QtCore.QObject, StringIO.StringIO):
    bufferMessage = QtCore.pyqtSignal(str)

    def __init__(self, *args, **kwargs):
        QtCore.QObject.__init__(self)
        StringIO.StringIO.__init__(self, *args, **kwargs)

    def write(self, message):
        if message:
            self.bufferMessage.emit(unicode(message))

        StringIO.StringIO.write(self, message)

class myThread(QtCore.QThread):
    def __init__(self, parent=None):
        super(myThread, self).__init__(parent)
        self.iteration = None

    def start(self):
        self.iteration = 3

        return super(myThread, self).start()

    def run(self):        
        while self.iteration:
            logging.info("Hello from thread {0}! {1}".format(0, self.iteration))
            self.iteration -= 1

            time.sleep(3)

class myThread1(QtCore.QThread):
    def __init__(self, parent=None):
        super(myThread1, self).__init__(parent)
        self.iteration = None
        self.logger = logging.getLogger(__name__)

    def start(self):
        self.iteration = 3

        return super(myThread1, self).start()

    def run(self):        
        time.sleep(1)
        while self.iteration:
            self.logger.info("Hello from thread {0}! {1}".format(1, self.iteration))
            self.iteration -= 1

            time.sleep(3)


class myWindow(QtGui.QWidget):
    def __init__(self, parent=None):
        super(myWindow, self).__init__(parent)

        self.pushButton = QtGui.QPushButton(self)
        self.pushButton.setText("Send Log Message")
        self.pushButton.clicked.connect(self.on_pushButton_clicked)

        self.pushButtonThread = QtGui.QPushButton(self)
        self.pushButtonThread.setText("Start Threading")
        self.pushButtonThread.clicked.connect(self.on_pushButtonThread_clicked)

        self.lineEdit = QtGui.QLineEdit(self)
        self.lineEdit.setText("Hello!")

        self.label = QtGui.QLabel(self)

        self.layout = QtGui.QVBoxLayout(self)
        self.layout.addWidget(self.lineEdit)
        self.layout.addWidget(self.pushButton)
        self.layout.addWidget(self.pushButtonThread)
        self.layout.addWidget(self.label)

        self.logBuffer = logBuffer()
        self.logBuffer.bufferMessage.connect(self.on_logBuffer_bufferMessage)

        logFormatter = logging.Formatter('%(levelname)s: %(message)s')

        logHandler = logging.StreamHandler(self.logBuffer)
        logHandler.setFormatter(logFormatter)

        self.logger = logging.getLogger()
        self.logger.setLevel(logging.INFO)
        self.logger.addHandler(logHandler)

        self.thread = myThread(self)
        self.thread1 = myThread1(self)

    @QtCore.pyqtSlot()
    def on_pushButtonThread_clicked(self):
        self.thread.start()
        self.thread1.start()

    @QtCore.pyqtSlot(str)
    def on_logBuffer_bufferMessage(self, message):
        self.label.setText(message)

    @QtCore.pyqtSlot()
    def on_pushButton_clicked(self):
        message = self.lineEdit.text()
        self.logger.info(message if message else "No new messages")

if __name__ == "__main__":
    import sys

    app = QtGui.QApplication(sys.argv)
    app.setApplicationName('myWindow')

    main = myWindow()
    main.show()

    sys.exit(app.exec_())

Die beste Sache über diese Methode ist, dass Sie können log-Meldungen aus Module/threads von Euch Haupt-app, ohne dass jede Referenz auf den logger, z.B. durch den Aufruf logging.log(logging.INFO, logging_message) oder logging.info(logging_message)