urwid 2.6.4__py3-none-any.whl → 2.6.6__py3-none-any.whl

urwid/widget/overlay.py

@@ -4,6 +4,7 @@ import typing
 import warnings
 
 from urwid.canvas import CanvasOverlay, CompositeCanvas
+from urwid.split_repr import remove_defaults
 
 from .constants import (
     RELATIVE_100,
@@ -32,6 +33,10 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
 
+TopWidget = typing.TypeVar("TopWidget")
+BottomWidget = typing.TypeVar("BottomWidget")
+
+
 class OverlayError(WidgetError):
     """Overlay specific errors."""
 
@@ -67,7 +72,7 @@ class OverlayOptions(typing.NamedTuple):
     bottom: int
 
 
-class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
+class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin, typing.Generic[TopWidget, BottomWidget]):
     """
     Overlay contains two box widgets and renders one on top of the other
     """
@@ -93,8 +98,8 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
     def __init__(
         self,
-        top_w: Widget,
-        bottom_w: Widget,
+        top_w: TopWidget,
+        bottom_w: BottomWidget,
         align: (
             Literal["left", "center", "right"]
             | Align
@@ -227,7 +232,11 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         return frozenset(sizing)
 
-    def pack(self, size: tuple[()] | tuple[int] | tuple[int, int] = (), focus: bool = False) -> tuple[int, int]:
+    def pack(
+        self,
+        size: tuple[()] | tuple[int] | tuple[int, int] = (),
+        focus: bool = False,
+    ) -> tuple[int, int]:
         if size:
             return super().pack(size, focus)
 
@@ -322,8 +331,67 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             f"min_height={self.min_height!r}"
         )
 
-    def _repr_words(self) -> list[str]:
-        return [*super()._repr_words(), f"top={self.top_w!r}", f"bottom={self.bottom_w!r}"]
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        attrs = {
+            **super()._repr_attrs(),
+            "top_w": self.top_w,
+            "bottom_w": self.bottom_w,
+            "align": self.align,
+            "width": self.width,
+            "valign": self.valign,
+            "height": self.height,
+            "min_width": self.min_width,
+            "min_height": self.min_height,
+            "left": self.left,
+            "right": self.right,
+            "top": self.top,
+            "bottom": self.bottom,
+        }
+        return remove_defaults(attrs, Overlay.__init__)
+
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "top", self.top_w
+        yield "bottom", self.bottom_w
+        yield "align", self.align
+        yield "width", self.width
+        yield "valign", self.valign
+        yield "height", self.height
+        yield "min_width", self.min_width
+        yield "min_height", self.min_height
+        yield "left", self.left
+        yield "right", self.right
+        yield "top", self.top
+        yield "bottom", self.bottom
+
+    @property
+    def align(self) -> Align | tuple[Literal[WHSettings.RELATIVE], int]:
+        return simplify_align(self.align_type, self.align_amount)
+
+    @property
+    def width(
+        self,
+    ) -> (
+        Literal[WHSettings.CLIP, WHSettings.PACK]
+        | int
+        | tuple[Literal[WHSettings.RELATIVE], int]
+        | tuple[Literal[WHSettings.WEIGHT], int | float]
+    ):
+        return simplify_width(self.width_type, self.width_amount)
+
+    @property
+    def valign(self) -> VAlign | tuple[Literal[WHSettings.RELATIVE], int]:
+        return simplify_valign(self.valign_type, self.valign_amount)
+
+    @property
+    def height(
+        self,
+    ) -> (
+        int
+        | Literal[WHSettings.FLOW, WHSettings.PACK]
+        | tuple[Literal[WHSettings.RELATIVE], int]
+        | tuple[Literal[WHSettings.WEIGHT], int | float]
+    ):
+        return simplify_height(self.height_type, self.height_amount)
 
     @staticmethod
     def options(
@@ -478,13 +546,20 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """Return selectable from top_w."""
         return self.top_w.selectable()
 
-    def keypress(self, size: tuple[()] | tuple[int] | tuple[int, int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[()] | tuple[int] | tuple[int, int],
+        key: str,
+    ) -> str | None:
         """Pass keypress to top_w."""
         real_size = self.pack(size, True)
-        return self.top_w.keypress(self.top_w_size(real_size, *self.calculate_padding_filler(real_size, True)), key)
+        return self.top_w.keypress(
+            self.top_w_size(real_size, *self.calculate_padding_filler(real_size, True)),
+            key,
+        )
 
     @property
-    def focus(self) -> Widget:
+    def focus(self) -> TopWidget:
         """
         Read-only property returning the child widget in focus for
         container widgets.  This default implementation
@@ -492,7 +567,7 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """
         return self.top_w
 
-    def _get_focus(self) -> Widget:
+    def _get_focus(self) -> TopWidget:
         warnings.warn(
             f"method `{self.__class__.__name__}._get_focus` is deprecated, "
             f"please use `{self.__class__.__name__}.focus` property",
@@ -567,7 +642,7 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """
 
         # noinspection PyMethodParameters
-        class OverlayContents(typing.Sequence[typing.Tuple[Widget, OverlayOptions]]):
+        class OverlayContents(typing.Sequence[typing.Tuple[typing.Union[TopWidget, BottomWidget], OverlayOptions]]):
             # pylint: disable=no-self-argument
             def __len__(inner_self) -> int:
                 return 2
@@ -595,7 +670,10 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         self.contents[0] = new_contents[0]
         self.contents[1] = new_contents[1]
 
-    def _contents__getitem__(self, index: Literal[0, 1]) -> tuple[Widget, OverlayOptions]:
+    def _contents__getitem__(
+        self,
+        index: Literal[0, 1],
+    ) -> tuple[TopWidget | BottomWidget, OverlayOptions]:
         if index == 0:
             return (self.bottom_w, self._DEFAULT_BOTTOM_OPTIONS)
 
@@ -621,7 +699,11 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             )
         raise IndexError(f"Overlay.contents has no position {index!r}")
 
-    def _contents__setitem__(self, index: Literal[0, 1], value: tuple[Widget, OverlayOptions]) -> None:
+    def _contents__setitem__(
+        self,
+        index: Literal[0, 1],
+        value: tuple[TopWidget | BottomWidget, OverlayOptions],
+    ) -> None:
         try:
             value_w, value_options = value
         except (ValueError, TypeError) as exc:
@@ -675,7 +757,10 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             raise IndexError(f"Overlay.contents has no position {index!r}")
         self._invalidate()
 
-    def get_cursor_coords(self, size: tuple[()] | tuple[int] | tuple[int, int]) -> tuple[int, int] | None:
+    def get_cursor_coords(
+        self,
+        size: tuple[()] | tuple[int] | tuple[int, int],
+    ) -> tuple[int, int] | None:
         """Return cursor coords from top_w, if any."""
         if not hasattr(self.top_w, "get_cursor_coords"):
             return None

urwid/widget/padding.py

@@ -20,8 +20,9 @@ from .constants import (
 from .widget_decoration import WidgetDecoration, WidgetError, WidgetWarning
 
 if typing.TYPE_CHECKING:
-    from typing_extensions import Literal
+    from collections.abc import Iterator
 
+    from typing_extensions import Literal
 
 WrappedWidget = typing.TypeVar("WrappedWidget")
 
@@ -34,7 +35,7 @@ class PaddingWarning(WidgetWarning):
     """Padding related warnings."""
 
 
-class Padding(WidgetDecoration[WrappedWidget]):
+class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
     def __init__(
         self,
         w: WrappedWidget,
@@ -185,6 +186,14 @@ class Padding(WidgetDecoration[WrappedWidget]):
         }
         return remove_defaults(attrs, Padding.__init__)
 
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "w", self.original_widget
+        yield "align", self.align
+        yield "width", self.width
+        yield "min_width", self.min_width
+        yield "left", self.left
+        yield "right", self.right
+
     @property
     def align(
         self,
@@ -268,7 +277,11 @@ class Padding(WidgetDecoration[WrappedWidget]):
         )
         self.width = width
 
-    def pack(self, size: tuple[()] | tuple[int] | tuple[int, int] = (), focus: bool = False) -> tuple[int, int]:
+    def pack(
+        self,
+        size: tuple[()] | tuple[int] | tuple[int, int] = (),
+        focus: bool = False,
+    ) -> tuple[int, int]:
         if size:
             return super().pack(size, focus)
         if self._width_type == WHSettings.CLIP:

urwid/widget/pile.py

@@ -6,15 +6,16 @@ from itertools import chain, repeat
 
 from urwid.canvas import CanvasCombine, CompositeCanvas, SolidCanvas
 from urwid.command_map import Command
-from urwid.monitored_list import MonitoredFocusList, MonitoredList
+from urwid.split_repr import remove_defaults
 from urwid.util import is_mouse_press
 
 from .constants import Sizing, WHSettings
 from .container import WidgetContainerListContentsMixin, WidgetContainerMixin, _ContainerElementSizingFlag
+from .monitored_list import MonitoredFocusList, MonitoredList
 from .widget import Widget, WidgetError, WidgetWarning
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
+    from collections.abc import Iterable, Iterator, Sequence
 
     from typing_extensions import Literal
 
@@ -58,36 +59,42 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         # BOX-only widget
         >>> Pile((SolidFill("#"),))
-        <Pile box widget>
+        <Pile box widget (1 item)>
 
         # GIVEN BOX -> BOX/FLOW
         >>> Pile(((10, SolidFill("#")),))
-        <Pile box/flow widget>
+        <Pile box/flow widget (1 item)>
 
         # FLOW-only
         >>> Pile((ProgressBar(None, None),))
-        <Pile flow widget>
+        <Pile flow widget (1 item)>
 
         # FIXED -> FIXED
         >>> Pile(((WHSettings.PACK, BigText("0", font)),))
-        <Pile fixed widget>
+        <Pile fixed widget (1 item)>
 
         # FLOW/FIXED -> FLOW/FIXED
         >>> Pile(((WHSettings.PACK, Text("text")),))
-        <Pile fixed/flow widget>
+        <Pile fixed/flow widget (1 item)>
 
         # FLOW + FIXED widgets -> FLOW/FIXED
         >>> Pile((ProgressBar(None, None), (WHSettings.PACK, BigText("0", font))))
-        <Pile fixed/flow widget>
+        <Pile fixed/flow widget (2 items) focus_item=0>
 
         # GIVEN BOX + FIXED widgets -> BOX/FLOW/FIXED (GIVEN BOX allows overriding its height & allows any width)
         >>> Pile(((10, SolidFill("#")), (WHSettings.PACK, BigText("0", font))))
-        <Pile widget>
+        <Pile widget (2 items) focus_item=0>
 
         # Invalid sizing combination -> use fallback settings (and produce warning)
         >>> Pile(((WHSettings.WEIGHT, 1, BigText("0", font)),))
-        <Pile box/flow widget>
+        <Pile box/flow widget (1 item)>
+
+        # Special case: empty pile widget sizing is impossible to calculate
+        >>> Pile(())
+        <Pile box/flow widget ()>
         """
+        if not self.contents:
+            return frozenset((Sizing.BOX, Sizing.FLOW))
         strict_box = False
         has_flow = False
 
@@ -225,6 +232,43 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         self.pref_col = 0
 
+    def _repr_words(self) -> list[str]:
+        if len(self.contents) > 1:
+            contents_string = f"({len(self.contents)} items)"
+        elif self.contents:
+            contents_string = "(1 item)"
+        else:
+            contents_string = "()"
+        return [*super()._repr_words(), contents_string]
+
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        attrs = {**super()._repr_attrs(), "focus_item": self.focus_position if len(self._contents) > 1 else None}
+        return remove_defaults(attrs, Pile.__init__)
+
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        widget_list: list[
+            Widget
+            | tuple[Literal[WHSettings.PACK] | int, Widget]
+            | tuple[Literal[WHSettings.WEIGHT], int | float, Widget]
+        ] = []
+
+        for w_instance, (sizing, amount) in self._contents:
+            if sizing == WHSettings.GIVEN:
+                widget_list.append((amount, w_instance))
+            elif sizing == WHSettings.PACK:
+                widget_list.append((WHSettings.PACK, w_instance))
+            elif sizing == WHSettings.WEIGHT:
+                if amount == 1:
+                    widget_list.append(w_instance)
+                else:
+                    widget_list.append((WHSettings.WEIGHT, amount, w_instance))
+
+        yield "widget_list", widget_list
+        yield "focus_item", self.focus_position if self._contents else None
+
+    def __len__(self) -> int:
+        return len(self._contents)
+
     def _contents_modified(self) -> None:
         """Recalculate whether this widget should be selectable whenever the contents has been changed."""
         self._selectable = any(w.selectable() for w, o in self.contents)
@@ -281,7 +325,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 chain(self.contents, repeat((None, (WHSettings.WEIGHT, 1)))),
             )
         ]
-        if focus_position < len(widgets):
+        if focus_position < len(widgets):  # pylint: disable=consider-using-max-builtin  # pylint bug
             self.focus_position = focus_position
 
     @property
@@ -321,7 +365,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             (w, ({Sizing.FIXED: WHSettings.GIVEN, Sizing.FLOW: WHSettings.PACK}.get(new_t, new_t), new_height))
             for ((new_t, new_height), (w, options)) in zip(item_types, self.contents)
         ]
-        if focus_position < len(item_types):
+        if focus_position < len(item_types):  # pylint: disable=consider-using-max-builtin  # pylint bug
             self.focus_position = focus_position
 
     @property
@@ -715,7 +759,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 w_h_args.append((maxcol, height))
             elif f == WHSettings.PACK or len(size) == 1:
                 if Sizing.FLOW in w_sizing:
-                    w_h_arg = (maxcol,)
+                    w_h_arg: tuple[int] | tuple[()] = (maxcol,)
                 elif Sizing.FIXED in w_sizing and f == WHSettings.PACK:
                     w_h_arg = ()
                 else:

urwid/widget/progress_bar.py

@@ -106,7 +106,11 @@ class ProgressBar(Widget):
         percent = min(100, max(0, int(self.current * 100 / self.done)))
         return f"{percent!s} %"
 
-    def render(self, size: tuple[int], focus: bool = False) -> TextCanvas:
+    def render(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> TextCanvas:
         """
         Render the progress bar.
         """

urwid/widget/scrollable.py

@@ -43,7 +43,7 @@ if typing.TYPE_CHECKING:
 __all__ = ("ScrollBar", "Scrollable", "ScrollableError", "ScrollbarSymbols")
 
 
-WrappedWidget = typing.TypeVar("WrappedWidget")
+WrappedWidget = typing.TypeVar("WrappedWidget", bound="SupportsScroll")
 
 
 class ScrollableError(WidgetError):
@@ -153,7 +153,11 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
         self.force_forward_keypress = force_forward_keypress
         super().__init__(widget)
 
-    def render(self, size: tuple[int, int], focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> CompositeCanvas:
         from urwid import canvas
 
         maxcol, maxrow = size
@@ -270,7 +274,11 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
 
         return canv
 
-    def keypress(self, size: tuple[int, int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         from urwid.command_map import Command
 
         # Maybe offer key to original widget
@@ -311,7 +319,7 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
 
     def mouse_event(
         self,
-        size: tuple[int, int],
+        size: tuple[int, int],  # type: ignore[override]
         event: str,
         button: int,
         col: int,
@@ -375,7 +383,10 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
             elif cursrow >= self._trim_top + maxrow:
                 self._trim_top = max(0, cursrow - maxrow + 1)
 
-    def _get_original_widget_size(self, size: tuple[int, int]) -> tuple[int] | tuple[()]:
+    def _get_original_widget_size(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+    ) -> tuple[int] | tuple[()]:
         ow = self._original_widget
         sizing = ow.sizing()
         if Sizing.FLOW in sizing:
@@ -465,7 +476,11 @@ class ScrollBar(WidgetDecoration[WrappedWidget]):
         self.scrollbar_width = max(1, width)
         self._original_widget_size = (0, 0)
 
-    def render(self, size: tuple[int, int], focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> Canvas:
         from urwid import canvas
 
         maxcol, maxrow = size
@@ -566,12 +581,16 @@ class ScrollBar(WidgetDecoration[WrappedWidget]):
 
         raise ScrollableError(f"Not compatible to be wrapped by ScrollBar: {w!r}")
 
-    def keypress(self, size: tuple[int, int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         return self._original_widget.keypress(self._original_widget_size, key)
 
     def mouse_event(
         self,
-        size: tuple[int, int],
+        size: tuple[int, int],  # type: ignore[override]
         event: str,
         button: int,
         col: int,
@@ -580,7 +599,7 @@ class ScrollBar(WidgetDecoration[WrappedWidget]):
     ) -> bool | None:
         ow = self._original_widget
         ow_size = self._original_widget_size
-        handled = False
+        handled: bool | None = False
         if hasattr(ow, "mouse_event"):
             handled = ow.mouse_event(ow_size, event, button, col, row, focus)
 

urwid/widget/solid_fill.py

@@ -31,7 +31,11 @@ class SolidFill(Widget):
     def _repr_words(self) -> list[str]:
         return [*super()._repr_words(), repr(self.fill_char)]
 
-    def render(self, size: tuple[int, int], focus: bool = False) -> SolidCanvas:
+    def render(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> SolidCanvas:
         """
         Render the Fill as a canvas and return it.
 

urwid/widget/text.py

@@ -72,7 +72,7 @@ class Text(Widget):
         [('bold', 5)]
         """
         super().__init__()
-        self._cache_maxcol = None
+        self._cache_maxcol: int | None = None
         self.set_text(markup)
         self.set_layout(align, wrap, layout)
 
@@ -245,7 +245,11 @@ class Text(Widget):
     def layout(self):
         return self._layout
 
-    def render(self, size: tuple[int] | tuple[()], focus: bool = False) -> TextCanvas:
+    def render(
+        self,
+        size: tuple[int] | tuple[()],  # type: ignore[override]
+        focus: bool = False,
+    ) -> TextCanvas:
         """
         Render contents with wrapping and alignment.  Return canvas.
 
@@ -312,7 +316,11 @@ class Text(Widget):
         self._cache_maxcol = maxcol
         self._cache_translation = self.layout.layout(text, maxcol, self._align_mode, self._wrap_mode)
 
-    def pack(self, size: tuple[int] | tuple[()] | None = None, focus: bool = False) -> tuple[int, int]:
+    def pack(
+        self,
+        size: tuple[()] | tuple[int] | None = None,  # type: ignore[override]
+        focus: bool = False,
+    ) -> tuple[int, int]:
         """
         Return the number of screen columns and rows required for
         this Text widget to be displayed without wrapping or

urwid/{treetools.py → widget/treetools.py}

@@ -32,26 +32,34 @@ from __future__ import annotations
 
 import typing
 
-import urwid
+from .columns import Columns
+from .constants import WHSettings
+from .listbox import ListBox, ListWalker
+from .padding import Padding
+from .text import Text
+from .widget import WidgetWrap
+from .wimp import SelectableIcon
 
 if typing.TYPE_CHECKING:
     from collections.abc import Hashable, Sequence
 
+__all__ = ("TreeWidgetError", "TreeWidget", "TreeNode", "ParentNode", "TreeWalker", "TreeListBox")
+
 
 class TreeWidgetError(RuntimeError):
     pass
 
 
-class TreeWidget(urwid.WidgetWrap[urwid.Padding]):
+class TreeWidget(WidgetWrap[Padding[typing.Union[Text, Columns]]]):
     """A widget representing something in a nested tree display."""
 
     indent_cols = 3
-    unexpanded_icon = urwid.SelectableIcon("+", 0)
-    expanded_icon = urwid.SelectableIcon("-", 0)
+    unexpanded_icon = SelectableIcon("+", 0)
+    expanded_icon = SelectableIcon("-", 0)
 
     def __init__(self, node: TreeNode) -> None:
         self._node = node
-        self._innerwidget: urwid.Text | None = None
+        self._innerwidget: Text | None = None
         self.is_leaf = not hasattr(node, "get_first_child")
         self.expanded = True
         widget = self.get_indented_widget()
@@ -63,31 +71,32 @@ class TreeWidget(urwid.WidgetWrap[urwid.Padding]):
         """
         return not self.is_leaf
 
-    def get_indented_widget(self) -> urwid.Padding:
+    def get_indented_widget(self) -> Padding[Text | Columns]:
         widget = self.get_inner_widget()
         if not self.is_leaf:
-            widget = urwid.Columns(
+            widget = Columns(
                 [(1, [self.unexpanded_icon, self.expanded_icon][self.expanded]), widget],
                 dividechars=1,
             )
         indent_cols = self.get_indent_cols()
-        return urwid.Padding(widget, width=(urwid.RELATIVE, 100), left=indent_cols)
+        return Padding(widget, width=(WHSettings.RELATIVE, 100), left=indent_cols)
 
     def update_expanded_icon(self) -> None:
         """Update display widget text for parent widgets"""
         # icon is first element in columns indented widget
-        self._w.base_widget.widget_list[0] = [self.unexpanded_icon, self.expanded_icon][self.expanded]
+        icon = [self.unexpanded_icon, self.expanded_icon][self.expanded]
+        self._w.original_widget.contents[0] = (icon, (WHSettings.GIVEN, 1, False))
 
     def get_indent_cols(self) -> int:
         return self.indent_cols * self.get_node().get_depth()
 
-    def get_inner_widget(self) -> urwid.Text:
+    def get_inner_widget(self) -> Text:
         if self._innerwidget is None:
             self._innerwidget = self.load_inner_widget()
         return self._innerwidget
 
-    def load_inner_widget(self) -> urwid.Widget:
-        return urwid.Text(self.get_display_text())
+    def load_inner_widget(self) -> Text:
+        return Text(self.get_display_text())
 
     def get_node(self) -> TreeNode:
         return self._node
@@ -141,7 +150,11 @@ class TreeWidget(urwid.WidgetWrap[urwid.Padding]):
             prev_node = this_node.get_parent()
         return prev_node.get_widget()
 
-    def keypress(self, size: tuple[int] | tuple[()], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int] | tuple[()],
+        key: str,
+    ) -> str | None:
         """Handle expand & collapse requests (non-leaf nodes)"""
         if self.is_leaf:
             return key
@@ -227,7 +240,7 @@ class TreeNode:
         self._parent = parent
         self._value = value
         self._depth = depth
-        self._widget = None
+        self._widget: TreeWidget | None = None
 
     def get_widget(self, reload: bool = False) -> TreeWidget:
         """Return the widget for this node."""
@@ -403,7 +416,7 @@ class ParentNode(TreeNode):
         return len(self.get_child_keys()) > 0
 
 
-class TreeWalker(urwid.ListWalker):
+class TreeWalker(ListWalker):
     """ListWalker-compatible class for displaying TreeWidgets
 
     positions are TreeNodes."""
@@ -438,12 +451,16 @@ class TreeWalker(urwid.ListWalker):
     # pylint: enable=arguments-renamed
 
 
-class TreeListBox(urwid.ListBox):
+class TreeListBox(ListBox):
     """A ListBox with special handling for navigation and
     collapsing of TreeWidgets"""
 
-    def keypress(self, size: tuple[int, int], key: str) -> str | None:
-        key = super().keypress(size, key)
+    def keypress(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
+        key: str | None = super().keypress(size, key)
         return self.unhandled_input(size, key)
 
     def unhandled_input(self, size: tuple[int, int], data: str) -> str | None: