staging.inyokaproject.org

#Emitter Klasse
class Emiterer(QtCore.QThread):
    f = QtCore.pyqtSignal(int)

    def __init__(self):
        super(Emiterer, self).__init__()

    def run(self):
        self.f.emit(42)

#Qt Fenster
class MainWindow(QtWidgets.QMainWindow):
    def __init__(self, parent = None):
        super().__init__(parent)

        self.e = Emiterer()
        self.e.f.connect(self.receive_signal)

        #Klick auf btGo: execute_method
        self.ui.btGo.clicked.connect(self.execute_method)

    def execute_method(self):
        #run method
        self.e.start()

    def receive_signal(self, return_value):
        print(return_value)
        self.ui.tbConsole.append(str(return_value))

import logging
logger = logging.getLogger(__name__)

def do_something():
    logger.info("I am doing something")

#!/usr/bin/env python3
from datetime import datetime
import sys
import time
import logging
from qtpy.QtCore import QObject, Signal, QThread
from qtpy.QtWidgets import QWidget, QTextEdit, QPushButton, QVBoxLayout

import mylib

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)


class ConsoleWindowLogHandler(logging.Handler, QObject):
    sigLog = Signal(str)
    def __init__(self):
        logging.Handler.__init__(self)
        QObject.__init__(self)

    def emit(self, logRecord):
        ts = datetime.fromtimestamp(logRecord.created)
        message = f"{datetime.isoformat(ts, timespec='seconds')}:{logRecord.levelname}:{logRecord.name}: {logRecord.getMessage()}"
        self.sigLog.emit(message)


class Window(QWidget):
    def __init__(self):
        super(Window, self).__init__()

        # Size
        self.setMinimumSize(640, 480)

        # Layout
        self.textBox = QTextEdit()
        self.textBox.setReadOnly(True)
        self.button = QPushButton('Click Me')
        vertLayout = QVBoxLayout()
        vertLayout.addWidget(self.textBox)
        vertLayout.addWidget(self.button)
        self.setLayout(vertLayout)

        # Connect button
        self.button.clicked.connect(self.buttonPressed)

        # Thread
        self.bee = Worker(self.someProcess, ())
        self.bee.finished.connect(self.restoreUi)

        # Console handler
        self.consoleHandler = ConsoleWindowLogHandler()
        self.consoleHandler.sigLog.connect(self.textBox.append)
        logger.addHandler(self.consoleHandler)

    def buttonPressed(self):
        self.button.setEnabled(False)
        self.bee.start()

    def someProcess(self):
        logger.info("starting process")
        for i in range(10):
            logger.debug(f"iteration {i}")
            mylib.do_something()
            time.sleep(1)

    def restoreUi(self):
        logger.debug("re-enable button")
        self.button.setEnabled(True)


class Worker(QThread):
    def __init__(self, func, args):
        super(Worker, self).__init__()
        self.func = func
        self.args = args

    def run(self):
        self.func(*self.args)


def main():
    from qtpy.QtWidgets import QApplication
    app = QApplication(sys.argv)
    window = Window()
    mylib.logger.addHandler(window.consoleHandler)  # wire up the Handler for the module
    mylib.logger.setLevel(logging.INFO)  # set the desired log level for the module's logger
    window.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()

import ...
import mylib

...

logger = logging.getLogger(__name__)

#keine Veränderung der ConsoleWindowLogHandler Klasse
class ConsoleWindowLogHandler(logging.Handler, QObject):
    sigLog = Signal(str)
    def __init__(self):
        logging.Handler.__init__(self)
        QObject.__init__(self)

    def emit(self, logRecord):
        ts = datetime.fromtimestamp(logRecord.created)
        message = f"{datetime.isoformat(ts, timespec='seconds')}:{logRecord.levelname}:{logRecord.name}: {logRecord.getMessage()}"
        self.sigLog.emit(message)

class MainWindow(QtWidgets.QMainWindow):
    def __init__(self, parent = None):
        ...
        super().__init__(parent)
        #Nach meinem Verständnis: Erstellung des Handlers und des Connectors
        self.consoleHandler = ConsoleWindowLogHandler()
        self.consoleHandler.setLevel(logging.DEBUG)
        self.consoleHandler.sigLog.connect(self.ui.TextBox.append)
        ...
        #Klick auf den Button
        self.ui.mybutton.clicked.connect(self.on_button_click_test)
        ...
        #Aufruf der mylib.do_something Methode (s.u.)
    def on_button_click_test(self):
        mylib.logger.addHandler(self.consoleHandler)  # wire up the Handler for the module #Nach meinem Verständnis: Übergabe des Handlers
        mylib.logger.setLevel(logging.DEBUG)  # set the desired log level for the module's logger #Nach meinem Verständnis: Log-Level. Sollte gesetzt werden, da sonst WARNING
        mylib.do_something()

import logging
import time
logger = logging.getLogger(__name__)

def do_something():
    print("Hello World")
    logger.debug("Debug-Level")
    time.sleep(2)
    logger.info("Info-Level")
    time.sleep(2)
    logger.warning("Warning-Level")
    time.sleep(1)