qpython3使用手册图片_日志操作手册

import datetime

import logging

import random

import sys

import time

# Deal with minor differences between PySide2 and PyQt5

try:

from PySide2 import QtCore, QtGui, QtWidgets

Signal = QtCore.Signal

Slot = QtCore.Slot

except ImportError:

from PyQt5 import QtCore, QtGui, QtWidgets

Signal = QtCore.pyqtSignal

Slot = QtCore.pyqtSlot

logger = logging.getLogger(__name__)

#

# Signals need to be contained in a QObject or subclass in order to be correctly

# initialized.

#

class Signaller(QtCore.QObject):

signal = Signal(str, logging.LogRecord)

#

# Output to a Qt GUI is only supposed to happen on the main thread. So, this

# handler is designed to take a slot function which is set up to run in the main

# thread. In this example, the function takes a string argument which is a

# formatted log message, and the log record which generated it. The formatted

# string is just a convenience - you could format a string for output any way

# you like in the slot function itself.

#

# You specify the slot function to do whatever GUI updates you want. The handler

# doesn't know or care about specific UI elements.

#

class QtHandler(logging.Handler):

def __init__(self, slotfunc, *args, **kwargs):

super(QtHandler, self).__init__(*args, **kwargs)

self.signaller = Signaller()

self.signaller.signal.connect(slotfunc)

def emit(self, record):

s = self.format(record)

self.signaller.signal.emit(s, record)

#

# This example uses QThreads, which means that the threads at the Python level

# are named something like "Dummy-1". The function below gets the Qt name of the

# current thread.

#

def ctname():

return QtCore.QThread.currentThread().objectName()

#

# Used to generate random levels for logging.

#

LEVELS = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR,

logging.CRITICAL)

#

# This worker class represents work that is done in a thread separate to the

# main thread. The way the thread is kicked off to do work is via a button press

# that connects to a slot in the worker.

#

# Because the default threadName value in the LogRecord isn't much use, we add

# a qThreadName which contains the QThread name as computed above, and pass that

# value in an "extra" dictionary which is used to update the LogRecord with the

# QThread name.

#

# This example worker just outputs messages sequentially, interspersed with

# random delays of the order of a few seconds.

#

class Worker(QtCore.QObject):

@Slot()

def start(self):

extra = {'qThreadName': ctname() }

logger.debug('Started work', extra=extra)

i = 1

# Let the thread run until interrupted. This allows reasonably clean

# thread termination.

while not QtCore.QThread.currentThread().isInterruptionRequested():

delay = 0.5 + random.random() * 2

time.sleep(delay)

level = random.choice(LEVELS)

logger.log(level, 'Message after delay of%3.1f:%d', delay, i, extra=extra)

i += 1

#

# Implement a simple UI for this cookbook example. This contains:

#

# * A read-only text edit window which holds formatted log messages

# * A button to start work and log stuff in a separate thread

# * A button to log something from the main thread

# * A button to clear the log window

#

class Window(QtWidgets.QWidget):

COLORS = {

logging.DEBUG: 'black',

logging.INFO: 'blue',

logging.WARNING: 'orange',

logging.ERROR: 'red',

logging.CRITICAL: 'purple',

}

def __init__(self, app):

super(Window, self).__init__()

self.app = app

self.textedit = te = QtWidgets.QPlainTextEdit(self)

# Set whatever the default monospace font is for the platform

f = QtGui.QFont('nosuchfont')

f.setStyleHint(f.Monospace)

te.setFont(f)

te.setReadOnly(True)

PB = QtWidgets.QPushButton

self.work_button = PB('Start background work', self)

self.log_button = PB('Log a message at a random level', self)

self.clear_button = PB('Clear log window', self)

self.handler = h = QtHandler(self.update_status)

# Remember to use qThreadName rather than threadName in the format string.

fs = '%(asctime)s%(qThreadName)-12s%(levelname)-8s%(message)s'

formatter = logging.Formatter(fs)

h.setFormatter(formatter)

logger.addHandler(h)

# Set up to terminate the QThread when we exit

app.aboutToQuit.connect(self.force_quit)

# Lay out all the widgets

layout = QtWidgets.QVBoxLayout(self)

layout.addWidget(te)

layout.addWidget(self.work_button)

layout.addWidget(self.log_button)

layout.addWidget(self.clear_button)

self.setFixedSize(900, 400)

# Connect the non-worker slots and signals

self.log_button.clicked.connect(self.manual_update)

self.clear_button.clicked.connect(self.clear_display)

# Start a new worker thread and connect the slots for the worker

self.start_thread()

self.work_button.clicked.connect(self.worker.start)

# Once started, the button should be disabled

self.work_button.clicked.connect(lambda : self.work_button.setEnabled(False))

def start_thread(self):

self.worker = Worker()

self.worker_thread = QtCore.QThread()

self.worker.setObjectName('Worker')

self.worker_thread.setObjectName('WorkerThread') # for qThreadName

self.worker.moveToThread(self.worker_thread)

# This will start an event loop in the worker thread

self.worker_thread.start()

def kill_thread(self):

# Just tell the worker to stop, then tell it to quit and wait for that

# to happen

self.worker_thread.requestInterruption()

if self.worker_thread.isRunning():

self.worker_thread.quit()

self.worker_thread.wait()

else:

print('worker has already exited.')

def force_quit(self):

# For use when the window is closed

if self.worker_thread.isRunning():

self.kill_thread()

# The functions below update the UI and run in the main thread because

# that's where the slots are set up

@Slot(str, logging.LogRecord)

def update_status(self, status, record):

color = self.COLORS.get(record.levelno, 'black')

s = '

' % (color, status)

self.textedit.appendHtml(s)

@Slot()

def manual_update(self):

# This function uses the formatted message passed in, but also uses

# information from the record to format the message in an appropriate

# color according to its severity (level).

level = random.choice(LEVELS)

extra = {'qThreadName': ctname() }

logger.log(level, 'Manually logged!', extra=extra)

@Slot()

def clear_display(self):

self.textedit.clear()

def main():

QtCore.QThread.currentThread().setObjectName('MainThread')

logging.getLogger().setLevel(logging.DEBUG)

app = QtWidgets.QApplication(sys.argv)

example = Window(app)

example.show()

sys.exit(app.exec_())

if __name__=='__main__':

main()