How to detect whether a key has been pressing?

[labo-China]

I have been developing a music player for some time. I want to implement a feature that allows users to add a song to the default song list by tapping a key ('l' in the case) while they can also add it to other song list by pressing the key for longer time (~0.5s) and choose the target song list to add.

I have looked through your documention references and only find the Key event instead of something like KeyDown and KeyUp. Moreover, I can only see the Key event be frequently sent when I press a key for a long time. So it is difficult for me to tell whether a key is continuously pressed or just tapped.

I do not know if it is because of some kind of terminal limitations. However, I have a draft solution for this but I think it will be CPU-consuming and insensitive.

from textual.app import App
from textual.widgets import Static
from textual.reactive import reactive

class CustomWidget(Static):
	cnt = reactive(0)
	is_pressing = False

	def watch_cnt(self, v):
		if v > 1 and not self.is_pressing:
			self.app.notify('Press start!')
			self.is_pressing = True
		elif v == 0:
			if self.is_pressing:
				self.app.notify('Press end!')
				self.is_pressing = False
			else:
				self.app.notify('Tapped!')

	def down(self):
		self.cnt -= 1

	def up(self):
		self.cnt += 1
		self.set_timer(0.1, self.down)  # the 'key' event sends about 10 time/s when pressing keys

class MyApp(App):
	def compose(self):
		yield CustomWidget()
	
	def on_key(self, e):
		self.query_one(CustomWidget).up()


MyApp().run()

I love this cool and awesome project and look forward to any suggestions or better solutions :)

[davep]

As you point out, there are bindings and there is the Key event; I believe the way this is designed is, as you suggest, down to limitations in terminal support.

[labo-China]

Thanks for your instant reply! I still wonder that if there is an alternative solution to achieve it 👀 .

[davep]

You may want to have a chat with the author of upiano, they looked into this too.

[labo-China]

Thanks for your advice! Have a nice weekend :D

[bwagner]

I've looked at the upiano project and tried it, but it doesn't seem to help in the question how to handle KeyDown and KeyUp properly. Quoting from upiano README:

Note that since the terminal doesn't really support key press and release events (it receives a stream of characters instead), there is no way to support two key playing at the same time with the computer keyboard only.

I have a solution to handle KeyDown/KeyUp-events independently of textual (see below), but it would be helpful if there were support for both KeyDown and KeyUp events in textual.

#!/usr/bin/env python

import sys
import termios
import tty
from pynput import keyboard

# Save original terminal settings
original_settings = termios.tcgetattr(sys.stdin)

def set_raw_mode():
    """ Disable echoing and enable raw mode """
    new_settings = termios.tcgetattr(sys.stdin)
    new_settings[3] &= ~termios.ECHO  # Disable echo
    new_settings[3] &= ~termios.ICANON  # Disable line buffering
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)

def restore_terminal_settings():
    """ Restore original terminal settings """
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, original_settings)

def flush_input():
    """ Flush input buffer to remove any buffered characters """
    termios.tcflush(sys.stdin, termios.TCIFLUSH)

def clear_line():
    """ Clears the entire line properly """
    sys.stdout.write("\r\033[K")  # Move to start of line & clear it
    sys.stdout.flush()

# Keep track of pressed keys to prevent auto-repeat
pressed_keys = set()

def on_press(key):
    """ Handle key press, ignoring repeats """
    key_str = None
    try:
        key_str = key.char  # Get character representation
    except AttributeError:
        key_str = str(key)  # Handle special keys (e.g., Key.shift, Key.esc)

    if key_str and key_str not in pressed_keys:  # Prevent auto-repeat
        clear_line()
        print(f"Key pressed: {key_str}", end="", flush=True)
        pressed_keys.add(key_str)

    # Exit on 'q' or 'esc'
    if key == keyboard.Key.esc or key_str == 'q':
        print("\nExiting...")
        return False  # Stop listener

def on_release(key):
    """ Handle key release """
    key_str = None
    try:
        key_str = key.char
    except AttributeError:
        key_str = str(key)

    if key_str in pressed_keys:
        clear_line()
        print(f"Key released: {key_str}", end="", flush=True)
        pressed_keys.remove(key_str)

if __name__ == "__main__":

    print("Press keys (press 'q' or 'Esc' to exit)...")
    set_raw_mode()  # Disable echo and buffering

    try:
        with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
            listener.join()
    except KeyboardInterrupt:
        print("\nExiting...")
    finally:
        restore_terminal_settings()  # Restore normal terminal behavior
        flush_input()  # Flush any remaining buffered input
        print("\nTerminal settings restored.")