Examples of dynamically updating content

[SimplicityGuy]

I'm looking to create a TUI with a grid of 4 boxes, where the content of each box is updated from 4 async calls. I'd love to make the setup as simple as possible, and do something like layout["box1"].print(f"... {data}").

Is there a good tutorial or example on doing something like that?

[bczsalba]

Hey there!

What kind of data would you have in these containers? As in, is it just text, or some widgets if various types?

[bczsalba]

Hmm, I think you have 2 main options then:

1. Changing a label's value

   If you are only looking for straight up text values to append, you could use a set of pre-assigned labels added to your windows and just manipulate their values:

   label1 = ptg.Label()
   manager.add(ptg.Window(label1), assign="box1")
   
   # ...later in your code
   label1.value = "something else"

2. Overwriting the container's widgets using set_widgets

   Otherwise, if you need to do more than just a label, you can also set the content of your given container:

   box1 = ptg.Window()
   manager.add(box1, assign="box1")
   
   # ...later in your coded
   box1.set_widgets([some_list_of_widgets])

   In this case, the list of widgets can contain anything that can be used to generate a widget.

Let me know how it goes!

[SimplicityGuy]

Thanks for the suggestion! In messing around with this, I'm still a bit confused. In a WindowManager, if I do:

# -- demo.py --
import pytermgui as ptg

with ptg.WindowManager() as manager:
    label1 = ptg.Label()
    box1 = ptg.Window(label1)
    manager.add(box1)
    
    label1.value = "something else"
    manager.add(box1)
    manager.run() # << ref1

    for n in range(0, 500):
        label1.value = str(n)

I need to Ctrl-C once the WindowManager is running, and then the code after runs. If I move the manager.run() to the end, only the last value is displayed (e.g., 499).

[bczsalba]

Running the manager will cause that behaviour, it starts a blocking loop of all the actions. It actually runs automatically if it wasn't called within the context, so if you just remove the ref1 line it should work.

Regarding the labels, you are changing the value of the single label, overwriting it every time. If you wanna extend its value, you could += the new value, otherwise you can use options 2 from above and a list of widgets, whos values you define within the loop.

[SimplicityGuy]

I tried 2 different ways:

import pytermgui as ptg

with ptg.WindowManager() as manager:
    box1 = ptg.Window(title="box1")
    manager.add(box1)

    widgets = []
    for n in range(0, 500):
        label = ptg.Label()
        label.value = f"{n}"
        widgets.append(label)
        box1.set_widgets(widgets)

This essentially hangs on what seems to be rendering the Window.

Second approach:

import pytermgui as ptg

with ptg.WindowManager() as manager:
    label = ptg.Label()
    box1 = ptg.Window(label, title="box1")
    manager.add(box1)

    for n in range(0, 500):
        label.value += f"{n}\n"

This only displays 0 and doesn't seem that the Window resizes.

[bczsalba]

This notification totally escaped me, sorry!

So the second way I think doesn't work because the window's height is only recalculated when a new object is added to it, so the label's value changing won't affect it.

In case of the first option, calling set_widgets requires a lot of get_lines calls. These are probably the most expensive built in calls through the entire library, so that's probably the cause of the hang.

Here is some code that would work, btw:

import pytermgui as ptg

with ptg.WindowManager() as manager:
    box1 = ptg.Window(title="box1", height=30, overflow=ptg.Overflow.SCROLL)
    manager.add(box1)

    for n in range(0, 500):
        label = ptg.Label(f"{n}")
        box1.lazy_add(label)

Instead of using set_widgets (which, to be fair, I was the one to suggest), lazy_add lets us do the entire operation basically instantly, as it doesn't call get_lines every time. That doesn't quite help our updating situation, however.

One easy way I can think of solving this is something like the following:

import pytermgui as ptg


def _append(label: ptg.Label, text: str) -> None:
    label.value += text


with ptg.WindowManager() as manager:
    manager.layout.add_slot("Box1")
    manager.layout.add_slot("Box2")

    box1_label = ptg.Label("box1")
    box2_label = ptg.Label("box2")

    manager.add(
        ptg.Window(box1_label, vertical_align=ptg.VerticalAlignment.TOP),
        assign="box1",
    )
    manager.add(
        ptg.Window(box2_label, vertical_align=ptg.VerticalAlignment.TOP),
        assign="box2",
    )

    manager.bind("1", lambda *_: _append(box1_label, "\nbox1"))
    manager.bind("2", lambda *_: _append(box2_label, "\nbox2"))

Here, by using layouts we enforce the windows to be tall enough to display the new content (added by pressing "1" or "2", respectively). Once there is too much content on a window it will overflow and get cut off, but that can be resolved using overflow=ptg.Overflow.SCROLL in the window definition. The vertical_align settings aren't necessary for the example to work, but they make things a bit more understandable when running the app.

BTW, I'm currently rewriting the documentation and will surely focus on this type of usecase to help future users. Thank you for your questions so far!