Interacting with a live display

[ig-perez]

Hi Will, thanks for building and sharing rich, it is awesome!

I'm trying to build a TUI, and I was exploring if I can do it with rich. I want to display a table with some rows, and below it a string of text showing some options, for example [R]efresh, [Q]uit, [S]ave

Then capture the user input and update the table (pressed key was R), quit, or save the table in the disk.

I see rich offers a class called Live but I couldn't find a way to use Prompt.ask to capture the user input and act based on it.

Can I achieve my needs with rich as it is today? If so, can you please suggest me how to do it?

If it is not possible, which package would you recommend me to use?

Thanks a lot!

[Cristianasp]

Hello. I have the same request here. It seams that it is not supported... :-(

I tried several libraries.. but no success. My idea was to add a library that gets keyboard input, write to a file (or maybe send a signal?), and read it in the program.

The code below was the best I could get... gotta hit ESC then ControlC to exit. But if you change focus to another window you will crash everything. To start, you need a output.txt already created .

# declare your layout etc..

# keyboard listener

from pynput import keyboard

def on_press(key):
    try:
        with open("Output.txt", "w") as text_file:
            text_file.write(key.char)
    except AttributeError:
        print('special key {0} pressed'.format(key))

def on_release(key):
    print('{0} released'.format( key))
    if key == keyboard.Key.esc:
        # Stop listener
        return false
        # exit() # crashes 


listener = keyboard.Listener(
    on_press=on_press,
    on_release=on_release, suppress=True)
    
listener.start()

i=0
with Live(layout, screen=True):
    while True:
        f = open("Output.txt","r+")
        c = f.read(1)
        if c != "":
            layout["whatever"].update(Panel("a text"+ str(i)))
            f.seek(0)
            f.truncate()
            f.close()
            i=i+1

Any contributions to this code ? Thanks

[willmcgugan]

@ig-perez @Cristianasp To answer both your questions...

Rich doesn't yet handle keyboard input, other than Input() (or Prompt.ask). Unfortunately input() is unlikely to work well with Live.

@Cristianasp Your idea of using using pynput is probably a good one (although I haven't tried myself). No need to write to files though. What I would suggest you do is put your logic inside on_press. Update layout["whatever"] there.

Your live loop need only do something like the following:

with Live(layout, screen=True):
    while True:
        sleep(1)

Hope that helps!

[Cristianasp]

Thank you ! I improved the code and it is working (except for a problem if I focus another window in linux...)
Here is the snippet:

from pynput import keyboard

def on_press(key):
    if key == keyboard.Key.esc:
        return False
    if hasattr(key, 'char'):
        layout["header"].update(Panel(key.char+ " text"))

listener = keyboard.Listener(on_press=on_press,suppress=True)   
listener.start()

with Live(layout, screen=True):  
    while True:
        try:
            sleep(1)
        except KeyboardInterrupt:
            break

Here is the documentation: https://pynput.readthedocs.io/en/latest/keyboard.html#monitoring-the-keyboard

[ig-perez]

That's a good one @Cristianasp , thanks for sharing!

[ig-perez]

Thanks @willmcgugan and @Cristianasp for your ideas and suggestions. In my case I ended up creating a shell with a cmdloop. That is enough for the MVP I'm building right now, but I'm eager to switch to Rich when the keyboard input for Live is supported.

I'm really excited with Rich. I think that building TUIs is an excellent option to make an idea or project come true in a simple and fast way (assuming your target users are not afraid of terminals of course 🤓). It doesn't have the complexity of a Web User Interface nor faces the portability issues of desktop apps. The recently added Layouts are fantastic!

[LorhanSohaky]

I don't know if the way I did it creates some kind of bottleneck, but the concept would be something like this.
The way I thought it is possible to have "sleep" and receive user input

menu.mp4

import random
import readchar
import asyncio
from threading import Timer

from rich.live import Live
from rich.table import Table


def list_systems():
    names = ["Ubuntu", "Debian", "Kali", "Arch", "Fedora", "CentOS"]
    states = ["Stopped", "Running"]

    values = []
    for name in names:
        values.append(
            {
                "name": name,
                "state": random.choice(states),
            }
        )

    return values


def generate_table(cursor_line: int) -> Table:
    """Make a new table."""
    systems = list_systems()
    table = Table(title="All Systems")
    table.add_column(" ", justify="center", no_wrap=True)
    table.add_column("#", justify="center", no_wrap=True)
    table.add_column("Name", justify="center")
    table.add_column("State", justify="center")

    for number, system in enumerate(systems, 1):
        color = "green" if system["state"] == "Stopped" else "red"
        check = "X" if cursor_line == number else ""
        table.add_row(check, str(number), system["name"], system["state"], style=color)

    return table


async def key_listener(callback):
    while True:
        key = readchar.readkey()

        if key in [readchar.key.ENTER, readchar.key.ENTER_2]:
            break
        if key in [readchar.key.UP, readchar.key.DOWN]:
            if key == readchar.key.UP:
                callback("up")
            else:
                callback("down")

    print("Listener stopped")


async def set_timeout(i, callback):
    Timer(i, callback).start()


async def run():
    cursor_line = 1
    timer_interval = 1
    with Live(generate_table(cursor_line), auto_refresh=False) as live:
        while True:
            print("Waiting")

            def callback():
                live.update(generate_table(cursor_line))
                live.refresh()

            def callback_timer():
                callback()
                nonlocal timer
                timer.cancel()
                timer = Timer(timer_interval, callback_timer)
                timer.start()

            def callback_key(arrow_direction: str):
                nonlocal cursor_line
                cursor_line = (
                    cursor_line + 1 if arrow_direction == "down" else cursor_line - 1
                )
                callback()

            timer = Timer(timer_interval, callback_timer)
            timer.start()

            events = [
                asyncio.create_task(key_listener(callback_key)),
            ]

            done, pending = await asyncio.wait(
                events,
            )
            print("Done", done, "Pending", pending)
            timer.cancel()
            break


asyncio.run(run())