Cannot get app to dynamically update

[dominicfmazza]

I am struggling to get a dynamic UI up an running to monitor the status of rosnodes in ROS system. I have tried multiple different
refactors with no success. Nothing is updating correctly, and I am honestly struggling. Any help is appreciated!!

topic_analyzer.py

# textual inmports
from textual.app import App, ComposeResult
from textual.widgets import Static, Footer, DataTable
from textual.widget import Widget
from textual.reactive import reactive
from textual.screen import Screen
from textual.coordinate import Coordinate
from textual.containers import Horizontal

# rich renderables
from rich.table import Table
from rich.panel import Panel
from rich.style import Style
from rich.layout import Layout

# utility
from datetime import datetime
from config import build_topics, Topic
from os import environ

# rospy
import rospy
import rostopic
import warnings


class Message(Widget):
    msg = reactive("", always_update=True)

    def render(self):
        return self.msg

    def watch_msg(self, new_msg):
        self.refresh()


class Grid(Widget):
    hz = reactive("", always_update=True)
    topic: Topic

    def render(self):
        grid = Table.grid(expand=True)
        grid.add_column(
            style=Style(
                color="white",
                frame=True,
                bold=True,
            ),
        )
        grid.add_column(
            style=Style(
                color="white",
            ),
        )
        grid.add_row("Name:", self.topic.display_name)
        grid.add_row("Topic:", self.topic.handle)
        grid.add_row("HZ:", f"{self.hz}/{self.topic.hz_target}")
        return grid

    def update_topic(self, topic):
        self.topic = topic
        self.refresh()

    def watch_hz(self, new_hz):
        self.refresh()


class Info(Widget):
    info = reactive("", always_update=True)

    def watch_info(self, new_info):
        self.refresh()

    def render(self):
        return self.info


# Header of the topic display
class Header(Widget):
    current_time = reactive(datetime.now().ctime(), always_update=True)

    def render(self):
        grid = Table.grid(expand=True)
        grid.add_column(justify="center", ratio=1)
        grid.add_column(justify="right")
        grid.add_row("AVC Topic Analyzer", self.current_time)
        return grid


class TopicFocus(Screen):

    BINDINGS = [
        ("l", "change_to_list()", "Change to List View"),
        ("q", "exit()", "Exit Topic Analyzer"),
    ]

    subscriber: rospy.Subscriber
    topic = reactive(None, always_update=True)

    def compose(self) -> ComposeResult:
        self.info = Info()
        self.grid = Grid()
        self.message = Message()
        yield Header()
        yield Horizontal(
            self.info,
            self.grid,
            self.message,
        )
        yield Footer()

    def watch_topic(self, topic):
        if topic is not None:
            self.subscriber = rospy.Subscriber(
                topic.handle,
                topic.topic_class,
                self.callback,
            )
            self.grid.update_topic(topic)
            self.grid.hz = self.topic.get_hz()
            self.info.info = rostopic.get_info_text(topic.handle)
        self.grid.refresh()
        self.info.refresh()
        self.message.refresh()

    def callback(self, msg):
        self.message.msg = repr(msg)

    def action_change_to_list(self):
        self.app.switch_screen("outline")

    def action_exit(self):
        self.app.exit()
        exit()


class TopicOutline(Screen):
    BINDINGS = {
        ("t", "select_topic()", "Focus Clicked Topic"),
        ("q", "exit()", "Exit Topic Analyzer"),
    }

    table = reactive(DataTable, always_update=True)

    def compose(self):
        yield Header()
        yield self.table
        yield Footer()

    def on_mount(self):
        self.table.cursor_type = "row"
        self.table.add_column("Name")
        self.table.add_column("Topic")
        self.table.add_column("HZ")
        self.table.add_column("HZ Target")
        self.table.add_column("Message Type")
        for index, topic in enumerate(self.app.topics):
            name = topic.display_name
            topic_handle = topic.handle
            hz = round(topic.get_hz(), 2)
            hz_target = topic.hz_target
            msg_type = topic.msg_type
            self.table.add_row(
                name,
                topic_handle,
                hz,
                hz_target,
                msg_type,
            )

    def action_select_topic(self):
        self.app.index = self.table.cursor_row
        self.app.get_screen("focus").topic = self.app.get_topic()
        self.app.switch_screen("focus")

    # gives the rates of rostopics a color to indicate status
    # returns hz and the target hz as well to reduce the locking
    # in ROSTopicHZ.get_hz()
    def rate_status_color(self, hz, target):
        if target != 0 and hz / target > 0.9:
            return "green", hz, target
        elif target != 0 and hz / target > 0.75:
            return "yellow", hz, target
        else:
            return "red", hz, target

    def action_exit(self):
        self.app.exit()
        exit()


# Handles the entire UI
# Members:
#   - layout: layout of the entire UI
#   - live: auto_refreshing display for the UI
class TopicUI(App):
    CSS_PATH = "display.css"

    config_file: str = (
        "/home/{}/vehicle/src/tools/topic_analyzer/cfg/topics.json".format(
            environ.get("USERNAME")
        )
    )

    SCREENS = {
        "outline": TopicOutline(),
        "focus": TopicFocus(),
    }

    def __init__(self):
        warnings.filterwarnings(
            action="ignore",
            message="unclosed",
            category=ResourceWarning,
        )

        self.topics = build_topics(self.config_file)
        self.index = 0
        super().__init__()

    def get_topic(self):
        return self.topics[self.index]

    def on_mount(self):
        self.push_screen("focus")
        self.push_screen("outline")

    def callback_after_refresh(self):
        if self.get_screen("outline").table.row_count > 0:
            for index, topic in enumerate(self.topics):
                self.get_screen("outline").table.update_cell_at(
                    Coordinate(index, 2), topic.get_hz()
                )
            self.get_screen("outline").table.refresh()


if __name__ == "__main__":
    rospy.init_node("topic_analyzer")
    # TODO: Create a dialog of available configuration files for the user to choose from
    app = TopicUI()
    app.run()

config.py

import json
import rospy
import rostopic

# Object that holds all relevant topic information
# Members:
#   - readable_name: The plaintext names for the topic, ex: "Radar 1"
#   - handle: The actual ROS topic, ex: "/sensor/radar/radar_1"
#   - hz_target: Targetted rate of topic, ex: 60.00 (float in hz)
#   - msg_type: Type of ROS msg, ex: "std_msgs.msg/float"
#   - hz_class: Is of type ROSTopicHZ, allows for tracking of hz
class Topic:
    def __init__(
        self,
        display_name,
        handle,
        hz_target,
    ):
        self.display_name = display_name
        self.handle = handle
        self.hz_current = 0.0
        self.hz_target = hz_target
        # Message type and hz_class are set in TopicAnalyzer initialization
        self.msg_type = ""
        self.topic_class = None
        self.hz_class = None
        self.subscriber = None

    # Custom defined method for getting hz
    # ROSTopicHZ class does have a get_hz() method, but this returns a tuple
    # of values, not just the rate. When you attempt to access individual elements of
    # the tuple, the display hangs (dunno why)
    # This function is just the rate calculation from the ROSTopicHZ.get_hz() function
    def update_hz(self):
        # Check to make sure timestamps aren't empty
        if not self.hz_class.get_times():
            self.hz_current = 0.0
        elif self.hz_class.get_msg_tn() == self.hz_class.get_last_printed_tn():
            self.hz_current = 0.0
        # Lock execution to prevent callbacks during the calculation
        with self.hz_class.lock:
            # number of samples
            n = len(self.hz_class.get_times())
            # mean times over the amount of samples
            mean = (sum(self.hz_class.get_times()) / n) if n != 0.0 else 0.0
            # rate in hz
            rate = 1.0 / mean if mean > 0.0 else 0.0
            self.hz_current = rate

    def get_hz(self):
        self.update_hz()
        return self.hz_current


# builds a list of topic objects from a configuration json
def build_topics(config_file):
    with open(config_file) as file:
        topic_dict = json.load(file)
        topics = []
        for topic in topic_dict["topics"]:
            topic = Topic(
                display_name=topic["display_name"],
                handle=topic["handle"],
                hz_target=topic["hz_target"],
            )
            # All we need from rostopic.get_topic_class() is the message type
            (topic.topic_class, _, _) = rostopic.get_topic_class(topic.handle)
            # _type gives us a human readable msg type
            topic.msg_type = str(topic.topic_class._type)
            # Creates a ros-defined object that tracks the rate of topics
            topic.hz_class = rostopic.ROSTopicHz(100)
            # Subscribe to the correct topic, with the callback being the hz callback
            topic.subscriber = rospy.Subscriber(
                topic.handle, topic.topic_class, topic.hz_class.callback_hz
            )

            topics.append(topic)
        return topics

textual diagnose

# Textual Diagnostics

## Versions

| Name    | Value  |
|---------|--------|
| Textual | 0.12.1 |
| Rich    | 13.3.1 |

## Python

| Name           | Value            |
|----------------|------------------|
| Version        | 3.8.10           |
| Implementation | CPython          |
| Compiler       | GCC 9.4.0        |
| Executable     | /usr/bin/python3 |

## Operating System

| Name    | Value                                               |
|---------|-----------------------------------------------------|
| System  | Linux                                               |
| Release | 5.15.0-60-generic                                   |
| Version | #66~20.04.1-Ubuntu SMP Wed Jan 25 09:41:30 UTC 2023 |

## Terminal

| Name                 | Value          |
|----------------------|----------------|
| Terminal Application | *Unknown*      |
| TERM                 | xterm-256color |
| COLORTERM            | *Not set*      |
| FORCE_COLOR          | *Not set*      |
| NO_COLOR             | *Not set*      |

## Rich Console options

| Name           | Value                |
|----------------|----------------------|
| size           | width=254, height=61 |
| legacy_windows | False                |
| min_width      | 1                    |
| max_width      | 254                  |
| is_terminal    | True                 |
| encoding       | utf-8                |
| max_height     | 61                   |
| justify        | None                 |
| overflow       | None                 |
| no_wrap        | False                |
| highlight      | None                 |
| markup         | None                 |
| height         | None                 |

[davep]

Unfortunately that's quite a lot of code to take in, and has dependencies such that it's not easy to try out or follow. It would be helpful if you could possibly reduce your problem to the smallest stand-alone bit of code possible, then it might be easier to help out.

[mharig]

Asyncio works only correctly, when ALL modules use asyncio. If not, you must introduce multithreading/multiprocessing at the right place. This thread may help you:

#1828