Updating DataTable data

[weissjonas]

Dear all,

I want to use a DataTable to View data that changes rapidly.
Would anyone be able to help me with a working example of a refresh of the DataTable?
I tried the "update_cell" function. But was unable to get it running.

from textual.app import App, ComposeResult
from textual.containers import ScrollableContainer, Vertical
from textual.reactive import reactive
from textual.widgets import  DataTable
from rich.text import Text
import random


def read_value():
    return random.uniform(0, 1)


class ParamView(Vertical):
    """A widget that shows parameters"""

    param = reactive(read_value())

    ROWS = [
        ("parameter", "value", "unit"),
        ("param1", param, "myUnit"),
    ]

    def ParamTable( self ) -DataTable:
        table = DataTable()
        table.cursor_type   = "row"
        table.add_columns(*self.ROWS[0])
        for row in self.ROWS[1:]:
            # Adding styled and justified `Text` objects instead of plain strings.
            styled_row = [
                row[0],Text(str(row[1]), justify="right"),row[-1]
            ]
            table.add_row(*styled_row,key=row[0])
        return table

    def compose( self ) -ComposeResult:
        yield self.ParamTable()

    # def render(self):
    #     self.query_one(ParamView).update_cell("param1", "value", 42)
    # Yield Error:
    # NoMatches: No nodes match <DOMQuery query='ParamView'>



class minimalApp(App):
    """Minimal Textual app to change DataTable data."""

    def compose(self) -ComposeResult:
        """Called to add widgets to the app."""
        yield ScrollableContainer(ParamView())


if __name__ == "__main__":
    app = minimalApp()
    app.run()

Thank You!
I also want express my gratitude for this great project!

[davep]

There's a couple of things that are an issue in the code you post above. First off, you wouldn't use render to update a widget like that; the render method is generally used to provide the renderable value for widget that doesn't compose other widgets.

Second: you're trying to perform a CSS type query on a widget type that doesn't exist. You're looking for ParamView on itself, but a query looks at all of the descendants of a widget. On top of that, ParamView in your code is a Vertical, it isn't a DataTable, so the call to update_cell wouldn't work anyway.

If it helps, here's a small example of a table that gets updated every so often with a random value:

from random import randint, random

from textual.app import App, ComposeResult
from textual.widgets import DataTable

class UpdatingTableExampleApp(App[None]):

    def compose(self) -> ComposeResult:
        yield DataTable()

    def on_mount(self) -> None:

        table = self.query_one(DataTable)
        table.add_column("Parameter", key="param")
        table.add_column("Value", key="value")
        for n in range(50):
            table.add_row(f"Paramater {n}", 0, key=f"param{n}")

        self.set_interval(0.1, self.update_table)

    def update_table(self) -> None:
        table = self.query_one(DataTable)
        row = randint(0, 49)
        table.update_cell(f"param{row}", "value", random())

if __name__ == "__main__":
    UpdatingTableExampleApp().run()

[vigne-Sh]

Just wanted to check if this scenario is possible in textual through function call

for eg. if a particular function fetches data from api service calls and returns a rich Table which is yielded as a widget in the app

• users after opening the textual app in their terminal

• the function which returns the table data, should be refreshing in smaller intervals to fetch the latest data from API service calls and update the latest data to the users

• Similar to fetching weather information through API service call every xx minutes

[davep]

This might have been better as a discussion question in its own right, but: some of the specifics of what you're asking aren't quite clear to me, but more generally yes you could absolutely write a Textual application that polls an API and updates a DataTable or some other widget.

[TomJGooding]

the function which returns the table data, should be refreshing in smaller intervals to fetch the latest data from API service calls and update the latest data to the users

Textual has a set_interval method to call a function at periodic intervals (see the Tutorial). But I'm not actually sure if it's okay to use a Worker as the callback?

import httpx
from textual import work
from textual.app import App, ComposeResult
from textual.widgets import Static


class ExampleApp(App):
    def compose(self) -> ComposeResult:
        yield Static("Europe/Amsterdam")
        yield Static(id="time")

    def on_mount(self) -> None:
        # is it okay to use a worker as the callback here?
        self.set_interval(1, self.update_time)

    @work(exclusive=True)
    async def update_time(self) -> None:
        time_widget = self.query_one("#time", Static)
        url = "https://timeapi.io/api/Time/current/zone?timeZone=Europe/Amsterdam"
        async with httpx.AsyncClient() as client:
            response = await client.get(url)
            data = response.json()
            time_str = f"{data['hour']:02}:{data['minute']:02}:{data['seconds']:02}"
            time_widget.update(time_str)


if __name__ == "__main__":
    app = ExampleApp()
    app.run()

[illeatmyhat]

A big huge facepalm moment is realizing that when defining columns, the key field is extremely important and easily forgettable.
table.add_column("Value", key="value")
The docs should probably be updated so that using update_cell() has an actual example.

[vigne-Sh]

sorry about that, I have opened a new discussion - discussions/3379
with a short example