Как заставить работать асинхронные функции в потоке PyQt5

Господа, подскажите, как сделать так, что бы асинхронная функция заработала в потоке PyQt5.

from PyQt5 import QtCore, QtWidgets
import asyncio
import logging
from datetime import datetime
from ocpp.routing import on
from ocpp.v16 import ChargePoint as cp
from ocpp.v16.enums import Action, RegistrationStatus
from ocpp.v16 import call_result
import DataBase

try:
    import websockets
except ModuleNotFoundError:
    print("This example relies on the 'websockets' package.")
    print("Please install it by running: ")
    print()
    print(" $ pip install websockets")
    import sys
    sys.exit(1)


logging.basicConfig(level=logging.INFO)

User = 0

class ChargePoint(cp):
    @on(Action.BootNotification)
    def on_boot_notification(self, charge_point_vendor: str, charge_point_model: str, **kwargs):
        CP=DataBase.connect(DataBase.Get_ChargePoint())
        for row in CP:
            if charge_point_vendor == row[2] and charge_point_model == row[1]:
                return call_result.BootNotificationPayload(
                    current_time=datetime.utcnow().isoformat(),
                    interval=10,
                    status=RegistrationStatus.accepted
                    )
            else:
                return call_result.BootNotificationPayload(
                    current_time=datetime.utcnow().isoformat(),
                    interval=10,
                    status=RegistrationStatus.rejected
                )
            break
    @on(Action.StatusNotification)
    def on_status_notification(self, connector_id: int, error_code: str, status: str, timestamp:str, **kwargs):
        return call_result.StatusNotificationPayload()

    @on(Action.Authorize)
    def on_autorize(self, id_tag: str, **kwargs):
        global User
        Client = DataBase.connect(DataBase.Get_Client())
        for row in Client:
            if row[2] == id_tag:
                User = row[0]
                print('another connection')
                return call_result.AuthorizePayload(
                    id_tag_info={
                        'status': 'Accepted'
                        }
                        )
            else:
                print('Denied')
                return call_result.AuthorizePayload(
                    id_tag_info={
                        'status': 'Invalid'
                        }
                        )
            break

    @on(Action.Heartbeat)
    def on_hearbeat(self):
        print('Got a Heartbeat!')
        return call_result.HeartbeatPayload(
            current_time=datetime.utcnow().isoformat()
        )

    @on(Action.MeterValues)
    def on_meter_values(self, connector_id: int, meter_value: list, **kwargs):
        return call_result.MeterValuesPayload()

    @on(Action.StartTransaction)
    def on_start_transaction(self, connector_id: int, id_tag: str, meter_start: int, timestamp: str, **kwargs):
        idt = DataBase.connect(DataBase.Get_Trans())
        DataBase.connect(DataBase.Insert(User))
        return call_result.StartTransactionPayload(
            transaction_id=idt+1,
            id_tag_info={'status': 'Accepted'}
        )


    @on(Action.StopTransaction)
    def on_stop_transaction(self, meter_stop: int, timestamp: str, transaction_id: int, **kwargs):
        return call_result.StopTransactionPayload()

class MyThread(QtCore.QThread):
    mysignal = QtCore.pyqtSignal(str)

    def __init__(self, parent=None):
        QtCore.QThread.__init__(self, parent)

    async def on_connect(self, websocket, path):
        try:
            requested_protocols = websocket.request_headers[
                'Sec-WebSocket-Protocol']
        except KeyError:
            logging.error(
                "Client hasn't requested any Subprotocol. Closing Connection"
            )
            return await websocket.close()
        if websocket.subprotocol:
            logging.info("Protocols Matched: %s", websocket.subprotocol)
        else:
            logging.warning('Protocols Mismatched | Expected Subprotocols: %s,'
                            ' but client supports  %s | Closing connection',
                            websocket.available_subprotocols,
                            requested_protocols)
            return await websocket.close()

        charge_point_id = path.strip('/')
        cp = ChargePoint(charge_point_id, websocket)

        await cp.start()

    async def run(self):
        server = await websockets.serve(
            self.on_connect,
            '0.0.0.0',
            9000,
            subprotocols=['ocpp1.6']
        )

        logging.info("Server Started listening to new connections...")
        await server.wait_closed()


class MyWindow(QtWidgets.QWidget):
    def __init__(self, parent=None):
        QtWidgets.QWidget.__init__(self, parent)
        self.label = QtWidgets.QLabel("Нажмите кнопку для запуска потока")
        self.label.setAlignment(QtCore.Qt.AlignHCenter)
        self.button = QtWidgets.QPushButton("Запустить процесс")
        self.vbox = QtWidgets.QVBoxLayout()
        self.vbox.addWidget(self.label)
        self.vbox.addWidget(self.button)
        self.setLayout(self.vbox)
        self.mythread = MyThread()  # Создаем экземпляр класса
        self.button.clicked.connect(self.on_clicked)
        self.mythread.started.connect(self.on_started)
        self.mythread.finished.connect(self.on_finished)
        self.mythread.mysignal.connect(self.on_change, QtCore.Qt.QueuedConnection)

    async def on_clicked(self):
        self.button.setDisabled(True)  # Делаем кнопку неактивной
        await self.mythread.start()  # Запускаем поток

    def on_started(self):  # Вызывается при запуске потока
        self.label.setText("Вызван метод on_started ()")

    def on_finished(self):  # Вызывается при завершении потока
        self.label.setText("Вызван метод on_finished()")
        self.button.setDisabled(False)  # Делаем кнопку активной

    def on_change(self, s):
        self.label.setText(s)


if __name__ == "__main__":
    import sys

    app = QtWidgets.QApplication(sys.argv)
    window = MyWindow()
    window.setWindowTitle("Использование класса QThread")
    window.resize(300, 70)
    window.show()
    sys.exit(app.exec_())