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

urwid/widget/frame.py

@@ -4,6 +4,7 @@ import typing
 import warnings
 
 from urwid.canvas import CanvasCombine, CompositeCanvas
+from urwid.split_repr import remove_defaults
 from urwid.util import is_mouse_press
 
 from .constants import Sizing, VAlign
@@ -17,6 +18,11 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
 
+BodyWidget = typing.TypeVar("BodyWidget")
+HeaderWidget = typing.TypeVar("HeaderWidget")
+FooterWidget = typing.TypeVar("FooterWidget")
+
+
 class FrameError(WidgetError):
     pass
 
@@ -34,15 +40,14 @@ def _check_widget_subclass(widget: Widget | None) -> None:
         )
 
 
-class Frame(Widget, WidgetContainerMixin):
+class Frame(Widget, WidgetContainerMixin, typing.Generic[BodyWidget, HeaderWidget, FooterWidget]):
     """
     Frame widget is a box widget with optional header and footer
     flow widgets placed above and below the box widget.
 
     .. note:: The main difference between a Frame and a :class:`Pile` widget
         defined as: `Pile([('pack', header), body, ('pack', footer)])` is that
-        the Frame will not automatically change focus up and down in response to
-        keystrokes.
+        the Frame will not automatically change focus up and down in response to keystrokes.
     """
 
     _selectable = True
@@ -50,9 +55,9 @@ class Frame(Widget, WidgetContainerMixin):
 
     def __init__(
         self,
-        body: Widget,
-        header: Widget | None = None,
-        footer: Widget | None = None,
+        body: BodyWidget,
+        header: HeaderWidget = None,
+        footer: FooterWidget = None,
         focus_part: Literal["header", "footer", "body"] | Widget = "body",
     ):
         """
@@ -85,19 +90,35 @@ class Frame(Widget, WidgetContainerMixin):
         _check_widget_subclass(body)
         _check_widget_subclass(footer)
 
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        attrs = {
+            **super()._repr_attrs(),
+            "body": self._body,
+            "header": self._header,
+            "footer": self._footer,
+            "focus_part": self.focus_part,
+        }
+        return remove_defaults(attrs, Frame.__init__)
+
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "body", self._body
+        yield "header", self._header
+        yield "footer", self._footer
+        yield "focus_part", self.focus_part
+
     @property
-    def header(self) -> Widget | None:
+    def header(self) -> HeaderWidget:
         return self._header
 
     @header.setter
-    def header(self, header: Widget | None) -> None:
+    def header(self, header: HeaderWidget) -> None:
         _check_widget_subclass(header)
         self._header = header
         if header is None and self.focus_part == "header":
             self.focus_part = "body"
         self._invalidate()
 
-    def get_header(self) -> Widget | None:
+    def get_header(self) -> HeaderWidget:
         warnings.warn(
             f"method `{self.__class__.__name__}.get_header` is deprecated, "
             f"standard property `{self.__class__.__name__}.header` should be used instead",
@@ -106,7 +127,7 @@ class Frame(Widget, WidgetContainerMixin):
         )
         return self.header
 
-    def set_header(self, header: Widget | None):
+    def set_header(self, header: HeaderWidget) -> None:
         warnings.warn(
             f"method `{self.__class__.__name__}.set_header` is deprecated, "
             f"standard property `{self.__class__.__name__}.header` should be used instead",
@@ -116,16 +137,16 @@ class Frame(Widget, WidgetContainerMixin):
         self.header = header
 
     @property
-    def body(self) -> Widget:
+    def body(self) -> BodyWidget:
         return self._body
 
     @body.setter
-    def body(self, body: Widget) -> None:
+    def body(self, body: BodyWidget) -> None:
         _check_widget_subclass(body)
         self._body = body
         self._invalidate()
 
-    def get_body(self) -> Widget:
+    def get_body(self) -> BodyWidget:
         warnings.warn(
             f"method `{self.__class__.__name__}.get_body` is deprecated, "
             f"standard property {self.__class__.__name__}.body should be used instead",
@@ -134,7 +155,7 @@ class Frame(Widget, WidgetContainerMixin):
         )
         return self.body
 
-    def set_body(self, body: Widget) -> None:
+    def set_body(self, body: BodyWidget) -> None:
         warnings.warn(
             f"method `{self.__class__.__name__}.set_body` is deprecated, "
             f"standard property `{self.__class__.__name__}.body` should be used instead",
@@ -144,18 +165,18 @@ class Frame(Widget, WidgetContainerMixin):
         self.body = body
 
     @property
-    def footer(self) -> Widget | None:
+    def footer(self) -> FooterWidget:
         return self._footer
 
     @footer.setter
-    def footer(self, footer: Widget | None) -> None:
+    def footer(self, footer: FooterWidget) -> None:
         _check_widget_subclass(footer)
         self._footer = footer
         if footer is None and self.focus_part == "footer":
             self.focus_part = "body"
         self._invalidate()
 
-    def get_footer(self) -> Widget | None:
+    def get_footer(self) -> FooterWidget:
         warnings.warn(
             f"method `{self.__class__.__name__}.get_footer` is deprecated, "
             f"standard property `{self.__class__.__name__}.footer` should be used instead",
@@ -164,7 +185,7 @@ class Frame(Widget, WidgetContainerMixin):
         )
         return self.footer
 
-    def set_footer(self, footer: Widget | None) -> None:
+    def set_footer(self, footer: FooterWidget) -> None:
         warnings.warn(
             f"method `{self.__class__.__name__}.set_footer` is deprecated, "
             f"standard property `{self.__class__.__name__}.footer` should be used instead",
@@ -228,13 +249,13 @@ class Frame(Widget, WidgetContainerMixin):
         self.focus_position = part
 
     @property
-    def focus(self) -> Widget:
+    def focus(self) -> BodyWidget | HeaderWidget | FooterWidget:
         """
         child :class:`Widget` in focus: the body, header or footer widget.
         This is a read-only property."""
         return {"header": self._header, "footer": self._footer, "body": self._body}[self.focus_part]
 
-    def _get_focus(self) -> Widget:
+    def _get_focus(self) -> BodyWidget | HeaderWidget | FooterWidget:
         warnings.warn(
             f"method `{self.__class__.__name__}._get_focus` is deprecated, "
             f"please use `{self.__class__.__name__}.focus` property",
@@ -244,7 +265,12 @@ class Frame(Widget, WidgetContainerMixin):
         return {"header": self._header, "footer": self._footer, "body": self._body}[self.focus_part]
 
     @property
-    def contents(self) -> MutableMapping[Literal["header", "footer", "body"], tuple[Widget, None]]:
+    def contents(
+        self,
+    ) -> MutableMapping[
+        Literal["header", "footer", "body"],
+        tuple[BodyWidget | HeaderWidget | FooterWidget, None],
+    ]:
         """
         a dict-like object similar to::
 
@@ -267,7 +293,12 @@ class Frame(Widget, WidgetContainerMixin):
         """
 
         # noinspection PyMethodParameters
-        class FrameContents(typing.MutableMapping[str, typing.Tuple[Widget, None]]):
+        class FrameContents(
+            typing.MutableMapping[
+                str,
+                typing.Tuple[typing.Union[BodyWidget, HeaderWidget, FooterWidget], None],
+            ]
+        ):
             # pylint: disable=no-self-argument
 
             __slots__ = ()
@@ -298,7 +329,18 @@ class Frame(Widget, WidgetContainerMixin):
             keys.append("footer")
         return keys
 
-    def _contents__getitem__(self, key: Literal["header", "footer", "body"]):
+    @typing.overload
+    def _contents__getitem__(self, key: Literal["body"]) -> tuple[BodyWidget, None]: ...
+
+    @typing.overload
+    def _contents__getitem__(self, key: Literal["header"]) -> tuple[HeaderWidget, None]: ...
+
+    @typing.overload
+    def _contents__getitem__(self, key: Literal["footer"]) -> tuple[FooterWidget, None]: ...
+
+    def _contents__getitem__(
+        self, key: Literal["body", "header", "footer"]
+    ) -> tuple[BodyWidget | HeaderWidget | FooterWidget, None]:
         if key == "body":
             return (self._body, None)
         if key == "header" and self._header:
@@ -307,7 +349,20 @@ class Frame(Widget, WidgetContainerMixin):
             return (self._footer, None)
         raise KeyError(f"Frame.contents has no key: {key!r}")
 
-    def _contents__setitem__(self, key: Literal["header", "footer", "body"], value) -> None:
+    @typing.overload
+    def _contents__setitem__(self, key: Literal["body"], value: tuple[BodyWidget, None]) -> None: ...
+
+    @typing.overload
+    def _contents__setitem__(self, key: Literal["header"], value: tuple[HeaderWidget, None]) -> None: ...
+
+    @typing.overload
+    def _contents__setitem__(self, key: Literal["footer"], value: tuple[FooterWidget, None]) -> None: ...
+
+    def _contents__setitem__(
+        self,
+        key: Literal["body", "header", "footer"],
+        value: tuple[BodyWidget | HeaderWidget | FooterWidget, None],
+    ) -> None:
         if key not in {"body", "header", "footer"}:
             raise KeyError(f"Frame.contents has no key: {key!r}")
         try:
@@ -323,7 +378,7 @@ class Frame(Widget, WidgetContainerMixin):
         else:
             self.header = value_w
 
-    def _contents__delitem__(self, key: Literal["header", "footer", "body"]) -> None:
+    def _contents__delitem__(self, key: Literal["header", "footer"]) -> None:
         if key not in {"header", "footer"}:
             raise KeyError(f"Frame.contents can't remove key: {key!r}")
         if (key == "header" and self._header is None) or (key == "footer" and self._footer is None):
@@ -400,7 +455,11 @@ class Frame(Widget, WidgetContainerMixin):
 
         return (hrows, frows), (hrows, frows)
 
-    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:
         (maxcol, maxrow) = size
         (htrim, ftrim), (hrows, frows) = self.frame_top_bottom((maxcol, maxrow), focus)
 
@@ -436,7 +495,11 @@ class Frame(Widget, WidgetContainerMixin):
 
         return CanvasCombine(combinelist)
 
-    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:
         """Pass keypress to widget in focus."""
         (maxcol, maxrow) = size
 
@@ -464,7 +527,7 @@ class Frame(Widget, WidgetContainerMixin):
 
     def mouse_event(
         self,
-        size: tuple[int, int],
+        size: tuple[int, int],  # type: ignore[override]
         event: str,
         button: int,
         col: int,

urwid/widget/grid_flow.py

@@ -3,24 +3,29 @@ from __future__ import annotations
 import typing
 import warnings
 
-from urwid.monitored_list import MonitoredFocusList, MonitoredList
+from urwid.split_repr import remove_defaults
 
 from .columns import Columns
 from .constants import Align, Sizing, WHSettings
 from .container import WidgetContainerListContentsMixin, WidgetContainerMixin
 from .divider import Divider
+from .monitored_list import MonitoredFocusList, MonitoredList
 from .padding import Padding
 from .pile import Pile
-from .widget import Widget, WidgetError, WidgetWrap
+from .widget import Widget, WidgetError, WidgetWarning, WidgetWrap
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
+    from collections.abc import Iterable, Iterator, Sequence
 
     from typing_extensions import Literal
 
 
 class GridFlowError(WidgetError):
-    pass
+    """GridFlow specific error."""
+
+
+class GridFlowWarning(WidgetWarning):
+    """GridFlow specific warning."""
 
 
 class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListContentsMixin):
@@ -75,6 +80,37 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
         self._cache_maxcol = self._get_maxcol(())
         super().__init__(self.generate_display_widget((self._cache_maxcol,)))
 
+    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(),
+            "cell_width": self.cell_width,
+            "h_sep": self.h_sep,
+            "v_sep": self.v_sep,
+            "align": self.align,
+            "focus": self.focus_position if len(self._contents) > 1 else None,
+        }
+        return remove_defaults(attrs, GridFlow.__init__)
+
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "cells", [widget for widget, _ in self.contents]
+        yield "cell_width", self.cell_width
+        yield "h_sep", self.h_sep
+        yield "v_sep", self.v_sep
+        yield "align", self.align
+        yield "focus", self.focus_position
+
+    def __len__(self) -> int:
+        return len(self._contents)
+
     def _invalidate(self) -> None:
         self._cache_maxcol = None
         super()._invalidate()
@@ -123,7 +159,7 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
         )
         focus_position = self.focus_position
         self.contents = [(new, (WHSettings.GIVEN, self._cell_width)) for new in widgets]
-        if focus_position < len(widgets):
+        if focus_position < len(widgets):  # pylint: disable=consider-using-max-builtin  # pylint bug
             self.focus_position = focus_position
 
     def _get_cells(self):
@@ -384,6 +420,12 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
     def _get_maxcol(self, size: tuple[int] | tuple[()]) -> int:
         if size:
             (maxcol,) = size
+            if maxcol < self.cell_width:
+                warnings.warn(
+                    f"Size is smaller than cell width ({maxcol!r} < {self.cell_width!r})",
+                    GridFlowWarning,
+                    stacklevel=3,
+                )
         else:
             maxcol = len(self) * self.cell_width + (len(self) - 1) * self.h_sep
         return maxcol
@@ -435,18 +477,15 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
                 pad.first_position = i
                 p.contents.append((pad, p.options()))
 
-            c.contents.append((w, c.options(WHSettings.GIVEN, width_amount)))
+            # Use width == maxcol in case of maxcol < width amount
+            # Columns will use empty widget in case of GIVEN width > maxcol
+            c.contents.append((w, c.options(WHSettings.GIVEN, width_amount if width_amount <= maxcol else maxcol)))
             if (i == self.focus_position) or (not column_focused and w.selectable()):
                 c.focus_position = len(c.contents) - 1
                 column_focused = True
             if i == self.focus_position:
                 p.focus_position = len(p.contents) - 1
             used_space = sum(x[1][1] for x in c.contents) + self.h_sep * len(c.contents)
-            if width_amount > maxcol:
-                # special case: display is too narrow for the given
-                # width so we remove the Columns for better behaviour
-                # FIXME: determine why this is necessary
-                pad.original_widget = w
             pad.width = used_space - self.h_sep
 
         if self.v_sep:
@@ -482,7 +521,11 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
         # pad.first_position was set by generate_display_widget() above
         self.focus_position = pile_focus.first_position + col_focus_position
 
-    def keypress(self, size: tuple[int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         """
         Pass keypress to display widget for handling.
         Captures focus changes.
@@ -493,7 +536,11 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
             self._set_focus_from_display_widget()
         return key
 
-    def pack(self, size: tuple[int] | tuple[()] = (), focus: bool = False) -> tuple[int, int]:
+    def pack(
+        self,
+        size: tuple[int] | tuple[()] = (),  # type: ignore[override]
+        focus: bool = False,
+    ) -> tuple[int, int]:
         if size:
             return super().pack(size, focus)
         cols = len(self) * self.cell_width + (len(self) - 1) * self.h_sep
@@ -503,7 +550,11 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
         self.get_display_widget(size)
         return super().rows(size, focus=focus)
 
-    def render(self, size: tuple[int] | tuple[()], focus: bool = False):
+    def render(
+        self,
+        size: tuple[int] | tuple[()],  # type: ignore[override]
+        focus: bool = False,
+    ):
         self.get_display_widget(size)
         return super().render(size, focus)
 
@@ -521,7 +572,7 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
 
     def mouse_event(
         self,
-        size: tuple[int] | tuple[()],
+        size: tuple[int] | tuple[()],  # type: ignore[override]
         event: str,
         button: int,
         col: int,

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

@@ -29,20 +29,12 @@ from typing_extensions import Protocol, runtime_checkable
 
 from urwid import signals
 from urwid.canvas import CanvasCombine, SolidCanvas
-from urwid.command_map import Command
-from urwid.monitored_list import MonitoredFocusList, MonitoredList
-from urwid.signals import connect_signal, disconnect_signal
-from urwid.util import is_mouse_press
-from urwid.widget import (
-    Sizing,
-    VAlign,
-    WHSettings,
-    Widget,
-    WidgetContainerMixin,
-    calculate_top_bottom_filler,
-    nocache_widget_render_instance,
-    normalize_valign,
-)
+
+from .constants import Sizing, VAlign, WHSettings, normalize_valign
+from .container import WidgetContainerMixin
+from .filler import calculate_top_bottom_filler
+from .monitored_list import MonitoredFocusList, MonitoredList
+from .widget import Widget, nocache_widget_render_instance
 
 if typing.TYPE_CHECKING:
     from collections.abc import Callable, Hashable
@@ -51,6 +43,8 @@ if typing.TYPE_CHECKING:
 
     from urwid.canvas import Canvas, CompositeCanvas
 
+__all__ = ("ListWalkerError", "ListWalker", "SimpleListWalker", "SimpleFocusListWalker", "ListBoxError", "ListBox")
+
 _T = typing.TypeVar("_T")
 _K = typing.TypeVar("_K")
 
@@ -362,7 +356,7 @@ class ListBox(Widget, WidgetContainerMixin):
     @body.setter
     def body(self, body: Iterable[Widget] | ListWalker) -> None:
         with suppress(AttributeError):
-            disconnect_signal(self._body, "modified", self._invalidate)
+            signals.disconnect_signal(self._body, "modified", self._invalidate)
             # _body may be not yet assigned
 
         if getattr(body, "get_focus", None):
@@ -370,7 +364,7 @@ class ListBox(Widget, WidgetContainerMixin):
         else:
             self._body = SimpleListWalker(body)
         try:
-            connect_signal(self._body, "modified", self._invalidate)
+            signals.connect_signal(self._body, "modified", self._invalidate)
         except NameError:
             # our list walker has no modified signal so we must not
             # cache our canvases because we don't know when our
@@ -582,7 +576,11 @@ class ListBox(Widget, WidgetContainerMixin):
 
         return self._rows_max_cached
 
-    def render(self, size: tuple[int, int], focus: bool = False) -> CompositeCanvas | SolidCanvas:
+    def render(
+        self,
+        size: tuple[int, int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> CompositeCanvas | SolidCanvas:
         """
         Render ListBox and return canvas.
 
@@ -1180,7 +1178,11 @@ class ListBox(Widget, WidgetContainerMixin):
             self.shift_focus((maxcol, maxrow), maxrow - cy - 1)
             return
 
-    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:
         """Move selection through the list elements scrolling when
         necessary. Keystrokes are first passed to widget in focus
         in case that widget can handle them.
@@ -1191,6 +1193,8 @@ class ListBox(Widget, WidgetContainerMixin):
          'page up'   move cursor up one listbox length (or widget)
          'page down' move cursor down one listbox length (or widget)
         """
+        from urwid.command_map import Command
+
         (maxcol, maxrow) = size
 
         if self.set_focus_pending or self.set_focus_valign_pending:
@@ -1773,7 +1777,7 @@ class ListBox(Widget, WidgetContainerMixin):
 
     def mouse_event(
         self,
-        size: tuple[int, int],
+        size: tuple[int, int],  # type: ignore[override]
         event,
         button: int,
         col: int,
@@ -1784,6 +1788,8 @@ class ListBox(Widget, WidgetContainerMixin):
         Pass the event to the contained widgets.
         May change focus on button 1 press.
         """
+        from urwid.util import is_mouse_press
+
         (maxcol, maxrow) = size
         middle, top, bottom = self.calculate_visible((maxcol, maxrow), focus=True)
         if middle is None:
@@ -1875,8 +1881,7 @@ class ListBox(Widget, WidgetContainerMixin):
         """
         positions_fn = getattr(self._body, "positions", None)
         if positions_fn:
-            for pos in positions_fn():
-                yield pos
+            yield from positions_fn()
             return
 
         focus_widget, focus_pos = self._body.get_focus()
@@ -1907,8 +1912,7 @@ class ListBox(Widget, WidgetContainerMixin):
         """
         positions_fn = getattr(self._body, "positions", None)
         if positions_fn:
-            for pos in positions_fn(reverse=True):
-                yield pos
+            yield from positions_fn(reverse=True)
             return
 
         focus_widget, focus_pos = self._body.get_focus()

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

@@ -31,6 +31,8 @@ if typing.TYPE_CHECKING:
     ArgSpec = ParamSpec("ArgSpec")
     Ret = typing.TypeVar("Ret")
 
+__all__ = ("MonitoredList", "MonitoredFocusList")
+
 _T = typing.TypeVar("_T")