class TcpS(QDialog, Ui_TcpServer): """ ęä»¶ä¼ č¾ęå”åØ """ sendFileName = pyqtSignal(str) def __init__(self, parent=None): """ äøäŗåå§č®¾ē½® """ super(TcpS, self).__init__(parent) self.setupUi(self) self.payloadSize = 64 * 1024 # čÆ»åę°ę®64KB self.totalBytes = 0 # ę»å¤§å° self.bytesWritten = 0 # äæåēę°ę® self.bytesToWrite = 0 # ęÆꬔåå°čæę„åēę°ę®éå¤§å° self.theFileName = "" # ę件åļ¼äøå«č·Æå¾ļ¼ self.fileName = "" # ę件å Øå self.localFile = QFile() self.outBlock = QByteArray() # QByteArray()ēåÆ¹č±”ļ¼å³åčę°ē» self.time = QTime() self.initServer() def initServer(self): """ ē½ē»č®¾ē½®åå§å """ self.tcpPort = 7788 # ęå®äŗTCPē«Æå£äøŗ7788 self.tcpServer = QTcpServer(self) self.clientConnection = QTcpSocket(self) # åå»ŗäøäøŖTcpęå”åØåäøäøŖTcpå„ę„å self.tcpServer.newConnection.connect(self.sendMessage) # å½ęę°ēčæę„ę„ēę¶åååŗnewConnectionäæ”å·ļ¼ę们čæę„å°sendMessage()å½ę°ć self.serverStatuslabel.setText("čÆ·éę©č¦ä¼ éēę件") self.progressBar.reset() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.tcpServer.close() # ę¾ē¤ŗę们å¼å§åå»ŗēåƹčÆę”ļ¼ęå¼ęé®ęÆåÆēØēļ¼åéęé®ęÆäøåÆēØēļ¼čæåŗ¦ę”å¤ä½ļ¼å å ³éęå”åØć def refused(self): """ åƹē«Æęē»ę„ę¶ę件ļ¼äø»ēØåŗä¼č°ēØęå”åØērefused()å½ę°ļ¼å ³éęå”åØć """ self.tcpServer.close() self.serverStatuslabel.setText("åƹę¹ęē»ę„ę¶") def closeEvent(self, event): """ å ³éäŗ件 """ self.on_serverCloseBtn_clicked() # äŗ§ēå ³éäŗ件ļ¼ē“ę„č°ēØå ³éēŖå£ęé®å½ę°ć def sendMessage(self): """ åéę件 """ self.serverSendBtn.setEnabled(False) # åéęé®äøåÆēØ self.clientConnection = self.tcpServer.nextPendingConnection() # self.clientConnectionä½äøŗčæę„ēQTcpSocketåÆ¹č±”čæåäøäøäøŖęčµ·ēčæę„ć self.clientConnection.bytesWritten.connect(self.updateClientProgress) # å½čæę„äøęÆꬔå°ę°ę®ęęč½½č·åå „č®¾å¤ēå½ååééę¶ļ¼é½ä¼ååŗę¤äæ”å·ćåØę¤ęęč“č½½äøåå „ēę°ę®éäøŗåčę°ć self.serverStatuslabel.setText("å¼å§ä¼ éę件 {} ļ¼".format(self.theFileName)) self.localFile = QFile(self.fileName) if not (self.localFile.open(QFile.ReadOnly)): errorMsg = "ę ę³čÆ»åę件 {}:\n {}".format(self.fileName, self.localFile.errorString()) QMessageBox.warning(self, "åŗēØēØåŗ", errorMsg) return # å°čÆęå¼ę件ļ¼č¦ęÆååØé®é¢å°±ę„éć self.serverCloseBtn.setText("åę¶") self.totalBytes = self.localFile.size() # č®°å½äøäøéč¦ä¼ č¾ēę件大å°ćåä½ļ¼åč sendOut = QDataStream(self.outBlock, QIODevice.WriteOnly) # čæéēself.outBlockęÆQByteArray()ēåÆ¹č±”ļ¼å³åčę°ē»ļ¼QIODeviceēęØ”å¼äøŗWriteOnly sendOut.setVersion(QDataStream.Qt_5_4) # č®¾å®QDataStreamēēę¬äøŗQt_5_4 self.time.start() # å¼å§č®”ę¶ currentFile = self.fileName.split("/")[-1] # ä¼ č¾ēę件å sendOut.writeInt64(0) sendOut.writeInt64(0) sendOut.writeQString(currentFile) self.totalBytes += self.outBlock.size() # åØsendOutäøåå „ę件å仄åę件ååę件ē大å°ļ¼å¤§å°é½ęÆ仄åčäøŗåä½ēć sendOut.device().seek(0) sendOut.writeInt64(self.totalBytes) sendOut.writeInt64(self.outBlock.size() - 2) # QIODevicečÆ»åä½ē½®ē§»åØå°0ćē¶ååå«åå „ę»ē大å°åę件å大å°ć self.bytesToWrite = self.totalBytes - self.clientConnection.write( self.outBlock) # å¾ ä¼ č¾ę件ē大å°ć self.outBlock.resize(0) # outBlockęø é¶ć def updateClientProgress(self, numBytes): """ åéčæåŗ¦ę¾ē¤ŗ """ qApp.processEvents() # éæę¶é“å·„ä½ēØļ¼ä»„å ēŖå£åę» self.bytesWritten += numBytes if self.bytesWritten > 0: self.block = self.localFile.read( min(self.bytesToWrite, self.payloadSize)) self.bytesToWrite -= self.clientConnection.write(self.block) else: self.localFile.close() # å½ęä»¬å¾ åå „ēåčę°å¤§äŗ0ę¶ļ¼ę们ęÆꬔčÆ»åēę°ę®é½ęÆå°äŗēäŗself.payloadSizeēļ¼čæäøŖself.payloadSizeę们å®ä¹ęÆ64KBć # self.bytesToWriteęÆꬔåå°čæę„åēę°ę®é大å°ć # č¦ęÆå¾ åå „ēåčę°å°äŗēäŗ0ļ¼åå ³éę件ć byteSent = self.bytesWritten / (1024 * 1024) # å·²ē»åäŗå¤å°ę件 useTime = self.time.elapsed() / 1000 # ä¼ č¾ēØäŗå¤éæę¶é“ speed = self.bytesWritten / useTime / (1024 * 1024) # ä¼ č¾éåŗ¦ total = self.totalBytes / (1024 * 1024) # ę»å¤§å° left = (total - byteSent) / speed # č”Øē¤ŗå©ä½ę¶é“ if byteSent < 0.01: byteSent = self.bytesWritten / 1024 speed = self.bytesWritten / useTime / 1024 total = self.totalBytes / 1024 if left > 0: sendInfo = "å·²åé {0:.2f}KBļ¼{1:.2f}KB/s)\nå ±{2:.2f}KB å·²ēØę¶ļ¼{3:.1f}ē§\n ä¼°č®”å©ä½ę¶é“:{4:.1f}ē§".format( byteSent, speed, total, useTime, left) else: sendInfo = "å·²åé {0:.2f}KBļ¼{1:.2f}KB/s)\nå ±{2:.2f}KB ēØę¶ļ¼{3:.1f}ē§\n".format( byteSent, speed, total, useTime) else: if left > 0: sendInfo = "å·²åé {0:.2f}MBļ¼{1:.2f}MB/s)\nå ±{2:.2f}MB å·²ēØę¶ļ¼{3:.1f}ē§\n ä¼°č®”å©ä½ę¶é“:{4:.1f}ē§".format( byteSent, speed, total, useTime, left) else: sendInfo = "å·²åé {0:.2f}MBļ¼{1:.2f}MB/s)\nå ±{2:.2f}MB ēØę¶ļ¼{3:.1f}ē§\n".format( byteSent, speed, total, useTime) self.progressBar.setMaximum(total) self.progressBar.setValue(byteSent) if self.bytesWritten == self.totalBytes: self.serverCloseBtn.setText("å ³é") # čæåŗ¦ę”ę¾ē¤ŗēę¹å¼ļ¼ä»„åå½ä¼ č¾ēåčę°ēäŗę»ēåčę°ēę¶åļ¼ęé®å°±ę¾ē¤ŗå ³éć self.serverStatuslabel.setText(sendInfo) @pyqtSlot() def on_serverOpenBtn_clicked(self): """ ęå¼ę件åå¤åé """ self.fileName = QFileDialog.getOpenFileName(self, 'ęå¼ę件', './')[0] if self.fileName: self.theFileName = self.fileName.split("/")[-1] self.serverStatuslabel.setText("č¦ä¼ éēę件äøŗļ¼{}".format( self.theFileName)) self.serverSendBtn.setEnabled(True) self.serverOpenBtn.setEnabled(False) @pyqtSlot() def on_serverSendBtn_clicked(self): """ åéę件ļ¼ēå¾ ę„ę¶ """ if not (self.tcpServer.listen(QHostAddress.Any, self.tcpPort)): errorMsg = self.tcpServer.errorString() QMessageBox.warning(self, "éčÆÆ", "åéå¤±č“„ļ¼\n {}".format(errorMsg)) self.TcpServer.close() return self.serverStatuslabel.setText("ēå¾ åƹę¹ę„ę¶... ...") self.serverSendBtn.setEnabled(False) self.sendFileName.emit(self.theFileName) @pyqtSlot() def on_serverCloseBtn_clicked(self): """ åę¶ęč å ³é """ if self.tcpServer.isListening(): self.tcpServer.close() if self.localFile.isOpen(): self.localFile.close() self.clientConnection.abort() if self.serverCloseBtn.text() == "åę¶": self.serverCloseBtn.setText("å ³é") else: self.close() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.progressBar.reset() self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.serverStatuslabel.setText("čÆ·éę©č¦ä¼ éēę件")
class Dialog(QDialog): TotalBytes = 50 * 1024 * 1024 PayloadSize = 65536 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.clientProgressBar = QProgressBar() 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.clientProgressBar) mainLayout.addWidget(self.clientStatusLabel) mainLayout.addWidget(self.serverProgressBar) mainLayout.addWidget(self.serverStatusLabel) mainLayout.addStretch(1) mainLayout.addSpacing(10) mainLayout.addWidget(buttonBox) self.setLayout(mainLayout) self.setWindowTitle("Loopback") def start(self): self.startButton.setEnabled(False) QApplication.setOverrideCursor(Qt.WaitCursor) self.bytesWritten = 0 self.bytesReceived = 0 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): self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write( QByteArray(Dialog.PayloadSize, "@")) self.clientStatusLabel.setText("Connected") def updateServerProgress(self): self.bytesReceived += self.tcpServerConnection.bytesAvailable() self.tcpServerConnection.readAll() self.serverProgressBar.setMaximum(Dialog.TotalBytes) self.serverProgressBar.setValue(self.bytesReceived) self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived / (1024 * 1024))) if self.bytesReceived == Dialog.TotalBytes: self.tcpServerConnection.close() self.startButton.setEnabled(True) QApplication.restoreOverrideCursor() def updateClientProgress(self, numBytes): self.bytesWritten += numBytes if self.bytesToWrite > 0: self.bytesToWrite -= self.tcpClient.write( QByteArray(min(self.bytesToWrite, Dialog.PayloadSize), "@")) self.clientProgressBar.setMaximum(Dialog.TotalBytes) self.clientProgressBar.setValue(self.bytesWritten) self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten / (1024 * 1024))) 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()
class Server(QWidget): def __init__(self): QWidget.__init__(self) self.serverOpen = False self.tcpServer = None self.tcpServerConnection = None self.textEdit = None self.lineEdit = None self.create_widgets() def create_widgets(self): self.tcpServer = QTcpServer() self.textEdit = QTextEdit() self.textEdit.setReadOnly(True) self.lineEdit = QLineEdit() self.lineEdit.setPlaceholderText("Enter response") self.lineEdit.setMaxLength(50) self.lineEdit.setEnabled(True) vBox = QVBoxLayout() vBox.addWidget(self.textEdit) vBox.addWidget(self.lineEdit) self.setLayout(vBox) self.tcpServer.newConnection.connect(self.accept_connection) def add_message(self, message): self.textEdit.moveCursor(QTextCursor.End) self.textEdit.insertPlainText(message) self.textEdit.moveCursor(QTextCursor.End) def open_server(self): if (len(self.lineEdit.text()) == 0): self.add_message("You must enter a response\n") QMessageBox.critical(self, "Error", "You must enter a response") return False self.tcpServer.listen(QHostAddress(__serverUrl__), 9000) self.serverOpen = self.tcpServer.isListening() if (self.serverOpen): serverAddress = self.tcpServer.serverAddress().toString() serverPort = self.tcpServer.serverPort() self.add_message("Server opened on %s on port %d\n" % (serverAddress, serverPort)) self.lineEdit.setEnabled(False) else: self.add_message(self.tcpServer.errorString()) QMessageBox.critical(self, "Error", self.tcpServer.errorString()) return True def accept_connection(self): self.tcpServerConnection = self.tcpServer.nextPendingConnection() self.tcpServerConnection.readyRead.connect(self.receive_data) self.tcpServerConnection.disconnected.connect(self.socket_disconnected) peerAddress = self.tcpServerConnection.peerAddress().toString() peerPort = self.tcpServerConnection.peerPort() self.add_message("Connected to %s on port %d\n" % (peerAddress, peerPort)) def receive_data(self): rxData = self.tcpServerConnection.readAll() self.add_message("Received '" + rxData.data().decode('utf8') + "'\n") txString = self.lineEdit.text() self.tcpServerConnection.write(txString.encode()) self.add_message("Wrote '" + txString + "'\n") def socket_disconnected(self): self.add_message("Disconnected from client\n") def close_server(self): if (self.serverOpen): self.tcpServer.close() self.lineEdit.setEnabled(True)
class TcpS(QDialog, Ui_TcpServer): """ Class documentation goes here. """ sendFileName = pyqtSignal(str) def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ super(TcpS, self).__init__(parent) self.setupUi(self) self.payloadSize = 64 * 1024 self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.theFileName = "" self.fileName = "" self.localFile = QFile() self.outBlock = QByteArray() self.time = QTime() self.initServer() def initServer(self): """ ē½ē»č®¾ē½®åå§å """ self.tcpPort = 7788 self.tcpServer = QTcpServer(self) self.clientConnection = QTcpSocket(self) self.tcpServer.newConnection.connect(self.sendMessage) self.serverStatuslabel.setText("čÆ·éę©č¦ä¼ éēę件") self.progressBar.reset() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.tcpServer.close() def refused(self): """ åƹē«Æęē»ę„ę¶ę件 """ self.tcpServer.close() self.serverStatuslabel.setText("åƹę¹ęē»ę„ę¶") def closeEvent(self, event): """ å ³éäŗ件 """ self.on_serverCloseBtn_clicked() def sendMessage(self): """ åéę件 """ self.serverSendBtn.setEnabled(False) self.clientConnection = self.tcpServer.nextPendingConnection() self.clientConnection.bytesWritten.connect(self.updateClientProgress) self.serverStatuslabel.setText("å¼å§ä¼ éę件 {} ļ¼".format(self.theFileName)) self.localFile = QFile(self.fileName) if not (self.localFile.open(QFile.ReadOnly)): errorMsg = "ę ę³čÆ»åę件 {}:\n {}".format(self.fileName, self.localFile.errorString()) QMessageBox.warning(self, "åŗēØēØåŗ", errorMsg) return self.serverCloseBtn.setText("åę¶") self.totalBytes = self.localFile.size() #åä½ļ¼åč sendOut = QDataStream(self.outBlock, QIODevice.WriteOnly) sendOut.setVersion(QDataStream.Qt_5_4) self.time.start() currentFile = self.fileName.split("/")[-1] sendOut.writeInt64(0) sendOut.writeInt64(0) sendOut.writeQString(currentFile) self.totalBytes += self.outBlock.size() sendOut.device().seek(0) sendOut.writeInt64(self.totalBytes) sendOut.writeInt64(self.outBlock.size() - 2) self.bytesToWrite = self.totalBytes - self.clientConnection.write( self.outBlock) self.outBlock.resize(0) def updateClientProgress(self, numBytes): """ åéčæåŗ¦ę¾ē¤ŗ """ qApp.processEvents() self.bytesWritten += numBytes if self.bytesWritten > 0: self.block = self.localFile.read( min(self.bytesToWrite, self.payloadSize)) self.bytesToWrite -= self.clientConnection.write(self.block) else: self.localFile.close() byteSent = self.bytesWritten / (1024 * 1024) useTime = self.time.elapsed() / 1000 speed = self.bytesWritten / useTime / (1024 * 1024) total = self.totalBytes / (1024 * 1024) left = (total - byteSent) / speed if byteSent < 0.01: byteSent = self.bytesWritten / 1024 speed = self.bytesWritten / useTime / 1024 total = self.totalBytes / 1024 if left > 0: sendInfo = "å·²åé {0:.2f}KBļ¼{1:.2f}KB/s)\nå ±{2:.2f}KB å·²ēØę¶ļ¼{3:.1f}ē§\n ä¼°č®”å©ä½ę¶é“:{4:.1f}ē§".format( byteSent, speed, total, useTime, left) else: sendInfo = "å·²åé {0:.2f}KBļ¼{1:.2f}KB/s)\nå ±{2:.2f}KB ēØę¶ļ¼{3:.1f}ē§\n".format( byteSent, speed, total, useTime) else: if left > 0: sendInfo = "å·²åé {0:.2f}MBļ¼{1:.2f}MB/s)\nå ±{2:.2f}MB å·²ēØę¶ļ¼{3:.1f}ē§\n ä¼°č®”å©ä½ę¶é“:{4:.1f}ē§".format( byteSent, speed, total, useTime, left) else: sendInfo = "å·²åé {0:.2f}MBļ¼{1:.2f}MB/s)\nå ±{2:.2f}MB ēØę¶ļ¼{3:.1f}ē§\n".format( byteSent, speed, total, useTime) self.progressBar.setMaximum(total) self.progressBar.setValue(byteSent) if self.bytesWritten == self.totalBytes: self.serverCloseBtn.setText("å ³é") self.serverStatuslabel.setText(sendInfo) @pyqtSlot() def on_serverOpenBtn_clicked(self): """ ęå¼ę件 """ self.fileName = QFileDialog.getOpenFileName(self, 'ęå¼ę件', './')[0] if self.fileName: self.theFileName = self.fileName.split("/")[-1] self.serverStatuslabel.setText("č¦ä¼ éēę件äøŗļ¼{}".format( self.theFileName)) self.serverSendBtn.setEnabled(True) self.serverOpenBtn.setEnabled(False) @pyqtSlot() def on_serverSendBtn_clicked(self): """ åéę件 """ if not (self.tcpServer.listen(QHostAddress.Any, self.tcpPort)): errorMsg = self.tcpServer.errorString() QMessageBox.warning(self, "éčÆÆ", "åéå¤±č“„ļ¼\n {}".format(errorMsg)) self.TcpServer.close() return self.serverStatuslabel.setText("ēå¾ åƹę¹ę„ę¶... ...") self.serverSendBtn.setEnabled(False) self.sendFileName.emit(self.theFileName) @pyqtSlot() def on_serverCloseBtn_clicked(self): """ åę¶ęč å ³é """ if self.tcpServer.isListening(): self.tcpServer.close() if self.localFile.isOpen(): self.localFile.close() self.clientConnection.abort() if self.serverCloseBtn.text() == "åę¶": self.serverCloseBtn.setText("å ³é") else: self.close() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.progressBar.reset() self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.serverStatuslabel.setText("čÆ·éę©č¦ä¼ éēę件")
class Window(QWidget, Ui_FormFrameworkTools): def __init__(self, *args, **kwargs): super(Window, self).__init__(*args, **kwargs) self.setupUi(self) # åå§åserver self._server = QTcpServer(self) self._server.newConnection.connect(self.onNewConnection) self._server.listen(QHostAddress.LocalHost, 49496) self._getPsPath() self._initCodeEdit() # č®¾ē½®é»č®¤ä»£ē ååę° self.argsEdit.setPlainText('testColor("{}")'.format( os.path.abspath('Resources/GM6C6860.jpg').replace('\\', '/'))) self.codeEdit.setText(self._formatArgs(Template)) def _formatArgs(self, code): code = code.replace( '#1#', os.path.abspath('Resources/ProgressBar.jsx').replace('\\', '/')) code = code.replace( '#2#', os.path.abspath('Resources/Core.jsx').replace('\\', '/')) code = code.replace( '#3#', os.path.abspath('Resources/test.jsx').replace('\\', '/')) return code def _initCodeEdit(self): # åå§åē¼č¾åØēå·„ä½ self.codeEdit.setUtf8(True) self.codeEdit.linesChanged.connect(self.onLinesChanged) # č”ę¹å # 代ē é«äŗ® self.codeEdit.setLexer(QsciLexerJavaScript(self)) # čŖåØęå self.codeEdit.setMarginType(3, QsciScintilla.SymbolMargin) self.codeEdit.setMarginLineNumbers(3, False) self.codeEdit.setMarginWidth(3, 15) self.codeEdit.setMarginSensitivity(3, True) # ę¾ē¤ŗč”å· #self.codeEdit.setMarginType(0, QsciScintilla.NumberMargin) self.codeEdit.setMarginLineNumbers(0, True) self.onLinesChanged() # 代ē ęē¤ŗ sciApi = QsciAPIs(self.codeEdit.lexer()) sciApi.prepare() self.codeEdit.setAutoCompletionSource(QsciScintilla.AcsAll) # č®¾ē½®ęŗ self.codeEdit.setAutoCompletionCaseSensitivity(True) # č®¾ē½®čŖåØ蔄å Ø大å°åęę self.codeEdit.setAutoCompletionThreshold(1) # č®¾ē½®ęÆč¾å „äøäøŖåē¬¦å°±ä¼åŗē°čŖåØ蔄å Øēęē¤ŗ # č®¾ē½®åä½ self.codeEdit.setFont(QFont('Consolas', 16)) self.codeEdit.setMarginsFont(self.codeEdit.font()) # č®¾ē½®ē¼ē self.codeEdit.SendScintilla(QsciScintilla.SCI_SETCODEPAGE, QsciScintilla.SC_CP_UTF8) self.codeEdit.setBraceMatching(QsciScintilla.StrictBraceMatch) # č®¾ē½®å½åč”é«äŗ® self.codeEdit.setCaretLineVisible(True) self.codeEdit.setCaretLineBackgroundColor(Qt.lightGray) self.codeEdit.setCaretForegroundColor(Qt.white) # tab # table relative self.codeEdit.setIndentationsUseTabs(True) self.codeEdit.setIndentationWidth(4) self.codeEdit.setTabIndents(True) self.codeEdit.setAutoIndent(True) self.codeEdit.setBackspaceUnindents(True) self.codeEdit.setTabWidth(4) # indentation guides self.codeEdit.setIndentationGuides(True) # folding margin self.codeEdit.setFolding(QsciScintilla.PlainFoldStyle) self.codeEdit.setMarginWidth(2, 12) # čŖåØę¢č” self.codeEdit.setWrapMode(QsciScintilla.WrapWord) def onLinesChanged(self): # åØęč®¾ē½®å·¦č¾¹ēč¾¹č· self.codeEdit.setMarginWidth( 0, self.codeEdit.fontMetrics().width(str(self.codeEdit.lines())) + 5) def _getPsPath(self): # č·åpsēč·Æå¾ settings = QSettings('FrameworkTools', 'Settings') psPath = settings.value('path', '') if not psPath: # å¦ęę²”ęę¾å°čŖå·±äæåēč·Æå¾åå»ę¾ē³»ē»å®č£ ēč·Æå¾ settings = QSettings( 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Photoshop.exe', QSettings.NativeFormat) psPath = settings.value('.', '') self.pathEdit.setText(psPath) def onNewConnection(self): # å½ęę°ēčæę„ę„ę¶ while self._server.hasPendingConnections(): socket = self._server.nextPendingConnection() socket.readyRead.connect(self.onReadyRead) if socket.bytesAvailable() > 0: # å¦ęå·²ęę°ę®åéčæę„ self.doRecv(socket) def onReadyRead(self): # åå¤ę„ę¶ę°ę® socket = self.sender() if socket.bytesAvailable() > 0: self.doRecv(socket) def doRecv(self, socket): # ę„ę¶ę°ę® try: data = socket.readAll().data().decode() # åƹę°ę®č§£åÆ data = xxtea.decryptFromBase64(data, '0123456789abcdef') method, args = data.split('|') self.resultEdit.append('č¢«č°ēØå½ę°: {}, åę°: {}'.format(method, args)) try: args = eval(args) except Exception as e: args = [] # åØęę§č”å½ę° if hasattr(self, method): getattr(self, method)(socket, *args) except Exception as e: self.resultEdit.append(str(e)) def getCode(self, socket): # ä¼ éåę°ēå½ę° args = self.argsEdit.toPlainText().strip() args = xxtea.encryptToBase64(args, '0123456789abcdef') + '\n' print('åéå åÆę°ę®: ', args) socket.write(args.encode()) socket.flush() def showError(self, _, message): # ę¾ē¤ŗéčÆÆę¶ęÆ if message: QMessageBox.critical(self, 'éčÆÆ', message) @pyqtSlot() def on_selectButton_clicked(self): # ęåØéę©č·Æå¾ path, _ = QFileDialog.getOpenFileName(self, 'éę©Psč·Æå¾', '', 'Photoshop.exe') if path: self.pathEdit.setText(path) settings = QSettings('FrameworkTools', 'Settings') settings.setValue('path', path) settings.sync() @pyqtSlot() def on_runButton_clicked(self): # čæč”ęé® code = self.codeEdit.text().strip() if not code: return if not code.startswith('#target'): code = '#target photoshop\n' + code path = tempfile.mktemp('.jsx') open(path, 'wb').write(code.encode('utf-8')) subprocess.call([self.pathEdit.text().strip(), path]) def closeEvent(self, event): if self._server.isListening(): self._server.close() self._server.deleteLater() super(Window, self).closeEvent(event)
class TcpServer(QObject): ''' TCP/IP server class. Usage: import sys import tcp from PyQt4.QtCore import QCoreApplication from PyQt4.QtNetwork import QHostAddress def main(): application = QCoreApplication(sys.argv) tcpServer = tcp.TcpServer() def onConnected(descriptor): print("Client [%s] connected. Now total: %s" % (descriptor, len(tcpServer.descriptors()))) tcpServer.write(descriptor, "Hello dude") def onDisconnected(descriptor): print("Client [%s] disconnected. Now total: %s" % (descriptor, len(tcpServer.descriptors()))) def onError(descriptor, error): print("Error [%s]: ", descriptor, error) def onRead(descriptor, data): print("Read from [%s] %s byte(s): %s" % (descriptor, len(data), data)) tcpServer.onConnected = onConnected tcpServer.onDisconnected = onDisconnected tcpServer.onError = onError tcpServer.onRead = onRead tcpServer.listen(QHostAddress.Any, 9000) sys.exit(application.exec_()) if __name__ == "__main__": main() ''' def __init__(self, parent=None): QObject.__init__(self, parent) self.__server = QTcpServer(parent) self.__clients = dict() # All active clients # Callbacks self.__on_connected = None self.__on_disconnected = None self.__on_error = None self.__on_read = None # Signals and slots connections self.__server.newConnection.connect(self.__onNewConnection) # Slots @pyqtSlot() def __onNewConnection(self): ''' The slot is called every time a client connects to the server. The client's socket(QTcpSocket) <socket> and descriptor(int) <descriptor> are defined. The socket is appended to the dictionary of connected clients(key=client's descriptor, value=client's socket). Then, socket's descriptor is passed to __onConnected method. :return: None ''' socket = self.__server.nextPendingConnection() socket.disconnected.connect(self.__onDisconnected) socket.error.connect(self.__onError) socket.readyRead.connect(self.__onReadyRead) descriptor = id(socket) self.__clients[descriptor] = socket self.__onConnected(descriptor) @pyqtSlot() def __onConnected(self, descriptor): ''' The method is called by __onNewConnection every time a client connects to the server. If __on_connected callback is set, it is executed with socket's descriptor(int) <descriptor> argument. :param descriptor(int): a newly connected client's socket descriptor, the socket itself is in self.__clients dictionary(key=client's descriptor, value=client's socket); :return: None ''' if self.__on_connected: self.__on_connected(descriptor) @pyqtSlot() def __onDisconnected(self): ''' The slot is called when the connected client disconnects from the server. The client's socket(QTcpSocket) <socket> and its descriptor(int) <descriptor> are defined, and then the descriptor is passed to __on_disconnected callback. :return: None ''' if self.__on_disconnected: socket = self.sender() descriptor = id(socket) self.__clients.pop(descriptor, None) self.__on_disconnected(descriptor) @pyqtSlot() def __onError(self, socketError): ''' The slot is called when an error(PyQt4.QtNetwork.SocketError) <socketError> occurs. The socket's descriptor(int) <descriptor> with error code(int) <errorCode> and description(str) <errorDescription> are defined and passed to __on_error callback. :param error(QAbstractSocket.SocketError): socket error; :return: None ''' if self.__on_error: socket = self.__server.sender() descriptor = id(socket) errorCode = int(socketError) errorDescription = str(self.__server.errorString()) error = (errorCode, errorDescription) self.__on_error(descriptor, error) @pyqtSlot() def __onReadyRead(self): ''' The slot is called when new data is available for reading from the client. The client's socket descriptor(int) <descriptor> is defined, and all available data(str) <data> is read. Then, the socket descriptor and the data are passed to __on_read callback. :return: None ''' if self.__on_read: socket = self.sender() descriptor = id(socket) data = socket.readAll().data() self.__on_read(descriptor, data) # Setters def __connected(self, callback): self.__on_connected = callback def __disconnected(self, callback): self.__on_disconnected = callback def __error(self, callback): self.__on_error = callback def __read(self, callback): self.__on_read = callback # Methods def isListening(self): ''' Return True if the server is currently listening for incoming connections, otherwise returns False. :return: bool ''' return self.__server.isListening() def listen(self, address=None, port=0): ''' Tell the server to listen for incoming connections on address(QHostAddress) <address> and port(int) <port>. If port is 0, a port is chosen automatically. If address is QHostAddress.Any, the server will listen on all network interfaces. :param address(QHosAddress): address to listen to; :param port(int): the port to listen to; :return: bool, return True on success, otherwise return False ''' self.__server.listen(address, port) def socket(self, descriptor): ''' Return socket(QTcpSocket) with the given descriptor(int) <descriptor> or None if it is not found. :param descriptor(int): socket descriptor; :return: socket(QTcpSocket) or None ''' return self.__clients.get(descriptor, None) def descriptors(self): ''' Return all sockets' descriptors available. :return list of int ''' return sorted(self.__clients.keys()) def write(self, descriptor, data): ''' Write data(str) <data> to the client's socket with the given descriptor(int) <descriptor>. :param descriptor(int): client's socket descriptor; :param data(str), data to be written; :return: int, the number of bytes that were actually written, or -1 if an error occurred ''' socket = self.socket(descriptor) if socket: return socket.write(data) else: return -1 def disconnect(self, descriptor): ''' Disconnect the client socket with the given descriptor(int) <descriptor>. :param descriptor(int): client's socket descriptor; :return: None ''' socket = self.socket(descriptor) if socket: socket.close() def close(self): ''' Close the server. :return: None ''' for socket in self.__clients.values(): socket.close() self.__server.close() # Properties onConnected = property(fset=__connected) onDisconnected = property(fset=__disconnected) onError = property(fset=__error) onRead = property(fset=__read)
class Dialog(QDialog): TotalBytes = 50 * 1024 * 1024 PayloadSize = 65536 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.clientProgressBar = QProgressBar() 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.clientProgressBar) mainLayout.addWidget(self.clientStatusLabel) mainLayout.addWidget(self.serverProgressBar) mainLayout.addWidget(self.serverStatusLabel) mainLayout.addStretch(1) mainLayout.addSpacing(10) mainLayout.addWidget(buttonBox) self.setLayout(mainLayout) self.setWindowTitle("Loopback") def start(self): self.startButton.setEnabled(False) QApplication.setOverrideCursor(Qt.WaitCursor) self.bytesWritten = 0 self.bytesReceived = 0 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): self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write(QByteArray(Dialog.PayloadSize, '@')) self.clientStatusLabel.setText("Connected") def updateServerProgress(self): self.bytesReceived += self.tcpServerConnection.bytesAvailable() self.tcpServerConnection.readAll() self.serverProgressBar.setMaximum(Dialog.TotalBytes) self.serverProgressBar.setValue(self.bytesReceived) self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived / (1024 * 1024))) if self.bytesReceived == Dialog.TotalBytes: self.tcpServerConnection.close() self.startButton.setEnabled(True) QApplication.restoreOverrideCursor() def updateClientProgress(self, numBytes): self.bytesWritten += numBytes if self.bytesToWrite > 0: self.bytesToWrite -= self.tcpClient.write(QByteArray( min(self.bytesToWrite, Dialog.PayloadSize), '@')) self.clientProgressBar.setMaximum(Dialog.TotalBytes) self.clientProgressBar.setValue(self.bytesWritten) self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten / (1024 * 1024))) 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()
class BaristaServer(): MIN_PORT = 0 MAX_PORT = 65535 DEFAULT_PORT = 4200 def __init__(self, application, ip, port, sessionPath): self.application = application self.server = None self.port = int(port) self.ip = QHostAddress.Any if ip is not None: self.ip = QHostAddress(ip) self.sessionPath = sessionPath self.configpath = os.path.join(self.sessionPath, "barista.conf") #### self.hardware = [] self.trainOnHW = 0 self.transactionList = [] self._loadConfig() self.checkHardware() state = self._checkConfig() self.start() self.sessionManager = ServerSessionManager(self, self.sessionPath) def start(self): self.server = QTcpServer() self.server.listen(self.ip, self.port) self.server.newConnection.connect(self._newConnection) if self.server.isListening(): hostIP = str(self.server.serverAddress().toString()) if hostIP == '0.0.0.0': hostIP = '<any>' sys.stdout.write("Hostname: " + socket.gethostname() + "\tIP: " + hostIP + ":" + str(self.server.serverPort()) + "\n") else: sys.stderr.write( "Something went wrong. Server is not listening.\n") logging.error("Something went wrong. Server is not listening.") exit(1) def getBaristaStatus(self, pid=""): hardware = [k["name"] for k in self.hardware] statusdict = {"trainOnHW": self.trainOnHW, "hardware": hardware} statusdict["connections"] = len(self.transactionList) statusdict["config"] = self._checkConfig(False) statusdict["training"] = len( self.sessionManager.findSessionIDsWithState(State.RUNNING)) is 0 statusdict["sessioncount"] = len(self.sessionManager.sessions) statusdict["sessionpath"] = self.sessionPath if pid is not "": pidses = {} sessions = set(self.sessionManager.findSessionIDsByProjectId(pid)) pidses["pid"] = pid pidses["count"] = len(sessions) pidses["running"] = len( set(self.sessionManager.findSessionIDsWithState(State.RUNNING)) & sessions) pidses["running"] += len( set(self.sessionManager.findSessionIDsWithState(State.PAUSED)) & sessions) pidses["waiting"] = len( set(self.sessionManager.findSessionIDsWithState(State.WAITING)) & sessions) pidses["finished"] = len( set(self.sessionManager.findSessionIDsWithState( State.FINISHED)) & sessions) statusdict["projectsessions"] = pidses return statusdict def _newConnection(self): transaction = ServerTransaction(self) self.transactionList.append(transaction) transaction.socketClosed.connect( lambda item=transaction: self._deleteConnection(item)) transaction.acceptClient(self.server.nextPendingConnection()) def _deleteConnection(self, transaction): index = self.transactionList.index(transaction) del self.transactionList[index] def _saveConfig(self): #Save train on hardware tosave = dict() tosave["trainOnHW"] = self.trainOnHW with open(self.configpath, "w") as file: json.dump(tosave, file, sort_keys=True, indent=4) def _loadConfig(self): #### if not os.path.exists(self.configpath): # TODO Default pass else: with open(self.configpath, "r") as file: res = json.load(file) if "trainOnHW" in res: self.trainOnHW = res["trainOnHW"] else: # TODO default pass def _checkConfig(self, verbose=True): state = True caffe_versions.loadVersions(self.sessionPath) if caffe_versions.versionCount() == 0: if verbose: sys.stderr.write( "Warning: There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path.\n" ) logging.warning( "There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path." ) if self.trainOnHW >= len(self.hardware): self.trainOnHW = 0 if verbose: sys.stderr.write( "Warning: Currently selected Hardware could not be matched against detected Hardware." " Set to CPU mode!\n") logging.warning( "Currently selected Hardware could not be matched against detected Hardware." " Set to CPU mode!") return state def checkHardware(self, verbose=True, transaction=None): caffe_versions.loadVersions(self.sessionPath) if caffe_versions.versionCount() == 0: if verbose: sys.stderr.write( "Warning: Can't check hardware without Caffeversions\n") logging.warning("Can't check hardware without Caffeversions") if transaction: msg = { "key": Protocol.SCANHARDWARE, "status": False, "error": "Can't check hardware without Caffeversions" } transaction.send(msg) return try: binary = caffe_versions.getDefaultVersion().getBinarypath() self.hardware = checkHardware(binary, not verbose, transaction) if verbose: sys.stdout.write("Finished scanning Hardware. " + str(len(self.hardware)) + " devices found.\n") logging.info("Finished scanning Hardware. %s devices found.", str(len(self.hardware))) if transaction: msg = { "key": Protocol.SCANHARDWARE, "status": True, "finished": True, "hardware": self.hardware, "current": self.trainOnHW } transaction.send(msg) except: if verbose: sys.stderr.write("Error: Failed to check hardware!\n") logging.error("Failed to check hardware!") if transaction: msg = { "key": Protocol.SCANHARDWARE, "status": False, "error": "Failed to check hardware!" } transaction.send(msg) def setHardware(self, hid): if hid >= len(self.hardware): return False self.trainOnHW = hid self._saveConfig() return True
class Dialog(QDialog): def __init__(self, parent: QWidget = None) -> None: super().__init__(parent) self.tcpServer = QTcpServer() self.tcpClient = QTcpSocket() self.tcpServerConnection: QTcpSocket = None self.bytesToWrite = 0 self.bytesWritten = 0 self.bytesReceived = 0 self.clientProgressBar = QProgressBar() self.clientStatusLabel = QLabel(self.tr("Client ready")) self.serverProgressBar = QProgressBar() self.serverStatusLabel = QLabel(self.tr("Server ready")) self.startButton = QPushButton(self.tr("&Start")) self.quitButton = QPushButton(self.tr("&Quit")) self.buttonBox = QDialogButtonBox() self.buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole) self.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(self) mainLayout.addWidget(self.clientProgressBar) mainLayout.addWidget(self.clientStatusLabel) mainLayout.addWidget(self.serverProgressBar) mainLayout.addWidget(self.serverStatusLabel) mainLayout.addStretch(1) mainLayout.addSpacing(10) mainLayout.addWidget(self.buttonBox) @pyqtSlot() def start(self): self.startButton.setEnabled(False) QGuiApplication.setOverrideCursor(Qt.WaitCursor) self.bytesWritten = 0 self.bytesReceived = 0 while not self.tcpServer.isListening() and not self.tcpServer.listen(): ret = QMessageBox.critical( self, self.tr("Loopback"), self.tr( "Unable to start the test: %s" % (self.tcpServer.errorString()) ), QMessageBox.Retry | QMessageBox.Cancel, ) if ret == QMessageBox.Cancel: return self.serverStatusLabel.setText(self.tr("Listening")) self.clientStatusLabel.setText(self.tr("Connecting")) self.tcpClient.connectToHost( QHostAddress.LocalHost, self.tcpServer.serverPort() ) @pyqtSlot() def acceptConnection(self): self.tcpServerConnection = self.tcpServer.nextPendingConnection() if not self.tcpServerConnection: self.serverStatusLabel.setText( self.tr("Error: got invalid pending connection!") ) return self.tcpServerConnection.readyRead.connect(self.updateServerProgress) self.tcpServerConnection.error.connect(self.displayError) self.tcpServerConnection.disconnected.connect( self.tcpServerConnection.deleteLater ) self.serverStatusLabel.setText(self.tr("Accepted connection")) self.tcpServer.close() @pyqtSlot() def startTransfer(self): # called when the TCP client connected to the loopback server self.bytesToWrite = TOTAL_BYTES - int( self.tcpClient.write(QByteArray(PAYLOAD_SIZE, "@")) ) self.clientStatusLabel.setText(self.tr("Connected")) @pyqtSlot() def updateServerProgress(self): self.bytesReceived += int(self.tcpServerConnection.bytesAvailable()) self.tcpServerConnection.readAll() self.serverProgressBar.setMaximum(TOTAL_BYTES) self.serverProgressBar.setValue(self.bytesReceived) self.serverStatusLabel.setText( self.tr("Received %dMB" % (self.bytesReceived / (1024 * 1024),)) ) if self.bytesReceived == TOTAL_BYTES: self.tcpServerConnection.close() self.startButton.setEnabled(True) QGuiApplication.restoreOverrideCursor() @pyqtSlot("qint64") def updateClientProgress(self, numBytes): self.bytesWritten += int(numBytes) if self.bytesToWrite > 0 and self.tcpClient.bytesToWrite() <= 4 * PAYLOAD_SIZE: self.bytesToWrite -= self.tcpClient.write( QByteArray(min(self.bytesToWrite, PAYLOAD_SIZE), "@") ) self.clientProgressBar.setMaximum(TOTAL_BYTES) self.clientProgressBar.setValue(self.bytesWritten) self.clientStatusLabel.setText( self.tr("Sent %dMB" % (self.bytesWritten / (1024 * 1024),)) ) @pyqtSlot(QAbstractSocket.SocketError) def displayError(self, socketError): if socketError == QTcpSocket.RemoteHostClosedError: return QMessageBox.information( self, self.tr("Network error"), self.tr( "The following error occurred: %s." % (self.tcpClient.errorString(),) ), ) self.tcpClient.close() self.tcpServer.close() self.clientProgressBar.reset() self.serverProgressBar.reset() self.clientStatusLabel.setText(self.tr("Client ready")) self.serverStatusLabel.setText(self.tr("Server ready")) self.startButton.setEnabled(True) QGuiApplication.restoreOverrideCursor()
class ListenPipe(QObject): sig_data_arrived = pyqtSignal(QByteArray) sig_listening_state = pyqtSignal(bool) def __init__(self, parent=None): super(ListenPipe, self).__init__(parent=parent) self.tcpServer = QTcpServer() self.socketClients = [] self.tcpServer.newConnection.connect(self.on_newconnection) @pyqtSlot() def start_listen(self): print('start_listen:%s %s' % (appsetting.listen_ip, appsetting.listen_port)) self.tcpServer.close() for socketClient in self.socketClients: socketClient.close() socketClient.deleteLater() if appsetting.listen_enable != '0': self.tcpServer.listen(QHostAddress(appsetting.listen_ip), int(appsetting.listen_port)) self.sig_listening_state.emit(self.tcpServer.isListening()) @pyqtSlot() def on_newconnection(self): print('on_newconnection') socketClient = self.tcpServer.nextPendingConnection() socketClient.readyRead.connect(self.on_readyRead) socketClient.connected.connect(self.on_connected) socketClient.disconnected.connect(self.on_disconnected) socketClient.error.connect(self.on_error) self.socketClients.append(socketClient) print('self.socketClients size=%d' % len(self.socketClients)) @pyqtSlot() def on_readyRead(self): print("%s on_readyRead" % self.__class__.__name__) socketClient = self.sender() data = socketClient.readAll() #print(data) self.sig_data_arrived.emit(data) @pyqtSlot(QByteArray) def on_data_arrived(self, data): print("%s on_data_arrived" % self.__class__.__name__) for socketClient in self.socketClients: socketClient.write(data) @pyqtSlot() def on_connected(self): print('on_connected') @pyqtSlot() def on_disconnected(self): print('on_disconnected') socketClient = self.sender() self.socketClients.remove(socketClient) socketClient.deleteLater() print('self.socketClients size=%d' % len(self.socketClients)) @pyqtSlot() def on_error(self): socketClient = self.sender() print('%s on_error:%s' % (self.__class__.__name__, socketClient.errorString()))