sparkserial 0.1.0__tar.gz

sparkserial-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Spark Electronics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sparkserial-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: sparkserial
+Version: 0.1.0
+Summary: A premium Serial Utility Tool for professional hardware testing.
+Author-email: Spark Electronics <info@sparkelectronics.com>
+License: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyobjc-framework-cocoa>=12.1
+Requires-Dist: pyqt6>=6.10.2
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# SparkSerial Pro
+
+A premium serial communication and hardware testing tool built with Python and PyQt6. Inspired by professional tools like Docklight, **SparkSerial** provides a modern, high-performance interface for engineers and developers.
+
+![Icon](sparkserial/assets/icon.png)
+
+## Features
+
+- **Professional Configuration**: Comprehensive port settings (Baudrate up to 921600, Data Bits, Parity, Stop Bits, Flow Control).
+- **Command Shortcuts**: Save frequently used commands (Text or Hex) for quick access and batch testing.
+- **Advanced Terminal**: Real-time logging with timestamps, Hex view, and autoscroll.
+- **Persistence**: Automatically saves your command library and connection preferences.
+- **Modern UI**: Dark-mode aesthetic with optimized layout for hardware debugging.
+- **Cross-Platform**: Designed for macOS, Windows, and Linux.
+
+## Installation
+
+### From PyPI (Coming Soon)
+```bash
+pip install sparkserial
+```
+
+### Local Development
+Ensure you have [uv](https://github.com/astral-sh/uv) installed:
+
+```bash
+./setup.sh
+./run.sh
+```
+
+## Usage
+
+After installing via pip, you can launch the tool directly:
+```bash
+sparkserial
+```
+
+## Technologies Used
+
+- **UI Framework**: PyQt6
+- **Serial Communication**: PySerial
+- **Backend Architecture**: Worker-thread pattern for non-blocking I/O.
+- **Styling**: Custom CSS for premium dark-mode aesthetics.

sparkserial-0.1.0/README.md

@@ -0,0 +1,43 @@
+# SparkSerial Pro
+
+A premium serial communication and hardware testing tool built with Python and PyQt6. Inspired by professional tools like Docklight, **SparkSerial** provides a modern, high-performance interface for engineers and developers.
+
+![Icon](sparkserial/assets/icon.png)
+
+## Features
+
+- **Professional Configuration**: Comprehensive port settings (Baudrate up to 921600, Data Bits, Parity, Stop Bits, Flow Control).
+- **Command Shortcuts**: Save frequently used commands (Text or Hex) for quick access and batch testing.
+- **Advanced Terminal**: Real-time logging with timestamps, Hex view, and autoscroll.
+- **Persistence**: Automatically saves your command library and connection preferences.
+- **Modern UI**: Dark-mode aesthetic with optimized layout for hardware debugging.
+- **Cross-Platform**: Designed for macOS, Windows, and Linux.
+
+## Installation
+
+### From PyPI (Coming Soon)
+```bash
+pip install sparkserial
+```
+
+### Local Development
+Ensure you have [uv](https://github.com/astral-sh/uv) installed:
+
+```bash
+./setup.sh
+./run.sh
+```
+
+## Usage
+
+After installing via pip, you can launch the tool directly:
+```bash
+sparkserial
+```
+
+## Technologies Used
+
+- **UI Framework**: PyQt6
+- **Serial Communication**: PySerial
+- **Backend Architecture**: Worker-thread pattern for non-blocking I/O.
+- **Styling**: Custom CSS for premium dark-mode aesthetics.

sparkserial-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "sparkserial"
+version = "0.1.0"
+description = "A premium Serial Utility Tool for professional hardware testing."
+authors = [
+    { name = "Spark Electronics", email = "info@sparkelectronics.com" }
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "pyobjc-framework-cocoa>=12.1",
+    "pyqt6>=6.10.2",
+    "pyserial>=3.5",
+]
+license = { text = "MIT" }
+
+[project.scripts]
+sparkserial = "sparkserial.main:main"
+
+[tool.setuptools]
+packages = ["sparkserial", "sparkserial.core", "sparkserial.gui"]
+
+[tool.setuptools.package-data]
+sparkserial = ["assets/*.png"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

sparkserial-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sparkserial-0.1.0/sparkserial/core/command_manager.py

@@ -0,0 +1,58 @@
+import json
+import os
+
+class CommandManager:
+    def __init__(self, filename="saved_commands.json"):
+        self.filename = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), filename)
+        self.commands = []
+        self.load_commands()
+
+    def load_commands(self):
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, 'r') as f:
+                    self.commands = json.load(f)
+            except Exception as e:
+                print(f"Error loading commands: {e}")
+                self.commands = []
+        
+        if not self.commands:
+            # Default sample commands
+            self.commands = [
+                {"name": "Check Connection", "command": "AT", "is_hex": False},
+                {"name": "Get Device Info", "command": "ATI", "is_hex": False},
+                {"name": "Reset Device", "command": "ATZ", "is_hex": False}
+            ]
+            self.save_commands()
+
+    def save_commands(self):
+        try:
+            with open(self.filename, 'w') as f:
+                json.dump(self.commands, f, indent=4)
+        except Exception as e:
+            print(f"Error saving commands: {e}")
+
+    def add_command(self, name, command, is_hex=False):
+        self.commands.append({
+            "name": name,
+            "command": command,
+            "is_hex": is_hex
+        })
+        self.save_commands()
+
+    def update_command(self, index, name, command, is_hex=False):
+        if 0 <= index < len(self.commands):
+            self.commands[index] = {
+                "name": name,
+                "command": command,
+                "is_hex": is_hex
+            }
+            self.save_commands()
+
+    def delete_command(self, index):
+        if 0 <= index < len(self.commands):
+            self.commands.pop(index)
+            self.save_commands()
+
+    def get_commands(self):
+        return self.commands

sparkserial-0.1.0/sparkserial/core/serial_manager.py

@@ -0,0 +1,101 @@
+import serial
+import serial.tools.list_ports
+from PyQt6.QtCore import QThread, pyqtSignal, QObject
+import time
+
+class SerialWorker(QObject):
+    data_received = pyqtSignal(bytes)
+    error_occurred = pyqtSignal(str)
+    connection_status = pyqtSignal(bool)
+
+    def __init__(self, port_name, baudrate, bytesize, parity, stopbits, flowcontrol):
+        super().__init__()
+        self.port_name = port_name
+        self.baudrate = baudrate
+        self.bytesize = bytesize
+        self.parity = parity
+        self.stopbits = stopbits
+        self.flowcontrol = flowcontrol
+        self.serial_port = None
+        self.running = False
+
+    def run(self):
+        try:
+            self.serial_port = serial.Serial(
+                port=self.port_name,
+                baudrate=self.baudrate,
+                bytesize=self.bytesize,
+                parity=self.parity,
+                stopbits=self.stopbits,
+                xonxoff=False,
+                rtscts=self.flowcontrol == "Hardware (RTS/CTS)",
+                dsrdtr=False,
+                timeout=0.1
+            )
+            self.running = True
+            self.connection_status.emit(True)
+
+            while self.running:
+                if self.serial_port.in_waiting > 0:
+                    data = self.serial_port.read(self.serial_port.in_waiting)
+                    if data:
+                        self.data_received.emit(data)
+                time.sleep(0.01)
+
+        except Exception as e:
+            self.error_occurred.emit(str(e))
+        finally:
+            if self.serial_port and self.serial_port.is_open:
+                self.serial_port.close()
+            self.connection_status.emit(False)
+
+    def stop(self):
+        self.running = False
+
+    def send_data(self, data):
+        if self.serial_port and self.serial_port.is_open:
+            try:
+                self.serial_port.write(data)
+            except Exception as e:
+                self.error_occurred.emit(str(e))
+
+class SerialManager(QObject):
+    def __init__(self):
+        super().__init__()
+        self.worker = None
+        self.thread = None
+
+    def get_available_ports(self):
+        return [port.device for port in serial.tools.list_ports.comports()]
+
+    def connect(self, settings):
+        if self.thread and self.thread.isRunning():
+            return
+
+        self.thread = QThread()
+        self.worker = SerialWorker(
+            settings['port'],
+            settings['baudrate'],
+            settings['bytesize'],
+            settings['parity'],
+            settings['stopbits'],
+            settings['flowcontrol']
+        )
+        self.worker.moveToThread(self.thread)
+        
+        self.thread.started.connect(self.worker.run)
+        self.worker.connection_status.connect(self._handle_status)
+        
+        self.thread.start()
+        return self.worker
+
+    def disconnect(self):
+        if self.worker:
+            self.worker.stop()
+        if self.thread:
+            self.thread.quit()
+            self.thread.wait()
+
+    def _handle_status(self, status):
+        if not status:
+            self.disconnect()

sparkserial-0.1.0/sparkserial/gui/main_window.py

@@ -0,0 +1,504 @@
+import sys
+from PyQt6.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
+                             QGridLayout, QGroupBox, QLabel, QComboBox, 
+                             QPushButton, QPlainTextEdit, QLineEdit, QStatusBar,
+                             QCheckBox, QSplitter, QListWidget, QListWidgetItem,
+                             QDialog, QFormLayout, QDialogButtonBox, QMessageBox)
+from PyQt6.QtCore import Qt, pyqtSlot
+from PyQt6.QtGui import QIcon, QTextCursor
+import serial
+from sparkserial.core.serial_manager import SerialManager
+from sparkserial.core.command_manager import CommandManager
+from sparkserial.gui.styles import get_stylesheet
+import os
+import json
+
+class CommandDialog(QDialog):
+    def __init__(self, parent=None, command_info=None):
+        super().__init__(parent)
+        self.setWindowTitle("Add Command" if not command_info else "Edit Command")
+        self.setMinimumWidth(400)
+        
+        layout = QVBoxLayout(self)
+        form_layout = QFormLayout()
+        
+        self.name_input = QLineEdit()
+        self.name_input.setPlaceholderText("e.g., Get Version")
+        if command_info:
+            self.name_input.setText(command_info.get('name', ''))
+            
+        self.command_input = QLineEdit()
+        self.command_input.setPlaceholderText("e.g., AT+VER")
+        if command_info:
+            self.command_input.setText(command_info.get('command', ''))
+            
+        self.hex_check = QCheckBox("Send as Hex")
+        if command_info:
+            self.hex_check.setChecked(command_info.get('is_hex', False))
+            
+        form_layout.addRow("Name:", self.name_input)
+        form_layout.addRow("Command:", self.command_input)
+        form_layout.addRow("", self.hex_check)
+        
+        layout.addLayout(form_layout)
+        
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def get_data(self):
+        return {
+            "name": self.name_input.text().strip(),
+            "command": self.command_input.text().strip(),
+            "is_hex": self.hex_check.isChecked()
+        }
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.serial_manager = SerialManager()
+        self.command_manager = CommandManager()
+        self.current_worker = None
+        
+        self.init_ui()
+        self.apply_styles()
+        self.refresh_ports()
+
+    def init_ui(self):
+        self.setWindowTitle("SparkSerial Pro")
+        self.setMinimumSize(900, 600)
+        
+        # Set icon
+        icon_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "assets", "icon.png")
+        if os.path.exists(icon_path):
+            self.setWindowIcon(QIcon(icon_path))
+
+        main_widget = QWidget()
+        self.setCentralWidget(main_widget)
+        main_layout = QHBoxLayout(main_widget)
+
+        # Left Panel Tool Widget
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        left_panel.setFixedWidth(400)  # Increased slightly more for complex port names
+
+        # Connection Settings (Compact)
+        config_group = QGroupBox("Configuration")
+        config_grid = QGridLayout()
+        config_grid.setSpacing(10)  # Increased spacing for clarity
+        config_grid.setContentsMargins(10, 15, 10, 10)
+        config_grid.addWidget(QLabel("Port:"), 0, 0)
+        port_row = QHBoxLayout()
+        self.port_combo = QComboBox()
+        # Remove rigid fixed heights, use standard sizing
+        port_row.addWidget(self.port_combo, 1)
+        refresh_btn = QPushButton("↻")
+        refresh_btn.setToolTip("Refresh Ports")
+        refresh_btn.setFixedWidth(40)
+        refresh_btn.clicked.connect(self.refresh_ports)
+        port_row.addWidget(refresh_btn)
+        config_grid.addLayout(port_row, 0, 1, 1, 3)
+
+        # Baud & Data Bits
+        config_grid.addWidget(QLabel("Baud:"), 1, 0)
+        self.baud_combo = QComboBox()
+        self.baud_combo.addItems(["1200", "2400", "4800", "9600", "19200", "38400", "57600", "115200", "230400", "460800", "921600"])
+        self.baud_combo.setCurrentText("9600")
+        config_grid.addWidget(self.baud_combo, 1, 1)
+
+        config_grid.addWidget(QLabel("Data:"), 1, 2)
+        self.data_combo = QComboBox()
+        self.data_combo.addItems(["5", "6", "7", "8"])
+        self.data_combo.setCurrentText("8")
+        config_grid.addWidget(self.data_combo, 1, 3)
+
+        # Parity & Stop Bits
+        config_grid.addWidget(QLabel("Parity:"), 2, 0)
+        self.parity_combo = QComboBox()
+        self.parity_combo.addItems(["None", "Even", "Odd", "Mark", "Space"])
+        config_grid.addWidget(self.parity_combo, 2, 1)
+
+        config_grid.addWidget(QLabel("Stop:"), 2, 2)
+        self.stop_combo = QComboBox()
+        self.stop_combo.addItems(["1", "1.5", "2"])
+        config_grid.addWidget(self.stop_combo, 2, 3)
+
+        # Flow Control
+        config_grid.addWidget(QLabel("Flow:"), 3, 0)
+        self.flow_combo = QComboBox()
+        self.flow_combo.addItems(["None", "RTS/CTS", "XON/XOFF"])
+        config_grid.addWidget(self.flow_combo, 3, 1, 1, 3)
+
+        config_group.setLayout(config_grid)
+        left_layout.addWidget(config_group)
+
+        # Connect/Disconnect Button
+        self.connect_btn = QPushButton("Connect Device")
+        self.connect_btn.setObjectName("connectButton")
+        self.connect_btn.setMinimumHeight(40)  # Make it prominent
+        self.connect_btn.clicked.connect(self.toggle_connection)
+        left_layout.addWidget(self.connect_btn)
+
+        # Saved Commands (Now on left)
+        saved_group = QGroupBox("Command Shortcuts")
+        saved_group_layout = QVBoxLayout()
+        saved_group_layout.setContentsMargins(10, 15, 10, 10)
+        
+        self.commands_list = QListWidget()
+        self.commands_list.itemDoubleClicked.connect(self.load_saved_command)
+        saved_group_layout.addWidget(self.commands_list)
+        
+        cmd_btns = QHBoxLayout()
+        add_cmd_btn = QPushButton("Add")
+        add_cmd_btn.clicked.connect(self.add_command_dialog)
+        edit_cmd_btn = QPushButton("Edit")
+        edit_cmd_btn.clicked.connect(self.edit_command_dialog)
+        del_cmd_btn = QPushButton("Delete")
+        del_cmd_btn.clicked.connect(self.delete_command)
+        
+        # Consistent industry styling
+        for btn in [add_cmd_btn, edit_cmd_btn, del_cmd_btn]:
+            btn.setMinimumHeight(32)
+        
+        cmd_btns.addWidget(add_cmd_btn)
+        cmd_btns.addWidget(edit_cmd_btn)
+        cmd_btns.addWidget(del_cmd_btn)
+        saved_group_layout.addLayout(cmd_btns)
+        
+        saved_group.setLayout(saved_group_layout)
+        left_layout.addWidget(saved_group)
+
+        # Right Panel: Terminal and Tools
+        right_panel = QWidget()
+        right_layout = QVBoxLayout(right_panel)
+
+        # Terminal Settings
+        term_settings = QHBoxLayout()
+        self.autoscroll_check = QCheckBox("Autoscroll")
+        self.autoscroll_check.setChecked(True)
+        self.hex_view_check = QCheckBox("Hex View")
+        self.timestamp_check = QCheckBox("Timestamps")
+        self.logging_check = QCheckBox("Log to File")
+        self.logging_check.toggled.connect(self.toggle_logging)
+        
+        clear_btn = QPushButton("Clear")
+        clear_btn.clicked.connect(self.clear_terminal)
+        
+        term_settings.addWidget(self.autoscroll_check)
+        term_settings.addWidget(self.hex_view_check)
+        term_settings.addWidget(self.timestamp_check)
+        term_settings.addWidget(self.logging_check)
+        term_settings.addStretch()
+        term_settings.addWidget(clear_btn)
+        
+        right_layout.addLayout(term_settings)
+
+        # Terminal Output
+        self.terminal = QPlainTextEdit()
+        self.terminal.setReadOnly(True)
+        right_layout.addWidget(self.terminal)
+
+        # Input Area
+        input_group = QGroupBox("Send Command")
+        input_layout = QVBoxLayout()
+        
+        send_row = QHBoxLayout()
+        self.command_input = QLineEdit()
+        self.command_input.setPlaceholderText("Enter command...")
+        self.command_input.returnPressed.connect(self.send_command)
+        
+        self.line_ending_combo = QComboBox()
+        self.line_ending_combo.addItems(["None", "CR", "LF", "CR+LF"])
+        self.line_ending_combo.setCurrentText("CR+LF")
+        
+        send_btn = QPushButton("Send")
+        send_btn.clicked.connect(self.send_command)
+        
+        send_row.addWidget(self.command_input)
+        send_row.addWidget(self.line_ending_combo)
+        send_row.addWidget(send_btn)
+        
+        input_layout.addLayout(send_row)
+        
+        options_row = QHBoxLayout()
+        self.send_hex_check = QCheckBox("Send as Hex")
+        self.log_sent_check = QCheckBox("Log Sent")
+        self.log_sent_check.setChecked(True)
+        options_row.addWidget(self.send_hex_check)
+        options_row.addWidget(self.log_sent_check)
+        options_row.addStretch()
+        
+        input_layout.addLayout(options_row)
+        input_group.setLayout(input_layout)
+        right_layout.addWidget(input_group)
+
+        # Add panels to main layout
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+        splitter.addWidget(left_panel)
+        splitter.addWidget(right_panel)
+        splitter.setStretchFactor(1, 1) # Terminal panel gets more space
+        main_layout.addWidget(splitter)
+        
+        self.refresh_commands_list()
+
+        # Status Bar
+        self.status_bar = QStatusBar()
+        self.setStatusBar(self.status_bar)
+        self.status_bar.showMessage("Disconnected")
+        
+        # Logging State
+        self.log_file = None
+        self.log_path = None
+
+    def apply_styles(self):
+        self.setStyleSheet(get_stylesheet())
+
+    def refresh_ports(self):
+        current_port = self.port_combo.currentText()
+        self.port_combo.clear()
+        ports = self.serial_manager.get_available_ports()
+        self.port_combo.addItems(ports)
+        if current_port in ports:
+            self.port_combo.setCurrentText(current_port)
+
+    def toggle_connection(self):
+        if self.current_worker:
+            self.disconnect_serial()
+        else:
+            self.connect_serial()
+
+    def toggle_logging(self, enabled):
+        if enabled:
+            from PyQt6.QtWidgets import QFileDialog
+            from datetime import datetime
+            
+            default_name = f"serial_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+            initial_path = os.path.join(os.getcwd(), "logs", default_name)
+            
+            # Ensure logs directory exists as a default suggestion
+            if not os.path.exists("logs"):
+                os.makedirs("logs")
+
+            file_path, _ = QFileDialog.getSaveFileName(
+                self,
+                "Select Log File Location",
+                initial_path,
+                "Text Files (*.txt);;All Files (*)"
+            )
+
+            if file_path:
+                try:
+                    self.log_path = file_path
+                    self.log_file = open(self.log_path, "a", encoding="utf-8")
+                    self.status_bar.showMessage(f"Logging to: {os.path.basename(self.log_path)}")
+                except Exception as e:
+                    self.status_bar.showMessage(f"Logging Error: {str(e)}")
+                    self.logging_check.setChecked(False)
+            else:
+                # User cancelled the dialog
+                self.logging_check.setChecked(False)
+        else:
+            if self.log_file:
+                self.log_file.close()
+                self.log_file = None
+                self.status_bar.showMessage("Logging stopped")
+
+    def connect_serial(self):
+        port = self.port_combo.currentText()
+        if not port:
+            self.status_bar.showMessage("Error: No port selected")
+            return
+
+        settings = {
+            'port': port,
+            'baudrate': int(self.baud_combo.currentText()),
+            'bytesize': int(self.data_combo.currentText()),
+            'parity': getattr(serial, f"PARITY_{self.parity_combo.currentText().upper()}"),
+            'stopbits': {
+                "1": serial.STOPBITS_ONE,
+                "1.5": serial.STOPBITS_ONE_POINT_FIVE,
+                "2": serial.STOPBITS_TWO
+            }[self.stop_combo.currentText()],
+            'flowcontrol': self.flow_combo.currentText()
+        }
+
+        self.current_worker = self.serial_manager.connect(settings)
+        if self.current_worker:
+            self.current_worker.data_received.connect(self.handle_data)
+            self.current_worker.error_occurred.connect(self.handle_error)
+            self.current_worker.connection_status.connect(self.update_connection_ui)
+            
+            self.connect_btn.setText("Disconnect")
+            self.connect_btn.setObjectName("disconnectButton")
+            self.apply_styles()
+            self.status_bar.showMessage(f"Connected to {port}")
+
+    def disconnect_serial(self):
+        self.serial_manager.disconnect()
+        self.current_worker = None
+        self.connect_btn.setText("Connect")
+        self.connect_btn.setObjectName("connectButton")
+        self.apply_styles()
+        self.status_bar.showMessage("Disconnected")
+
+    @pyqtSlot(bool)
+    def update_connection_ui(self, connected):
+        if not connected:
+            self.disconnect_serial()
+
+    @pyqtSlot(bytes)
+    def handle_data(self, data):
+        from datetime import datetime
+        now = datetime.now()
+        
+        if self.hex_view_check.isChecked():
+            text = " ".join([f"{b:02X}" for b in data]) + " "
+        else:
+            try:
+                text = data.decode('utf-8', errors='replace')
+            except:
+                text = str(data)
+
+        timestamp_str = now.strftime("[%H:%M:%S.%f] ")[:-4] + "] "
+        
+        # Display logic
+        display_text = text
+        if self.timestamp_check.isChecked():
+            if not self.terminal.toPlainText() or self.terminal.toPlainText().endswith('\n'):
+                display_text = timestamp_str + display_text
+            display_text = display_text.replace('\n', f'\n{timestamp_str}')
+
+        self.terminal.moveCursor(QTextCursor.MoveOperation.End)
+        self.terminal.insertPlainText(display_text)
+        
+        if self.autoscroll_check.isChecked():
+            self.terminal.verticalScrollBar().setValue(self.terminal.verticalScrollBar().maximum())
+
+        # Logging logic
+        if self.log_file:
+            log_entry = text
+            if self.timestamp_check.isChecked() or True: # Always timestamp logs for better utility
+                if not hasattr(self, '_log_at_newline') or self._log_at_newline:
+                    log_entry = f"RX {timestamp_str}{log_entry}"
+                log_entry = log_entry.replace('\n', f'\nRX {timestamp_str}')
+                self._log_at_newline = text.endswith('\n')
+            
+            self.log_file.write(log_entry)
+            self.log_file.flush()
+
+    @pyqtSlot(str)
+    def handle_error(self, message):
+        self.status_bar.showMessage(f"Error: {message}")
+        self.disconnect_serial()
+
+    def send_command(self):
+        if not self.current_worker:
+            self.status_bar.showMessage("Error: Not connected")
+            return
+
+        command = self.command_input.text()
+        if not command:
+            return
+
+        try:
+            if self.send_hex_check.isChecked():
+                data = bytes.fromhex(command.replace(" ", ""))
+            else:
+                data = command.encode('utf-8')
+                
+            # Add line ending
+            ending = self.line_ending_combo.currentText()
+            line_end = b''
+            if ending == "CR":
+                line_end = b'\r'
+            elif ending == "LF":
+                line_end = b'\n'
+            elif ending == "CR+LF":
+                line_end = b'\r\n'
+            
+            full_data = data + line_end
+
+            self.current_worker.send_data(full_data)
+            
+            # Log sent command
+            if self.log_file and self.log_sent_check.isChecked():
+                from datetime import datetime
+                ts = datetime.now().strftime("[%H:%M:%S.%f] ")[:-4] + "] "
+                sent_text = command
+                if self.send_hex_check.isChecked():
+                    sent_text = f"HEX({command})"
+                self.log_file.write(f"TX {ts}{sent_text}\n")
+                self.log_file.flush()
+                self._log_at_newline = True
+
+            self.command_input.clear()
+        except Exception as e:
+            self.status_bar.showMessage(f"Send Error: {str(e)}")
+
+    def clear_terminal(self):
+        self.terminal.clear()
+
+    # Saved Commands Methods
+    def refresh_commands_list(self):
+        self.commands_list.clear()
+        for cmd in self.command_manager.get_commands():
+            display_text = f"{cmd['name']} : {cmd['command']}"
+            item = QListWidgetItem(display_text)
+            tooltip = f"Command: {cmd['command']}\nType: {'Hex' if cmd['is_hex'] else 'Text'}"
+            item.setToolTip(tooltip)
+            self.commands_list.addItem(item)
+
+    def add_command_dialog(self):
+        dialog = CommandDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data['name'] and data['command']:
+                self.command_manager.add_command(data['name'], data['command'], data['is_hex'])
+                self.refresh_commands_list()
+            else:
+                QMessageBox.warning(self, "Invalid Input", "Name and Command cannot be empty.")
+
+    def edit_command_dialog(self):
+        index = self.commands_list.currentRow()
+        if index < 0:
+            QMessageBox.information(self, "Selection Required", "Please select a command to edit.")
+            return
+            
+        cmd_info = self.command_manager.get_commands()[index]
+        dialog = CommandDialog(self, cmd_info)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            data = dialog.get_data()
+            if data['name'] and data['command']:
+                self.command_manager.update_command(index, data['name'], data['command'], data['is_hex'])
+                self.refresh_commands_list()
+
+    def delete_command(self):
+        index = self.commands_list.currentRow()
+        if index < 0:
+            return
+            
+        confirm = QMessageBox.question(
+            self, "Confirm Delete", 
+            f"Are you sure you want to delete '{self.command_manager.get_commands()[index]['name']}'?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        
+        if confirm == QMessageBox.StandardButton.Yes:
+            self.command_manager.delete_command(index)
+            self.refresh_commands_list()
+
+    def load_saved_command(self, item):
+        index = self.commands_list.row(item)
+        cmd_info = self.command_manager.get_commands()[index]
+        self.command_input.setText(cmd_info['command'])
+        self.send_hex_check.setChecked(cmd_info['is_hex'])
+
+if __name__ == "__main__":
+    from PyQt6.QtWidgets import QApplication
+    app = QApplication(sys.argv)
+    window = MainWindow()
+    window.show()
+    sys.exit(app.exec())

sparkserial-0.1.0/sparkserial/gui/styles.py

@@ -0,0 +1,178 @@
+def get_stylesheet():
+    return """
+    QMainWindow {
+        background-color: #1e1e2e;
+        color: #cdd6f4;
+    }
+    
+    QWidget {
+        font-family: 'Segoe UI', 'Inter', sans-serif;
+        font-size: 13px;
+    }
+
+    QGroupBox {
+        border: 1px solid #45475a;
+        border-radius: 8px;
+        margin-top: 20px;
+        padding-top: 20px;
+        font-weight: bold;
+        color: #89b4fa;
+    }
+
+    QGroupBox::title {
+        subcontrol-origin: margin;
+        left: 10px;
+        padding: 0 5px;
+    }
+
+    QLabel {
+        color: #bac2de;
+    }
+
+    QComboBox, QLineEdit, QPlainTextEdit {
+        background-color: #313244;
+        border: 1px solid #45475a;
+        border-radius: 4px;
+        padding: 4px;
+        color: #cdd6f4;
+    }
+
+    QComboBox {
+        padding-left: 10px;
+    }
+
+    QComboBox::drop-down {
+        subcontrol-origin: padding;
+        subcontrol-position: top right;
+        width: 25px;
+        border-left: 1px solid #45475a;
+    }
+
+    QComboBox::down-arrow {
+        image: none;
+        border-left: 4px solid transparent;
+        border-right: 4px solid transparent;
+        border-top: 4px solid #89b4fa;
+    }
+
+    QComboBox QAbstractItemView {
+        background-color: #313244;
+        color: #cdd6f4;
+        selection-background-color: #45475a;
+        selection-color: #89b4fa;
+        border: 1px solid #45475a;
+        outline: none;
+    }
+
+    QComboBox QAbstractItemView::item {
+        min-height: 30px;
+        padding-left: 10px;
+    }
+
+    QComboBox:hover, QLineEdit:hover {
+        border: 1px solid #89b4fa;
+    }
+
+    QPushButton {
+        background-color: #45475a;
+        border: none;
+        border-radius: 4px;
+        padding: 8px 16px;
+        color: #cdd6f4;
+        font-weight: bold;
+    }
+
+    QPushButton:hover {
+        background-color: #585b70;
+    }
+
+    QPushButton#connectButton {
+        background-color: #a6e3a1;
+        color: #11111b;
+    }
+
+    QPushButton#connectButton:hover {
+        background-color: #94e2d5;
+    }
+
+    QPushButton#disconnectButton {
+        background-color: #f38ba8;
+        color: #11111b;
+    }
+
+    QPushButton#disconnectButton:hover {
+        background-color: #eba0ac;
+    }
+
+    QPlainTextEdit {
+        font-family: 'Consolas', 'Courier New', monospace;
+        font-size: 12px;
+        selection-background-color: #89b4fa;
+        selection-color: #1e1e2e;
+    }
+
+    QStatusBar {
+        background-color: #181825;
+        color: #bac2de;
+    }
+
+    QScrollBar:vertical {
+        border: none;
+        background: #1e1e2e;
+        width: 10px;
+        margin: 0px;
+    }
+
+    QScrollBar::handle:vertical:hover {
+        background: #585b70;
+    }
+
+    QListWidget {
+        background-color: #313244;
+        border: 1px solid #45475a;
+        border-radius: 4px;
+        color: #cdd6f4;
+        padding: 5px;
+        outline: none;
+    }
+
+    QListWidget::item {
+        padding: 8px;
+        border-bottom: 1px solid #45475a;
+    }
+
+    QListWidget::item:selected {
+        background-color: #45475a;
+        color: #89b4fa;
+        border-radius: 4px;
+    }
+
+    QListWidget::item:hover {
+        background-color: #3b3d52;
+    }
+
+    QDialog {
+        background-color: #1e1e2e;
+        color: #cdd6f4;
+    }
+
+    QTabWidget::pane {
+        border: 1px solid #45475a;
+        top: -1px;
+        background: #1e1e2e;
+    }
+
+    QTabBar::tab {
+        background: #313244;
+        color: #cdd6f4;
+        padding: 8px 12px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        margin-right: 2px;
+    }
+
+    QTabBar::tab:selected {
+        background: #1e1e2e;
+        border-bottom: 2px solid #89b4fa;
+    }
+    """

sparkserial-0.1.0/sparkserial/main.py

@@ -0,0 +1,46 @@
+import sys
+import os
+from PyQt6.QtWidgets import QApplication
+from sparkserial.gui.main_window import MainWindow
+
+def set_macos_app_details():
+    if sys.platform == "darwin":
+        try:
+            # Set App Name in Dock/Menu
+            from Cocoa import NSBundle
+            bundle = NSBundle.mainBundle()
+            if bundle:
+                info = bundle.localizedInfoDictionary() or bundle.infoDictionary()
+                if info:
+                    info['CFBundleName'] = "SparkSerial Pro"
+                    info['CFBundleDisplayName'] = "SparkSerial Pro"
+
+            # Set Dock Icon
+            from AppKit import NSApp, NSImage
+            icon_path = os.path.join(os.path.dirname(__file__), "assets", "icon.png")
+            if os.path.exists(icon_path):
+                image = NSImage.alloc().initWithContentsOfFile_(icon_path)
+                if image:
+                    NSApp.setApplicationIconImage_(image)
+        except Exception as e:
+            print(f"macOS specific setup failed: {e}")
+
+def main():
+    # Set the application ID for better process management
+    # No-op on macOS for name but helps overall
+    import ctypes
+    if sys.platform == "win32":
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("antigravity.sparkserial.1.0")
+        
+    app = QApplication(sys.argv)
+    app.setApplicationName("SparkSerial Pro")
+    
+    # Needs to be called after QApplication init for NSApp to exist
+    set_macos_app_details()
+    
+    window = MainWindow()
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

sparkserial-0.1.0/sparkserial.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: sparkserial
+Version: 0.1.0
+Summary: A premium Serial Utility Tool for professional hardware testing.
+Author-email: Spark Electronics <info@sparkelectronics.com>
+License: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyobjc-framework-cocoa>=12.1
+Requires-Dist: pyqt6>=6.10.2
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# SparkSerial Pro
+
+A premium serial communication and hardware testing tool built with Python and PyQt6. Inspired by professional tools like Docklight, **SparkSerial** provides a modern, high-performance interface for engineers and developers.
+
+![Icon](sparkserial/assets/icon.png)
+
+## Features
+
+- **Professional Configuration**: Comprehensive port settings (Baudrate up to 921600, Data Bits, Parity, Stop Bits, Flow Control).
+- **Command Shortcuts**: Save frequently used commands (Text or Hex) for quick access and batch testing.
+- **Advanced Terminal**: Real-time logging with timestamps, Hex view, and autoscroll.
+- **Persistence**: Automatically saves your command library and connection preferences.
+- **Modern UI**: Dark-mode aesthetic with optimized layout for hardware debugging.
+- **Cross-Platform**: Designed for macOS, Windows, and Linux.
+
+## Installation
+
+### From PyPI (Coming Soon)
+```bash
+pip install sparkserial
+```
+
+### Local Development
+Ensure you have [uv](https://github.com/astral-sh/uv) installed:
+
+```bash
+./setup.sh
+./run.sh
+```
+
+## Usage
+
+After installing via pip, you can launch the tool directly:
+```bash
+sparkserial
+```
+
+## Technologies Used
+
+- **UI Framework**: PyQt6
+- **Serial Communication**: PySerial
+- **Backend Architecture**: Worker-thread pattern for non-blocking I/O.
+- **Styling**: Custom CSS for premium dark-mode aesthetics.

sparkserial-0.1.0/sparkserial.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+sparkserial/__init__.py
+sparkserial/main.py
+sparkserial.egg-info/PKG-INFO
+sparkserial.egg-info/SOURCES.txt
+sparkserial.egg-info/dependency_links.txt
+sparkserial.egg-info/entry_points.txt
+sparkserial.egg-info/requires.txt
+sparkserial.egg-info/top_level.txt
+sparkserial/assets/icon.png
+sparkserial/core/__init__.py
+sparkserial/core/command_manager.py
+sparkserial/core/serial_manager.py
+sparkserial/gui/__init__.py
+sparkserial/gui/main_window.py
+sparkserial/gui/styles.py

sparkserial-0.1.0/sparkserial.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sparkserial-0.1.0/sparkserial.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sparkserial = sparkserial.main:main

sparkserial-0.1.0/sparkserial.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pyobjc-framework-cocoa>=12.1
+pyqt6>=6.10.2
+pyserial>=3.5

sparkserial-0.1.0/sparkserial.egg-info/top_level.txt

@@ -0,0 +1 @@
+sparkserial