urwid 2.4.6__cp37-cp37m-win32.whl → 2.5.1__cp37-cp37m-win32.whl

urwid/listbox.py

@@ -25,6 +25,8 @@ import warnings
 from collections.abc import Iterable, Sized
 from contextlib import suppress
 
+from typing_extensions import Protocol, runtime_checkable
+
 from urwid import signals
 from urwid.canvas import CanvasCombine, SolidCanvas
 from urwid.command_map import Command
@@ -50,12 +52,30 @@ if typing.TYPE_CHECKING:
     from urwid.canvas import CompositeCanvas
 
 _T = typing.TypeVar("_T")
+_K = typing.TypeVar("_K")
 
 
 class ListWalkerError(Exception):
     pass
 
 
+@runtime_checkable
+class ScrollSupportingBody(Sized, Protocol):
+    """Protocol for ListWalkers that support Scrolling."""
+
+    def get_focus(self) -> tuple[Widget, _K]: ...
+
+    def set_focus(self, position: _K) -> None: ...
+
+    def __getitem__(self, index: _K) -> _T: ...
+
+    def positions(self, reverse: bool = False) -> Iterable[_K]: ...
+
+    def get_next(self, position: _K) -> tuple[Widget, _K] | tuple[None, None]: ...
+
+    def get_prev(self, position: _K) -> tuple[Widget, _K] | tuple[None, None]: ...
+
+
 class ListWalker(metaclass=signals.MetaSignals):
     signals: typing.ClassVar[list[str]] = ["modified"]
 
@@ -262,6 +282,8 @@ class ListBoxError(Exception):
 
 
 class _Middle(typing.NamedTuple):
+    """Named tuple for ListBox internals."""
+
     offset: int
     focus_widget: Widget
     focus_pos: Hashable
@@ -269,20 +291,30 @@ class _Middle(typing.NamedTuple):
     cursor: tuple[int, int] | tuple[int] | None
 
 
+class _FillItem(typing.NamedTuple):
+    """Named tuple for ListBox internals."""
+
+    widget: Widget
+    position: Hashable
+    rows: int
+
+
 class _TopBottom(typing.NamedTuple):
+    """Named tuple for ListBox internals."""
+
     trim: int
-    fill: list[tuple[Widget, Hashable, int]]
+    fill: list[_FillItem]
 
 
 class ListBox(Widget, WidgetContainerMixin):
     """
-    a horizontally stacked list of widgets
+    Vertically stacked list of widgets
     """
 
     _selectable = True
     _sizing = frozenset([Sizing.BOX])
 
-    def __init__(self, body: ListWalker) -> None:
+    def __init__(self, body: ListWalker | Iterable[Widget]) -> None:
         """
         :param body: a ListWalker subclass such as :class:`SimpleFocusListWalker`
             that contains widgets to be displayed inside the list box
@@ -314,6 +346,10 @@ class ListBox(Widget, WidgetContainerMixin):
         # variable for delayed valign change used by set_focus_valign
         self.set_focus_valign_pending = None
 
+        # used for scrollable protocol
+        self._rows_max_cached = 0
+        self._rendered_size = 0, 0
+
     @property
     def body(self) -> ListWalker:
         """
@@ -323,7 +359,7 @@ class ListBox(Widget, WidgetContainerMixin):
         return self._body
 
     @body.setter
-    def body(self, body):
+    def body(self, body: Iterable[Widget] | ListWalker) -> None:
         with suppress(AttributeError):
             disconnect_signal(self._body, "modified", self._invalidate)
             # _body may be not yet assigned
@@ -383,12 +419,10 @@ class ListBox(Widget, WidgetContainerMixin):
             *cursor coords* or ``None``)
         *top*
             (*# lines to trim off top*,
-            list of (*widget*, *position*, *rows*) tuples above focus
-            in order from bottom to top)
+            list of (*widget*, *position*, *rows*) tuples above focus in order from bottom to top)
         *bottom*
             (*# lines to trim off bottom*,
-            list of (*widget*, *position*, *rows*) tuples below focus
-            in order from top to bottom)
+            list of (*widget*, *position*, *rows*) tuples below focus in order from top to bottom)
         """
         (maxcol, maxrow) = size
 
@@ -441,7 +475,7 @@ class ListBox(Widget, WidgetContainerMixin):
 
             p_rows = prev.rows((maxcol,))
             if p_rows:  # filter out 0-height widgets
-                fill_above.append((prev, pos, p_rows))
+                fill_above.append(_FillItem(prev, pos, p_rows))
             if p_rows > fill_lines:  # crosses top edge?
                 trim_top = p_rows - fill_lines
                 break
@@ -462,7 +496,7 @@ class ListBox(Widget, WidgetContainerMixin):
 
             n_rows = next_pos.rows((maxcol,))
             if n_rows:  # filter out 0-height widgets
-                fill_below.append((next_pos, pos, n_rows))
+                fill_below.append(_FillItem(next_pos, pos, n_rows))
             if n_rows > fill_lines:  # crosses bottom edge?
                 trim_bottom = n_rows - fill_lines
                 fill_lines -= n_rows
@@ -488,7 +522,7 @@ class ListBox(Widget, WidgetContainerMixin):
                 break
 
             p_rows = prev.rows((maxcol,))
-            fill_above.append((prev, pos, p_rows))
+            fill_above.append(_FillItem(prev, pos, p_rows))
             if p_rows > fill_lines:  # more than required
                 trim_top = p_rows - fill_lines
                 offset_rows += fill_lines
@@ -503,6 +537,54 @@ class ListBox(Widget, WidgetContainerMixin):
             _TopBottom(trim_bottom, fill_below),
         )
 
+    def get_scrollpos(self, size: tuple[int, int] | None = None, focus: bool = False) -> int:
+        """Current scrolling position."""
+        if not isinstance(self._body, ScrollSupportingBody):
+            raise ListBoxError(f"{self} body do not implement methods required for scrolling protocol")
+
+        if not self._body:
+            return 0
+
+        if size is not None:
+            self._rendered_size = size
+
+        _, focus_pos = self._body.get_focus()
+
+        mid, top, bottom = self.calculate_visible(self._rendered_size, focus)
+
+        start_row = top.trim
+        maxcol = self._rendered_size[0]
+
+        if top.fill:
+            pos = top.fill[-1].position
+        else:
+            pos = mid.focus_pos
+
+        prev, pos = self._body.get_prev(pos)
+        while prev is not None:
+            start_row += prev.rows((maxcol,))
+            prev, pos = self._body.get_prev(pos)
+
+        return start_row
+
+    def rows_max(self, size: tuple[int, int] | None = None, focus: bool = False) -> int:
+        """Scrollable protocol for sized iterable and not wrapped around contents."""
+        if not isinstance(self._body, ScrollSupportingBody):
+            raise ListBoxError(f"{self} body do not implement methods required for scrolling protocol")
+
+        if getattr(self._body, "wrap_around", False):
+            raise ListBoxError("Body is wrapped around")
+
+        if size is not None:
+            self._rendered_size = size
+
+        if size or not self._rows_max_cached:
+            self._rows_max_cached = sum(
+                self._body[position].rows((self._rendered_size[0],), focus) for position in self._body.positions()
+            )
+
+        return self._rows_max_cached
+
     def render(self, size: tuple[int, int], focus: bool = False) -> CompositeCanvas | SolidCanvas:
         """
         Render ListBox and return canvas.
@@ -511,6 +593,8 @@ class ListBox(Widget, WidgetContainerMixin):
         """
         (maxcol, maxrow) = size
 
+        self._rendered_size = size
+
         middle, top, bottom = self.calculate_visible((maxcol, maxrow), focus=focus)
         if middle is None:
             return SolidCanvas(" ", maxcol, maxrow)
@@ -615,9 +699,7 @@ class ListBox(Widget, WidgetContainerMixin):
     ):
         """Set the focus widget's display offset and inset.
 
-        :param valign: one of:
-            'top', 'middle', 'bottom'
-            ('relative', percentage 0=top 100=bottom)
+        :param valign: one of: 'top', 'middle', 'bottom' ('relative', percentage 0=top 100=bottom)
         """
         vt, va = normalize_valign(valign, ListBoxError)
         self.set_focus_valign_pending = vt, va
@@ -756,10 +838,7 @@ class ListBox(Widget, WidgetContainerMixin):
         """
 
     def _set_focus_valign_complete(self, size: tuple[int, int], focus: bool) -> None:
-        """
-        Finish setting the offset and inset now that we have have a
-        maxcol & maxrow.
-        """
+        """Finish setting the offset and inset now that we have have a maxcol & maxrow."""
         (maxcol, maxrow) = size
         vt, va = self.set_focus_valign_pending
         self.set_focus_valign_pending = None
@@ -784,10 +863,7 @@ class ListBox(Widget, WidgetContainerMixin):
         self.shift_focus((maxcol, maxrow), rtop)
 
     def _set_focus_first_selectable(self, size: tuple[int, int], focus: bool) -> None:
-        """
-        Choose the first visible, selectable widget below the
-        current focus as the focus widget.
-        """
+        """Choose the first visible, selectable widget below the current focus as the focus widget."""
         (maxcol, maxrow) = size
         self.set_focus_valign_pending = None
         self.set_focus_pending = None
@@ -813,9 +889,7 @@ class ListBox(Widget, WidgetContainerMixin):
             new_row_offset += rows
 
     def _set_focus_complete(self, size: tuple[int, int], focus: bool) -> None:
-        """
-        Finish setting the position now that we have maxcol & maxrow.
-        """
+        """Finish setting the position now that we have maxcol & maxrow."""
         (maxcol, maxrow) = size
         self._invalidate()
         if self.set_focus_pending == "first selectable":
@@ -1716,7 +1790,18 @@ class ListBox(Widget, WidgetContainerMixin):
             )
             return False
 
-        return w.mouse_event((maxcol,), event, button, col, row - wrow, focus)
+        handled = w.mouse_event((maxcol,), event, button, col, row - wrow, focus)
+        if handled:
+            return True
+
+        if is_mouse_press(event):
+            if button == 4:
+                return not self._keypress_up((maxcol, maxrow))
+
+            if button == 5:
+                return not self._keypress_down((maxcol, maxrow))
+
+        return False
 
     def ends_visible(self, size: tuple[int, int], focus: bool = False) -> list[Literal["top", "bottom"]]:
         """

urwid/monitored_list.py

@@ -337,12 +337,10 @@ class MonitoredFocusList(MonitoredList[_T], typing.Generic[_T]):
         self.focus = focus
 
     @typing.overload
-    def __setitem__(self, i: int, y: _T) -> None:
-        ...
+    def __setitem__(self, i: int, y: _T) -> None: ...
 
     @typing.overload
-    def __setitem__(self, i: slice, y: Collection[_T]) -> None:
-        ...
+    def __setitem__(self, i: slice, y: Collection[_T]) -> None: ...
 
     def __setitem__(self, i: int | slice, y: _T | Collection[_T]) -> None:
         """

urwid/util.py

@@ -34,8 +34,7 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Protocol, Self
 
     class CanBeStopped(Protocol):
-        def stop(self) -> None:
-            ...
+        def stop(self) -> None: ...
 
 
 try:

urwid/version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '2.4.6'
-__version_tuple__ = version_tuple = (2, 4, 6)
+__version__ = version = '2.5.1'
+__version_tuple__ = version_tuple = (2, 5, 1)

urwid/vterm.py

@@ -1437,11 +1437,11 @@ class TermCanvas(Canvas):
     def content(
         self,
         trim_left: int = 0,
-        trim_right: int = 0,
+        trim_top: int = 0,
         cols: int | None = None,
         rows: int | None = None,
         attr=None,
-    ):
+    ) -> Iterable[list[tuple[object, object, bytes]]]:
         if self.scrolling_up == 0:
             yield from self.term
         else:
@@ -1669,7 +1669,7 @@ class Terminal(Widget):
         elif hasattr(self, "old_tios"):
             RealTerminal().tty_signal_keys(*self.old_tios)
 
-    def render(self, size: tuple[int, int], focus: bool = False):
+    def render(self, size: tuple[int, int], focus: bool = False) -> TermCanvas:
         if not self.terminated:
             self.change_focus(focus)
 

urwid/widget/__init__.py

@@ -34,6 +34,7 @@ from .padding import Padding, PaddingError, PaddingWarning, calculate_left_right
 from .pile import Pile, PileError, PileWarning
 from .popup import PopUpLauncher, PopUpTarget
 from .progress_bar import ProgressBar
+from .scrollable import Scrollable, ScrollableError, ScrollBar
 from .solid_fill import SolidFill
 from .text import Text, TextError
 from .widget import (
@@ -151,6 +152,9 @@ __all__ = (
     "ProgressBar",
     "WidgetContainerListContentsMixin",
     "WidgetWarning",
+    "Scrollable",
+    "ScrollableError",
+    "ScrollBar",
 )
 
 # Backward compatibility

urwid/widget/attr_map.py

@@ -5,22 +5,24 @@ from collections.abc import Hashable, Mapping
 
 from urwid.canvas import CompositeCanvas
 
-from .widget import Widget, WidgetError, delegate_to_widget_mixin
+from .widget import WidgetError, delegate_to_widget_mixin
 from .widget_decoration import WidgetDecoration
 
+WrappedWidget = typing.TypeVar("WrappedWidget")
+
 
 class AttrMapError(WidgetError):
     pass
 
 
-class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration):
+class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[WrappedWidget]):
     """
     AttrMap is a decoration that maps one set of attributes to another.
     This object will pass all function calls and variable references to the
     wrapped widget.
     """
 
-    def __init__(self, w: Widget, attr_map, focus_map=None) -> None:
+    def __init__(self, w: WrappedWidget, attr_map, focus_map=None) -> None:
         """
         :param w: widget to wrap (stored as self.original_widget)
         :type w: widget

urwid/widget/bar_graph.py

@@ -5,7 +5,7 @@ import typing
 from urwid.canvas import CanvasCombine, CompositeCanvas, SolidCanvas
 from urwid.util import get_encoding_mode
 
-from .constants import Sizing
+from .constants import BAR_SYMBOLS, Sizing
 from .text import Text
 from .widget import Widget, WidgetError, WidgetMeta, nocache_widget_render, nocache_widget_render_instance
 
@@ -49,10 +49,10 @@ class BarGraph(Widget, metaclass=BarGraphMeta):
 
     ignore_focus = True
 
-    eighths = " ▁▂▃▄▅▆▇"
+    eighths = BAR_SYMBOLS.VERTICAL[:8]  # Full height is done by style
     hlines = "_⎺⎻─⎼⎽"
 
-    def __init__(self, attlist, hatt=None, satt=None):
+    def __init__(self, attlist, hatt=None, satt=None) -> None:
         """
         Create a bar graph with the passed display characteristics.
         see set_segment_attributes for a description of the parameters.
@@ -134,7 +134,7 @@ class BarGraph(Widget, metaclass=BarGraphMeta):
                 raise BarGraphError(f"fg ({fg}) not > bg ({bg})")
         self.satt = satt
 
-    def set_data(self, bardata, top, hlines=None):
+    def set_data(self, bardata, top: float, hlines=None) -> None:
         """
         Store bar data, bargraph top and horizontal line positions.
 
@@ -428,7 +428,7 @@ class BarGraph(Widget, metaclass=BarGraphMeta):
         return canv
 
 
-def calculate_bargraph_display(bardata, top, bar_widths, maxrow: int):
+def calculate_bargraph_display(bardata, top: float, bar_widths: list[int], maxrow: int):
     """
     Calculate a rendering of the bar graph described by data, bar_widths
     and height.
@@ -574,7 +574,7 @@ def calculate_bargraph_display(bardata, top, bar_widths, maxrow: int):
 class GraphVScale(Widget):
     _sizing = frozenset([Sizing.BOX])
 
-    def __init__(self, labels, top):
+    def __init__(self, labels, top: float) -> None:
         """
         GraphVScale( [(label1 position, label1 markup),...], top )
         label position -- 0 < position < top for the y position
@@ -587,7 +587,7 @@ class GraphVScale(Widget):
         super().__init__()
         self.set_scale(labels, top)
 
-    def set_scale(self, labels, top):
+    def set_scale(self, labels, top: float) -> None:
         """
         set_scale( [(label1 position, label1 markup),...], top )
         label position -- 0 < position < top for the y position
@@ -610,7 +610,7 @@ class GraphVScale(Widget):
         """
         return False
 
-    def render(self, size: tuple[int, int], focus: bool = False):
+    def render(self, size: tuple[int, int], focus: bool = False) -> SolidCanvas | CompositeCanvas:
         """
         Render GraphVScale.
         """
@@ -641,7 +641,7 @@ class GraphVScale(Widget):
         return c
 
 
-def scale_bar_values(bar, top, maxrow: int):
+def scale_bar_values(bar, top: float, maxrow: int) -> list[int]:
     """
     Return a list of bar values aliased to integer values of maxrow.
     """

urwid/widget/box_adapter.py

@@ -8,22 +8,21 @@ from urwid.canvas import CompositeCanvas
 from .constants import Sizing
 from .widget_decoration import WidgetDecoration, WidgetError
 
-if typing.TYPE_CHECKING:
-    from .widget import Widget
+WrappedWidget = typing.TypeVar("WrappedWidget")
 
 
 class BoxAdapterError(WidgetError):
     pass
 
 
-class BoxAdapter(WidgetDecoration):
+class BoxAdapter(WidgetDecoration[WrappedWidget]):
     """
     Adapter for using a box widget where a flow widget would usually go
     """
 
     no_cache: typing.ClassVar[list[str]] = ["rows"]
 
-    def __init__(self, box_widget, height):
+    def __init__(self, box_widget: WrappedWidget, height: int) -> None:
         """
         Create a flow widget that contains a box widget
 
@@ -47,7 +46,7 @@ class BoxAdapter(WidgetDecoration):
 
     # originally stored as box_widget, keep for compatibility
     @property
-    def box_widget(self) -> Widget:
+    def box_widget(self) -> WrappedWidget:
         warnings.warn(
             "original stored as original_widget, keep for compatibility",
             PendingDeprecationWarning,
@@ -56,7 +55,7 @@ class BoxAdapter(WidgetDecoration):
         return self.original_widget
 
     @box_widget.setter
-    def box_widget(self, widget: Widget):
+    def box_widget(self, widget: WrappedWidget) -> None:
         warnings.warn(
             "original stored as original_widget, keep for compatibility",
             PendingDeprecationWarning,
@@ -104,7 +103,7 @@ class BoxAdapter(WidgetDecoration):
     def mouse_event(
         self,
         size: tuple[int],
-        event,
+        event: str,
         button: int,
         col: int,
         row: int,

urwid/widget/columns.py

@@ -6,6 +6,7 @@ from itertools import chain, repeat
 
 import urwid
 from urwid.canvas import Canvas, CanvasJoin, CompositeCanvas, SolidCanvas
+from urwid.command_map import Command
 from urwid.monitored_list import MonitoredFocusList, MonitoredList
 from urwid.util import is_mouse_press
 
@@ -455,9 +456,9 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
     @staticmethod
     def options(
-        width_type: (
-            Literal["pack", "given", "weight", WHSettings.PACK, WHSettings.GIVEN, WHSettings.WEIGHT]
-        ) = WHSettings.WEIGHT,
+        width_type: Literal[
+            "pack", "given", "weight", WHSettings.PACK, WHSettings.GIVEN, WHSettings.WEIGHT
+        ] = WHSettings.WEIGHT,
         width_amount: int | None = 1,
         box_widget: bool = False,
     ) -> tuple[Literal[WHSettings.PACK], None, bool] | tuple[Literal[WHSettings.GIVEN, WHSettings.WEIGHT], int, bool]:
@@ -795,13 +796,16 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 else:
                     w_h_args[i] = (0,)
 
-            elif Sizing.FIXED in w_sizing and (Sizing.FLOW in w_sizing or is_box):
-                width, height = widget.pack((), focused)
+            elif Sizing.FLOW in w_sizing or is_box:
+                if Sizing.FIXED in w_sizing:
+                    width, height = widget.pack((), focused)
+                else:
+                    width = self.min_width
+
                 weighted.setdefault(size_weight, []).append((widget, i, is_box, focused))
                 weights.append(size_weight)
                 weight_max_sizes.setdefault(size_weight, width)
                 weight_max_sizes[size_weight] = max(weight_max_sizes[size_weight], width)
-
             else:
                 raise ColumnsError(f"Unsupported combination of {size_kind} box={is_box!r} for {widget}")
 
@@ -819,6 +823,9 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                     else:
                         box.append(i)
 
+        if not heights:
+            raise ColumnsError(f"No height information for pack {self!r} as FIXED")
+
         max_height = max(heights.values())
         for idx in box:
             heights[idx] = max_height
@@ -1019,7 +1026,7 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
     def mouse_event(
         self,
         size: tuple[()] | tuple[int] | tuple[int, int],
-        event,
+        event: str,
         button: int,
         col: int,
         row: int,
@@ -1115,15 +1122,15 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         i = self.focus_position
         w, _ = self.contents[i]
-        if self._command_map[key] not in {"cursor up", "cursor down", "cursor page up", "cursor page down"}:
+        if self._command_map[key] not in {Command.UP, Command.DOWN, Command.PAGE_UP, Command.PAGE_DOWN}:
             self.pref_col = None
         if w.selectable():
             key = w.keypress(size_args[i], key)
 
-        if self._command_map[key] not in {"cursor left", "cursor right"}:
+        if self._command_map[key] not in {Command.LEFT, Command.RIGHT}:
             return key
 
-        if self._command_map[key] == "cursor left":
+        if self._command_map[key] == Command.LEFT:
             candidates = list(range(i - 1, -1, -1))  # count backwards to 0
         else:  # key == 'right'
             candidates = list(range(i + 1, len(self.contents)))