flowchem-qt 0.0.1__tar.gz

flowchem_qt-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Automated Chemistry @ Max Plank Institute of Colloids and Interfaces
+
+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.

flowchem_qt-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: flowchem-qt
+Version: 0.0.1
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: flowchem
+Requires-Dist: PySide6>=6.5
+Requires-Dist: PySide6-Fluent-Widgets>=1.11.2
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: loguru>=0.7
+Requires-Dist: zeroconf>=0.149.7
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file

flowchem_qt-0.0.1/README.md

@@ -0,0 +1,124 @@
+<p align="center">
+  <img src="resources/icons/flowchem_logo.svg" alt="FlowChem logo" width="400"/>
+</p>
+
+<h1 align="center">FlowChem GUI</h1>
+
+<p align="center">
+  A desktop application to manage the <a href="https://github.com/automatedchemistry/flowchem">FlowChem</a> server — configure devices, control the server process, and auto-discover hardware, all from one window.
+</p>
+
+---
+
+## Requirements
+
+- Python ≥ 3.11
+- FlowChem installed and available on `PATH` (activate your FlowChem virtualenv before launching)
+
+## Installation
+
+```bash
+pip install flowchem-qt
+```
+
+Or, to install from source:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+flowchem-qt        # launches silently (no console window on Windows)
+python main.py     # development / debug
+```
+
+---
+
+## Window Overview
+
+The main window has four tabs and a persistent status bar at the bottom showing a coloured dot:
+
+- **Red dot** — server is stopped
+- **Green dot** — server is running
+
+### Config editor
+
+Edit the FlowChem `config.toml` directly in the app. Browse for a file, load it into the editor, make changes, and save — no external editor needed. This tab is disabled while the server is running.
+
+<p align="center">
+  <img src="resources/editor.png" alt="Config editor tab" width="480"/>
+</p>
+
+| Element | Description |
+|---|---|
+| Path field | Full path to the config file. Remembered between sessions. |
+| Browse | Opens a file dialog to pick a `.toml` file. |
+| Load | Reads the selected file into the editor. |
+| Save | Writes the editor content back to disk. |
+| Editor area | Plain-text editor for the raw TOML content. The FlowChem server validates on startup. |
+
+---
+
+### Server
+
+Start and stop the FlowChem server and open the interactive API browser.
+
+<p align="center">
+  <img src="resources/server.png" alt="Server tab" width="480"/>
+</p>
+
+| Element | Description |
+|---|---|
+| Server address | Base URL of the running server (default `http://localhost:8000`). |
+| Debug mode | Passes `--debug` to FlowChem for verbose log output. |
+| Simulation mode | Launches `flowchem-sim` instead of `flowchem`. All device drivers are replaced with simulated counterparts — no physical hardware required. |
+| Start / Stop | Single toggle button. Starts or stops the server process. |
+| Open API browser | Opens `<server address>/docs` in the system browser. |
+
+> The address field, debug checkbox, and simulation mode checkbox are disabled while the server is running.
+
+---
+
+### Discover
+
+Run `flowchem-autodiscover` to detect connected devices and generate a starter config.
+
+<p align="center">
+  <img src="resources/discover.png" alt="Discover tab" width="480"/>
+</p>
+
+| Element | Description |
+|---|---|
+| Run autodiscover | Shows a safety warning, then runs `flowchem-autodiscover`. Output streams in real time. |
+| Output area | Read-only display of autodiscover stdout and stderr. |
+| Copy to editor | Copies the output into the Config editor for review and saving. |
+
+> **Warning:** autodiscovery communicates over serial ports and may place unsupported devices in an unsafe state. A confirmation dialog is shown before running.
+>
+> This tab is disabled while the server is running.
+
+---
+
+### Logs
+
+Live log viewer — always accessible, even while the server is running.
+
+| Element | Description |
+|---|---|
+| Log area | Streams output from the FlowChem server process and internal GUI events. Auto-scrolls to the latest entry. |
+| Clear | Clears the log area. |
+
+---
+
+## System tray
+
+Closing the main window minimises to the system tray — the application keeps running in the background. Right-click the tray icon to access:
+
+| Menu item | Description |
+|---|---|
+| Show window | Brings the main window back to the foreground. |
+| Start server | Starts the FlowChem server (uses the config path set in the Config editor). |
+| Stop server | Stops the running server. |
+| Quit | Fully exits the application. |

flowchem_qt-0.0.1/app/main_window.py

@@ -0,0 +1,83 @@
+from pathlib import Path
+
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QLabel, QMainWindow, QMessageBox, QStatusBar, QTabWidget
+
+from app.server_manager import ServerManager
+from app.tabs.config_tab import ConfigTab
+from app.tabs.discover_tab import DiscoverTab
+from app.tabs.logs_tab import LogsTab
+from app.tabs.server_tab import ServerTab
+
+_ICON_PATH = (
+    Path(__file__).parent.parent / "resources" / "icons" / "flowchem_app_icon.ico"
+)
+
+
+class MainWindow(QMainWindow):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("FlowChem Manager")
+        self.setWindowIcon(QIcon(str(_ICON_PATH)))
+        self.resize(900, 650)
+
+        self.server_manager = ServerManager(self)
+
+        self.config_tab = ConfigTab()
+        self.server_tab = ServerTab(self.server_manager, self.config_tab)
+        self.discover_tab = DiscoverTab(self.config_tab)
+        self.logs_tab = LogsTab()
+
+        tabs = QTabWidget()
+        tabs.addTab(self.config_tab, "Config editor")
+        tabs.addTab(self.server_tab, "Server")
+        tabs.addTab(self.discover_tab, "Discover")
+        tabs.addTab(self.logs_tab, "Logs")
+        tabs.setTabToolTip(0, "Edit and save the FlowChem TOML configuration.")
+        tabs.setTabToolTip(1, "Start, stop, and open the FlowChem server API.")
+        tabs.setTabToolTip(2, "Detect connected devices and copy the generated config.")
+        tabs.setTabToolTip(3, "View FlowChem server output and GUI events.")
+        self.setCentralWidget(tabs)
+
+        self._status_dot = QLabel("● Server stopped")
+        self._status_dot.setToolTip("Current FlowChem server status.")
+        self._status_dot.setStyleSheet("color: red;")
+        status_bar = QStatusBar()
+        status_bar.setToolTip("Shows the latest FlowChem Manager status message.")
+        status_bar.addWidget(self._status_dot)
+        self.setStatusBar(status_bar)
+
+        self.server_manager.started.connect(self._on_started)
+        self.server_manager.stopped.connect(self._on_stopped)
+        self.server_manager.error.connect(self._on_error)
+        self.server_manager.stdout_ready.connect(self.logs_tab.append_process_output)
+        self.server_manager.stderr_ready.connect(self.logs_tab.append_process_output)
+
+    def closeEvent(self, event):
+        event.ignore()
+        self.hide()
+
+    def _on_started(self):
+        self._status_dot.setText("● Server running")
+        self._status_dot.setToolTip("FlowChem server is running.")
+        self._status_dot.setStyleSheet("color: green;")
+        self.statusBar().showMessage("Server started", 3000)
+        self.config_tab.setEnabled(False)
+        self.discover_tab.setEnabled(False)
+
+    def _on_stopped(self, exit_code):
+        self._status_dot.setText("● Server stopped")
+        self._status_dot.setToolTip("FlowChem server is stopped.")
+        self._status_dot.setStyleSheet("color: red;")
+        msg = (
+            "Server stopped"
+            if exit_code == 0
+            else f"Server stopped (exit code {exit_code})"
+        )
+        self.statusBar().showMessage(msg, 5000)
+        self.config_tab.setEnabled(True)
+        self.discover_tab.setEnabled(True)
+
+    def _on_error(self, msg: str):
+        self.statusBar().showMessage(f"Error: {msg}", 0)  # 0 = stays until next message
+        QMessageBox.critical(self, "Server error", msg)

flowchem_qt-0.0.1/app/server_manager.py

@@ -0,0 +1,66 @@
+from PySide6.QtCore import QObject, QProcess, QTimer, Signal
+from loguru import logger
+
+_PROC_ERRORS = {
+    QProcess.ProcessError.FailedToStart: "Failed to start — is 'flowchem' on your PATH?",
+    QProcess.ProcessError.Crashed: "Process crashed unexpectedly",
+    QProcess.ProcessError.Timedout: "Process timed out",
+    QProcess.ProcessError.WriteError: "Write error communicating with process",
+    QProcess.ProcessError.ReadError: "Read error communicating with process",
+    QProcess.ProcessError.UnknownError: "Unknown process error",
+}
+
+
+class ServerManager(QObject):
+    started = Signal()
+    stopped = Signal(int)
+    stdout_ready = Signal(str)
+    stderr_ready = Signal(str)
+    error = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._proc = QProcess(self)
+        self._proc.readyReadStandardOutput.connect(self._on_stdout)
+        self._proc.readyReadStandardError.connect(self._on_stderr)
+        self._proc.started.connect(self.started)
+        self._proc.finished.connect(self._on_finished)
+        self._proc.errorOccurred.connect(self._on_error)
+
+    def start(self, config_path: str, debug: bool = False, sim: bool = False):
+        exe = "flowchem-sim" if sim else "flowchem"
+        args = [config_path] + (["--debug"] if debug else [])
+        logger.info(f"Starting: {exe} {' '.join(args)}")
+        self._proc.start(exe, args)
+
+    def stop(self):
+        if not self.is_running():
+            return
+        logger.info("Stopping flowchem server")
+        self._proc.terminate()
+        QTimer.singleShot(3000, self._force_kill)
+
+    def is_running(self) -> bool:
+        return self._proc.state() == QProcess.ProcessState.Running
+
+    def _force_kill(self):
+        if self.is_running():
+            logger.warning("Server did not stop gracefully — killing process")
+            self._proc.kill()
+
+    def _on_stdout(self):
+        text = self._proc.readAllStandardOutput().data().decode(errors="replace")
+        self.stdout_ready.emit(text)
+
+    def _on_stderr(self):
+        text = self._proc.readAllStandardError().data().decode(errors="replace")
+        self.stderr_ready.emit(text)
+
+    def _on_error(self, error):
+        msg = _PROC_ERRORS.get(error, f"Process error ({error})")
+        logger.error(f"FlowChem process error: {msg}")
+        self.error.emit(msg)
+
+    def _on_finished(self, exit_code, _status):
+        logger.info(f"FlowChem exited with code {exit_code}")
+        self.stopped.emit(exit_code)

flowchem_qt-0.0.1/app/tabs/config_tab.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+
+from PySide6.QtCore import QSettings
+from PySide6.QtWidgets import (
+    QFileDialog,
+    QHBoxLayout,
+    QPlainTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+from qfluentwidgets import LineEdit, PrimaryPushButton, PushButton
+from loguru import logger
+
+
+class ConfigTab(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._settings = QSettings("flowchem", "gui")
+
+        self.path_edit = LineEdit()
+        self.path_edit.setPlaceholderText("Path to config.toml")
+        browse_btn = PushButton("Browse")
+        load_btn = PushButton("Load")
+        self.save_btn = PrimaryPushButton("Save")
+        self.editor = QPlainTextEdit()
+
+        self.path_edit.setToolTip("Path to the FlowChem TOML configuration file.")
+        browse_btn.setToolTip("Select a FlowChem TOML configuration file.")
+        load_btn.setToolTip("Load the selected TOML file into the editor.")
+        self.save_btn.setToolTip("Save the editor contents to the selected TOML file.")
+        self.editor.setToolTip("Edit the raw FlowChem TOML configuration.")
+
+        path_row = QHBoxLayout()
+        path_row.addWidget(self.path_edit)
+        path_row.addWidget(browse_btn)
+        path_row.addWidget(load_btn)
+        path_row.addWidget(self.save_btn)
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(path_row)
+        layout.addWidget(self.editor)
+
+        browse_btn.clicked.connect(self._browse)
+        load_btn.clicked.connect(self._load)
+        self.save_btn.clicked.connect(self._save)
+
+        saved = self._settings.value("config_path", "")
+        if saved and Path(saved).exists():
+            self.path_edit.setText(saved)
+            self._load()
+
+    def get_config_path(self) -> str:
+        return self.path_edit.text()
+
+    def set_content(self, text: str):
+        self.editor.setPlainText(text)
+
+    def _browse(self):
+        path, _ = QFileDialog.getOpenFileName(
+            self, "Select config file", "", "TOML files (*.toml)"
+        )
+        if path:
+            self.path_edit.setText(path)
+
+    def _load(self):
+        path = Path(self.path_edit.text())
+        if not path.exists():
+            logger.warning(f"Config file not found: {path}")
+            return
+        self.editor.setPlainText(path.read_text(encoding="utf-8"))
+        self._settings.setValue("config_path", str(path))
+        logger.info(f"Loaded config: {path}")
+
+    def _save(self):
+        path = Path(self.path_edit.text())
+        path.write_text(self.editor.toPlainText(), encoding="utf-8")
+        self._settings.setValue("config_path", str(path))
+        logger.info(f"Saved config: {path}")

flowchem_qt-0.0.1/app/tabs/discover_tab.py

@@ -0,0 +1,78 @@
+from PySide6.QtCore import QProcess
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QMessageBox,
+    QPlainTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+from qfluentwidgets import PrimaryPushButton, PushButton
+from loguru import logger
+
+_WARNING = (
+    "Autodiscover communicates over serial ports.\n"
+    "Unsupported devices could be placed in an unsafe state.\n\n"
+    "Continue?"
+)
+
+
+class DiscoverTab(QWidget):
+    def __init__(self, config_tab, parent=None):
+        super().__init__(parent)
+        self._cfg = config_tab
+        self._proc = QProcess(self)
+
+        self.output = QPlainTextEdit(readOnly=True)
+        run_btn = PrimaryPushButton("Run autodiscover")
+        self.copy_btn = PushButton("Copy to editor")
+        self.copy_btn.setEnabled(False)
+
+        self.output.setToolTip("Autodiscover output from stdout and stderr.")
+        run_btn.setToolTip("Run flowchem-autodiscover after confirming the warning.")
+        self.copy_btn.setToolTip("Copy autodiscover output into the Config editor.")
+
+        btn_row = QHBoxLayout()
+        btn_row.addWidget(run_btn)
+        btn_row.addWidget(self.copy_btn)
+        btn_row.addStretch()
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(btn_row)
+        layout.addWidget(self.output)
+
+        run_btn.clicked.connect(self._run)
+        self.copy_btn.clicked.connect(self._copy_to_editor)
+        self._proc.readyReadStandardOutput.connect(
+            lambda: self._append(self._proc.readAllStandardOutput().data())
+        )
+        self._proc.readyReadStandardError.connect(
+            lambda: self._append(self._proc.readAllStandardError().data())
+        )
+        self._proc.finished.connect(self._on_finished)
+
+    def _run(self):
+        reply = QMessageBox.warning(
+            self,
+            "Warning",
+            _WARNING,
+            QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
+        )
+        if reply != QMessageBox.StandardButton.Ok:
+            return
+        self.output.clear()
+        self.copy_btn.setEnabled(False)
+        logger.info("Running flowchem-autodiscover")
+        self._proc.start("flowchem-autodiscover", ["--assume-yes"])
+
+    def _append(self, data: bytes):
+        text = data.decode(errors="replace").rstrip()
+        if text:
+            self.output.appendPlainText(text)
+
+    def _on_finished(self, exit_code, _status):
+        logger.info(f"Autodiscover finished (exit code {exit_code})")
+        self.copy_btn.setEnabled(bool(self.output.toPlainText()))
+
+    def _copy_to_editor(self):
+        self._cfg.set_content(self.output.toPlainText())
+        logger.info("Autodiscover output copied to config editor")

flowchem_qt-0.0.1/app/tabs/logs_tab.py

@@ -0,0 +1,46 @@
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QPlainTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+from qfluentwidgets import PushButton
+from loguru import logger
+
+
+class LogsTab(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.log_view = QPlainTextEdit(readOnly=True)
+
+        clear_btn = PushButton("Clear")
+        self.log_view.setToolTip("Live FlowChem process output and GUI log events.")
+        clear_btn.setToolTip("Clear the displayed log output.")
+        clear_btn.clicked.connect(self.log_view.clear)
+
+        btn_row = QHBoxLayout()
+        btn_row.addStretch()
+        btn_row.addWidget(clear_btn)
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.log_view)
+        layout.addLayout(btn_row)
+
+        logger.add(
+            self._log_sink,
+            level="DEBUG",
+            format="{time:HH:mm:ss} | {level:<8} | {message}",
+        )
+
+    def _log_sink(self, message):
+        self._append(message.strip())
+
+    def append_process_output(self, text: str):
+        self._append(text.rstrip())
+
+    def _append(self, text: str):
+        if not text:
+            return
+        self.log_view.appendPlainText(text)
+        sb = self.log_view.verticalScrollBar()
+        sb.setValue(sb.maximum())

flowchem_qt-0.0.1/app/tabs/server_tab.py

@@ -0,0 +1,102 @@
+import socket
+from urllib.parse import urlparse
+
+from PySide6.QtCore import QUrl
+from PySide6.QtWidgets import (
+    QFormLayout,
+    QHBoxLayout,
+    QMessageBox,
+    QVBoxLayout,
+    QWidget,
+)
+from qfluentwidgets import CheckBox, HyperlinkButton, LineEdit, PrimaryPushButton
+
+
+class ServerTab(QWidget):
+    def __init__(self, server_manager, config_tab, parent=None):
+        super().__init__(parent)
+        self._mgr = server_manager
+        self._cfg = config_tab
+
+        self.address_edit = LineEdit()
+        self.address_edit.setText("http://localhost:8000")
+        self.debug_chk = CheckBox("Debug mode")
+        self.sim_chk = CheckBox("Simulation mode")
+        self.toggle_btn = PrimaryPushButton("Start")
+        self.open_btn = HyperlinkButton(self._resolved_docs_url(), self._docs_label())
+
+        self.address_edit.setToolTip("Base URL for the running FlowChem server.")
+        self.debug_chk.setToolTip("Pass --debug to FlowChem for verbose logging.")
+        self.sim_chk.setToolTip("Launch flowchem-sim instead of real device drivers.")
+        self.toggle_btn.setToolTip("Start or stop the FlowChem server.")
+        self.open_btn.setToolTip("Open the server API documentation in your browser.")
+
+        form = QFormLayout()
+        form.addRow("Server address:", self.address_edit)
+        form.addRow("", self.debug_chk)
+        form.addRow("", self.sim_chk)
+
+        btn_row = QHBoxLayout()
+        btn_row.addWidget(self.toggle_btn)
+        btn_row.addWidget(self.open_btn)
+        btn_row.addStretch()
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(form)
+        layout.addLayout(btn_row)
+        layout.addStretch()
+
+        self.toggle_btn.clicked.connect(self._toggle)
+        self.address_edit.textChanged.connect(self._update_open_btn)
+        server_manager.started.connect(self._on_started)
+        server_manager.stopped.connect(self._on_stopped)
+
+    def _toggle(self):
+        if self._mgr.is_running():
+            self._mgr.stop()
+        else:
+            path = self._cfg.get_config_path()
+            if not path:
+                QMessageBox.warning(
+                    self,
+                    "No config file",
+                    "Please select a config file in the Config editor tab before starting the server.",
+                )
+                return
+            self._mgr.start(
+                path, debug=self.debug_chk.isChecked(), sim=self.sim_chk.isChecked()
+            )
+
+    def _resolved_docs_url(self) -> str:
+        base = self.address_edit.text().rstrip("/")
+        try:
+            parsed = urlparse(base)
+            if parsed.hostname in ("localhost", "127.0.0.1", "::1"):
+                ip = socket.gethostbyname(socket.gethostname())
+                base = base.replace(parsed.hostname, ip, 1)
+        except OSError:
+            pass
+        return base + "/docs"
+
+    def _docs_label(self) -> str:
+        url = self._resolved_docs_url()
+        display = url.replace("http://", "").replace("https://", "")
+        return f"Open API browser — {display}"
+
+    def _update_open_btn(self):
+        self.open_btn.setUrl(QUrl(self._resolved_docs_url()))
+        self.open_btn.setText(self._docs_label())
+
+    def _on_started(self):
+        self.toggle_btn.setText("Stop")
+        self.toggle_btn.setToolTip("Stop the running FlowChem server.")
+        self.address_edit.setEnabled(False)
+        self.debug_chk.setEnabled(False)
+        self.sim_chk.setEnabled(False)
+
+    def _on_stopped(self, _exit_code):
+        self.toggle_btn.setText("Start")
+        self.toggle_btn.setToolTip("Start the FlowChem server.")
+        self.address_edit.setEnabled(True)
+        self.debug_chk.setEnabled(True)
+        self.sim_chk.setEnabled(True)

flowchem_qt-0.0.1/app/tray.py

@@ -0,0 +1,51 @@
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication, QMenu, QSystemTrayIcon
+from loguru import logger
+
+
+class TrayIcon(QSystemTrayIcon):
+    def __init__(self, window, server_manager, icon: QIcon, parent=None):
+        super().__init__(icon, parent)
+        self._window = window
+        self._mgr = server_manager
+        self.setToolTip("Flowchem Manager")
+
+        menu = QMenu()
+        act_show = menu.addAction("Show window", window.show)
+        act_show.setToolTip("Show the FlowChem Manager window.")
+        menu.addSeparator()
+        self._act_start = menu.addAction("Start server", self._start)
+        self._act_stop = menu.addAction("Stop server", server_manager.stop)
+        self._act_start.setToolTip("Start the FlowChem server.")
+        self._act_stop.setToolTip("Stop the FlowChem server.")
+        menu.addSeparator()
+        act_quit = menu.addAction("Quit", QApplication.quit)
+        act_quit.setToolTip("Quit FlowChem Manager.")
+        self.setContextMenu(menu)
+
+        self.activated.connect(self._on_activated)
+        server_manager.started.connect(self._on_started)
+        server_manager.stopped.connect(self._on_stopped)
+        self._on_stopped(0)
+
+        if not QSystemTrayIcon.isSystemTrayAvailable():
+            logger.warning("System tray not available on this desktop environment")
+        else:
+            self.show()
+
+    def _on_activated(self, reason):
+        if reason == QSystemTrayIcon.ActivationReason.DoubleClick:
+            self._window.show()
+            self._window.raise_()
+
+    def _start(self):
+        self._window.show()
+        self._window.server_tab._toggle()
+
+    def _on_started(self):
+        self._act_start.setEnabled(False)
+        self._act_stop.setEnabled(True)
+
+    def _on_stopped(self, _exit_code=0):
+        self._act_start.setEnabled(True)
+        self._act_stop.setEnabled(False)

flowchem_qt-0.0.1/flowchem_qt.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: flowchem-qt
+Version: 0.0.1
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: flowchem
+Requires-Dist: PySide6>=6.5
+Requires-Dist: PySide6-Fluent-Widgets>=1.11.2
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: loguru>=0.7
+Requires-Dist: zeroconf>=0.149.7
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file

flowchem_qt-0.0.1/flowchem_qt.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+main.py
+pyproject.toml
+app/__init__.py
+app/main_window.py
+app/server_manager.py
+app/tray.py
+app/tabs/__init__.py
+app/tabs/config_tab.py
+app/tabs/discover_tab.py
+app/tabs/logs_tab.py
+app/tabs/server_tab.py
+flowchem_qt.egg-info/PKG-INFO
+flowchem_qt.egg-info/SOURCES.txt
+flowchem_qt.egg-info/dependency_links.txt
+flowchem_qt.egg-info/entry_points.txt
+flowchem_qt.egg-info/requires.txt
+flowchem_qt.egg-info/top_level.txt

flowchem_qt-0.0.1/flowchem_qt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flowchem_qt-0.0.1/flowchem_qt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gui_scripts]
+flowchem-qt = main:main

flowchem_qt-0.0.1/flowchem_qt.egg-info/requires.txt

@@ -0,0 +1,9 @@
+flowchem
+PySide6>=6.5
+PySide6-Fluent-Widgets>=1.11.2
+tomli-w>=1.0
+loguru>=0.7
+zeroconf>=0.149.7
+
+[test]
+pytest

flowchem_qt-0.0.1/flowchem_qt.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+app
+main

flowchem_qt-0.0.1/main.py

@@ -0,0 +1,47 @@
+import ctypes
+import sys
+from pathlib import Path
+
+from qfluentwidgets import Theme, setTheme, setThemeColor
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication
+
+from app.main_window import MainWindow
+from app.tray import TrayIcon
+
+_APP_ID = "org.flowchem.gui"
+
+
+def _set_windows_app_id():
+    if sys.platform != "win32":
+        return
+    ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(_APP_ID)
+
+
+def main():
+    _set_windows_app_id()
+
+    # pythonw suppresses the console — redirect stderr so crashes before the
+    # Qt window appears are not silently swallowed.
+    log_path = Path.home() / ".flowchem-qt" / "error.log"
+    log_path.parent.mkdir(exist_ok=True)
+    sys.stderr = open(log_path, "a", encoding="utf-8")
+
+    app = QApplication(sys.argv)
+    setTheme(Theme.AUTO)
+    setThemeColor("#0065d5")
+    app.setQuitOnLastWindowClosed(False)
+
+    icon_dir = Path(__file__).parent / "resources" / "icons"
+    window_icon = QIcon(str(icon_dir / "flowchem_app_icon.ico"))
+    tray_icon = QIcon(str(icon_dir / "flowchem_logo.svg"))
+    app.setWindowIcon(window_icon)
+
+    window = MainWindow()
+    TrayIcon(window, window.server_manager, tray_icon, app)
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

flowchem_qt-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flowchem-qt"
+version = "0.0.1"
+requires-python = ">=3.11"
+dependencies = [
+    "flowchem",
+    "PySide6>=6.5",
+    "PySide6-Fluent-Widgets>=1.11.2",
+    "tomli-w>=1.0",
+    "loguru>=0.7",
+    "zeroconf>=0.149.7",
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.gui-scripts]
+flowchem-qt = "main:main"
+
+[tool.setuptools]
+py-modules = ["main"]
+packages = ["app", "app.tabs"]

flowchem_qt-0.0.1/setup.cfg

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