PyQt6 + Sockerserver | Как запустить 2 формы, 1я - главная, 2я из сокет сервера

from main import Main
from ov_con_rec import OverlayConnectReq
import threading
from PyQt6.QtWidgets import QApplication, QMainWindow, QMenu, QWidget, QLineEdit, QSystemTrayIcon, QMessageBox
from PyQt6 import uic, QtCore, QtGui
from PyQt6.QtCore import Qt
import sys
import socketserver
import sqlite3
import time
 
def get_settings():
    conn = sqlite3.connect('settings/settings.db')
    c = conn.cursor()
 
    c.execute("""SELECT * FROM server""")
    temp = c.fetchall()[0]
    result = dict()
 
    for _ in range(1):
        for _2, _3 in zip(c.description, temp):
            result['server_' + _2[0]] = _3
 
    return result
 
 
 
settings = get_settings()
print(settings)
 
 
def except_hook(cls, exception, traceback):
    sys.__excepthook__(cls, exception, traceback)
 
 
class MyTCPHandler(socketserver.BaseRequestHandler):
 
    def checking_data(self):
        time.sleep(2)
        if self.flag_data_exists is True:
            self.flag_data_exists = False
        else:
            self.server.close_request(self.request)
 
    def handle(self):
        try:
            print('Str')
            self.flag_isconnected = False
            #th_check = threading.Thread(daemon=True)
            #th_check.start()
            print(f"[+] {self.client_address} is connected.")
            while True:
                bytes_read = self.request.recv(settings['server_buffer_size'])
                    if bytes_read.startswith(b'cmd'):
                        bytes_read = bytes_read.decode('utf-8').split()
                        if bytes_read[1] == 'connect':
                            if bytes_read[2] != '5':
                                result = 'ERROR: Incorrect password'
                            else:
                                runnable = OverlayConnectReq()
                                QtCore.QThreadPool.globalInstance().start(runnable)
                                print('[~] user connected')
                            else:
                                pass
                                ###
                        elif self.flag_isconnected is True:
                            pass
                            ###
                print(bytes_read)
                self.request.sendall(result if type(result) is bytes else bytes(result, 'utf-8'))
        except ConnectionResetError:
            print('[-] Connection aborted')
        print('data ended')
 
 
def start_server():
    try:
        with socketserver.TCPServer((settings['server_ip'], settings['server_port']), MyTCPHandler) as server:
            print('Server started at {0}:{1}'.format(settings['server_ip'], settings['server_port']))
            server.serve_forever()
    except KeyboardInterrupt as err:
        print(err)
 
 
if __name__ == "__main__":
    # start thr of server
    thr_server = threading.Thread(target=start_server, daemon=True)
    thr_server.start()
 
 
    app = QApplication(sys.argv)
    menu_main = Main()
    menu_main.setWindowFlags(QtCore.Qt.WindowType.FramelessWindowHint)
    menu_main.show()
    if not QSystemTrayIcon.isSystemTrayAvailable():
        QMessageBox.critical(None, "System Tray", "System tray was not detected!")
        sys.exit(1)
    tray = QSystemTrayIcon(QtGui.QIcon(u"icons/main/logos/windows/state.svg"), app)
    menu = QMenu()
    action_message_box = QtGui.QAction("Show app")
    menu.addAction(action_message_box)
    action_tray_message = QtGui.QAction("Break connection")
    menu.addAction(action_tray_message)
    action_hide = QtGui.QAction("Open filetransfer")
    menu.addAction(action_hide)
    action_r = QtGui.QAction("Connect to ...")
    menu.addAction(action_r)
    action_exit = QtGui.QAction("Exit")
    action_exit.triggered.connect(app.exit)
    menu.addAction(action_exit)
    tray.setToolTip("NEVERN")
    tray.setContextMenu(menu)
    tray.show()
    sys.excepthook = except_hook
    sys.exit(app.exec())

import time
 
from PyQt6.QtWidgets import QApplication, QMainWindow, QMenu, QWidget, QSizePolicy, QSizeGrip
from PyQt6 import uic, QtCore, QtGui
import sys
import threading
 
 
def set_property(sender, objname):
    sender.setObjectName(objname)
    old = sender.styleSheet()
    if not old:
        sender.setStyleSheet('* {}')
    sender.setStyleSheet(old)
 
 
class OverlayConnectReq(QWidget, QtCore.QRunnable):
 
    def __init__(self):
        self.app = QApplication.instance()
        self.result = None
        super(OverlayConnectReq, self).__init__()
        f = open('styles/css/overlay_con_rec.css', 'r')
        self.styleData = f.read()
        f.close()
        self.ui = uic.loadUi('ui/overlay_con_rec.ui', self)
        self.setStyleSheet(self.styleData)
        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_TranslucentBackground)
        self.btn_decline.clicked.connect(lambda: self.closes(False))
        self.btn_accept.clicked.connect(lambda: self.closes(True))
        self.text_msg.setText('{0}:{1} REQUESTS CONNECTION'.format(424, 424))
        print('IM HERE')
        #thr = threading.Thread(target=self.line_edit, daemon=True)
        #thr.start()
        self.show()
 
    def line_edit(self):
        temp = self.line_bar.size().width() // 100
        for _ in range(100):
            self.line_bar.resize(self.line_bar.size().width() - temp, 5)
            time.sleep(0.1)
        self.btn_decline.click()
 
    def closes(self, arg):
        self.result = arg
        self.app.quit()
 
 
def except_hook(cls, exception, traceback):
    sys.__excepthook__(cls, exception, traceback)

#!/usr/bin/env python3
 
from PyQt5.QtCore import QByteArray, Qt
from PyQt5.QtWidgets import (QApplication, QDialog, QDialogButtonBox, QLabel,
        QMessageBox, QProgressBar, QPushButton, QVBoxLayout, QLineEdit)
from PyQt5.QtNetwork import QHostAddress, QTcpServer, QTcpSocket
 
 
class Dialog(QDialog):
 
    def __init__(self, parent=None):
        super(Dialog, self).__init__(parent)
 
        self.tcpServer = QTcpServer()
        self.tcpClient = QTcpSocket()
        self.bytesToWrite = 0
        self.bytesWritten = 0
        self.bytesReceived = 0
 
        self.clientLine = QLineEdit()
        self.clientStatusLabel = QLabel("Client ready")
        self.serverProgressBar = QProgressBar()
        self.serverStatusLabel = QLabel("Server ready")
 
        self.startButton = QPushButton("&Start")
        self.quitButton = QPushButton("&Quit")
 
        buttonBox = QDialogButtonBox()
        buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
        buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
 
        self.startButton.clicked.connect(self.start)
        self.quitButton.clicked.connect(self.close)
        self.tcpServer.newConnection.connect(self.acceptConnection)
        self.tcpClient.connected.connect(self.startTransfer)
        self.tcpClient.bytesWritten.connect(self.updateClientProgress)
        self.tcpClient.error.connect(self.displayError)
 
        mainLayout = QVBoxLayout()
        mainLayout.addWidget(self.clientLine)
        mainLayout.addWidget(self.clientStatusLabel)
        mainLayout.addWidget(self.serverStatusLabel)
        mainLayout.addStretch(1)
        mainLayout.addSpacing(10)
        mainLayout.addWidget(buttonBox)
        self.setLayout(mainLayout)
 
        self.setWindowTitle("Loopback")
 
    def start(self):
        while not self.tcpServer.isListening() and not self.tcpServer.listen():
            ret = QMessageBox.critical(self, "Loopback",
                    "Unable to start the test: %s." % self.tcpServer.errorString(),
                    QMessageBox.Retry | QMessageBox.Cancel)
            if ret == QMessageBox.Cancel:
                return
 
        self.serverStatusLabel.setText("Listening")
        self.clientStatusLabel.setText("Connecting")
 
        self.tcpClient.connectToHost(QHostAddress(QHostAddress.LocalHost), self.tcpServer.serverPort())
 
    def acceptConnection(self):
        self.tcpServerConnection = self.tcpServer.nextPendingConnection()
        self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
        self.tcpServerConnection.error.connect(self.displayError)
 
        self.serverStatusLabel.setText("Accepted connection")
        self.tcpServer.close()
 
    def startTransfer(self):
        msg = self.clientLine.text().encode()
        if not msg: return
        self.tcpClient.write(msg)
        self.clientStatusLabel.setText("Connected")
 
    def updateServerProgress(self):
        bytesReceived = self.tcpServerConnection.bytesAvailable()
        msg = bytes(self.tcpServerConnection.readAll())
        QMessageBox.information(self, "",msg.decode())
        self.serverStatusLabel.setText("Received %d" % bytesReceived)
        self.tcpServerConnection.close()
 
    def updateClientProgress(self, numBytes):
        print(numBytes)
 
    def displayError(self, socketError):
        if socketError == QTcpSocket.RemoteHostClosedError:
            return
 
        QMessageBox.information(self, "Network error",
                "The following error occured: %s." % self.tcpClient.errorString())
 
        self.tcpClient.close()
        self.tcpServer.close()
        self.clientProgressBar.reset()
        self.serverProgressBar.reset()
        self.clientStatusLabel.setText("Client ready")
        self.serverStatusLabel.setText("Server ready")
        self.startButton.setEnabled(True)
        QApplication.restoreOverrideCursor()
 
 
if __name__ == '__main__':
 
    import sys
 
    app = QApplication(sys.argv)
    dialog = Dialog()
    dialog.show()
    sys.exit(dialog.exec_())