MQTT Monitor: comparison MqttMonitor/MqttMonitorWidget.py

-:28d69b9e1b6a
+:3d7e63ed4fd1
 from EricWidgets.EricPathPicker import EricPathPickerModes
 from .Ui_MqttMonitorWidget import Ui_MqttMonitorWidget
 from .MqttClient import (
-MqttClient, mqttConnackMessage, mqttErrorMessage, mqttLogLevelString
+MqttClient,
+mqttConnackMessage,
+mqttErrorMessage,
+mqttLogLevelString,
 )
 from .MqttReasonCodes import mqttReasonCode
 from .MqttProtocols import MqttProtocols
 import UI.PixmapCache
 class MqttMonitorWidget(QWidget, Ui_MqttMonitorWidget):
 """
 Class implementing the MQTT Monitor widget.
 """
 BrokerStatusTopicPrefix = "$SYS/broker/"
 BrokerStatusTopic = "$SYS/broker/#"
 BrokerStatusTopicLoadPrefix = "$SYS/broker/load/"
 def __init__(self, plugin, usesDarkPalette, parent=None):
 """
 Constructor
 @param plugin reference to the plug-in object
 @type MqttMonitorPlugin
 @param usesDarkPalette flag indicating the use of a dark application
 palette
 @type bool
 @param parent reference to the parent widget
 @type QWidget
 """
 super().__init__(parent)
 self.setupUi(self)
 self.layout().setContentsMargins(0, 3, 0, 0)
 self.__plugin = plugin
 self.__iconSuffix = "dark" if usesDarkPalette else "light"
 self.__connectedToBroker = False
 self.__brokerStatusTopicSubscribed = False
 with contextlib.suppress(AttributeError):
 # backward compatibility
 if not ericApp().usesSmallScreen():
-self.pixmapLabel.setPixmap(UI.PixmapCache.getPixmap(
+self.pixmapLabel.setPixmap(
-os.path.join("MqttMonitor", "icons",
+UI.PixmapCache.getPixmap(
-"mqtt48-{0}".format(self.__iconSuffix))
+os.path.join(
-))
+"MqttMonitor",
+"icons",
-self.publishPayloadFilePicker.setMode(
+"mqtt48-{0}".format(self.__iconSuffix),
-EricPathPickerModes.OPEN_FILE_MODE)
+)
+)
+)
+self.publishPayloadFilePicker.setMode(EricPathPickerModes.OPEN_FILE_MODE)
 self.publishPayloadFilePicker.setFilters(self.tr("All Files (*)"))
 self.brokerComboBox.lineEdit().setClearButtonEnabled(True)
 self.publishTopicComboBox.lineEdit().setClearButtonEnabled(True)
 self.__messagesFormat = self.messagesEdit.currentCharFormat()
 self.__messagesTopicFormat = self.messagesEdit.currentCharFormat()
 self.__messagesTopicFormat.setFontWeight(QFont.Weight.Bold)
 self.__messagesQosFormat = self.messagesEdit.currentCharFormat()
 self.__messagesQosFormat.setFontItalic(True)
 self.__messagesSubheaderFormat = self.messagesEdit.currentCharFormat()
 self.__messagesSubheaderFormat.setFontUnderline(True)
 self.__propertiesFormat = self.propertiesEdit.currentCharFormat()
 self.__propertiesTopicFormat = self.propertiesEdit.currentCharFormat()
 self.__propertiesTopicFormat.setFontWeight(QFont.Weight.Bold)
 self.__propertiesNameFormat = self.propertiesEdit.currentCharFormat()
 self.__propertiesNameFormat.setFontItalic(True)
 self.messagesSearchWidget.attachTextEdit(self.messagesEdit)
 self.messagesSearchWidget.setWidthForHeight(False)
 self.__isMessageAlternate = False
 self.__isPropertiesAlternate = False
-for logLevel in (MqttClient.LogDisabled,
+for logLevel in (
-MqttClient.LogDebug,
+MqttClient.LogDisabled,
-MqttClient.LogInfo,
+MqttClient.LogDebug,
-MqttClient.LogNotice,
+MqttClient.LogInfo,
-MqttClient.LogWarning,
+MqttClient.LogNotice,
-MqttClient.LogError):
+MqttClient.LogWarning,
-self.logLevelComboBox.addItem(mqttLogLevelString(
+MqttClient.LogError,
-logLevel, isMqttLogLevel=False), logLevel)
+):
-self.logLevelComboBox.setCurrentIndex(
+self.logLevelComboBox.addItem(
-self.logLevelComboBox.count() - 1)
+mqttLogLevelString(logLevel, isMqttLogLevel=False), logLevel
+)
+self.logLevelComboBox.setCurrentIndex(self.logLevelComboBox.count() - 1)
 if usesDarkPalette:
 self.__logMessagesBackgrounds = {
 MqttClient.LogDebug: QBrush(QColor("#2f2f2f")),
 MqttClient.LogInfo: QBrush(QColor("#868686")),
 MqttClient.LogNotice: QBrush(QColor("#009900")),
 MqttClient.LogWarning: QBrush(Qt.GlobalColor.yellow),
 MqttClient.LogError: QBrush(Qt.GlobalColor.red),
 MqttClient.LogDisabled: QBrush(Qt.GlobalColor.magenta)
 # reuse LogDisabled for unknown log levels
 }
 self.logSearchWidget.attachTextEdit(self.logEdit)
 self.logSearchWidget.setWidthForHeight(False)
 self.brokerWidget.setCurrentIndex(0)
 self.__connectionModeProfile = True
 self.__setConnectionMode(True)  # initial mode is 'profile connection'
 self.__populateProfileComboBox()
 self.connectButton.setIcon(UI.PixmapCache.getIcon("ircConnect"))
-self.brokerConnectionOptionsButton.setIcon(UI.PixmapCache.getIcon(
+self.brokerConnectionOptionsButton.setIcon(
-os.path.join("MqttMonitor", "icons",
+UI.PixmapCache.getIcon(
-"connectionOptions-{0}".format(self.__iconSuffix))
+os.path.join(
-))
+"MqttMonitor",
+"icons",
+"connectionOptions-{0}".format(self.__iconSuffix),
+)
+)
+)
 self.__populateBrokerComboBoxes()
 self.brokerStatusLabel.hide()
-self.clearWillButton.setIcon(
+self.clearWillButton.setIcon(UI.PixmapCache.getIcon("certificateDelete"))
-UI.PixmapCache.getIcon("certificateDelete"))
 self.subscribeTopicComboBox.lineEdit().setClearButtonEnabled(True)
 self.subscribeTopicComboBox.lineEdit().returnPressed.connect(
-self.on_subscribeButton_clicked)
+self.on_subscribeButton_clicked
+)
 self.__populateSubscribeTopicComboBox()
 self.subscribeButton.setIcon(UI.PixmapCache.getIcon("plus"))
 self.subscribeButton.setEnabled(False)
-self.subscribePropertiesButton.setIcon(
+self.subscribePropertiesButton.setIcon(UI.PixmapCache.getIcon("listSelection"))
-UI.PixmapCache.getIcon("listSelection"))
 self.subscribePropertiesButton.setEnabled(False)
 self.subscribePropertiesButton.setVisible(False)
 self.unsubscribeButton.setIcon(UI.PixmapCache.getIcon("minus"))
 self.unsubscribeButton.setEnabled(False)
 self.unsubscribePropertiesButton.setIcon(
-UI.PixmapCache.getIcon("listSelection"))
+UI.PixmapCache.getIcon("listSelection")
+)
 self.unsubscribePropertiesButton.setEnabled(False)
 self.unsubscribePropertiesButton.setVisible(False)
 self.__initPropertiesEditMenu()
 self.__subscribedTopics = []
 self.__topicQueue = {}
 self.__updateUnsubscribeTopicComboBox()
 self.__publishedTopics = []
 self.__updatePublishTopicComboBox()
 self.publishButton.setEnabled(False)
-self.publishPropertiesButton.setIcon(
+self.publishPropertiesButton.setIcon(UI.PixmapCache.getIcon("listSelection"))
-UI.PixmapCache.getIcon("listSelection"))
 self.publishPropertiesButton.setEnabled(False)
 self.publishPropertiesButton.setVisible(False)
 self.__connectionOptions = None
 prefix = MqttMonitorWidget.BrokerStatusTopicPrefix
 self.__statusLabelMapping = {
 # broker
 prefix + "version": self.versionLabel,
 prefix + "timestamp": self.timestampLabel,
 prefix + "store/messages/count": self.messagesStoredLabel,
 prefix + "messages/inflight": self.messagesInflightLabel,
 prefix + "retained messages/count": self.messagesRetainedLabel,
 # publish messages
 prefix + "publish/messages/sent": self.publishMessagesSentLabel,
-prefix + "publish/messages/received":
+prefix + "publish/messages/received": self.publishMessagesReceivedLabel,
-self.publishMessagesReceivedLabel,
+prefix + "publish/messages/dropped": self.publishMessagesDroppedLabel,
-prefix + "publish/messages/dropped":
-self.publishMessagesDroppedLabel,
 # traffic
 prefix + "bytes/sent": self.bytesSentLabel,
 prefix + "bytes/received": self.bytesReceivedLabel,
 # load
 prefix + "load/bytes/sent": self.loadBytesSentLabel,
 prefix + "load/publish/received": self.loadPublishReceivedLabel,
 prefix + "load/publish/dropped": self.loadPublishDroppedLabel,
 prefix + "load/connections": self.loadConnectionsLabel,
 prefix + "load/sockets": self.loadSocketsLabel,
 }
-self.__statusLoadValues = collections.defaultdict(
+self.__statusLoadValues = collections.defaultdict(self.__loadDefaultDictFactory)
-self.__loadDefaultDictFactory)
+def __createClient(self, clientId="", cleanSession=None, protocol=None):
-def __createClient(self, clientId="", cleanSession=None,
-protocol=None):
 """
 Private method to instantiate a MQTT client for a given protocol.
 @param clientId ID to be used for the client
 @type str
 @param cleanSession flag indicating to start a clean session
 @type bool
 @param protocol MQTT protocol version to be used (defaults to None)
 @return created and connected MQTT client object
 @rtype MqttClient
 """
 if protocol is None:
 protocol = self.__plugin.getPreferences("DefaultProtocol")
-client = MqttClient(clientId=clientId, cleanSession=cleanSession,
+client = MqttClient(
-protocol=protocol)
+clientId=clientId, cleanSession=cleanSession, protocol=protocol
+)
 # connect the MQTT client signals
 client.onConnectV3.connect(self.__brokerConnected)
 client.onConnectV5.connect(self.__brokerConnected)
 client.onDisconnectedV3.connect(self.__brokerDisconnected)
 client.onDisconnectedV5.connect(self.__brokerDisconnected)
 client.onPublish.connect(self.__messagePublished)
 client.onSubscribeV3.connect(self.__topicSubscribed)
 client.onSubscribeV5.connect(self.__topicSubscribedV5)
 client.onUnsubscribeV3.connect(self.__topicUnsubscribed)
 client.onUnsubscribeV5.connect(self.__topicUnsubscribedV5)
 client.connectTimeout.connect(self.__connectTimeout)
 return client
 def __initPropertiesEditMenu(self):
 """
 Private method to create the properties output context menu.
 """
 self.__propertiesEditMenu = QMenu(self)
 self.__copyPropertiesAct = self.__propertiesEditMenu.addAction(
 UI.PixmapCache.getIcon("editCopy"),
-self.tr("Copy"), self.propertiesEdit.copy)
+self.tr("Copy"),
+self.propertiesEdit.copy,
+)
 self.__propertiesEditMenu.addSeparator()
 self.__selectAllPropertiesAct = self.__propertiesEditMenu.addAction(
 UI.PixmapCache.getIcon("editSelectAll"),
-self.tr("Select All"), self.propertiesEdit.selectAll)
+self.tr("Select All"),
+self.propertiesEdit.selectAll,
+)
 self.__propertiesEditMenu.addSeparator()
 self.__clearPropertiesAct = self.__propertiesEditMenu.addAction(
 UI.PixmapCache.getIcon("editDelete"),
-self.tr("Clear"), self.propertiesEdit.clear)
+self.tr("Clear"),
+self.propertiesEdit.clear,
-self.propertiesEdit.copyAvailable.connect(
+)
-self.__copyPropertiesAct.setEnabled)
+self.propertiesEdit.copyAvailable.connect(self.__copyPropertiesAct.setEnabled)
 self.__copyPropertiesAct.setEnabled(False)
 #######################################################################
 ## Slots handling MQTT related signals
 #######################################################################
 @pyqtSlot(dict, int)
 @pyqtSlot(dict, int, int, dict)
 def __brokerConnected(self, flags, rc, packetType=None, properties=None):
 """
 Private slot to handle being connected to a broker.
 @param flags flags set for the connection
 @type dict
 @param rc CONNACK result code or MQTTv5 reason code
 @type int
 @param packetType packet type as reported by the client
 @param properties dictionary containing the received connection
 properties
 @type dict
 """
 self.brokerStatusLabel.hide()
 if rc == 0:
 self.__connectedToBroker = True
 self.__connectionOptions = None
 try:
 sessionPresent = flags["session present"] == 1
 except KeyError:
 sessionPresent = False
 msg = (
 mqttReasonCode(rc, packetType)
-if packetType is not None else
+if packetType is not None
-mqttConnackMessage(rc)
+else mqttConnackMessage(rc)
 )
 if sessionPresent:
 msg = self.tr("{0} - Session still present").format(msg)
 self.__flashBrokerStatusLabel(msg)
 if properties:
 self.__showProperties("Connect", properties)
 self.connectButton.setEnabled(True)
 if rc == 0:
 self.__connectedToBroker = True
 self.__connectionOptions = None
-self.connectButton.setIcon(
+self.connectButton.setIcon(UI.PixmapCache.getIcon("ircDisconnect"))
-UI.PixmapCache.getIcon("ircDisconnect"))
 self.subscribeGroup.setEnabled(True)
 self.subscribePropertiesButton.setVisible(
-self.__client.getProtocol() == MqttProtocols.MQTTv5)
+self.__client.getProtocol() == MqttProtocols.MQTTv5
+)
 self.unsubscribeGroup.setEnabled(True)
 self.unsubscribePropertiesButton.setVisible(
-self.__client.getProtocol() == MqttProtocols.MQTTv5)
+self.__client.getProtocol() == MqttProtocols.MQTTv5
+)
 self.publishGroup.setEnabled(True)
 self.brokerStatusButton.setEnabled(True)
 self.publishPropertiesButton.setVisible(
-self.__client.getProtocol() == MqttProtocols.MQTTv5)
+self.__client.getProtocol() == MqttProtocols.MQTTv5
+)
 self.__statusLoadValues.clear()
 self.__clearBrokerStatusLabels()
 self.__setBrokerStatusSubscribed(False)
 else:
 self.__client.stopLoop()
 @pyqtSlot()
 def __connectTimeout(self):
 """
 Private slot handling a timeout during a connection attempt.
 """
 self.__flashBrokerStatusLabel(self.tr("Connection timed out"))
 self.__setConnectButtonState()
 @pyqtSlot(int)
 @pyqtSlot(int, int)
 def __brokerDisconnected(self, rc, packetType=None):
 """
 Private slot to handle a disconnection from the broker.
 @param rc MQTT error result code
 @type int
 @param packetType packet type as reported by the client
 @type int
 """
 self.__connectedToBroker = False
 # ensure, the client loop is stopped
 self.__client.stopLoop()
 msg = (
 # MQTT v5
 mqttReasonCode(rc, packetType)
-if packetType is not None else
+if packetType is not None
+else
 # MQTT v3
 (
 mqttErrorMessage(rc)
-if rc > 0 else
+if rc > 0
-self.tr("Connection to Broker shut down cleanly.")
+else self.tr("Connection to Broker shut down cleanly.")
 )
 )
 self.__flashBrokerStatusLabel(msg)
 self.connectButton.setIcon(UI.PixmapCache.getIcon("ircConnect"))
 self.__setConnectButtonState()
 self.__subscribedTopics = []
 self.__topicQueue = {}
 self.__updateUnsubscribeTopicComboBox()
 self.__updatePublishTopicComboBox()
 self.subscribeGroup.setEnabled(False)
 self.subscribePropertiesButton.setVisible(False)
 self.unsubscribeGroup.setEnabled(False)
 self.unsubscribePropertiesButton.setVisible(False)
 self.publishGroup.setEnabled(False)
 self.publishPropertiesButton.setVisible(False)
 self.brokerStatusButton.setEnabled(False)
 self.__statusLoadValues.clear()
 @pyqtSlot(int, str)
 def __clientLog(self, level, message):
 """
 Private slot to handle the receipt of a log message.
 @param level log level
 @type int
 @param message log message
 @type str
 """
 with contextlib.suppress(KeyError):
 if MqttClient.LogLevelMap[level] < self.logLevelComboBox.itemData(
-self.logLevelComboBox.currentIndex()):
+self.logLevelComboBox.currentIndex()
+):
 return
 scrollbarValue = self.logEdit.verticalScrollBar().value()
 textCursor = self.logEdit.textCursor()
 if not self.logEdit.document().isEmpty():
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.logEdit.setTextCursor(textCursor)
 self.logEdit.insertPlainText("\n")
 textBlockFormat = textCursor.blockFormat()
 try:
 textBlockFormat.setBackground(
-self.__logMessagesBackgrounds[MqttClient.LogLevelMap[level]])
+self.__logMessagesBackgrounds[MqttClient.LogLevelMap[level]]
+)
 except KeyError:
 textBlockFormat.setBackground(
-self.__logMessagesBackgrounds[MqttClient.LogDisabled])
+self.__logMessagesBackgrounds[MqttClient.LogDisabled]
+)
 textCursor.setBlockFormat(textBlockFormat)
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.logEdit.setTextCursor(textCursor)
 txt = self.tr("{0}: {1}").format(mqttLogLevelString(level), message)
 self.logEdit.insertPlainText(Utilities.filterAnsiSequences(txt))
 if self.followLogMessagesCheckBox.isChecked():
 self.logEdit.ensureCursorVisible()
 else:
 self.logEdit.verticalScrollBar().setValue(scrollbarValue)
 @pyqtSlot(str, bytes, int, bool)
 @pyqtSlot(str, bytes, int, bool, dict)
 def __messageReceived(self, topic, payload, qos, retain, properties=None):
 """
 Private slot to handle the receipt of a message.
 @param topic topic of the message
 @type str
 @param payload payload (i.e. data) of the message
 @type bytes
 @param qos quality of service indicator
 """
 if topic.startswith(MqttMonitorWidget.BrokerStatusTopicPrefix):
 # handle broker status messages
 self.__handleBrokerStatusMessage(topic, payload)
 else:
-self.__appendMessage(topic, payload, qos, retain,
+self.__appendMessage(topic, payload, qos, retain, properties=properties)
-properties=properties)
 @pyqtSlot(int)
 def __messagePublished(self, mid):
 """
 Private slot to handle a message being published.
 @param mid ID of the published message
 @type int
 """
 # nothing to show for this
 pass
 @pyqtSlot(int)
 def __topicSubscribed(self, mid):
 """
 Private slot to handle being subscribed to topics (MQTT v3.1,
 MQTT v3.1.1).
 @param mid ID of the subscribe request
 @type int
 """
 if mid in self.__topicQueue:
 topic = self.__topicQueue.pop(mid)
 self.__subscribedTopics.append(topic)
 self.__addTopicToRecent(topic)
 self.__updateUnsubscribeTopicComboBox()
 self.__updatePublishTopicComboBox()
 @pyqtSlot(int, list, dict)
 def __topicSubscribedV5(self, mid, reasonCodes, properties):
 """
 Private slot to handle being subscribed to topics (MQTT v5).
 @param mid ID of the subscribe request
 @type int
 @param reasonCodes list of reason codes, one for each topic
 @type list of ReasonCodes
 @param properties dictionary containing the received subscribe
 properties
 @type dict
 """
 msg = mqttReasonCode(reasonCodes[0].value, reasonCodes[0].packetType)
 self.__flashBrokerStatusLabel(msg)
 if properties:
 self.__showProperties("Subscribe", properties)
 self.__topicSubscribed(mid)
 @pyqtSlot(int)
 def __topicUnsubscribed(self, mid):
 """
 Private slot to handle being unsubcribed from a topic (MQTT v3.1,
 MQTT v3.1.1).
 @param mid ID of the unsubscribe request
 @type int
 """
 if mid in self.__topicQueue:
 topic = self.__topicQueue.pop(mid)
 with contextlib.suppress(ValueError):
 self.__subscribedTopics.remove(topic)
 self.__updateUnsubscribeTopicComboBox()
 self.__updatePublishTopicComboBox()
 @pyqtSlot(int, int, int, dict)
 def __topicUnsubscribedV5(self, mid, rc, packetType, properties):
 """
 Private slot to handle being unsubscribed to topics (MQTT v5).
 @param mid ID of the subscribe request
 @type int
 @param rc MQTTv5 reason code
 @type int
 @param packetType packet type as reported by the client
 properties
 @type dict
 """
 msg = mqttReasonCode(rc, packetType)
 self.__flashBrokerStatusLabel(msg)
 if properties:
 self.__showProperties("Unsubscribe", properties)
 self.__topicUnsubscribed(mid)
 #######################################################################
 ## Slots handling UI interactions
 #######################################################################
 @pyqtSlot()
 def __flashBrokerStatusLabel(self, message):
 """
 Private slot to show the broker status label with some text for
 5 seconds.
 @param message message to be shown
 @type str
 """
 self.brokerStatusLabel.setText(message)
 self.brokerStatusLabel.show()
 QTimer.singleShot(5000, self.brokerStatusLabel.hide)
 @pyqtSlot()
 def on_modeButton_clicked(self):
 """
 Private slot to switch between connection profiles and direct
 connection mode.
 """
 self.__setConnectionMode(not self.__connectionModeProfile)
 @pyqtSlot(str)
 def on_profileComboBox_currentIndexChanged(self, profileName):
 """
 Private slot handling the change of the selected profile.
 @param profileName name of the selected profile
 @type str
 """
 self.__setConnectButtonState()
 @pyqtSlot(str)
 def on_brokerComboBox_editTextChanged(self, host):
 """
 Private slot to handling entering or selecting a broker host name.
 @param host host name of the broker
 @type str
 """
 self.__setConnectButtonState()
 @pyqtSlot()
 def on_brokerConnectionOptionsButton_clicked(self):
 """
 Private slot to show a dialog to modify connection options or a
 dialog to edit connection profiles.
 """
 if self.__connectionModeProfile:
-from .MqttConnectionProfilesDialog import (
+from .MqttConnectionProfilesDialog import MqttConnectionProfilesDialog
-MqttConnectionProfilesDialog
-)
 profileName = self.profileComboBox.currentText()
 dlg = MqttConnectionProfilesDialog(
 self.__plugin.getPreferences("BrokerProfiles"),
-currentProfile=profileName, parent=self)
+currentProfile=profileName,
+parent=self,
+)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 profilesDict = dlg.getProfiles()
 self.__plugin.setPreferences("BrokerProfiles", profilesDict)
 self.__populateProfileComboBox()
 else:
-from .MqttConnectionOptionsDialog import (
+from .MqttConnectionOptionsDialog import MqttConnectionOptionsDialog
-MqttConnectionOptionsDialog
-)
+dlg = MqttConnectionOptionsDialog(self.__connectionOptions, parent=self)
-dlg = MqttConnectionOptionsDialog(
-self.__connectionOptions, parent=self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 self.__connectionOptions = dlg.getConnectionOptions()
 if self.__connectionOptions["TlsEnable"]:
 port = self.brokerPortComboBox.currentText().strip()
 if port == "1883":
 else:
 port = self.brokerPortComboBox.currentText().strip()
 if port == "8883":
 # it is default TLS port => set to non-encrypted port
 self.brokerPortComboBox.setEditText("1883")
 @pyqtSlot()
 def on_connectButton_clicked(self):
 """
 Private slot to handle a connect or disconnect request.
 """
 else:
 if self.__connectionModeProfile:
 self.__profileConnectToBroker()
 else:
 self.__directConnectToBroker()
 @pyqtSlot()
 def on_subscribePropertiesButton_clicked(self):
 """
 Private slot to edit the subscribe user properties.
 """
 topic = self.subscribeTopicComboBox.currentText()
 self.__editProperties(
 "subscribe",
 self.tr("SUBSCRIBE: User Properties for '{0}'").format(topic),
-topic
+topic,
 )
 @pyqtSlot(str)
 def on_subscribeTopicComboBox_editTextChanged(self, topic):
 """
 Private slot to handle a change of the entered topic.
 @param topic entered topic text
 @type str
 """
 self.subscribeButton.setEnabled(bool(topic))
 self.subscribePropertiesButton.setEnabled(bool(topic))
 @pyqtSlot()
 def on_subscribeButton_clicked(self):
 """
 Private slot to subscribe to the entered topic.
 """
 if topic:
 if topic.startswith(MqttMonitorWidget.BrokerStatusTopicPrefix):
 EricMessageBox.warning(
 self,
 self.tr("Subscribe to Topic"),
-self.tr("Subscriptions to the Status topic '$SYS' shall"
+self.tr(
-" be done on the 'Status' tab."))
+"Subscriptions to the Status topic '$SYS' shall"
+" be done on the 'Status' tab."
+),
+)
 else:
 properties = (
-self.__plugin.getPreferences("SubscribeProperties")
+self.__plugin.getPreferences("SubscribeProperties").get(topic, [])
-.get(topic, [])
+if self.__client.getProtocol() == MqttProtocols.MQTTv5
-if self.__client.getProtocol() == MqttProtocols.MQTTv5 else
+else None
-None
 )
 result, mid = self.__client.subscribe(
-topic, qos=qos, properties=properties)
+topic, qos=qos, properties=properties
+)
 self.__topicQueue[mid] = topic
 @pyqtSlot()
 def on_unsubscribePropertiesButton_clicked(self):
 """
 Private slot to edit the unsubscribe user properties.
 """
 topic = self.unsubscribeTopicComboBox.currentText()
 self.__editProperties(
 "unsubscribe",
 self.tr("UNSUBSCRIBE: User Properties for '{0}'").format(topic),
-topic
+topic,
 )
 @pyqtSlot(str)
 def on_unsubscribeTopicComboBox_currentIndexChanged(self, topic):
 """
 Private slot to handle the selection of a topic to unsubscribe from.
 @param topic topic text
 @type str
 """
 self.unsubscribeButton.setEnabled(bool(topic))
 self.unsubscribePropertiesButton.setEnabled(bool(topic))
 @pyqtSlot()
 def on_unsubscribeButton_clicked(self):
 """
 Private slot to unsubscribe from the selected topic.
 """
 topic = self.unsubscribeTopicComboBox.currentText()
 if topic:
 properties = (
-self.__plugin.getPreferences("SubscribeProperties")
+self.__plugin.getPreferences("SubscribeProperties").get(topic, [])
-.get(topic, [])
+if self.__client.getProtocol() == MqttProtocols.MQTTv5
-if self.__client.getProtocol() == MqttProtocols.MQTTv5 else
+else None
-None
+)
-)
+result, mid = self.__client.unsubscribe(topic, properties=properties)
-result, mid = self.__client.unsubscribe(
-topic, properties=properties)
 self.__topicQueue[mid] = topic
 @pyqtSlot()
 def on_publishPropertiesButton_clicked(self):
 """
 Private slot to edit the publish user properties.
 """
 topic = self.publishTopicComboBox.currentText()
 self.__editProperties(
 "publish",
 self.tr("PUBLISH: User Properties for '{0}'").format(topic),
-topic
+topic,
 )
 @pyqtSlot(str)
 def on_publishTopicComboBox_editTextChanged(self, topic):
 """
 Private slot to handle changes of the publish topic name.
 @param topic topic text
 @type str
 """
 self.publishButton.setEnabled(bool(topic))
 self.publishPropertiesButton.setEnabled(bool(topic))
 @pyqtSlot()
 def on_publishButton_clicked(self):
 """
 Private slot to publish the entered message.
 """
 topic = self.publishTopicComboBox.currentText()
 qos = self.publishQosSpinBox.value()
 retain = self.publishRetainCheckBox.isChecked()
 payloadFile = self.publishPayloadFilePicker.text()
 if (
-bool(payloadFile) and
+bool(payloadFile)
-os.path.exists(payloadFile) and
+and os.path.exists(payloadFile)
-os.path.getsize(payloadFile) <= 268435455
+and os.path.getsize(payloadFile) <= 268435455
 ):
 # payload size limit is 268,435,455 bytes
 try:
 with open(payloadFile, "rb") as f:
 payloadStr = f.read()
 except EnvironmentError as err:
 EricMessageBox.critical(
 self,
 self.tr("Read Payload from File"),
-self.tr("""<p>The file <b>{0}</b> could not be read."""
+self.tr(
-""" Aborting...</p><p>Reason: {1}</p>""").format(
+"""<p>The file <b>{0}</b> could not be read."""
-payloadFile, str(err)))
+""" Aborting...</p><p>Reason: {1}</p>"""
+).format(payloadFile, str(err)),
+)
 return
 else:
 payloadStr = self.publishPayloadEdit.toPlainText()
 if not payloadStr:
 # use empty string together with the retain flag to clean
 # a retained message by sending None instead
 payloadStr = None
 properties = (
 self.__plugin.getPreferences("PublishProperties").get(topic, [])
-if self.__client.getProtocol() == MqttProtocols.MQTTv5 else
+if self.__client.getProtocol() == MqttProtocols.MQTTv5
-None
+else None
 )
 msgInfo = self.__client.publish(
-topic, payload=payloadStr, qos=qos, retain=retain,
+topic, payload=payloadStr, qos=qos, retain=retain, properties=properties
-properties=properties)
+)
 if msgInfo.rc == 0:
 if topic not in self.__publishedTopics:
 self.__publishedTopics.append(topic)
 self.__updatePublishTopicComboBox(resetTopic=False)
 if self.clearPublishCheckBox.isChecked():
 self.on_publishClearButton_clicked()
 @pyqtSlot()
 def on_publishClearRetainedButton_clicked(self):
 """
 Private slot to clear the retained messages for the topic.
 """
 topic = self.publishTopicComboBox.currentText()
 properties = (
 self.__plugin.getPreferences("PublishProperties").get(topic, [])
-if self.__client.getProtocol() == MqttProtocols.MQTTv5 else
+if self.__client.getProtocol() == MqttProtocols.MQTTv5
-None
+else None
 )
 msgInfo = self.__client.publish(
-topic, payload=None, retain=True, properties=properties)
+topic, payload=None, retain=True, properties=properties
+)
 if msgInfo.rc == 0:
 if topic not in self.__publishedTopics:
 self.__publishedTopics.append(topic)
 self.__updatePublishTopicComboBox(resetTopic=False)
 @pyqtSlot()
 def on_publishClearButton_clicked(self):
 """
 Private slot to clear the publish data fields.
 """
 self.publishTopicComboBox.clearEditText()
 self.publishPayloadEdit.clear()
 self.publishQosSpinBox.setValue(0)
 self.publishRetainCheckBox.setChecked(False)
 self.publishPayloadFilePicker.clear()
 @pyqtSlot(str)
 def on_publishPayloadFilePicker_textChanged(self, path):
 """
 Private slot handling a change of path of the payload file.
 @param path path of the payload file
 @type str
 """
 self.publishPayloadEdit.setEnabled(not bool(path))
 @pyqtSlot(QPoint)
 def on_propertiesEdit_customContextMenuRequested(self, pos):
 """
 Private slot to show the context menu for the properties output.
 @param pos the position of the mouse pointer
 @type QPoint
 """
 self.__propertiesEditMenu.popup(self.propertiesEdit.mapToGlobal(pos))
 @pyqtSlot()
 def on_brokerStatusButton_clicked(self):
 """
 Private slot to subscribe or unsubscribe the broker status topic.
 """
 if self.__brokerStatusTopicSubscribed:
 # unsubscribe status topic
-rc, _ = self.__client.unsubscribe(
+rc, _ = self.__client.unsubscribe(MqttMonitorWidget.BrokerStatusTopic)
-MqttMonitorWidget.BrokerStatusTopic)
 if rc == 0:
 # successfully sent
 self.__setBrokerStatusSubscribed(False)
 else:
 # subscribe status topic
-rc, _ = self.__client.subscribe(
+rc, _ = self.__client.subscribe(MqttMonitorWidget.BrokerStatusTopic)
-MqttMonitorWidget.BrokerStatusTopic)
 if rc == 0:
 # successfully sent
 self.__setBrokerStatusSubscribed(True)
 @pyqtSlot(int)
 def on_messagesEdit_blockCountChanged(self, newBlockCount):
 """
 Private slot handling changes of received messages.
 @param newBlockCount (ignored)
 @type int
 """
 enable = not self.messagesEdit.document().isEmpty()
 self.saveMessagesButton.setEnabled(enable)
 self.clearMessagesButton.setEnabled(enable)
 @pyqtSlot()
 def on_saveMessagesButton_clicked(self):
 """
 Private slot to save the received messages.
 """
 self,
 self.tr("Save Messages"),
 "",
 self.tr("Messages Files (*.txt);;All Files (*)"),
 "",
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if fn:
 if fn.endswith("."):
 fn = fn[:-1]
 ext = QFileInfo(fn).suffix()
 if not ext:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fn += ex
 if QFileInfo(fn).exists():
 res = EricMessageBox.yesNo(
 self,
 self.tr("Save Messages"),
-self.tr("<p>The file <b>{0}</b> already exists."
+self.tr(
-" Overwrite it?</p>").format(fn),
+"<p>The file <b>{0}</b> already exists." " Overwrite it?</p>"
-icon=EricMessageBox.Warning)
+).format(fn),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
 fn = Utilities.toNativeSeparators(fn)
 try:
 with open(fn, "w") as f:
 f.write(self.messagesEdit.toPlainText())
 except EnvironmentError as err:
 EricMessageBox.critical(
 self,
 self.tr("Save Messages"),
-self.tr("""<p>The file <b>{0}</b> could not be written."""
+self.tr(
-"""</p><p>Reason: {1}</p>""").format(
+"""<p>The file <b>{0}</b> could not be written."""
-fn, str(err)))
+"""</p><p>Reason: {1}</p>"""
+).format(fn, str(err)),
+)
 @pyqtSlot(int)
 def on_logEdit_blockCountChanged(self, newBlockCount):
 """
 Private slot handling changes of received messages.
 @param newBlockCount (ignored)
 @type int
 """
 enable = not self.logEdit.document().isEmpty()
 self.saveLogMessagesButton.setEnabled(enable)
 self.clearLogMessagesButton.setEnabled(enable)
 @pyqtSlot()
 def on_saveLogMessagesButton_clicked(self):
 """
 Private slot to save the log messages.
 """
 self,
 self.tr("Save Log Messages"),
 "",
 self.tr("Log Files (*.log);;All Files (*)"),
 "",
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if fn:
 if fn.endswith("."):
 fn = fn[:-1]
 ext = QFileInfo(fn).suffix()
 if not ext:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fn += ex
 if QFileInfo(fn).exists():
 res = EricMessageBox.yesNo(
 self,
 self.tr("Save Log Messages"),
-self.tr("<p>The file <b>{0}</b> already exists."
+self.tr(
-" Overwrite it?</p>").format(fn),
+"<p>The file <b>{0}</b> already exists." " Overwrite it?</p>"
-icon=EricMessageBox.Warning)
+).format(fn),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
 fn = Utilities.toNativeSeparators(fn)
 try:
 with open(fn, "w") as f:
 f.write(self.logEdit.toPlainText())
 except EnvironmentError as err:
 EricMessageBox.critical(
 self,
 self.tr("Save Log Messages"),
-self.tr("""<p>The file <b>{0}</b> could not be written."""
+self.tr(
-"""</p><p>Reason: {1}</p>""").format(
+"""<p>The file <b>{0}</b> could not be written."""
-fn, str(err)))
+"""</p><p>Reason: {1}</p>"""
+).format(fn, str(err)),
+)
 #######################################################################
 ## Utility methods
 #######################################################################
 def __setBrokerStatusSubscribed(self, subscribed):
 """
 Private method to set the subscription status for the broker status
 topics.
 @param subscribed subscription status for the broker status topics
 @type bool
 """
 self.__brokerStatusTopicSubscribed = subscribed
 if subscribed:
 self.brokerStatusButton.setText(self.tr("Unsubscribe"))
 self.brokerStatusButton.setToolTip(
-self.tr("Press to deactivate the status display"))
+self.tr("Press to deactivate the status display")
+)
 else:
 self.brokerStatusButton.setText(self.tr("Subscribe"))
 self.brokerStatusButton.setToolTip(
-self.tr("Press to activate the status display"))
+self.tr("Press to activate the status display")
+)
 def __addBrokerToRecent(self, host, port):
 """
 Private method to add a host name to the list of recently connected
 brokers.
 @param host host name of broker
 @type str
 @param port port number of the connection
 @type int
 """
 brokerList.insert(0, hostAndPort)
 # limit the most recently used entries
 maxBrokers = self.__plugin.getPreferences("RecentBrokersNumber")
 brokerList = brokerList[:maxBrokers]
 self.__plugin.setPreferences("RecentBrokersWithPort", brokerList)
 self.__populateBrokerComboBoxes()
 def __populateBrokerComboBoxes(self):
 """
 Private method to populate the broker name and port combo boxes.
 """
 brokerPortList = self.__plugin.getPreferences("RecentBrokersWithPort")
 # step 1: clear combo boxes
 self.brokerComboBox.clear()
 self.brokerPortComboBox.clear()
 # step 2a: populate the broker name list
 currentBroker = brokerPortList[0][0] if brokerPortList else ""
 brokerSet = {b[0].strip() for b in brokerPortList}
 self.brokerComboBox.addItems(sorted(brokerSet))
 index = self.brokerComboBox.findText(currentBroker)
 self.brokerComboBox.setCurrentIndex(index)
 # step 2b: populate the broker ports list
 currentPort = brokerPortList[0][1] if brokerPortList else 1883
 currentPortStr = "{0:5}".format(currentPort)
 portsSet = {b[1] for b in brokerPortList}
 portsSet.update({1883, 8883})
-self.brokerPortComboBox.addItems(
+self.brokerPortComboBox.addItems(sorted("{0:5}".format(p) for p in portsSet))
-sorted("{0:5}".format(p) for p in portsSet))
 index = self.brokerPortComboBox.findText(currentPortStr)
 self.brokerPortComboBox.setCurrentIndex(index)
 # step 3: update the connect button state
 self.__setConnectButtonState()
 def __populateProfileComboBox(self):
 """
 Private method to populate the profiles selection box.
 """
 profilesDict = self.__plugin.getPreferences("BrokerProfiles")
 mostRecentProfile = self.__plugin.getPreferences("MostRecentProfile")
 self.profileComboBox.clear()
 self.profileComboBox.addItems(sorted(profilesDict.keys()))
 if mostRecentProfile:
 index = self.profileComboBox.findText(mostRecentProfile)
 if index >= 0:
 self.profileComboBox.setCurrentIndex(index)
 self.__setConnectButtonState()
 def __addTopicToRecent(self, topic):
 """
 Private method to add a topic to the list of recently subscribed
 topics.
 @param topic subscribed topic
 @type str
 """
 topicsList = self.__plugin.getPreferences("RecentTopics")
 if topic in topicsList:
 topicsList.insert(0, topic)
 # limit the most recently used entries
 maxTopics = self.__plugin.getPreferences("RecentTopicsNumber")
 topicsList = topicsList[:maxTopics]
 self.__plugin.setPreferences("RecentTopics", topicsList)
 self.__populateSubscribeTopicComboBox()
 def __populateSubscribeTopicComboBox(self):
 """
 Private method to populate the subscribe topic combo box.
 """
 topicsList = self.__plugin.getPreferences("RecentTopics")
 self.subscribeTopicComboBox.clear()
 self.subscribeTopicComboBox.addItems(sorted(topicsList))
 self.subscribeTopicComboBox.clearEditText()
 def __updateUnsubscribeTopicComboBox(self):
 """
 Private method to update the unsubcribe topic combo box.
 """
 self.unsubscribeTopicComboBox.clear()
 self.unsubscribeTopicComboBox.addItems(sorted(self.__subscribedTopics))
-self.unsubscribeButton.setEnabled(
+self.unsubscribeButton.setEnabled(bool(self.__subscribedTopics))
-bool(self.__subscribedTopics))
+self.unsubscribePropertiesButton.setEnabled(bool(self.__subscribedTopics))
-self.unsubscribePropertiesButton.setEnabled(
-bool(self.__subscribedTopics))
 def __updatePublishTopicComboBox(self, resetTopic=True):
 """
 Private method to update the publish topic combo box.
 @param resetTopic flag indicating to reset the topic
 @type bool
 """
 currentTopic = self.publishTopicComboBox.currentText()
 self.publishTopicComboBox.clear()
 self.publishTopicComboBox.addItems(
-list(set(self.__publishedTopics + self.__subscribedTopics)))
+list(set(self.__publishedTopics + self.__subscribedTopics))
+)
 if resetTopic:
 self.publishTopicComboBox.clearEditText()
 else:
 topicIndex = self.publishTopicComboBox.findText(currentTopic)
 self.publishTopicComboBox.setCurrentIndex(topicIndex)
 def __appendMessage(self, topic, payload, qos, retain, properties=None):
 """
 Private method to append a received message to the output.
 @param topic topic of the received message
 @type str
 @param payload payload of the received message
 @type bytes
 @param qos quality of service indicator (0, 1, 2)
 @type bool
 @param properties properties sent with the message (MQTT v5)
 @type dict
 """
 scrollbarValue = self.messagesEdit.verticalScrollBar().value()
 textCursor = self.messagesEdit.textCursor()
 if not self.messagesEdit.document().isEmpty():
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.messagesEdit.setTextCursor(textCursor)
 self.messagesEdit.insertPlainText("\n")
 textBlockFormat = textCursor.blockFormat()
 if self.__isMessageAlternate:
-textBlockFormat.setBackground(
+textBlockFormat.setBackground(self.messagesEdit.palette().alternateBase())
-self.messagesEdit.palette().alternateBase())
+else:
-else:
+textBlockFormat.setBackground(self.messagesEdit.palette().base())
-textBlockFormat.setBackground(
-self.messagesEdit.palette().base())
 textCursor.setBlockFormat(textBlockFormat)
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.messagesEdit.setTextCursor(textCursor)
 self.messagesEdit.setCurrentCharFormat(self.__messagesTopicFormat)
 self.messagesEdit.insertPlainText(topic + "\n")
 self.messagesEdit.setCurrentCharFormat(self.__messagesQosFormat)
 self.messagesEdit.insertPlainText(self.tr("QoS: {0}\n").format(qos))
 if retain:
 self.messagesEdit.setCurrentCharFormat(self.__messagesQosFormat)
 self.messagesEdit.insertPlainText(self.tr("Retained Message\n"))
 if properties:
-self.messagesEdit.setCurrentCharFormat(
+self.messagesEdit.setCurrentCharFormat(self.__messagesSubheaderFormat)
-self.__messagesSubheaderFormat)
 self.messagesEdit.insertPlainText(self.tr("Properties:\n"))
 self.messagesEdit.setCurrentCharFormat(self.__messagesFormat)
 for name, value in sorted(properties.items()):
 self.messagesEdit.insertPlainText(
-self.tr("{0}: {1}\n", "property name, property value")
+self.tr("{0}: {1}\n", "property name, property value").format(
-.format(name, value)
+name, value
 )
+)
 self.messagesEdit.setCurrentCharFormat(self.__messagesSubheaderFormat)
 self.messagesEdit.insertPlainText(self.tr("Message:\n"))
 payloadStr = str(payload, encoding="utf-8", errors="replace")
 payloadStr = Utilities.filterAnsiSequences(payloadStr)
 self.messagesEdit.setCurrentCharFormat(self.__messagesFormat)
 if payloadStr:
 self.messagesEdit.insertPlainText(payloadStr)
 else:
 self.messagesEdit.insertPlainText(self.tr("<empty>"))
 if self.followMessagesCheckBox.isChecked():
 self.messagesEdit.ensureCursorVisible()
 else:
 self.messagesEdit.verticalScrollBar().setValue(scrollbarValue)
 self.__isMessageAlternate = not self.__isMessageAlternate
 def __handleBrokerStatusMessage(self, topic, payload):
 """
 Private method to handle a status message of the broker.
 @param topic topic of the received message
 @type str
 @param payload payload of the received message
 @type bytes
 """
 payloadStr = str(payload, encoding="utf-8", errors="replace").strip()
 topic = topic.strip()
 if topic.startswith(MqttMonitorWidget.BrokerStatusTopicLoadPrefix):
 self.__handleBrokerLoadStatusMessage(topic, payloadStr)
 else:
 with contextlib.suppress(KeyError):
 label = self.__statusLabelMapping[topic]
 label.setText(payloadStr)
 def __handleBrokerLoadStatusMessage(self, topic, payloadStr):
 """
 Private method to append a received message to the output.
 @param topic topic of the received message
 @type str
 @param payloadStr string representation of the payload of the
 received message
 @type str
 """
 subtopic, topicElement = topic.rsplit("/", 1)
 self.__statusLoadValues[subtopic][topicElement] = payloadStr
 with contextlib.suppress(KeyError):
 label = self.__statusLabelMapping[subtopic]
-label.setText("{0} / {1} / {2}".format(
+label.setText(
-self.__statusLoadValues[subtopic]["1min"],
+"{0} / {1} / {2}".format(
-self.__statusLoadValues[subtopic]["5min"],
+self.__statusLoadValues[subtopic]["1min"],
-self.__statusLoadValues[subtopic]["15min"],
+self.__statusLoadValues[subtopic]["5min"],
-))
+self.__statusLoadValues[subtopic]["15min"],
+)
+)
 def __clearBrokerStatusLabels(self):
 """
 Private method to clear the broker status labels.
 """
 for statusLabelKey in self.__statusLabelMapping:
 label = (
 "- / - / -"
 if statusLabelKey.startswith(
-MqttMonitorWidget.BrokerStatusTopicLoadPrefix) else
+MqttMonitorWidget.BrokerStatusTopicLoadPrefix
-"-"
+)
+else "-"
 )
 self.__statusLabelMapping[statusLabelKey].setText(label)
 def __loadDefaultDictFactory(self):
 """
 Private method to populate non-existing load items.
 @return default dictionary entry
 @rtype dict
 """
 return {
 "1min": "-",
 "5min": "-",
 "15min": "-",
 }
 def __setConnectionMode(self, profileMode):
 """
 Private method to set the connection mode.
 @param profileMode flag indicating the profile connection mode
 @type bool
 """
 self.__connectionModeProfile = profileMode
 if profileMode:
-self.modeButton.setIcon(UI.PixmapCache.getIcon(
+self.modeButton.setIcon(
-os.path.join("MqttMonitor", "icons",
+UI.PixmapCache.getIcon(
-"profiles-{0}".format(self.__iconSuffix))
+os.path.join(
-))
+"MqttMonitor", "icons", "profiles-{0}".format(self.__iconSuffix)
-else:
+)
-self.modeButton.setIcon(UI.PixmapCache.getIcon(
+)
-os.path.join("MqttMonitor", "icons",
+)
-"quickopen-{0}".format(self.__iconSuffix))
+else:
-))
+self.modeButton.setIcon(
+UI.PixmapCache.getIcon(
+os.path.join(
+"MqttMonitor",
+"icons",
+"quickopen-{0}".format(self.__iconSuffix),
+)
+)
+)
 self.profileComboBox.setVisible(profileMode)
 self.brokerConnectionWidget.setVisible(not profileMode)
 self.__setConnectButtonState()
 def __setConnectButtonState(self):
 """
 Private method to set the enabled state of the connect button.
 """
 if self.__connectionModeProfile:
-self.connectButton.setEnabled(
+self.connectButton.setEnabled(bool(self.profileComboBox.currentText()))
-bool(self.profileComboBox.currentText()))
+else:
-else:
+self.connectButton.setEnabled(bool(self.brokerComboBox.currentText()))
-self.connectButton.setEnabled(
-bool(self.brokerComboBox.currentText()))
 def __directConnectToBroker(self):
 """
 Private method to connect to the broker with entered data.
 """
 host = self.brokerComboBox.currentText()
 except ValueError:
 # use standard port at 1883
 port = 1883
 if host:
 self.brokerStatusLabel.setText(
-self.tr("Connecting to {0}:{1} ...").format(
+self.tr("Connecting to {0}:{1} ...").format(host, port)
-host, port))
+)
 self.brokerStatusLabel.show()
 self.__addBrokerToRecent(host, port)
 self.connectButton.setEnabled(False)
 if self.clearWillButton.isChecked():
 clearWill = True
 self.clearWillButton.setChecked(False)
 else:
 clearWill = False
 if self.__connectionOptions is None:
 self.__client = self.__createClient()
-self.__client.connectToServer(
+self.__client.connectToServer(host, port=port, clearWill=clearWill)
-host, port=port, clearWill=clearWill)
 else:
 self.__client = self.__createClient(
 clientId=self.__connectionOptions["ClientId"],
 cleanSession=self.__connectionOptions["CleanSession"],
-protocol=self.__connectionOptions["Protocol"]
+protocol=self.__connectionOptions["Protocol"],
 )
 self.__client.connectToServerWithOptions(
-host, port=port, options=self.__connectionOptions,
+host,
-clearWill=clearWill)
+port=port,
+options=self.__connectionOptions,
+clearWill=clearWill,
+)
 def __profileConnectToBroker(self):
 """
 Private method to connect to the broker with selected profile.
 """
 profileName = self.profileComboBox.currentText()
 if profileName:
 self.__plugin.setPreferences("MostRecentProfile", profileName)
 profilesDict = self.__plugin.getPreferences("BrokerProfiles")
 connectionProfile = copy.deepcopy(profilesDict[profileName])
 host = connectionProfile["BrokerAddress"]
 port = connectionProfile["BrokerPort"]
 try:
 protocol = connectionProfile["Protocol"]
 except KeyError:
 protocol = MqttProtocols(
-self.__plugin.getPreferences("DefaultProtocol"))
+self.__plugin.getPreferences("DefaultProtocol")
+)
 self.brokerStatusLabel.setText(
-self.tr("Connecting to {0}:{1} ...").format(
+self.tr("Connecting to {0}:{1} ...").format(host, port)
-host, port))
+)
 self.brokerStatusLabel.show()
 self.connectButton.setEnabled(False)
 if self.clearWillButton.isChecked():
 clearWill = True
 self.clearWillButton.setChecked(False)
 else:
 clearWill = False
 self.__client = self.__createClient(
 clientId=connectionProfile["ClientId"],
 cleanSession=connectionProfile["CleanSession"],
-protocol=protocol
+protocol=protocol,
 )
 self.__client.connectToServerWithOptions(
-host, port=port, options=connectionProfile,
+host, port=port, options=connectionProfile, clearWill=clearWill
-clearWill=clearWill)
+)
 def __showProperties(self, typeStr, properties):
 """
 Private method to display the received properties in the properties
 pane.
 @param typeStr message type
 @type str
 @param properties dictionary containing the relevant properties
 @type dict
 """
 textCursor = self.propertiesEdit.textCursor()
 if not self.propertiesEdit.document().isEmpty():
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.propertiesEdit.setTextCursor(textCursor)
 textBlockFormat = textCursor.blockFormat()
 if self.__isPropertiesAlternate:
-textBlockFormat.setBackground(
+textBlockFormat.setBackground(self.propertiesEdit.palette().alternateBase())
-self.propertiesEdit.palette().alternateBase())
+else:
-else:
+textBlockFormat.setBackground(self.propertiesEdit.palette().base())
-textBlockFormat.setBackground(
-self.propertiesEdit.palette().base())
 textCursor.setBlockFormat(textBlockFormat)
 textCursor.movePosition(QTextCursor.MoveOperation.End)
 self.propertiesEdit.setTextCursor(textCursor)
 self.propertiesEdit.setCurrentCharFormat(self.__propertiesTopicFormat)
 self.propertiesEdit.insertPlainText(typeStr + "\n")
 for name, value in sorted(properties.items()):
-self.propertiesEdit.setCurrentCharFormat(
+self.propertiesEdit.setCurrentCharFormat(self.__propertiesNameFormat)
-self.__propertiesNameFormat)
 self.propertiesEdit.insertPlainText("{0}: ".format(name))
 self.propertiesEdit.setCurrentCharFormat(self.__propertiesFormat)
 self.propertiesEdit.insertPlainText("{0}\n".format(str(value)))
 self.propertiesEdit.ensureCursorVisible()
 self.__isPropertiesAlternate = not self.__isPropertiesAlternate
 def __editProperties(self, propertiesType, header, key):
 """
 Private method to edit user properties of a given type.
 @param propertiesType properties type (one of 'subscribe',
 'unsubscribe', 'publish')
 @type str
 @param header header to be shown in the edit dialog
 @type str
 @param key key to retrieve the right properties
 @type str
 """
 from .MqttUserPropertiesEditor import MqttUserPropertiesEditorDialog
 preferencesKey = "{0}Properties".format(propertiesType.capitalize())
 properties = self.__plugin.getPreferences(preferencesKey)
-dlg = MqttUserPropertiesEditorDialog(
+dlg = MqttUserPropertiesEditorDialog(header, properties.get(key, []), self)
-header, properties.get(key, []), self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 properties[key] = dlg.getProperties()
 self.__plugin.setPreferences(preferencesKey, properties)

Mercurial Repositories > MQTT Monitor / file comparison

comparison: MqttMonitor/MqttMonitorWidget.py

MqttMonitor/MqttMonitorWidget.py