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

urwid/widget/box_adapter.py

@@ -90,7 +90,11 @@ class BoxAdapter(WidgetDecoration[WrappedWidget]):
             return None
         return self._original_widget.get_pref_col((maxcol, self.height))
 
-    def keypress(self, size: tuple[int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         (maxcol,) = size
         return self._original_widget.keypress((maxcol, self.height), key)
 
@@ -102,7 +106,7 @@ class BoxAdapter(WidgetDecoration[WrappedWidget]):
 
     def mouse_event(
         self,
-        size: tuple[int],
+        size: tuple[int],  # type: ignore[override]
         event: str,
         button: int,
         col: int,
@@ -114,7 +118,11 @@ class BoxAdapter(WidgetDecoration[WrappedWidget]):
             return False
         return self._original_widget.mouse_event((maxcol, self.height), event, button, col, row, focus)
 
-    def render(self, size: tuple[int], focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> CompositeCanvas:
         (maxcol,) = size
         canv = CompositeCanvas(self._original_widget.render((maxcol, self.height), focus))
         return canv

urwid/widget/columns.py

@@ -7,15 +7,16 @@ 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.split_repr import remove_defaults
 from urwid.util import is_mouse_press
 
 from .constants import Align, 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
 
@@ -66,40 +67,47 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         # BOX-only widget
         >>> Columns((SolidFill("#"),))
-        <Columns box widget>
+        <Columns box widget (1 item)>
 
         # BOX-only widget with "get height from max"
         >>> Columns((SolidFill("#"),), box_columns=(0,))
-        <Columns box widget>
+        <Columns box widget (1 item)>
 
         # FLOW-only
         >>> Columns((Edit(),))
-        <Columns selectable flow widget>
+        <Columns selectable flow widget (1 item)>
 
         # FLOW allowed by "box_columns"
         >>> Columns((Edit(), SolidFill("#")), box_columns=(1,))
-        <Columns selectable flow widget>
+        <Columns selectable flow widget (2 items) focus_column=0>
 
         # FLOW/FIXED
         >>> Columns((Text("T"),))
-        <Columns fixed/flow widget>
+        <Columns fixed/flow widget (1 item)>
 
         # GIVEN BOX only -> BOX only
         >>> Columns(((5, SolidFill("#")),), box_columns=(0,))
-        <Columns box widget>
+        <Columns box widget (1 item)>
 
         # No FLOW - BOX only
         >>> Columns(((5, SolidFill("#")), SolidFill("*")), box_columns=(0, 1))
-        <Columns box widget>
+        <Columns box widget (2 items) focus_column=0>
 
-        # FIXED only -> FIXED
+        # FIXED only -> FIXED (and FLOW via drop/expand)
         >>> Columns(((WHSettings.PACK, BigText("1", font)),))
-        <Columns fixed widget>
+        <Columns fixed/flow widget (1 item)>
 
         # Invalid sizing combination -> use fallback settings (and produce warning)
         >>> Columns(((WHSettings.PACK, SolidFill("#")),))
-        <Columns box/flow widget>
+        <Columns box/flow widget (1 item)>
+
+        # Special case: empty columns widget sizing is impossible to calculate
+        >>> Columns(())
+        <Columns box/flow widget ()>
         """
+        if not self.contents:
+            return frozenset((urwid.BOX, urwid.FLOW))
+
         strict_box = False
         has_flow = False
 
@@ -176,6 +184,7 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 supported.add(Sizing.FLOW)
 
             if has_fixed and not block_fixed:
+                supported.add(Sizing.FLOW)
                 supported.add(Sizing.FIXED)
 
         if not supported:
@@ -238,10 +247,12 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         self._cache_column_widths: list[int] = []
         super().__init__()
         self._contents: MonitoredFocusList[
-            Widget,
-            tuple[Literal[WHSettings.PACK], None, bool]
-            | tuple[Literal[WHSettings.GIVEN], int, bool]
-            | tuple[Literal[WHSettings.WEIGHT], int | float, bool],
+            tuple[
+                Widget,
+                tuple[Literal[WHSettings.PACK], None, bool]
+                | tuple[Literal[WHSettings.GIVEN], int, bool]
+                | tuple[Literal[WHSettings.WEIGHT], int | float, bool],
+            ],
         ] = MonitoredFocusList()
         self._contents.set_modified_callback(self._contents_modified)
         self._contents.set_focus_changed_callback(lambda f: self._invalidate())
@@ -278,6 +289,53 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         self.min_width = min_width
         self._cache_maxcol = None
 
+    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(),
+            "dividechars": self.dividechars,
+            "focus_column": self.focus_position if len(self._contents) > 1 else None,
+            "min_width": self.min_width,
+        }
+        return remove_defaults(attrs, Columns.__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]
+        ] = []
+        box_columns: list[int] = []
+        for idx, (w_instance, (sizing, amount, is_box)) in enumerate(self._contents):
+            if sizing == WHSettings.GIVEN:
+                widget_list.append((amount, w_instance))
+            elif sizing == WHSettings.PACK:
+                widget_list.append((WHSettings.PACK, w_instance))
+            elif amount == 1:
+                widget_list.append(w_instance)
+            else:
+                widget_list.append((WHSettings.WEIGHT, amount, w_instance))
+
+            if is_box:
+                box_columns.append(idx)
+
+        yield "widget_list", widget_list
+        yield "dividechars", self.dividechars
+        yield "focus_column", self.focus_position if self._contents else None
+        yield "min_width", self.min_width
+        yield "box_columns", box_columns
+
+    def __len__(self) -> int:
+        return len(self._contents)
+
     def _contents_modified(self) -> None:
         """
         Recalculate whether this widget should be selectable whenever the
@@ -342,7 +400,7 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 chain(self.contents, repeat((None, (WHSettings.WEIGHT, 1, False)))),
             )
         ]
-        if focus_position < len(widgets):
+        if focus_position < len(widgets):  # pylint: disable=consider-using-max-builtin  # pylint bug
             self.focus_position = focus_position
 
     @property
@@ -383,7 +441,7 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             (w, ({Sizing.FIXED: WHSettings.GIVEN, Sizing.FLOW: WHSettings.PACK}.get(new_t, new_t), new_n, b))
             for ((new_t, new_n), (w, (t, n, b))) in zip(column_types, self.contents)
         ]
-        if focus_position < len(column_types):
+        if focus_position < len(column_types):  # pylint: disable=consider-using-max-builtin  # pylint bug
             self.focus_position = focus_position
 
     @property
@@ -442,10 +500,12 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
     def contents(
         self,
     ) -> MonitoredFocusList[
-        Widget,
-        tuple[Literal[WHSettings.PACK], None, bool]
-        | tuple[Literal[WHSettings.GIVEN], int, bool]
-        | tuple[Literal[WHSettings.WEIGHT], int | float, bool],
+        tuple[
+            Widget,
+            tuple[Literal[WHSettings.PACK], None, bool]
+            | tuple[Literal[WHSettings.GIVEN], int, bool]
+            | tuple[Literal[WHSettings.WEIGHT], int | float, bool],
+        ],
     ]:
         """
         The contents of this Columns as a list of `(widget, options)` tuples.
@@ -886,11 +946,17 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 box.append(i)
 
             elif Sizing.FLOW in w_sizing:
-                heights[i] = widget.rows((width,), focus and i == self.focus_position)
+                if width > 0:
+                    heights[i] = widget.rows((width,), focus and i == self.focus_position)
+                else:
+                    heights[i] = 0
                 w_h_args[i] = (width,)
 
             elif size_kind == WHSettings.PACK:
-                heights[i] = widget.pack((), focus and i == self.focus_position)[1]
+                if width > 0:
+                    heights[i] = widget.pack((), focus and i == self.focus_position)[1]
+                else:
+                    heights[i] = 0
                 w_h_args[i] = ()
 
             else:
@@ -922,7 +988,11 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             tuple(w_h_args[idx] for idx in range(len(w_h_args))),
         )
 
-    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]:
         """Get packed sized for widget."""
         if size:
             return super().pack(size, focus)
@@ -1113,16 +1183,16 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         see :meth:`Widget.rows` for details
         """
-        widths = self.column_widths(size, focus)
+        _, heights, _ = self.get_column_sizes(size, focus)
+        if heights:
+            return max(1, *heights)
+        return 1
 
-        rows = 1
-        for i, (mc, (w, (_t, _n, b))) in enumerate(zip(widths, self.contents)):
-            if b or mc <= 0:
-                continue
-            rows = max(rows, w.rows((mc,), focus=focus and self.focus_position == i))
-        return rows
-
-    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 the focus column.
 

urwid/widget/constants.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import dataclasses
 import enum
 import typing
 
@@ -454,91 +455,51 @@ def simplify_height(
     return (WHSettings(height_type), height_amount)
 
 
-class _LightBoxSymbols(typing.NamedTuple):
-    """Box symbols for drawing.
+@dataclasses.dataclass(frozen=True)
+class _BoxSymbols:
+    """Box symbols for drawing."""
 
-    The Thin version includes extra symbols.
-    Symbols are ordered as in Unicode except dashes.
-    """
+    HORIZONTAL: str
+    VERTICAL: str
+    TOP_LEFT: str
+    TOP_RIGHT: str
+    BOTTOM_LEFT: str
+    BOTTOM_RIGHT: str
+    # Joints for tables making
+    LEFT_T: str
+    RIGHT_T: str
+    TOP_T: str
+    BOTTOM_T: str
+    CROSS: str
 
-    # fmt: off
 
-    HORIZONTAL: str =   "─"
-    VERTICAL: str =     "│"
-    TOP_LEFT: str =     "┌"
-    TOP_RIGHT: str =    "┐"
-    BOTTOM_LEFT: str =  "└"
-    BOTTOM_RIGHT: str = "┘"
-    # Joints for tables making
-    LEFT_T: str =   "├"
-    RIGHT_T: str =  "┤"
-    TOP_T: str =    "┬"
-    BOTTOM_T: str = "┴"
-    CROSS: str =    "┼"
-    # Dashes
-    HORIZONTAL_4_DASHES: str = "┈"
-    HORIZONTAL_3_DASHES: str = "┄"
-    HORIZONTAL_2_DASHES: str = "╌"
-    VERTICAL_2_DASH: str = "╎"
-    VERTICAL_3_DASH: str = "┆"
-    VERTICAL_4_DASH: str = "┊"
-    # Unique for light only
-    TOP_LEFT_ROUNDED: str =     "╭"
-    TOP_RIGHT_ROUNDED: str =    "╮"
-    BOTTOM_RIGHT_ROUNDED: str = "╯"
-    BOTTOM_LEFT_ROUNDED: str =  "╰"
-
-
-class _HeavyBoxSymbols(typing.NamedTuple):
+@dataclasses.dataclass(frozen=True)
+class _BoxSymbolsWithDashes(_BoxSymbols):
     """Box symbols for drawing.
 
-    The Heavy version includes extra symbols.
-    Symbols are ordered as in Unicode except dashes.
+    Extra dashes symbols.
     """
 
-    # fmt: off
+    HORIZONTAL_4_DASHES: str
+    HORIZONTAL_3_DASHES: str
+    HORIZONTAL_2_DASHES: str
+    VERTICAL_2_DASH: str
+    VERTICAL_3_DASH: str
+    VERTICAL_4_DASH: str
 
-    HORIZONTAL: str =   "━"
-    VERTICAL: str =     "┃"
-    TOP_LEFT: str =     "┏"
-    TOP_RIGHT: str =    "┓"
-    BOTTOM_LEFT: str =  "┗"
-    BOTTOM_RIGHT: str = "┛"
-    # Joints for tables making
-    LEFT_T: str =   "┣"
-    RIGHT_T: str =  "┫"
-    TOP_T: str =    "┳"
-    BOTTOM_T: str = "┻"
-    CROSS: str =    "╋"
-    # Dashes
-    HORIZONTAL_4_DASHES: str = "┉"
-    HORIZONTAL_3_DASHES: str = "┅"
-    HORIZONTAL_2_DASHES: str = "╍"
-    VERTICAL_2_DASH: str = "╏"
-    VERTICAL_3_DASH: str = "┇"
-    VERTICAL_4_DASH: str = "┋"
-
-
-class _DoubleBoxSymbols(typing.NamedTuple):
+
+@dataclasses.dataclass(frozen=True)
+class _LightBoxSymbols(_BoxSymbolsWithDashes):
     """Box symbols for drawing.
 
-    Symbols are ordered as in Unicode.
+    The Thin version includes extra symbols.
+    Symbols are ordered as in Unicode except dashes.
     """
 
-    # fmt: off
-
-    HORIZONTAL: str =   "═"
-    VERTICAL: str =     "║"
-    TOP_LEFT: str =     "╔"
-    TOP_RIGHT: str =    "╗"
-    BOTTOM_LEFT: str =  "╚"
-    BOTTOM_RIGHT: str = "╝"
-    # Joints for tables making
-    LEFT_T: str =   "╠"
-    RIGHT_T: str =  "╣"
-    TOP_T: str =    "╦"
-    BOTTOM_T: str = "╩"
-    CROSS: str =    "╬"
+    TOP_LEFT_ROUNDED: str
+    TOP_RIGHT_ROUNDED: str
+    BOTTOM_LEFT_ROUNDED: str
+    BOTTOM_RIGHT_ROUNDED: str
 
 
 class _BoxSymbolsCollection(typing.NamedTuple):
@@ -551,9 +512,15 @@ class _BoxSymbolsCollection(typing.NamedTuple):
 
     # fmt: off
 
-    LIGHT: _LightBoxSymbols = _LightBoxSymbols()
-    HEAVY: _HeavyBoxSymbols = _HeavyBoxSymbols()
-    DOUBLE: _DoubleBoxSymbols = _DoubleBoxSymbols()
+    LIGHT: _LightBoxSymbols = _LightBoxSymbols(
+        "─", "│", "┌", "┐", "└", "┘", "├", "┤", "┬", "┴", "┼", "┈", "┄", "╌", "╎", "┆", "┊", "╭", "╮", "╰", "╯"
+    )
+    HEAVY: _BoxSymbolsWithDashes = _BoxSymbolsWithDashes(
+        "━", "┃", "┏", "┓", "┗", "┛", "┣", "┫", "┳", "┻", "╋", "┉", "┅", "╍", "╏", "┇", "┋"
+    )
+    DOUBLE: _BoxSymbols = _BoxSymbols(
+        "═", "║", "╔", "╗", "╚", "╝", "╠", "╣", "╦", "╩", "╬"
+    )
 
 
 BOX_SYMBOLS = _BoxSymbolsCollection()

urwid/widget/container.py

@@ -97,11 +97,11 @@ class WidgetContainerMixin:
 
         positions -- sequence of positions
         """
-        w = self
+        w: Widget = self
         for p in positions:
             if p != w.focus_position:
                 w.focus_position = p  # modifies w.focus
-            w = w.focus.base_widget
+            w = w.focus.base_widget  # type: ignore[assignment]
 
     def get_focus_widgets(self) -> list[Widget]:
         """

urwid/widget/divider.py

@@ -92,7 +92,11 @@ class Divider(Widget):
         (_maxcol,) = size
         return self.top + 1 + self.bottom
 
-    def render(self, size: tuple[int], focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> CompositeCanvas:
         """
         Render the divider as a canvas and return it.
 

urwid/widget/edit.py

@@ -153,7 +153,7 @@ class Edit(Text):
 
         return self._caption + (self._mask * len(self._edit_text)), self._attrib
 
-    def set_text(self, markup: tuple[str, list[tuple[Hashable, int]]]) -> None:
+    def set_text(self, markup: str | tuple[Hashable, str] | list[str | tuple[Hashable, str]]) -> None:
         """
         Not supported by Edit widget.
 
@@ -308,8 +308,8 @@ class Edit(Text):
         self._emit("change", text)
         old_text = self._edit_text
         self._edit_text = text
-        if self.edit_pos > len(text):
-            self.edit_pos = len(text)
+        self.edit_pos = min(self.edit_pos, len(text))
+
         self._emit("postchange", old_text)
         self._invalidate()
 
@@ -359,10 +359,7 @@ class Edit(Text):
         self.highlight = None
 
     def _normalize_to_caption(self, text: str | bytes) -> str | bytes:
-        """
-        Return text converted to the same type as self.caption
-        (bytes or unicode)
-        """
+        """Return text converted to the same type as self.caption (bytes or unicode)"""
         tu = isinstance(text, str)
         cu = isinstance(self._caption, str)
         if tu == cu:
@@ -400,7 +397,11 @@ class Edit(Text):
         result_pos += len(text)
         return (result_text, result_pos)
 
-    def keypress(self, size: tuple[int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         """
         Handle editing keystrokes, return others.
 
@@ -421,9 +422,6 @@ class Edit(Text):
         pos = self.edit_pos
         if self.valid_char(key):
             if isinstance(key, str) and not isinstance(self._caption, str):
-                # screen is sending us unicode input, must be using utf-8
-                # encoding because that's all we support, so convert it
-                # to bytes to match our caption's type
                 key = key.encode("utf-8")
             self.insert_text(key)
             return None
@@ -546,7 +544,7 @@ class Edit(Text):
 
     def mouse_event(
         self,
-        size: tuple[int],
+        size: tuple[int],  # type: ignore[override]
         event: str,
         button: int,
         col: int,
@@ -581,7 +579,11 @@ class Edit(Text):
         self.highlight = None
         return True
 
-    def render(self, size: tuple[int], focus: bool = False) -> TextCanvas | CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> TextCanvas | CompositeCanvas:
         """
         Render edit widget and return canvas.  Include cursor when in
         focus.
@@ -679,7 +681,11 @@ class IntEdit(Edit):
             val = ""
         super().__init__(caption, val)
 
-    def keypress(self, size: tuple[int], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         """
         Handle editing keystrokes.  Remove leading zeros.
 

urwid/widget/filler.py

@@ -22,7 +22,6 @@ from .widget_decoration import WidgetDecoration, WidgetError
 if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
-
 WrappedWidget = typing.TypeVar("WrappedWidget")
 
 
@@ -231,7 +230,11 @@ class Filler(WidgetDecoration[WrappedWidget]):
             self.bottom,
         )
 
-    def render(self, size: tuple[int, int] | tuple[int], focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[int, int] | tuple[int],  # type: ignore[override]
+        focus: bool = False,
+    ) -> CompositeCanvas:
         """Render self.original_widget with space above and/or below."""
         maxcol, maxrow = self.pack(size, focus)
         top, bottom = self.filler_values(size, focus)
@@ -252,7 +255,11 @@ class Filler(WidgetDecoration[WrappedWidget]):
         canv.pad_trim_top_bottom(top, bottom)
         return canv
 
-    def keypress(self, size: tuple[int, int] | tuple[()], key: str) -> str | None:
+    def keypress(
+        self,
+        size: tuple[int, int] | tuple[()],  # type: ignore[override]
+        key: str,
+    ) -> str | None:
         """Pass keypress to self.original_widget."""
         maxcol, maxrow = self.pack(size, True)
         if self.height_type == WHSettings.PACK:
@@ -309,7 +316,7 @@ class Filler(WidgetDecoration[WrappedWidget]):
 
     def mouse_event(
         self,
-        size: tuple[int, int] | tuple[int],
+        size: tuple[int, int] | tuple[int],  # type: ignore[override]
         event,
         button: int,
         col: int,