multiserialviewer 25.1.4__py3-none-any.whl

multiserialviewer/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__

multiserialviewer/__main__.py

@@ -0,0 +1,12 @@
+import sys
+from multiserialviewer import __version__
+from multiserialviewer.application.application import Application
+
+
+def main() -> int | str:
+    app = Application(__version__, sys.argv)
+    return app.exec()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

multiserialviewer/__version__.py

@@ -0,0 +1,13 @@
+# Version scheme:
+# YEAR.MONTH.COUNTER
+# YEAR, MONTH are two digits and zero-padded
+# COUNTER resets every month and starts with 0
+# For example:
+# - 23.09.0
+# - 23.09.1
+# - 23.10.0
+#
+# Development versions contain the DEV-COUNTER postfix:
+# - 24.01.0.DEV-1
+
+__version__ = '25.1.4'

multiserialviewer/application/application.py

@@ -0,0 +1,189 @@
+from PySide6.QtWidgets import QApplication
+from PySide6.QtCore import Slot, Qt, QUrl
+from PySide6.QtGui import QDesktopServices, QGuiApplication
+from typing import List
+from platformdirs import user_config_dir
+import copy
+
+from multiserialviewer.gui_main.mainWindow import MainWindow
+from multiserialviewer.settings.serialConnectionSettings import SerialConnectionSettings
+from multiserialviewer.settings.textHighlighterSettings import TextHighlighterSettings
+from multiserialviewer.settings.serialViewerSettings import SerialViewerSettings, CounterSettings
+from multiserialviewer.application.serialViewerController import SerialViewerController
+from multiserialviewer.application.proxyStyle import ProxyStyle
+from multiserialviewer.icons.iconSet import IconSet
+from multiserialviewer.settings.settings import Settings
+
+
+class Application(QApplication):
+    NAME = 'MultiSerialViewer'
+
+    def __init__(self, version: str, arguments):
+        super().__init__(arguments)
+
+        self.configDir = user_config_dir(appname=Application.NAME, roaming=False, ensure_exists=True, appauthor=False)
+        self.settings: Settings = Settings(self.configDir)
+        self.settings.loadSettings()
+
+        self.captureActive: bool = False
+        self.controller = {}
+
+        colorScheme: Qt.ColorScheme = QGuiApplication.styleHints().colorScheme()
+        if colorScheme == Qt.ColorScheme.Dark:
+            self.icon_set = IconSet('google', 'CCCCCC')
+        else:
+            self.icon_set = IconSet('google', '434343')
+
+        self.mainWindow = MainWindow(f'{Application.NAME} {version}', self.icon_set)
+        self.mainWindow.updateCaptureButton(self.captureActive)
+
+        self.mainWindow.signal_showSerialViewerCreateDialog.connect(self.showSerialViewerCreateDialog)
+        self.mainWindow.signal_createSerialViewer.connect(self.createSerialViewer)
+        self.mainWindow.signal_clearAll.connect(self.clearAll)
+        self.mainWindow.signal_toggleCaptureState.connect(self.toggleCaptureState)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.persistCurrentSettings)
+        self.mainWindow.signal_aboutToBeClosed.connect(self.stopAllSerialViewer)
+        self.mainWindow.signal_editSettings.connect(self.showSettingsDialog)
+        self.mainWindow.signal_applySettings.connect(self.applyModifiedSettings)
+        self.mainWindow.signal_createTextHighlightEntry.connect(self.createTextHighlightEntry)
+
+        self.applySettings()
+        self.setStyle(ProxyStyle())
+        self.mainWindow.show()
+
+        if len(self.controller) == 0:
+            self.showSerialViewerCreateDialog()
+
+    @Slot(str)
+    def createTextHighlightEntry(self, text_to_highlight: str):
+        highlighterSettings = TextHighlighterSettings()
+        highlighterSettings.pattern = text_to_highlight
+
+        settings = copy.deepcopy(self.settings)
+        settings.textHighlighter.entries.append(highlighterSettings)
+        self.mainWindow.showSettingsDialog(settings)
+
+    @Slot()
+    def showSerialViewerCreateDialog(self):
+        already_used_ports = list(self.controller.keys())
+        self.mainWindow.showSerialViewerCreateDialog(already_used_ports)
+
+    @Slot()
+    def showSettingsDialog(self):
+        self.mainWindow.showSettingsDialog(copy.deepcopy(self.settings))
+
+    @Slot()
+    def applyModifiedSettings(self, modifiedSettings: Settings):
+        # this could cause some bugs if new values are added to Settings, but not here... -> refactor it
+        self.settings.application = modifiedSettings.application
+        self.settings.textHighlighter = modifiedSettings.textHighlighter
+        for ctrl in self.controller.values():
+            ctrl.view.setHighlighterSettings(self.settings.textHighlighter.entries)
+
+    @Slot(str, SerialConnectionSettings)
+    def createSerialViewer(self, settings: SerialViewerSettings):
+        if settings.connection.portName in self.controller:
+            raise Exception(f"{settings.connection.portName} exists already")
+
+        view = self.mainWindow.createSerialViewerWindow(settings.title,
+                                                        self.settings.textHighlighter.entries,
+                                                        size=settings.size,
+                                                        position=settings.position,
+                                                        splitterState=settings.splitterState,
+                                                        currentTabName=settings.currentTabName)
+        view.setSerialViewerSettings(settings)
+        ctrl = SerialViewerController(settings, view)
+
+        ctrl.terminated.connect(self.deleteSerialViewer, type=Qt.ConnectionType.QueuedConnection)
+        self.controller[settings.connection.portName] = ctrl
+
+        if self.captureActive:
+            if not ctrl.start():
+                self.stopAllSerialViewer()
+
+    @Slot()
+    def deleteSerialViewer(self, portName):
+        if portName in self.controller:
+            del self.controller[portName]
+        else:
+            raise Exception("Controller to remove does not exist in list")
+
+    @Slot()
+    def clearAll(self):
+        for ctrl in self.controller.values():
+            ctrl.clearAll()
+
+    @Slot(bool)
+    def toggleCaptureState(self):
+        if self.captureActive:
+            self.stopAllSerialViewer()
+        elif len(self.controller.values()) > 0:
+            self.startAllSerialViewer()
+
+    def startAllSerialViewer(self):
+        controller_started_count = 0
+        for ctrl in self.controller.values():
+            if ctrl.start():
+                controller_started_count += 1
+
+        if controller_started_count == len(self.controller):
+            self.captureActive = True
+            self.mainWindow.updateCaptureButton(self.captureActive)
+        else:
+            self.stopAllSerialViewer()
+
+    @Slot()
+    def stopAllSerialViewer(self):
+        for ctrl in self.controller.values():
+            ctrl.stop()
+        self.captureActive = False
+        self.mainWindow.updateCaptureButton(self.captureActive)
+
+    def applySettings(self):
+        self.mainWindow.resize(self.settings.mainWindow.size)
+        self.mainWindow.addToolBar(self.settings.mainWindow.toolBarArea, self.mainWindow.toolBar)
+
+        for serialViewerSetting in self.settings.serialViewer.entries:
+            self.createSerialViewer(serialViewerSetting)
+        # note: highlighter settings do not need to be applied here, because this is
+        #       done inside function createSerialViewer
+
+        if self.settings.application.restoreCaptureState:
+            if self.settings.application.captureActive:
+                self.startAllSerialViewer()
+            else:
+                self.stopAllSerialViewer()
+
+    def persistCurrentSettings(self):
+        self.settings.application.captureActive = self.captureActive
+
+        self.settings.mainWindow.size = self.mainWindow.size()
+        self.settings.mainWindow.toolBarArea = self.mainWindow.toolBarArea(self.mainWindow.toolBar)
+
+        self.settings.serialViewer.entries.clear()
+
+        ctrl: SerialViewerController
+        for ctrl in self.controller.values():
+            settings = SerialViewerSettings()
+            settings.title = ctrl.view.windowTitle()
+            settings.size = ctrl.view.size()
+            settings.position = ctrl.view.pos()
+            settings.splitterState = ctrl.view.splitter.saveState()
+            settings.currentTabName = ctrl.view.getCurrentTab()
+            settings.showNonPrintableCharsAsHex = ctrl.view.getSettingConvertNonPrintableCharsToHex()
+
+            settings.autoscrollActive = ctrl.view.autoscroll.autoscrollIsActive()
+            settings.autoscrollReactivate = ctrl.view.autoscroll.autoReactivateIsActive()
+
+            settings.counters = ctrl.counterHandler.getSettings()
+
+            connection: SerialConnectionSettings = ctrl.receiver.getSettings()
+            settings.connection.portName = connection.portName
+            settings.connection.baudrate = connection.baudrate
+            settings.connection.dataBits = connection.dataBits
+            settings.connection.parity = connection.parity
+            settings.connection.stopBits = connection.stopBits
+
+            self.settings.serialViewer.entries.append(settings)
+
+        self.settings.saveSettings()

multiserialviewer/application/counterHandler.py

@@ -0,0 +1,40 @@
+from PySide6.QtCore import QObject, Slot
+
+from multiserialviewer.settings.counterSettings import CounterSettings
+from multiserialviewer.serial_data.streamingTextExtractor import StreamingTextExtractor
+from multiserialviewer.serial_data.serialDataProcessor import SerialDataProcessor
+from multiserialviewer.application.counterTableModel import CounterTableModel
+
+
+class CounterHandler(QObject):
+    def __init__(self, settings: list[CounterSettings], dataSource: SerialDataProcessor):
+        super().__init__()
+        self.dataSource: SerialDataProcessor = dataSource
+        self.textExtractors: list[StreamingTextExtractor] = []
+        self.counterTableModel: CounterTableModel = CounterTableModel()
+
+        for counterSettings in settings:
+            self.createCounter(counterSettings.pattern)
+
+    def getSettings(self) -> list[CounterSettings]:
+        return self.counterTableModel.settings
+
+    def clear(self):
+        self.counterTableModel.resetCounters()
+
+    @Slot(str)
+    def createCounter(self, pattern: str):
+        idx = self.counterTableModel.addCounterEntry(pattern)
+        if idx >= 0:
+            textExtractor = StreamingTextExtractor(pattern, pattern)
+            self.dataSource.signal_asciiDataAvailable.connect(textExtractor.processBytesFromStream)
+            textExtractor.signal_textExtracted.connect(self.counterTableModel.incrementCounterValue)
+            self.textExtractors.append(textExtractor)
+
+    @Slot(int)
+    def removeCounter(self, index: int):
+        if self.counterTableModel.removeCounterEntry(index):
+            textExtractor = self.textExtractors[index]
+            self.dataSource.signal_asciiDataAvailable.disconnect(textExtractor.processBytesFromStream)
+            textExtractor.signal_textExtracted.disconnect(self.counterTableModel.incrementCounterValue)
+            del self.textExtractors[index]

multiserialviewer/application/counterTableModel.py

@@ -0,0 +1,82 @@
+from PySide6.QtCore import Qt, QAbstractTableModel, QModelIndex, Slot
+from multiserialviewer.settings.counterSettings import CounterSettings
+
+
+class CounterTableModel(QAbstractTableModel):
+    class CounterEntry:
+        def __init__(self, pattern: str, initialValue: int = 0):
+            self.pattern: str = pattern
+            self.value: int = initialValue
+
+        def increment(self):
+            self.value += 1
+
+    def __init__(self):
+        QAbstractTableModel.__init__(self)
+
+        self.settings: list[CounterSettings] = []
+        self.entries: list[CounterTableModel.CounterEntry] = []
+        self.patternToIndex: dict[str, int] = {}
+
+    @Slot()
+    def incrementCounterValue(self, pattern: str, unused: object):
+        if pattern in self.patternToIndex:
+            rowIndex = self.patternToIndex[pattern]
+            self.entries[rowIndex].increment()
+            self.dataChanged.emit(self.index(rowIndex, 1), self.index(rowIndex, 1))
+
+    def rowCount(self, parent=QModelIndex()):
+        return len(self.entries)
+
+    def columnCount(self, parent=QModelIndex()):
+        return 2  # pattern and value
+
+    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return None
+        if orientation == Qt.Orientation.Horizontal:
+            return ("Text/Pattern", "Counted")[section]
+        else:  # vertical
+            return f"{section}"
+
+    def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
+        column = index.column()
+        row = index.row()
+
+        if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
+            if column == 0:
+                return self.entries[row].pattern
+            elif column == 1:
+                return str(self.entries[row].value)
+        return None
+
+    def resetCounters(self):
+        for idx, entry in enumerate(self.entries):
+            entry.value = 0
+            self.dataChanged.emit(self.index(idx, 1), self.index(idx, 1))
+
+    def addCounterEntry(self, pattern) -> int:
+        rowIdx = -1
+        if pattern not in self.patternToIndex.keys():
+            rowIdx = len(self.settings)
+            self.beginInsertRows(QModelIndex(), rowIdx, rowIdx)
+            self.patternToIndex[pattern] = rowIdx
+            self.settings.append(CounterSettings(pattern))
+            self.entries.append(CounterTableModel.CounterEntry(pattern))
+            self.endInsertRows()
+
+            assert len(self.entries) == len(self.settings)
+        return rowIdx
+
+    def removeCounterEntry(self, index: int) -> bool:
+        assert len(self.entries) == len(self.settings)
+
+        if index < len(self.settings):
+            self.beginRemoveRows(QModelIndex(), index, index)
+            del self.settings[index]
+            del self.patternToIndex[self.entries[index].pattern]
+            del self.entries[index]
+            self.endRemoveRows()
+            return True
+        else:
+            return False

multiserialviewer/application/proxyStyle.py

@@ -0,0 +1,10 @@
+from PySide6.QtWidgets import QProxyStyle, QStyle
+
+
+class ProxyStyle(QProxyStyle):
+    def subElementRect(self, element, opt, widget=None):
+        if element == QStyle.SE_ItemViewItemCheckIndicator and not opt.text:
+            rect = super().subElementRect(element, opt, widget)
+            rect.moveCenter(opt.rect.center())
+            return rect
+        return super().subElementRect(element, opt, widget)

multiserialviewer/application/serialViewerController.py

@@ -0,0 +1,70 @@
+from PySide6.QtCore import QObject, Slot, Signal
+from datetime import datetime
+
+from multiserialviewer.settings.serialViewerSettings import SerialViewerSettings
+from multiserialviewer.gui_viewer.serialViewerWindow import SerialViewerWindow
+from multiserialviewer.serial_data.serialDataReceiver import SerialDataReceiver
+from multiserialviewer.serial_data.serialDataProcessor import SerialDataProcessor
+from multiserialviewer.application.counterHandler import CounterHandler
+
+
+class SerialViewerController(QObject):
+    terminated = Signal(str)
+
+    def __init__(self, settings: SerialViewerSettings, view: SerialViewerWindow):
+        super().__init__()
+
+        self.receiver: SerialDataReceiver = SerialDataReceiver(settings.connection)
+        self.processor: SerialDataProcessor = SerialDataProcessor()
+        self.counterHandler: CounterHandler = CounterHandler(settings.counters, self.processor)
+
+        self.processor.setConvertNonPrintableCharsToHex(settings.showNonPrintableCharsAsHex)
+
+        self.view: SerialViewerWindow = view
+        self.view.counterWidget.setCounterTableModel(self.counterHandler.counterTableModel)
+        self.view.textEdit.signal_createCounter.connect(self.counterHandler.createCounter)
+        self.view.textEdit.signal_createCounter.connect(self.view.selectTab_Count)
+        self.view.counterWidget.signal_createCounter.connect(self.counterHandler.createCounter)
+        self.view.counterWidget.signal_removeCounter.connect(self.counterHandler.removeCounter)
+        self.view.signal_settingConvertNonPrintableCharsToHexChanged.connect(self.processor.setConvertNonPrintableCharsToHex)
+
+        self.processor.signal_asciiDataAvailable.connect(self.view.appendData)
+        self.receiver.signal_rawDataAvailable.connect(self.processor.handleRawData)
+        self.view.signal_closed.connect(self.terminate)
+
+    def start(self) -> bool:
+        if self.receiver.openPort():
+            self.processor.start()
+            self.receiver.start()
+
+            self.show_message(f'Opened {self.receiver.getSettings().portName}')
+
+            return True
+        else:
+            self.show_error(f'Failed to open {self.receiver.getSettings().portName}')
+            return False
+
+    def stop(self):
+        if self.receiver.isReceiving():
+            self.receiver.stop()
+            self.receiver.closePort()
+            self.processor.stop()
+            self.show_message(f'Closed {self.receiver.getSettings().portName}')
+
+    def clearAll(self):
+        self.view.clear()
+        self.counterHandler.clear()
+
+    def show_message(self, text):
+        self.view.appendData(f'\n[MSG: {datetime.now().strftime("%Y/%b/%d %H:%M:%S")}: {text} :MSG]\n')
+
+    def show_error(self, text):
+        self.view.appendData(f'\n[ERR: {datetime.now().strftime("%Y/%b/%d %H:%M:%S")}: {text} :ERR]\n')
+
+    @Slot()
+    def terminate(self):
+        # view is already closed
+        self.receiver.stop()
+        self.receiver.closePort()
+        self.processor.stop()
+        self.terminated.emit(self.receiver.getSettings().portName)

multiserialviewer/gui_main/mainWindow.py

@@ -0,0 +1,148 @@
+from PySide6.QtWidgets import QMdiArea, QMainWindow, QToolBar, QMenu, QWidget, QSizePolicy, QScrollArea
+from PySide6.QtCore import Qt, QSize, QPoint, Signal, Slot, QByteArray
+from PySide6.QtGui import QAction
+from typing import List
+
+from multiserialviewer.ui_files.uiFileHelper import createWidgetFromUiFile
+from multiserialviewer.gui_viewer.serialViewerWindow import SerialViewerWindow
+from multiserialviewer.gui_viewer.serialViewerCreateDialog import SerialViewerCreateDialog
+from multiserialviewer.gui_main.settingsDialog import SettingsDialog
+from multiserialviewer.settings.settings import Settings
+from multiserialviewer.settings.textHighlighterSettings import TextHighlighterSettings
+from multiserialviewer.settings.serialViewerSettings import SerialViewerSettings
+from multiserialviewer.icons.iconSet import IconSet
+
+
+class MainWindow(QMainWindow):
+    signal_showSerialViewerCreateDialog: Signal = Signal()
+    signal_createSerialViewer: Signal = Signal(SerialViewerSettings)
+    signal_clearAll: Signal = Signal()
+    signal_toggleCaptureState: Signal = Signal()
+    signal_aboutToBeClosed: Signal = Signal()
+    signal_editSettings: Signal = Signal()
+    signal_applySettings: Signal = Signal(object)
+    signal_createTextHighlightEntry: Signal = Signal(str)
+    signal_openSettingsDirectory: Signal = Signal()
+
+    def __init__(self, title: str, iconSet: IconSet):
+        super(MainWindow, self).__init__()
+        self.iconSet = iconSet
+        self.actions = self.__createActions()
+        self.__connectActions()
+        self.toolBar: QToolBar = self.__createToolBar()
+
+        widget = createWidgetFromUiFile("mainWindow.ui")
+
+        self.setWindowTitle(title)
+        self.setWindowIcon(iconSet.getAppIcon())
+        self.setCentralWidget(widget)
+        self.mdiArea: QMdiArea = widget.findChild(QMdiArea, 'mdiArea')
+        self.updateCaptureButton(False)
+
+
+    def __createActions(self):
+        actions = {}
+
+        action: QAction = QAction(icon=self.iconSet.getSettingsIcon(), text="Settings", parent=self)
+        action.setToolTip("Edit settings")
+        actions['openSettingsDialog'] = action
+
+        action: QAction = QAction(icon=self.iconSet.getAddIcon(), text="Create Viewer", parent=self)
+        action.setToolTip("Create additional SerialViewer window")
+        actions['createSerialViewer'] = action
+
+        action: QAction = QAction(icon=self.iconSet.getClearContentIcon(), text="Clear Content", parent=self)
+        action.setToolTip("Remove received serial data")
+        actions['clearContent'] = action
+
+        action: QAction = QAction(icon=self.iconSet.getCaptureStartIcon(), text="Start Capture", parent=self)
+        action.setToolTip("Start/stop receiving serial data")
+        actions['capture'] = action
+
+        action: QAction = QAction(icon=self.iconSet.getTileIcon(), text="Arrange", parent=self)
+        action.setToolTip("Automatically arrange all SerialViewer windows side by side")
+        actions['arrangeSerialViewerWindows'] = action
+
+        return actions
+
+    def __connectActions(self):
+        self.actions['openSettingsDialog'].triggered.connect(self.signal_editSettings)
+        self.actions['createSerialViewer'].triggered.connect(self.signal_showSerialViewerCreateDialog)
+        self.actions['clearContent'].triggered.connect(self.signal_clearAll)
+        self.actions['capture'].triggered.connect(self.signal_toggleCaptureState)
+        self.actions['arrangeSerialViewerWindows'].triggered.connect(self.arrangeWindowsInTile)
+
+    def __createToolBar(self) -> QToolBar:
+        toolBar: QToolBar = QToolBar(self)
+        toolBar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextUnderIcon)
+        toolBar.setIconSize(QSize(32, 32))
+
+        toolBar.addAction(self.actions['createSerialViewer'])
+        toolBar.addAction(self.actions['capture'])
+        toolBar.addAction(self.actions['clearContent'])
+
+        # expanding space
+        space = QWidget()
+        space.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        toolBar.addWidget(space)
+
+        toolBar.addSeparator()
+        toolBar.addAction(self.actions['arrangeSerialViewerWindows'])
+        toolBar.addSeparator()
+
+        toolBar.addAction(self.actions['openSettingsDialog'])
+        return toolBar
+
+    def showSerialViewerCreateDialog(self, disabled_ports: list):
+        dialog = SerialViewerCreateDialog(self)
+        dialog.disablePorts(disabled_ports)
+        if dialog.exec():
+            self.signal_createSerialViewer.emit(dialog.getSerialViewerSettings())
+
+    def createSerialViewerWindow(self,
+                                 view_title: str,
+                                 highlighterSettings: List[TextHighlighterSettings],
+                                 size: QSize = None,
+                                 position: QPoint = None,
+                                 splitterState: QByteArray = None,
+                                 currentTabName: str = None):
+        view = SerialViewerWindow(view_title, self.iconSet)
+        view.setHighlighterSettings(highlighterSettings)
+        if size:
+            view.resize(size)
+        if position:
+            view.move(position)
+        if splitterState:
+            view.splitter.restoreState(splitterState)
+        if currentTabName:
+            view.setCurrentTab(currentTabName)
+
+        self.mdiArea.addSubWindow(view)
+        view.signal_createTextHighlightEntry.connect(self.signal_createTextHighlightEntry)
+        view.show()
+        return view
+
+    def showSettingsDialog(self, settings: Settings):
+        dialog = SettingsDialog(self, settings, self.iconSet)
+        if dialog.exec():
+            self.signal_applySettings.emit(dialog.settings)
+
+    def updateCaptureButton(self, captureState):
+        if captureState:
+            self.actions['capture'].setIcon(self.iconSet.getCaptureStopIcon())
+            self.actions['capture'].setText('Stop Capture')
+        else:
+            self.actions['capture'].setIcon(self.iconSet.getCaptureStartIcon())
+            self.actions['capture'].setText('Start Capture')
+
+    def closeEvent(self, event):
+        self.signal_aboutToBeClosed.emit()
+        event.accept()
+
+    @Slot()
+    def arrangeWindowsInCascade(self):
+        self.mdiArea.cascadeSubWindows()
+
+    @Slot()
+    def arrangeWindowsInTile(self):
+        self.mdiArea.tileSubWindows()