interactui 0.1.0rc1__py3-none-any.whl

interactui/__init__.py

@@ -0,0 +1,7 @@
+from interactui.app import App
+from interactui.key import KeyBinding
+from interactui.layout import Layout
+from interactui.text import String
+from interactui.view import View
+
+__all__ = ["App", "KeyBinding", "Layout", "String", "View"]

interactui/app.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import curses
+import os
+import sys
+from collections.abc import Sequence
+from functools import partial
+from typing import ClassVar
+
+from interactui.common import Callback, init_colors
+from interactui.component import Component
+from interactui.key import Key, KeyBinding, KeyBindingMap
+from interactui.layout import Layout
+from interactui.view import Center, FloatingView, Style, View
+
+
+class App(Component):
+    _key_bindings: ClassVar[list[KeyBinding]] = [
+        KeyBinding(Key("d", Key.CTRL), "Exit app", lambda _self, _key, app: app.exit(0)),  # pyright: ignore[reportUnknownLambdaType]
+        KeyBinding(Key("k", Key.CTRL), "Show Key Bindings", lambda _self, _key, app: app.show_key_bindings()),  # pyright: ignore[reportUnknownLambdaType]
+    ]
+
+    def __init__(self):
+        super().__init__()
+
+        self._layout: Layout | None = None
+
+    @property
+    def layout(self) -> Layout:
+        if self._layout is None:
+            raise RuntimeError("Tried accessing an App's layout before calling run()")
+
+        return self._layout
+
+    def send_key(self, key: Key) -> None:
+        if (focused_view := self.layout.focused) is None:
+            return
+
+        focused_view.handle_key(key, self)
+
+    def show_key_bindings(self) -> None:
+        self.layout.append(
+            Center(
+                FloatingView(
+                    title="Key Bindings",
+                    content=f"""\
+ - Global
+{self.key_bindings.as_str()}
+
+ - Local
+{KeyBindingMap(*FloatingView._key_bindings).as_str()}""",  # pyright: ignore[reportPrivateUsage]
+                    style=Style(border="rounded"),
+                )
+            )
+        )
+
+    def _run(
+        self,
+        stdscr: curses.window,
+        layout: Sequence[View],
+        *,
+        on_append_view: Callback | None,
+        on_remove_view: Callback | None,
+    ) -> None:
+        curses.curs_set(0)
+        init_colors()
+
+        self._layout = Layout(
+            layout,
+            stdscr,
+            on_append=None if on_append_view is None else partial(on_append_view, self),
+            on_remove=None if on_remove_view is None else partial(on_remove_view, self),
+        )
+
+        while True:
+            self.layout.render()
+            self.layout.execute_actions(self)
+
+            key = self.layout.get_key()
+
+            if not self.handle_key(key, self):
+                if (focused_view := self.layout.focused) is not None:
+                    focused_view.handle_key(key, self)
+
+    def run(
+        self, layout: Sequence[View], *, on_append_view: Callback | None = None, on_remove_view: Callback | None = None
+    ) -> None:
+        os.environ.setdefault("ESCDELAY", "25")
+
+        curses.wrapper(self._run, layout, on_append_view=on_append_view, on_remove_view=on_remove_view)
+
+    def exit(self, code: int) -> None:
+        sys.exit(code)

interactui/common.py

@@ -0,0 +1,29 @@
+import curses
+from typing import TYPE_CHECKING, Callable, Literal
+
+if TYPE_CHECKING:
+    from interactui.app import App
+    from interactui.view import View
+
+type Color = Literal["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"]
+type Callback = Callable[[App, View], None]
+type LayoutCallback = Callable[[View], None]
+
+
+def init_colors() -> None:
+    curses.use_default_colors()
+
+    for fg in ("BLACK", "RED", "GREEN", "YELLOW", "BLUE", "MAGENTA", "CYAN", "WHITE"):
+        fg_color = getattr(curses, "COLOR_" + fg)
+
+        for bg in ("BLACK", "RED", "GREEN", "YELLOW", "BLUE", "MAGENTA", "CYAN", "WHITE"):
+            bg_color = getattr(curses, "COLOR_" + bg)
+
+            curses.init_pair((fg_color * 8) + bg_color + 1, fg_color, bg_color)
+
+
+def get_color_pair(fg: Color, bg: Color = "black") -> int:
+    fg_color = getattr(curses, "COLOR_" + fg.upper())
+    bg_color = getattr(curses, "COLOR_" + bg.upper())
+
+    return curses.color_pair((fg_color * 8) + bg_color + 1)

interactui/component.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from interactui.key import Key, KeyBinding, KeyBindingMap
+
+if TYPE_CHECKING:
+    from interactui.app import App
+
+
+class Component:
+    _key_bindings: ClassVar[list[KeyBinding]] = []
+
+    def __init__(self) -> None:
+        self.key_bindings: KeyBindingMap = KeyBindingMap(*self._key_bindings)
+
+    def handle_key(self, key: Key, app: App) -> bool:
+        if (kb := self.key_bindings.get(key)) is None:
+            return False
+
+        if isinstance(kb.callback, str):
+            getattr(self, f"handle_{kb.callback}")(key, app)
+
+        else:
+            kb.callback(self, key, app)
+
+        return True

interactui/examples/get_key.py

@@ -0,0 +1,23 @@
+import sys
+from typing import ClassVar
+
+from interactui import App, KeyBinding
+from interactui.key import Key
+from interactui.view import Style, TextArea
+
+
+class TextAreaInput(TextArea):
+    _key_bindings: ClassVar[list[KeyBinding]] = [KeyBinding(Key(Key.ALL), "Press any key", "key_press")]
+
+    def handle_key_press(self, key: Key, _: App) -> None:
+        self.set_content(f"Key pressed: {key.as_str()} | value={key.value} ({key.raw_value})")
+        self.render()
+
+
+def main() -> int:
+    App().run([TextAreaInput("", style=Style(padding=1, margin=1, border="rounded"))])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

interactui/key.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import curses
+from typing import TYPE_CHECKING, Callable, ClassVar, Literal, NamedTuple, Self, override
+
+if TYPE_CHECKING:
+    from interactui.app import App
+    from interactui.component import Component
+
+
+class Key:
+    CTRL: ClassVar[int] = 1
+    ALT: ClassVar[int] = 2
+
+    ALL: ClassVar[int] = -1
+
+    Escape: ClassVar[Literal[27]] = 27
+    Enter: ClassVar[tuple[int, ...]] = (10, 13, curses.KEY_ENTER)
+    ArrowUp: ClassVar[int] = curses.KEY_UP
+    ArrowDown: ClassVar[int] = curses.KEY_DOWN
+    ArrowLeft: ClassVar[int] = curses.KEY_LEFT
+    ArrowRight: ClassVar[int] = curses.KEY_RIGHT
+
+    SPECIAL_KEYS: ClassVar[dict[int, tuple[str, int]]] = {
+        27: ("Esc", 27),
+        10: ("Enter", curses.KEY_ENTER),
+        13: ("Enter", curses.KEY_ENTER),
+        curses.KEY_ENTER: ("Enter", curses.KEY_ENTER),
+        curses.KEY_UP: ("Up arrow", curses.KEY_UP),
+        curses.KEY_DOWN: ("Down arrow", curses.KEY_DOWN),
+        curses.KEY_LEFT: ("Left arrow", curses.KEY_LEFT),
+        curses.KEY_RIGHT: ("Right arrow", curses.KEY_RIGHT),
+    }
+
+    def __init__(self, value: str | int | tuple[int, ...], modifiers: int = 0) -> None:
+        if isinstance(value, tuple):
+            value = value[-1]
+
+        assert isinstance(value, int) or len(value) == 1
+
+        self._value: str | int = value
+        self.modifiers: int = modifiers
+
+    @override
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, Key):
+            return False
+
+        return self._value == value._value and self.modifiers == value.modifiers
+
+    @override
+    def __hash__(self) -> int:
+        return hash(self._value) + hash(self.modifiers)
+
+    @property
+    def value(self) -> str:
+        if isinstance(self._value, str):
+            return self._value
+
+        return Key.SPECIAL_KEYS[self._value][0]
+
+    @property
+    def raw_value(self) -> str | int:
+        return self._value
+
+    @property
+    def is_CTRL(self) -> bool:
+        return bool(self.modifiers & Key.CTRL)
+
+    @property
+    def is_ALT(self) -> bool:
+        return bool(self.modifiers & Key.ALT)
+
+    @property
+    def is_plain(self) -> bool:
+        return self.modifiers == 0
+
+    @override
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}<{self.as_str()}>"
+
+    def as_str(self) -> str:
+        repr_ = self.value
+
+        if self.is_ALT:
+            repr_ = "M-" + repr_
+
+        if self.is_CTRL:
+            repr_ = "C-" + repr_
+
+        return f"<{repr_}>"
+
+    @classmethod
+    def get(cls, win: curses.window) -> Self:
+        win.keypad(True)
+
+        ch = win.getch()
+
+        if ch in cls.SPECIAL_KEYS and ch != 27:
+            return cls(cls.SPECIAL_KEYS[ch][1])
+
+        elif 0 < ch < 27:
+            return cls(chr(ch + 96), modifiers=Key.CTRL)
+
+        elif ch == 27:  # ALT was pressed
+            win.nodelay(True)
+            ch2 = win.getch()  # get the key pressed after ALT
+            win.nodelay(False)
+
+            if 0 < ch2 < 27:
+                return cls(chr(ch2 + 96), modifiers=Key.CTRL | Key.ALT)
+
+            elif ch2 == -1:
+                return cls(cls.Escape)
+
+            return cls(chr(ch2), modifiers=Key.ALT)
+
+        else:
+            return cls(chr(ch))
+
+
+class KeyBinding(NamedTuple):
+    """
+    A key-binding definition for a Component (App or View).
+    `callback` may be :
+        - a function to be called directly (arg: App)
+        - a string, in which case the Component's method with name `handle_<callback>` will be called (args: Key, App)
+    """
+
+    key: Key
+    binding: str
+    callback: Callable[[Component, Key, App], None] | str
+
+
+class KeyBindingMap:
+    def __init__(self, *key_bindings: KeyBinding) -> None:
+        self.keybindings: dict[Key, KeyBinding] = {kb.key: kb for kb in key_bindings}
+
+    def __add__(self, key_bindings: list[KeyBinding]) -> KeyBindingMap:
+        return KeyBindingMap(*self.keybindings.values(), *key_bindings)
+
+    def get(self, key: Key) -> KeyBinding | None:
+        binding = self.keybindings.get(key)
+        if binding is None:
+            return self.keybindings.get(Key(Key.ALL))
+
+        return binding
+
+    def as_str(self) -> str:
+        width_key = max(map(len, (kb.key.value for kb in self.keybindings.values())))
+        width_binding = max(map(len, (kb.binding for kb in self.keybindings.values())))
+
+        return "\n".join(
+            f"{kb.key.as_str():<{width_key}}  {kb.binding:<{width_binding}}" for kb in self.keybindings.values()
+        )

interactui/layout.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import curses
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from interactui.common import LayoutCallback
+from interactui.key import Key
+from interactui.view import Action, FloatingView, View
+from interactui.view.typing import ViewLike
+
+if TYPE_CHECKING:
+    from interactui.app import App
+
+
+def _get_height(height: int | str, max_height: int) -> int:
+    if isinstance(height, int):
+        return height
+
+    assert height.endswith("%")
+    return int(float(height[:-1]) * max_height)
+
+
+def _get_heights(views: Sequence[View], height: int) -> list[int]:
+    view_heights = [_get_height(view.style.height, height) for view in views]
+
+    leftover_height = height - sum(view_heights)
+    if leftover_height < 0:
+        msg = f"Cannot fit views in {height} lines"
+        raise ValueError(msg)
+
+    to_expand = sum(h == 0 for h in view_heights)
+
+    if to_expand == 0:
+        return view_heights
+
+    expansion_lines, r = divmod(leftover_height, to_expand)
+    if expansion_lines == 0:
+        msg = f"No lines left for {to_expand} expanded views"
+        raise ValueError(msg)
+
+    expanded_heights = iter([expansion_lines + 1] * r + [expansion_lines] * (to_expand - r))
+
+    return [h if h != 0 else next(expanded_heights) for h in view_heights]
+
+
+class Layout:
+    def __init__(
+        self,
+        views: Sequence[View],
+        window: curses.window,
+        *,
+        on_append: LayoutCallback | None = None,
+        on_remove: LayoutCallback | None = None,
+    ) -> None:
+        self._window: curses.window = window
+
+        self._id_map: dict[int, int]
+        self.fixed: list[View]
+
+        self.fixed, self._id_map = self._place_views(views, window)
+
+        self.floating: FloatingView | None = None
+
+        self._focus: int | None = None if not len(self.fixed) else self.fixed[-1].get_id()
+
+        self.on_append: LayoutCallback | None = on_append
+        self.on_remove: LayoutCallback | None = on_remove
+
+    @property
+    def focused(self) -> View | None:
+        if self._focus is None:
+            return None
+
+        index = self._id_map.get(self._focus)
+
+        if index is None:
+            assert self.floating is not None and self._focus == self.floating.get_id()
+            return self.floating
+
+        return self.fixed[index]
+
+    @staticmethod
+    def _place_views(views: Sequence[View], window: curses.window) -> tuple[list[View], dict[int, int]]:
+        height, width = window.getmaxyx()
+
+        heights = _get_heights(views, height)
+
+        views_init: list[View] = []
+        id_map: dict[int, int] = {}
+
+        begin_y = 0
+        for id, (view, view_height) in enumerate(zip(views, heights)):
+            view.init(id, window.subwin(view_height, width, begin_y, 0))
+            begin_y += view_height
+
+            views_init.append(view)
+            id_map[id] = id
+
+        return views_init, id_map
+
+    def append(self, view: ViewLike) -> None:
+        if callable(view):
+            view = view(self._window)
+
+        if isinstance(view, FloatingView):
+            view.init(self.get_next_id(), self._window.subwin(*view.size, view.y, view.x))
+            self.floating = view
+
+        else:
+            self.fixed, self._id_map = self._place_views(self.fixed + [view], self._window)
+
+        self._focus = view.get_id()
+        self.render()
+
+        if callable(self.on_append):
+            self.on_append(view)
+
+    def remove(self, id: int) -> None:
+        index = self._id_map.get(id)
+
+        if index is None:
+            if self.floating is not None and id == self.floating.get_id():
+                view = self.floating
+                self.floating = None
+
+            else:
+                msg = f"Layout does not contain a view with id `{id}`"
+                raise ValueError(msg)
+
+        else:
+            view = self.fixed.pop(index)
+            self.fixed, self._id_map = self._place_views(self.fixed, self._window)
+
+        if self._focus == id:
+            if not len(self.fixed):
+                self._focus = None
+
+            else:
+                self._focus = self.fixed[-1].get_id()
+
+        view.reset()
+        self.render()
+
+        if callable(self.on_remove):
+            self.on_remove(view)
+
+    # def replace(self, id: ID, view: View) -> None:
+    #     pass
+
+    def get_next_id(self) -> int:
+        ids = list(self._id_map.keys())
+        if (floating := self.floating) is not None:
+            ids.append(floating.get_id())
+
+        return max(ids) + 1
+
+    def get_key(self) -> Key:
+        window = self._window if self.focused is None else self.focused.get_windows()[1]
+
+        return Key.get(window)
+
+    def render(self) -> None:
+        for view in self.fixed:
+            view.render()
+
+        if (floating := self.floating) is not None:
+            floating.render()
+
+    def execute_actions(self, app: App) -> None:
+        for view in self.fixed:
+            if isinstance(view, Action):
+                res = view.execute(app)
+                self.remove(view.get_id())
+
+                if res.ok:
+                    view.on_ok(app)
+
+                else:
+                    view.on_err(app, res.reason)

interactui/samples/__init__.py

@@ -0,0 +1 @@
+

interactui/samples/form.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import curses
+from dataclasses import dataclass
+from typing import Any, Protocol, override, runtime_checkable
+
+from interactui.app import App
+from interactui.text import String
+from interactui.view import HLine, View
+from interactui.view.style import Style
+
+
+@dataclass
+class RecordItem:
+    item: String
+    details: str | None = None
+    data: Any = None
+
+
+class Record(View):
+    def __init__(self, *, style: Style | None = None) -> None:
+        super().__init__(style=style)
+        self.records: list[RecordItem] = []
+
+    def append(self, record: RecordItem) -> None:
+        self.records.append(record)
+
+    @property
+    def last(self) -> RecordItem:
+        return self.records[-1]
+
+    @override
+    def draw(self, window: curses.window) -> None:
+        y = 0
+        for item in self.records:
+            item.item.render(window, y, 0)
+            y += item.item.height
+
+            if item.details is not None:
+                details = String.parse(f"[└ {item.details};white dim italic]")
+                details.render(window, y, 1)
+                y += details.height
+
+
+@runtime_checkable
+class RecordableView(Protocol):
+    def get_record_item(self) -> RecordItem: ...
+
+
+class Form(App):
+    def __init__(self, questions: list[View], *, before: list[View] | None = None):
+        super().__init__()
+
+        self.before: list[View] = before or []
+        self.questions: list[View] = questions
+        self.index: int = -1
+
+        self.record: Record = Record(style={"padding": (1, 5)})
+
+    def next(self) -> View:
+        self.index += 1
+
+        if self.index >= len(self.questions):
+            raise StopIteration()
+
+        return self.questions[self.index]
+
+    def prev(self) -> View:
+        if self.index <= 0:
+            raise IndexError("Already at first question")
+
+        self.index -= 1
+        return self.questions[self.index]
+
+    def _on_remove_view(self, app: App, view: View) -> None:
+        if isinstance(view, RecordableView):
+            self.record.append(view.get_record_item())
+
+        try:
+            app.layout.append(self.next())
+
+        except StopIteration:
+            app.exit(0)
+
+    @override
+    def run(self) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return super().run(
+            self.before + [HLine(), self.record, HLine()] + [self.next()], on_remove_view=self._on_remove_view
+        )