urwid 4.0.3__tar.gz → 4.0.5__tar.gz

{urwid-4.0.3 → urwid-4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urwid
-Version: 4.0.3
+Version: 4.0.5
 Summary: A full-featured console (xterm et al.) user interface library
 Author-email: Ian Ward <ian@excess.org>
 License-Expression: LGPL-2.1-only

{urwid-4.0.3 → urwid-4.0.5}/docs/changelog.rst

@@ -2,6 +2,55 @@
 Changelog
 ---------
 
+Urwid 4.0.5
+===========
+
+2026-07-20
+
+New features 🗹
++++++++++++++++
+* Copy signal handlers before emission by @Sanjays2402 in https://github.com/urwid/urwid/pull/1187
+* Implement `_scrollbar_layout` and left click handling for `Scrollable` by @penguinolog in https://github.com/urwid/urwid/pull/1192
+Bug fixes 🕷
+++++++++++++
+* Fix rle_product for zero-len elements by @penguinolog in https://github.com/urwid/urwid/pull/1191
+Documentation 🕮
+++++++++++++++++
+* typing: fix `Filler` typing annotations by @penguinolog in https://github.com/urwid/urwid/pull/1183
+* typing: extend widget_decoration module typing coverage by @penguinolog in https://github.com/urwid/urwid/pull/1184
+* Typing: annotate and fix attr_map by @penguinolog in https://github.com/urwid/urwid/pull/1186
+Refactoring 🛠
+++++++++++++++
+* Migrate `Edit` widget to use `WidgetWrap` as base class and update methods by @penguinolog in https://github.com/urwid/urwid/pull/1180
+
+New Contributors
+++++++++++++++++
+* @Sanjays2402 made their first contribution in https://github.com/urwid/urwid/pull/1187
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.4...4.0.5
+
+Urwid 4.0.4
+===========
+
+2026-07-13
+
+New features 🗹
++++++++++++++++
+* urwid.Colmns: re-calculate column_widths only if pack widgets changed by @penguinolog in https://github.com/urwid/urwid/pull/1178
+Bug fixes 🕷
+++++++++++++
+* Fix IndexError in decompose_tagmarkup when a nested sublist is empty by @gaoflow in https://github.com/urwid/urwid/pull/1172
+Documentation 🕮
+++++++++++++++++
+* Typing: partially annotate examples and fix annotations by @penguinolog in https://github.com/urwid/urwid/pull/1173
+* urwid.WidgetContainerMixin: return use protocol base class by @penguinolog in https://github.com/urwid/urwid/pull/1181
+
+New Contributors
+++++++++++++++++
+* @gaoflow made their first contribution in https://github.com/urwid/urwid/pull/1172
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.3...4.0.4
+
 Urwid 4.0.3
 ===========
 

{urwid-4.0.3 → urwid-4.0.5}/docs/examples/bigtext.py

@@ -48,7 +48,7 @@ class SwitchingPadding(urwid.Padding[_Wrapped]):
 
 
 class BigTextDisplay:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, str, str] | tuple[str, str, str, str]]] = [
         ("body", "black", "light gray", "standout"),
         ("header", "white", "dark red", "bold"),
         ("button normal", "light gray", "dark blue", "standout"),

{urwid-4.0.3 → urwid-4.0.5}/docs/examples/graph.py

@@ -33,6 +33,9 @@ import typing
 
 import urwid
 
+if typing.TYPE_CHECKING:
+    from collections.abc import Callable
+
 UPDATE_INTERVAL = 0.2
 
 
@@ -52,7 +55,7 @@ class GraphModel:
 
     data_max_value = 100
 
-    def __init__(self):
+    def __init__(self) -> None:
         data = [
             ("Saw", list(range(0, 100, 2)) * 2),
             ("Square", [0] * 30 + [100] * 30),
@@ -66,13 +69,13 @@ class GraphModel:
             self.modes.append(m)
             self.data[m] = d
 
-    def get_modes(self):
+    def get_modes(self) -> list[str]:
         return self.modes
 
-    def set_mode(self, m) -> None:
+    def set_mode(self, m: str) -> None:
         self.current_mode = m
 
-    def get_data(self, offset, r):
+    def get_data(self, offset: int, r):
         """
         Return the data in [offset:offset+r], the maximum value
         for items returned, and the offset at which the data
@@ -95,7 +98,7 @@ class GraphView(urwid.WidgetWrap):
     graph display.
     """
 
-    palette: typing.ClassVar[tuple[str, str, str, ...]] = [
+    palette: typing.ClassVar[list[tuple[str, str, str] | tuple[str, str, str, str]]] = [
         ("body", "black", "light gray", "standout"),
         ("header", "white", "dark red", "bold"),
         ("screen edge", "light blue", "dark cyan"),
@@ -118,7 +121,7 @@ class GraphView(urwid.WidgetWrap):
     graph_num_bars = 5
     graph_offset_per_second = 5
 
-    def __init__(self, controller):
+    def __init__(self, controller) -> None:
         self.controller = controller
         self.started = True
         self.start_time = None
@@ -126,7 +129,7 @@ class GraphView(urwid.WidgetWrap):
         self.last_offset = None
         super().__init__(self.main_window())
 
-    def get_offset_now(self):
+    def get_offset_now(self) -> int:
         if self.start_time is None:
             return 0
         if not self.started:
@@ -134,7 +137,7 @@ class GraphView(urwid.WidgetWrap):
         tdelta = time.time() - self.start_time
         return int(self.offset + (tdelta * self.graph_offset_per_second))
 
-    def update_graph(self, force_update=False):
+    def update_graph(self, force_update: bool = False) -> bool:
         o = self.get_offset_now()
         if o == self.last_offset and not force_update:
             return False
@@ -164,32 +167,32 @@ class GraphView(urwid.WidgetWrap):
         self.animate_progress.current = prog
         return True
 
-    def on_animate_button(self, button):
+    def on_animate_button(self, button: urwid.AttrMap[urwid.Button]) -> None:
         """Toggle started state and button text."""
         if self.started:  # stop animation
-            button.base_widget.set_label("Start")
+            button.set_label("Start")
             self.offset = self.get_offset_now()
             self.started = False
             self.controller.stop_animation()
         else:
-            button.base_widget.set_label("Stop")
+            button.set_label("Stop")
             self.started = True
             self.start_time = time.time()
             self.controller.animate_graph()
 
-    def on_reset_button(self, w):
+    def on_reset_button(self, w: urwid.Button) -> None:
         self.offset = 0
         self.start_time = time.time()
         self.update_graph(True)
 
-    def on_mode_button(self, button, state):
+    def on_mode_button(self, button: urwid.RadioButton, state: bool) -> None:
         """Notify the controller of a new mode setting."""
         if state:
             # The new mode is the label of the button
             self.controller.set_mode(button.get_label())
         self.last_offset = None
 
-    def on_mode_change(self, m):
+    def on_mode_change(self, m: str) -> None:
         """Handle external mode change by updating radio buttons."""
         for rb in self.mode_buttons:
             if rb.base_widget.label == m:
@@ -197,7 +200,7 @@ class GraphView(urwid.WidgetWrap):
                 break
         self.last_offset = None
 
-    def on_unicode_checkbox(self, w, state):
+    def on_unicode_checkbox(self, w: urwid.CheckBox, state: bool) -> None:
         self.graph = self.bar_graph(state)
         self.graph_wrap._w = self.graph
         self.animate_progress = self.progress_bar(state)
@@ -235,30 +238,42 @@ class GraphView(urwid.WidgetWrap):
         )
         return w
 
-    def bar_graph(self, smooth=False):
+    def bar_graph(self, smooth: bool = False) -> urwid.BarGraph:
         satt = None
         if smooth:
             satt = {(1, 0): "bg 1 smooth", (2, 0): "bg 2 smooth"}
         w = urwid.BarGraph(["bg background", "bg 1", "bg 2"], satt=satt)
         return w
 
-    def button(self, t, fn):
+    def button(
+        self,
+        t: str,
+        fn: Callable[[urwid.Button], None],
+    ) -> urwid.AttrMap[urwid.Button]:
         w = urwid.Button(t, fn)
         w = urwid.AttrMap(w, "button normal", "button select")
         return w
 
-    def radio_button(self, g, label, fn):
+    def radio_button(
+        self,
+        g: list[urwid.RadioButton],
+        label: str,
+        fn: Callable[[urwid.RadioButton, bool], None],
+    ) -> urwid.AttrMap[urwid.RadioButton]:
         w = urwid.RadioButton(g, label, False, on_state_change=fn)
         w = urwid.AttrMap(w, "button normal", "button select")
         return w
 
-    def progress_bar(self, smooth=False):
-        if smooth:
-            return urwid.ProgressBar("pg normal", "pg complete", 0, 1, "pg smooth")
-
-        return urwid.ProgressBar("pg normal", "pg complete", 0, 1)
+    def progress_bar(self, smooth: bool = False) -> urwid.ProgressBar:
+        return urwid.ProgressBar(
+            "pg normal",
+            "pg complete",
+            0,
+            1,
+            "pg smooth" if smooth else None,
+        )
 
-    def exit_program(self, w):
+    def exit_program(self, w) -> typing.NoReturn:
         raise urwid.ExitMainLoop()
 
     def graph_controls(self):
@@ -271,7 +286,7 @@ class GraphView(urwid.WidgetWrap):
             self.mode_buttons.append(rb)
         # setup animate button
         self.animate_button = self.button("", self.on_animate_button)
-        self.on_animate_button(self.animate_button)
+        self.on_animate_button(self.animate_button.original_widget)
         self.offset = 0
         self.animate_progress = self.progress_bar()
         animate_controls = urwid.GridFlow(

{urwid-4.0.3 → urwid-4.0.5/docs}/examples/pop_up.py

@@ -7,12 +7,12 @@ import typing
 import urwid
 
 
-class PopUpDialog(urwid.WidgetWrap):
+class PopUpDialog(urwid.WidgetWrap[urwid.AttrMap[urwid.Filler[urwid.Pile]]]):
     """A dialog that appears with nothing but a close button"""
 
     signals: typing.ClassVar[list[str]] = ["close"]
 
-    def __init__(self):
+    def __init__(self) -> None:
         close_button = urwid.Button("that's pretty cool")
         urwid.connect_signal(close_button, "click", lambda button: self._emit("close"))
         pile = urwid.Pile(
@@ -24,7 +24,7 @@ class PopUpDialog(urwid.WidgetWrap):
         super().__init__(urwid.AttrMap(urwid.Filler(pile), "popbg"))
 
 
-class ThingWithAPopUp(urwid.PopUpLauncher):
+class ThingWithAPopUp(urwid.PopUpLauncher[urwid.Button]):
     def __init__(self) -> None:
         super().__init__(urwid.Button("click-me"))
         urwid.connect_signal(self.original_widget, "click", lambda button: self.open_pop_up())

{urwid-4.0.3 → urwid-4.0.5}/docs/examples/real_browse.py

@@ -178,9 +178,9 @@ class DirectoryNode(urwid.ParentNode):
         parent.set_child_node(self.get_key(), self)
         return parent
 
-    def load_child_keys(self):
-        dirs = []
-        files = []
+    def load_child_keys(self) -> list[str] | list[None]:
+        dirs: list[str] = []
+        files: list[str] = []
         try:
             path = self.get_value()
             # separate dirs and files
@@ -207,7 +207,7 @@ class DirectoryNode(urwid.ParentNode):
             keys = [None]
         return keys
 
-    def load_child_node(self, key) -> EmptyNode | DirectoryNode | FileNode:
+    def load_child_node(self, key: Hashable) -> EmptyNode | DirectoryNode | FileNode:
         """Return either a FileNode or DirectoryNode"""
         index = self.get_child_index(key)
         if key is None:
@@ -225,11 +225,11 @@ class DirectoryNode(urwid.ParentNode):
 
 
 class DirectoryBrowser:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, ...] | tuple[str, str, str, str]]] = [
         ("body", "black", "light gray"),
-        ("flagged", "black", "dark green", ("bold", "underline")),
+        ("flagged", "black", "dark green", "bold,underline"),
         ("focus", "light gray", "dark blue", "standout"),
-        ("flagged focus", "yellow", "dark cyan", ("bold", "standout", "underline")),
+        ("flagged focus", "yellow", "dark cyan", "bold,standout,underline"),
         ("head", "yellow", "black", "standout"),
         ("foot", "light gray", "black"),
         ("key", "light cyan", "black", "underline"),

{urwid-4.0.3 → urwid-4.0.5}/docs/examples/real_edit.py

@@ -51,10 +51,10 @@ class LineWalker(urwid.ListWalker):
         if self.file is not None:
             self.file.close()
 
-    def get_focus(self):
+    def get_focus(self) -> tuple[urwid.Edit, int] | tuple[None, None]:
         return self._get_at_pos(self.focus)
 
-    def set_focus(self, focus) -> None:
+    def set_focus(self, focus: int) -> None:
         self.focus = focus
         self._modified()
 
@@ -145,7 +145,7 @@ class LineWalker(urwid.ListWalker):
 
 
 class EditDisplay:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, str, str] | tuple[str, str, str, str]]] = [
         ("body", "default", "default"),
         ("foot", "dark cyan", "dark blue", "bold"),
         ("key", "light cyan", "dark blue", "underline"),
@@ -231,7 +231,7 @@ class EditDisplay:
                 prefix = "\n"
 
 
-def re_tab(s) -> str:
+def re_tab(s: str) -> str:
     """Return a tabbed string from an expanded one."""
     line = []
     p = 0

{urwid-4.0.3 → urwid-4.0.5}/docs/examples/tour.py

@@ -159,7 +159,7 @@ def main():
         " widget is used to keep the instructions at the top of the screen.",
     ]
 
-    def button_press(button):
+    def button_press(button: urwid.Button) -> None:
         frame.footer = urwid.AttrMap(urwid.Text(["Pressed: ", button.get_label()]), "header")
 
     radio_button_group = []
@@ -355,11 +355,11 @@ def main():
         ("body", "black", "light gray", "standout"),
         ("reverse", "light gray", "black"),
         ("header", "white", "dark red", "bold"),
-        ("important", "dark blue", "light gray", ("standout", "underline")),
+        ("important", "dark blue", "light gray", "standout,underline"),
         ("editfc", "white", "dark blue", "bold"),
         ("editbx", "light gray", "dark blue"),
         ("editcp", "black", "light gray", "standout"),
-        ("bright", "dark gray", "light gray", ("bold", "standout")),
+        ("bright", "dark gray", "light gray", "bold,standout"),
         ("buttn", "black", "dark cyan"),
         ("buttnf", "white", "dark blue", "bold"),
     ]

{urwid-4.0.3 → urwid-4.0.5}/examples/bigtext.py

@@ -48,7 +48,7 @@ class SwitchingPadding(urwid.Padding[_Wrapped]):
 
 
 class BigTextDisplay:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, str, str] | tuple[str, str, str, str]]] = [
         ("body", "black", "light gray", "standout"),
         ("header", "white", "dark red", "bold"),
         ("button normal", "light gray", "dark blue", "standout"),

{urwid-4.0.3 → urwid-4.0.5}/examples/browse.py

@@ -178,9 +178,9 @@ class DirectoryNode(urwid.ParentNode):
         parent.set_child_node(self.get_key(), self)
         return parent
 
-    def load_child_keys(self):
-        dirs = []
-        files = []
+    def load_child_keys(self) -> list[str] | list[None]:
+        dirs: list[str] = []
+        files: list[str] = []
         try:
             path = self.get_value()
             # separate dirs and files
@@ -207,7 +207,7 @@ class DirectoryNode(urwid.ParentNode):
             keys = [None]
         return keys
 
-    def load_child_node(self, key) -> EmptyNode | DirectoryNode | FileNode:
+    def load_child_node(self, key: Hashable) -> EmptyNode | DirectoryNode | FileNode:
         """Return either a FileNode or DirectoryNode"""
         index = self.get_child_index(key)
         if key is None:
@@ -225,11 +225,11 @@ class DirectoryNode(urwid.ParentNode):
 
 
 class DirectoryBrowser:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, ...] | tuple[str, str, str, str]]] = [
         ("body", "black", "light gray"),
-        ("flagged", "black", "dark green", ("bold", "underline")),
+        ("flagged", "black", "dark green", "bold,underline"),
         ("focus", "light gray", "dark blue", "standout"),
-        ("flagged focus", "yellow", "dark cyan", ("bold", "standout", "underline")),
+        ("flagged focus", "yellow", "dark cyan", "bold,standout,underline"),
         ("head", "yellow", "black", "standout"),
         ("foot", "light gray", "black"),
         ("key", "light cyan", "black", "underline"),

{urwid-4.0.3 → urwid-4.0.5}/examples/calc.py

@@ -40,7 +40,7 @@ import typing
 import urwid
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Hashable
+    from collections.abc import Hashable, Iterable
 
 # use appropriate Screen class
 if urwid.display.web.is_web_request():
@@ -99,7 +99,7 @@ class CalcEvent(Exception):
     def __init__(self, message: str | tuple[Hashable, str] | list[str | tuple[Hashable, str]]) -> None:
         self.message = message
 
-    def widget(self):
+    def widget(self) -> urwid.AttrMap[urwid.Text]:
         """Return a widget containing event information"""
         text = urwid.Text(self.message, urwid.CENTER)
         return urwid.AttrMap(text, self.attr)
@@ -110,7 +110,7 @@ class ColumnDeleteEvent(CalcEvent):
 
     attr = "confirm"
 
-    def __init__(self, letter: str, from_parent=0) -> None:
+    def __init__(self, letter: str, from_parent: int = 0) -> None:
         super().__init__(["Press ", ("key", "BACKSPACE"), " again to confirm column removal."])
         self.letter = letter
 
@@ -120,14 +120,14 @@ class UpdateParentEvent(Exception):
 
 
 class Cell:
-    def __init__(self, op) -> None:
+    def __init__(self, op: str | None) -> None:
         self.op = op
         self.is_top = op is None
         self.child = None
         self.setup_edit()
         self.result = urwid.Text("", layout=CALC_LAYOUT)
 
-    def show_result(self, next_cell) -> bool:
+    def show_result(self, next_cell: Cell | None) -> bool:
         """Return whether this widget should display its result.
 
         next_cell -- the cell following self or None"""
@@ -192,7 +192,7 @@ class Cell:
 class ParentEdit(urwid.Edit):
     """Edit widget modified to link to a child column"""
 
-    def __init__(self, op, letter: str) -> None:
+    def __init__(self, op: str | None, letter: str) -> None:
         """Use the operator and letter of the child column as caption
 
         op -- operator or None
@@ -226,20 +226,23 @@ class ParentEdit(urwid.Edit):
 
 
 class CellWalker(urwid.ListWalker):
-    def __init__(self, content):
+    def __init__(self, content: Iterable[Cell]) -> None:
         self.content = urwid.MonitoredList(content)
-        self.content.modified = self._modified
+        self.content.set_modified_callback(self._modified)
         self.focus = (0, 0)
         # everyone can share the same divider widget
         self.div = urwid.Divider("-")
 
-    def get_cell(self, i):
+    def get_cell(self, i: int) -> Cell | None:
         if i < 0 or i >= len(self.content):
             return None
 
         return self.content[i]
 
-    def _get_at_pos(self, pos):
+    def _get_at_pos(
+        self,
+        pos: tuple[int, int],
+    ) -> tuple[urwid.Divider | urwid.AttrMap[urwid.IntEdit] | urwid.Text, tuple[int, int]] | tuple[None, None]:
         i, sub = pos
         assert sub in {0, 1, 2}  # noqa: S101  # for examples "assert" is acceptable
         if i < 0 or i >= len(self.content):
@@ -252,13 +255,18 @@ class CellWalker(urwid.ListWalker):
 
         return self.content[i].result, pos
 
-    def get_focus(self):
+    def get_focus(
+        self,
+    ) -> tuple[urwid.Divider | urwid.AttrMap[urwid.IntEdit] | urwid.Text, tuple[int, int]] | tuple[None, None]:
         return self._get_at_pos(self.focus)
 
-    def set_focus(self, focus) -> None:
+    def set_focus(self, focus: tuple[int, int]) -> None:
         self.focus = focus
 
-    def get_next(self, position):
+    def get_next(
+        self,
+        position: tuple[int, int],
+    ) -> tuple[urwid.Divider | urwid.AttrMap[urwid.IntEdit] | urwid.Text, tuple[int, int]] | tuple[None, None]:
         i, sub = position
         assert sub in {0, 1, 2}  # noqa: S101  # for examples "assert" is acceptable
         if sub == 0:
@@ -272,7 +280,10 @@ class CellWalker(urwid.ListWalker):
 
         return self._get_at_pos((i + 1, 0))
 
-    def get_prev(self, position):
+    def get_prev(
+        self,
+        position: tuple[int, int],
+    ) -> tuple[urwid.Divider | urwid.AttrMap[urwid.IntEdit] | urwid.Text, tuple[int, int]] | tuple[None, None]:
         i, sub = position
         assert sub in {0, 1, 2}  # noqa: S101  # for examples "assert" is acceptable
         if sub == 0:
@@ -289,7 +300,7 @@ class CellWalker(urwid.ListWalker):
         return self._get_at_pos((i, 1))
 
 
-class CellColumn(urwid.WidgetWrap):
+class CellColumn(urwid.WidgetWrap[urwid.Frame[urwid.WidgetWrap[urwid.Text], urwid.ListBox, None]]):
     def __init__(self, letter: str) -> None:
         self.walker = CellWalker([Cell(None)])
         self.content = self.walker.content
@@ -304,7 +315,7 @@ class CellColumn(urwid.WidgetWrap):
         header = urwid.AttrMap(urwid.Text(["Column ", ("key", letter)], layout=CALC_LAYOUT), "colhead")
         self.frame = urwid.Frame(self.listbox, header)
 
-    def keypress(self, size, key: str) -> str | None:
+    def keypress(self, size: tuple[int, int], key: str) -> str | None:
         key = self.frame.keypress(size, key)
         if key is None:
             changed = self.update_results()
@@ -387,7 +398,7 @@ class CellColumn(urwid.WidgetWrap):
             return None
         return key
 
-    def move_focus_next(self, size) -> None:
+    def move_focus_next(self, size: tuple[int, int]) -> None:
         _f, (i, _sub) = self.walker.get_focus()
         assert i < len(self.content) - 1  # noqa: S101  # for examples "assert" is acceptable
 
@@ -396,7 +407,7 @@ class CellColumn(urwid.WidgetWrap):
             self.frame.keypress(size, "down")
             _nf, (ni, _nsub) = self.walker.get_focus()
 
-    def move_focus_prev(self, size) -> None:
+    def move_focus_prev(self, size: tuple[int, int]) -> None:
         _f, (i, _sub) = self.walker.get_focus()
         assert i > 0  # noqa: S101  # for examples "assert" is acceptable
 
@@ -442,7 +453,7 @@ class CellColumn(urwid.WidgetWrap):
 
         return True
 
-    def create_child(self, letter):
+    def create_child(self, letter: str) -> tuple[Cell, CellColumn] | tuple[None, None]:
         """Return (parent cell,child column) or None,None on failure."""
         _f, (i, sub) = self.walker.get_focus()
         if sub != 0:
@@ -479,7 +490,7 @@ class CellColumn(urwid.WidgetWrap):
 
         return "".join(lines)
 
-    def get_result(self):
+    def get_result(self) -> int | None:
         """Return the result of the last cell in the column."""
 
         return self.content[-1].get_result()
@@ -541,7 +552,7 @@ class HelpColumn(urwid.Widget):
         self.body = urwid.AttrMap(self.listbox, "help")
         self.frame = urwid.Frame(self.body, header=self.head)
 
-    def render(self, size, focus: bool = False) -> urwid.Canvas:
+    def render(self, size: tuple[int, int], focus: bool = False) -> urwid.Canvas:
         maxcol, maxrow = size
         head_rows = self.head.rows((maxcol,))
         if "bottom" in self.listbox.ends_visible((maxcol, maxrow - head_rows)):
@@ -551,17 +562,17 @@ class HelpColumn(urwid.Widget):
 
         return self.frame.render((maxcol, maxrow), focus)
 
-    def keypress(self, size, key: str) -> str | None:
+    def keypress(self, size: tuple[int, int], key: str) -> str | None:
         return self.frame.keypress(size, key)
 
 
 class CalcDisplay:
-    palette: typing.ClassVar[list[tuple[str, str, str, ...]]] = [
+    palette: typing.ClassVar[list[tuple[str, str, str] | tuple[str, str, str, str]]] = [
         ("body", "white", "dark blue"),
         ("edit", "yellow", "dark blue"),
         ("editfocus", "yellow", "dark cyan", "bold"),
-        ("key", "dark cyan", "light gray", ("standout", "underline")),
-        ("title", "white", "light gray", ("bold", "standout")),
+        ("key", "dark cyan", "light gray", "standout,underline"),
+        ("title", "white", "light gray", "bold,standout"),
         ("help", "black", "light gray", "standout"),
         ("helpnote", "dark green", "light gray"),
         ("colhead", "black", "light gray", "standout"),
@@ -586,7 +597,7 @@ class CalcDisplay:
         print(expression)
         print("Result:", result)
 
-    def input_filter(self, data, raw_input):
+    def input_filter(self, data: list[str | tuple[str, int, int, int]], raw_input: list[int]) -> list[str]:
         if "q" in data or "Q" in data:
             raise urwid.ExitMainLoop()
 
@@ -604,7 +615,7 @@ class CalcDisplay:
         # remove all input from further processing by MainLoop
         return []
 
-    def wrap_keypress(self, key: str) -> None:
+    def wrap_keypress(self, key: str | tuple[str, int, int, int]) -> None:
         """Handle confirmation and throw event on bad input."""
 
         try:
@@ -633,7 +644,7 @@ class CalcDisplay:
         if key not in EDIT_KEYS and key not in MOVEMENT_KEYS:
             raise CalcEvent(E_invalid_key % key.upper())
 
-    def keypress(self, key: str) -> str | None:
+    def keypress(self, key: str | tuple[str, int, int, int]) -> str | None:
         """Handle a keystroke."""
 
         self.loop.process_input([key])
@@ -774,7 +785,7 @@ class CalcNumLayout(urwid.TextLayout):
     the last line for the cursor.
     """
 
-    def layout(self, text, width: int, align, wrap):
+    def layout(self, text: str | bytes, width: int, align: typing.Any, wrap: typing.Any):
         """
         Return layout structure for calculator number display.
         """