cgse-tui 0.26.0__tar.gz

cgse_tui-0.26.0/.gitignore

@@ -0,0 +1,65 @@
+# Python versions and environment
+
+__pycache__
+.python-version
+.envrc
+
+# Build systems
+
+build
+dist
+**/*.egg-info
+
+# Apple specific
+
+.DS_Store
+
+# Unit testing
+
+.pytest_cache
+.coverage
+.coverage.*
+.nox
+htmlcov
+libs/cgse-core/temperature.csv
+
+# Prototypes
+
+**/prototypes/typed_serialization
+
+# dotenv, ignore all but the example file
+
+.env
+.env.*
+!.env.example
+
+# Virtual environments
+
+.venv
+venv
+
+# PyCharm IDE
+
+.idea
+
+# VSCode IDE
+
+.vscode
+*.code-workspace
+
+# MKDOCS documentation site
+
+/site
+
+# Packaging
+
+uv.lock
+libs/test_service_registry.db
+libs/cgse-core/metrics.duckdb
+install_influxdb3.sh
+.pylintrc
+
+# CGSE Specific
+
+.migrate_influx_to_questdb.state.json
+service_registry.db*

cgse_tui-0.26.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: cgse-tui
+Version: 0.26.0
+Summary: Terminal user interface with the status of the CGSE core services and device control servers
+Project-URL: Homepage, https://github.com/IvS-KULeuven/cgse/tree/main/projects/generic/cgse-tui
+Project-URL: Repository, https://github.com/IvS-KULeuven/cgse
+Project-URL: Releases, https://github.com/IvS-KULeuven/cgse/releases
+Project-URL: Changelog, https://github.com/IvS-KULeuven/cgse/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://ivs-kuleuven.github.io/cgse/
+Author: IvS KU Leuven
+Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>
+License-Expression: MIT
+Keywords: CGSE,Common-EGSE,hardware testing,software framework,textual
+Requires-Python: >=3.10
+Requires-Dist: cgse-common
+Requires-Dist: cgse-core
+Requires-Dist: textual>=2.0.0
+Requires-Dist: typer
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Description-Content-Type: text/markdown
+
+# CGSE TUI
+
+A terminal user interface, built with [Textual](https://textual.textualize.io/), that shows the status of the CGSE
+core services and device control servers.
+
+Start it with `cgse tui` or `cgse_tui`.
+
+The design and the status information it uses are described in `docs/dev_guide/tui_status_inventory.md`:
+
+- the services are found in the service registry;
+- control servers are followed live on their monitoring port, and asked for their status report when they appear or
+  are selected;
+- the registry, logger, notification hub and metrics hub are asked for their own status.
+
+The first version is read-only: an overview of all services and a detail screen with the status report of the
+selected service.
+
+Keys in the overview:
+
+- `enter`: show the status report of the selected service;
+- `r`: refresh, poll the registry and request the status of all services now (otherwise the status report of a
+  control server, with the device connection, is requested every 10 s);
+- `a`: start, stop or restart the selected service (also in the detail screen), see below;
+- `o`: select the columns of the overview (in the dialog: `space` toggles a column, `a` all, `n` none, `d` defaults,
+  `esc` or `o` closes it);
+- `l`: show or hide the log pane; with the focus in the log pane (`tab`), `m` makes it fill the screen and back
+  (`esc` too), and `w` wraps the long lines and back. The log pane follows the new messages while it's at the end;
+  scrolled up, it stays at the same lines (`end` follows again);
+- `L`: the log screen, also from the detail screen of the logger or with `cgse tui --logs`: the log messages of a time
+  window (the latest hour at first), read by the logger from its log files with its `history` command. `[` and `]`
+  move the window by its length, `p` and `n` by a day (yesterday), `-` and `+` make it shorter or longer (5 min to 1
+  day), `g` goes to a time, `t` to the latest window. The latest window is live: new messages are added every 2 s with
+  the `tail` command and the window moves with the time; the view follows while it's at the end (`end`). The tree at
+  the left has the loggers of the window with their number of messages; `space` selects a logger and those below it,
+  only their messages are shown. Below it the processes that logged the messages, `space` selects a process in the
+  same way (with both selected, a message must be of both); `c` clears the selection. `f`, `d` and `w` filter, hide
+  the DEBUG messages and wrap, as in the log panel of the logger;
+- `F1`: help, on every screen (from a detail screen or the log screen it opens at the part about that screen);
+- `ctrl+q`: quit.
+
+The overview also shows the device drivers of the project: every node of the Setup (loaded by the configuration
+manager) with a `cgse_object`, e.g. `gse.DAQ6510.cgse_object: daq6510`, with its `device_name` and optional
+`device_id`. A device that runs is shown as its service in the registry; one that doesn't run is shown dimmed, with an
+empty frame, and can be started with `a` (`cgse <object> start [<device_id>]`). See "Device drivers in the Setup" in
+`docs/libs/cgse-common/setup.md`.
+
+The detail screen shows the selected service in panels, updated every second:
+
+- Service: the registration in the service registry and the endpoints (Service, Process and Device have the same
+  height);
+- Process: PID, uptime, CPU and memory. CPU % and memory are shown in orange (warning) or red (critical) when the
+  process uses too much CPU or its memory keeps growing, with the reason below, see "CPU and memory warnings";
+- Device: the connection and simulator mode, only for services that control a device;
+- Details: the service specific status. For a control server these are the `details` of its status report,
+  updated with the live values of its monitoring messages (the border says `live`), for the registry, logger and
+  hubs their own status. The package of a device can show its details in its own way with a plugin (e.g. the
+  positions of the hexapods). The TUI has its own panels for the core services: the disk usage of the Storage
+  Manager, the observation and the whole Setup of the Configuration Manager, the messages per second, the queue
+  and the database of the Metrics Hub, the events of the Notification Hub, and the log file, the messages by level
+  and the last warning and error of the logger. Otherwise the details are shown as a tree, see "Details in the TUI"
+  in `docs/dev_guide/plugins.md`;
+- Registrations: only for the service registry, all registered services; `enter` shows the details of the selected
+  service, `esc` goes back.
+- Log: only for the logger, the last log lines, coloured by level, filling the lower part of the screen; new lines are
+  requested every 2 s with the `tail` command of the logger (a logger of an older version doesn't have it). The
+  lines follow the new messages while the view is at the end; scrolled up, the view stays at the same lines (`end`
+  follows again). `m` makes the panel fill the screen and back, `f` filters the lines on levels, process, logger or
+  module, words in the message, and a time range, and hides or dims the other lines; `d` hides the DEBUG lines, `w`
+  wraps the long lines. The panel keeps the last 1000 messages (the logger keeps 10 000 in memory), the filter applies
+  to those;
+- Core services: only for the Process Manager, the core services it manages with their state in the TUI; `enter`
+  shows the details of the selected service, `esc` goes back.
+
+CPU and memory warnings: the TUI judges the process of every service, and shows the CPU % and memory in orange or red,
+also in the overview, and writes a message in the log pane when this changes:
+
+- CPU: the average CPU % over the last minute, a warning from 50 %, critical from 90 %;
+- memory: the growth of the memory, the RSS plus what is swapped out, over the last 10 minutes, a warning from 10 %,
+  critical from 25 %. It's judged when there are samples of at least 5 minutes, so a process that just started isn't
+  taken for a leak. The swapped-out memory counts because leaked memory ends up in swap: the RSS alone can go down
+  while a process leaks. A service of an older version doesn't report its swap, then only the RSS counts.
+
+The limits are in `cgse_tui/data/health.py`.
+
+Panels are dimmed when the service is stale or not running. Keys in the detail screen: `r` requests the status report
+now (otherwise every 10 s), `a` starts, stops or restarts the service, `v` shows the raw status report, `m`, `f` and `d`
+maximize and filter the log lines of the logger and hide its DEBUG lines, `esc` goes back to the overview.
+
+Start, stop and restart run the `cgse <object> start|stop` command of the service, with its device identifier, e.g.
+`cgse puna stop PUNA_01`. The dialog shows the commands; selecting an action is the confirmation. A running service
+can be stopped or restarted, a core service that is not running can be started. With the simulator checkbox, the
+service is started with its simulator: a simulator that is a separate process (e.g. DAQ6510, TVAC) is started first
+with `cgse <object> start-sim` when it isn't running, other drivers are started with `--sim`. The checkbox is checked
+when the service runs with its simulator now. With the verbose debug checkbox, the service (and its simulator) is
+started with `VERBOSE_DEBUG=1`, otherwise without it. The progress and the result are written to the log pane: the
+TUI waits up to 30 s until a started service is registered, or a stopped service is no longer registered. The commands
+run in their own session, so the services started from the TUI don't belong to the terminal of the TUI.
+
+## Latest release
+
+- PyPI: https://pypi.org/project/cgse-tui/
+- GitHub releases: https://github.com/IvS-KULeuven/cgse/releases
+- Changelog: https://github.com/IvS-KULeuven/cgse/blob/main/CHANGELOG.md

cgse_tui-0.26.0/README.md

@@ -0,0 +1,103 @@
+# CGSE TUI
+
+A terminal user interface, built with [Textual](https://textual.textualize.io/), that shows the status of the CGSE
+core services and device control servers.
+
+Start it with `cgse tui` or `cgse_tui`.
+
+The design and the status information it uses are described in `docs/dev_guide/tui_status_inventory.md`:
+
+- the services are found in the service registry;
+- control servers are followed live on their monitoring port, and asked for their status report when they appear or
+  are selected;
+- the registry, logger, notification hub and metrics hub are asked for their own status.
+
+The first version is read-only: an overview of all services and a detail screen with the status report of the
+selected service.
+
+Keys in the overview:
+
+- `enter`: show the status report of the selected service;
+- `r`: refresh, poll the registry and request the status of all services now (otherwise the status report of a
+  control server, with the device connection, is requested every 10 s);
+- `a`: start, stop or restart the selected service (also in the detail screen), see below;
+- `o`: select the columns of the overview (in the dialog: `space` toggles a column, `a` all, `n` none, `d` defaults,
+  `esc` or `o` closes it);
+- `l`: show or hide the log pane; with the focus in the log pane (`tab`), `m` makes it fill the screen and back
+  (`esc` too), and `w` wraps the long lines and back. The log pane follows the new messages while it's at the end;
+  scrolled up, it stays at the same lines (`end` follows again);
+- `L`: the log screen, also from the detail screen of the logger or with `cgse tui --logs`: the log messages of a time
+  window (the latest hour at first), read by the logger from its log files with its `history` command. `[` and `]`
+  move the window by its length, `p` and `n` by a day (yesterday), `-` and `+` make it shorter or longer (5 min to 1
+  day), `g` goes to a time, `t` to the latest window. The latest window is live: new messages are added every 2 s with
+  the `tail` command and the window moves with the time; the view follows while it's at the end (`end`). The tree at
+  the left has the loggers of the window with their number of messages; `space` selects a logger and those below it,
+  only their messages are shown. Below it the processes that logged the messages, `space` selects a process in the
+  same way (with both selected, a message must be of both); `c` clears the selection. `f`, `d` and `w` filter, hide
+  the DEBUG messages and wrap, as in the log panel of the logger;
+- `F1`: help, on every screen (from a detail screen or the log screen it opens at the part about that screen);
+- `ctrl+q`: quit.
+
+The overview also shows the device drivers of the project: every node of the Setup (loaded by the configuration
+manager) with a `cgse_object`, e.g. `gse.DAQ6510.cgse_object: daq6510`, with its `device_name` and optional
+`device_id`. A device that runs is shown as its service in the registry; one that doesn't run is shown dimmed, with an
+empty frame, and can be started with `a` (`cgse <object> start [<device_id>]`). See "Device drivers in the Setup" in
+`docs/libs/cgse-common/setup.md`.
+
+The detail screen shows the selected service in panels, updated every second:
+
+- Service: the registration in the service registry and the endpoints (Service, Process and Device have the same
+  height);
+- Process: PID, uptime, CPU and memory. CPU % and memory are shown in orange (warning) or red (critical) when the
+  process uses too much CPU or its memory keeps growing, with the reason below, see "CPU and memory warnings";
+- Device: the connection and simulator mode, only for services that control a device;
+- Details: the service specific status. For a control server these are the `details` of its status report,
+  updated with the live values of its monitoring messages (the border says `live`), for the registry, logger and
+  hubs their own status. The package of a device can show its details in its own way with a plugin (e.g. the
+  positions of the hexapods). The TUI has its own panels for the core services: the disk usage of the Storage
+  Manager, the observation and the whole Setup of the Configuration Manager, the messages per second, the queue
+  and the database of the Metrics Hub, the events of the Notification Hub, and the log file, the messages by level
+  and the last warning and error of the logger. Otherwise the details are shown as a tree, see "Details in the TUI"
+  in `docs/dev_guide/plugins.md`;
+- Registrations: only for the service registry, all registered services; `enter` shows the details of the selected
+  service, `esc` goes back.
+- Log: only for the logger, the last log lines, coloured by level, filling the lower part of the screen; new lines are
+  requested every 2 s with the `tail` command of the logger (a logger of an older version doesn't have it). The
+  lines follow the new messages while the view is at the end; scrolled up, the view stays at the same lines (`end`
+  follows again). `m` makes the panel fill the screen and back, `f` filters the lines on levels, process, logger or
+  module, words in the message, and a time range, and hides or dims the other lines; `d` hides the DEBUG lines, `w`
+  wraps the long lines. The panel keeps the last 1000 messages (the logger keeps 10 000 in memory), the filter applies
+  to those;
+- Core services: only for the Process Manager, the core services it manages with their state in the TUI; `enter`
+  shows the details of the selected service, `esc` goes back.
+
+CPU and memory warnings: the TUI judges the process of every service, and shows the CPU % and memory in orange or red,
+also in the overview, and writes a message in the log pane when this changes:
+
+- CPU: the average CPU % over the last minute, a warning from 50 %, critical from 90 %;
+- memory: the growth of the memory, the RSS plus what is swapped out, over the last 10 minutes, a warning from 10 %,
+  critical from 25 %. It's judged when there are samples of at least 5 minutes, so a process that just started isn't
+  taken for a leak. The swapped-out memory counts because leaked memory ends up in swap: the RSS alone can go down
+  while a process leaks. A service of an older version doesn't report its swap, then only the RSS counts.
+
+The limits are in `cgse_tui/data/health.py`.
+
+Panels are dimmed when the service is stale or not running. Keys in the detail screen: `r` requests the status report
+now (otherwise every 10 s), `a` starts, stops or restarts the service, `v` shows the raw status report, `m`, `f` and `d`
+maximize and filter the log lines of the logger and hide its DEBUG lines, `esc` goes back to the overview.
+
+Start, stop and restart run the `cgse <object> start|stop` command of the service, with its device identifier, e.g.
+`cgse puna stop PUNA_01`. The dialog shows the commands; selecting an action is the confirmation. A running service
+can be stopped or restarted, a core service that is not running can be started. With the simulator checkbox, the
+service is started with its simulator: a simulator that is a separate process (e.g. DAQ6510, TVAC) is started first
+with `cgse <object> start-sim` when it isn't running, other drivers are started with `--sim`. The checkbox is checked
+when the service runs with its simulator now. With the verbose debug checkbox, the service (and its simulator) is
+started with `VERBOSE_DEBUG=1`, otherwise without it. The progress and the result are written to the log pane: the
+TUI waits up to 30 s until a started service is registered, or a stopped service is no longer registered. The commands
+run in their own session, so the services started from the TUI don't belong to the terminal of the TUI.
+
+## Latest release
+
+- PyPI: https://pypi.org/project/cgse-tui/
+- GitHub releases: https://github.com/IvS-KULeuven/cgse/releases
+- Changelog: https://github.com/IvS-KULeuven/cgse/blob/main/CHANGELOG.md

cgse_tui-0.26.0/pyproject.toml

@@ -0,0 +1,81 @@
+[project]
+name = "cgse-tui"
+version = "0.26.0"
+description = "Terminal user interface with the status of the CGSE core services and device control servers"
+authors = [
+    {name = "IvS KU Leuven"}
+]
+maintainers = [
+    {name = "Rik Huygen", email = "rik.huygen@kuleuven.be"},
+]
+readme = {"file" = "README.md", "content-type" = "text/markdown"}
+requires-python = ">=3.10"
+license = "MIT"
+keywords = [
+    "CGSE",
+    "Common-EGSE",
+    "hardware testing",
+    "software framework",
+    "textual",
+]
+dependencies = [
+    "cgse-common",
+    "cgse-core",
+    "textual>=2.0.0",
+    "typer",
+]
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-mock", "pytest-cov"]
+
+[project.scripts]
+cgse_tui = "cgse_tui.cli:main"
+
+[project.entry-points."cgse.version"]
+cgse-tui = 'egse.version:get_version_installed'
+
+[project.entry-points."cgse.command"]
+tui = 'cgse_tui.cli:tui'
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "/tests",
+    "/pytest.ini",
+    "/.gitignore",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cgse_tui"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["F", "I"]
+extend-select = ["E", "W"]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.9.0",
+    "pytest-asyncio>=0.26.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/IvS-KULeuven/cgse/tree/main/projects/generic/cgse-tui"
+Repository = "https://github.com/IvS-KULeuven/cgse"
+Releases = "https://github.com/IvS-KULeuven/cgse/releases"
+Changelog = "https://github.com/IvS-KULeuven/cgse/blob/main/CHANGELOG.md"
+Documentation = "https://ivs-kuleuven.github.io/cgse/"

cgse_tui-0.26.0/src/cgse_tui/__init__.py

@@ -0,0 +1 @@
+"""Terminal user interface with the status of the CGSE core services and device control servers."""

cgse_tui-0.26.0/src/cgse_tui/app.py

@@ -0,0 +1,175 @@
+"""The Textual application."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from egse.logfiles import CGSE_OBJECT as LOG_FILES_CGSE_OBJECT
+from egse.system import get_machine_id
+from textual.app import App
+from textual.screen import Screen
+
+from cgse_tui.data.actions import ServiceActions
+from cgse_tui.data.collector import Collector
+from cgse_tui.data.model import ServiceInfo
+from cgse_tui.data.model import ServiceState
+from cgse_tui.logs import BufferedLogHandler
+from cgse_tui.logs import capture_logging
+from cgse_tui.logs import create_log_file_handler
+from cgse_tui.plugins import DetailsRenderers
+from cgse_tui.screens.action_select import ActionSelectScreen
+from cgse_tui.screens.detail import DetailScreen
+from cgse_tui.screens.files_screen import LogFilesScreen
+from cgse_tui.screens.help import DETAIL_SCREEN_ANCHOR
+from cgse_tui.screens.help import LOG_SCREEN_ANCHOR
+from cgse_tui.screens.help import HelpScreen
+from cgse_tui.screens.log_screen import LogScreen
+from cgse_tui.screens.overview import OverviewScreen
+
+logger = logging.getLogger("cgse_tui.app")
+
+
+class CgseTuiApp(App):
+    """Shows the status of the CGSE core services and device control servers.
+
+    While the app runs, log messages are shown in the log pane of the overview instead of on the terminal.
+
+    Args:
+        collector: collects the status of the services, a default `Collector` when None.
+        refresh_interval: seconds between two updates of the overview.
+        log_file: file that gets all log messages, also those that are not shown in the log pane, e.g. the timeouts
+            of the client libraries. No log file when None.
+        actions: starts, stops and restarts the services, a default `ServiceActions` when None.
+        logs: opens the log screen at start-up, on top of the overview.
+    """
+
+    BINDINGS = [("f1", "help", "Help")]
+
+    TITLE = "CGSE"
+    SUB_TITLE = "Status of services and devices"
+
+    def __init__(
+        self,
+        collector: Collector | None = None,
+        refresh_interval: float = 1.0,
+        log_file: Path | None = None,
+        actions: ServiceActions | None = None,
+        logs: bool = False,
+    ):
+        super().__init__()
+        self.log_file = log_file
+        self.log_handler = BufferedLogHandler()
+        self._restore_logging = None
+        self.collector = collector if collector is not None else Collector()
+        self.refresh_interval = refresh_interval
+        self.actions = actions if actions is not None else ServiceActions(self.collector)
+        self.overview = OverviewScreen()
+        self.details_renderers = DetailsRenderers()
+        self._logs_at_start = logs
+
+    def get_default_screen(self) -> Screen:
+        return self.overview
+
+    def on_load(self) -> None:
+        handlers = [self.log_handler]
+        file_error = None
+        if self.log_file is not None:
+            try:
+                handlers.append(create_log_file_handler(self.log_file))
+            except OSError as exc:
+                file_error = exc
+        self._restore_logging = capture_logging(*handlers)
+        logging.getLogger("cgse_tui").setLevel(logging.INFO)  # e.g. the state changes logged by the collector
+
+        if file_error is not None:
+            logger.warning(f"Couldn't open the log file {self.log_file}: {file_error}")
+        elif self.log_file is not None:
+            logger.info(f"All log messages are also written to {self.log_file}")
+
+    def on_mount(self) -> None:
+        self.run_worker(self.collector.run(), name="collector", group="collector", exit_on_error=False)
+        self.call_after_refresh(self.update_overview)  # the overview screen is mounted by then
+        self.set_interval(self.refresh_interval, self.update_overview)
+        if self._logs_at_start:
+            self.call_after_refresh(self.show_logs)
+
+    def on_unmount(self) -> None:
+        if self._restore_logging is not None:
+            self._restore_logging()
+            self._restore_logging = None
+
+    def show_details(self, service_type: str) -> None:
+        """Opens the detail screen of a service, e.g. selected in the overview or in the registrations."""
+        service = next((s for s in self.collector.snapshot() if s.service_type == service_type), None)
+        if service is None:
+            self.notify(f"{service_type} is not known (yet).", severity="warning")
+            return
+        refresh = getattr(self.collector, "refresh_report", None)
+        self.push_screen(DetailScreen(service, refresh=refresh and (lambda: refresh(service_type))))
+
+    def find_logger(self) -> ServiceInfo | None:
+        """The logger service, None when it isn't known (yet)."""
+        return next((s for s in self.collector.snapshot() if s.cgse_object == "log" and s.host and s.port), None)
+
+    def show_logs(self) -> None:
+        """Opens the log screen with the latest hour of log messages, read from the log files by the logger."""
+        if not isinstance(self.screen, LogScreen):
+            self.push_screen(LogScreen(self.find_logger))
+
+    def find_log_file_services(self) -> list[ServiceInfo]:
+        """The log-files services, one per machine and log folder, see `egse.logfiles`."""
+        return [s for s in self.collector.snapshot() if s.cgse_object == LOG_FILES_CGSE_OBJECT and s.host and s.port]
+
+    def action_show_log_files(self) -> None:
+        """Opens the log-files screen with the files of the log folders of the machines."""
+        if not isinstance(self.screen, LogFilesScreen):
+            self.push_screen(LogFilesScreen(self.find_log_file_services))
+
+    def action_help(self) -> None:
+        """Shows the help, at the part about the detail screen or the log screen when opened from there; F1 in the help
+        closes it."""
+        if isinstance(self.screen, HelpScreen):
+            return
+        if isinstance(self.screen, DetailScreen):
+            anchor = DETAIL_SCREEN_ANCHOR
+        elif isinstance(self.screen, LogScreen):
+            anchor = LOG_SCREEN_ANCHOR
+        else:
+            anchor = None
+        self.push_screen(HelpScreen(anchor))
+
+    def select_action(self, service: ServiceInfo) -> None:
+        """Asks the user to start, stop or restart the service, and performs the selected action."""
+        if self.actions.is_busy(service.service_type):
+            self.notify(f"{service.name}: an action is still running.", severity="warning")
+            return
+        if service.cgse_object == LOG_FILES_CGSE_OBJECT and service.metadata.get("machine_id") != get_machine_id():
+            # `cgse lf` acts on the service of the machine where it runs, i.e. the machine of the TUI.
+            self.notify(f"{service.name} runs on another machine, use `cgse lf` there.", severity="warning")
+            return
+        is_running = getattr(self.collector, "is_running", None)
+        running = is_running(service.service_type) if is_running else service.state is not ServiceState.INACTIVE
+
+        def perform(choice: tuple[str, bool, bool] | None) -> None:
+            if choice is not None:
+                action, simulator, verbose_debug = choice
+                self.run_worker(self._perform(action, service, simulator, verbose_debug), group="actions")
+
+        simulator_support = getattr(self.actions, "simulator_support", None)
+        self.push_screen(ActionSelectScreen(service, running, simulator_support), perform)
+
+    async def _perform(self, action: str, service: ServiceInfo, simulator: bool, verbose_debug: bool = False) -> None:
+        ok = await self.actions.perform(action, service, simulator, verbose_debug=verbose_debug)
+        if not ok:
+            self.notify(f"{service.name}: {action} failed, see the log pane.", severity="error")
+        self.update_overview()
+
+    def update_overview(self) -> None:
+        services = self.collector.snapshot()
+        self.overview.show_services(services)
+        for screen in self.screen_stack:
+            if isinstance(screen, DetailScreen):
+                screen.show_services(services)
+        if messages := self.log_handler.drain():
+            self.overview.show_log_messages(messages)

cgse_tui-0.26.0/src/cgse_tui/cli.py

@@ -0,0 +1,32 @@
+"""The `cgse tui` command and the `cgse_tui` script."""
+
+from typing import Annotated
+
+import typer
+
+
+def tui(
+    logs: Annotated[
+        bool, typer.Option("--logs", help="Open the log screen: the log messages of the logger, read from its files.")
+    ] = False,
+):
+    """Start the terminal user interface with the status of the CGSE services and devices.
+
+    All log messages are written to `cgse_tui.log` in the CGSE log file location.
+    """
+    from pathlib import Path
+
+    from egse.env import get_log_file_location
+
+    from cgse_tui.app import CgseTuiApp  # Textual is only imported when the TUI is started
+    from cgse_tui.logs import LOG_FILE_NAME
+
+    CgseTuiApp(log_file=Path(get_log_file_location()).expanduser() / LOG_FILE_NAME, logs=logs).run()
+
+
+def main():
+    typer.run(tui)
+
+
+if __name__ == "__main__":
+    main()

cgse_tui-0.26.0/src/cgse_tui/data/__init__.py

@@ -0,0 +1 @@
+"""The data layer of the TUI. This package has no Textual imports, so it can be tested without a user interface."""