urwid 2.6.4__tar.gz → 2.6.6__tar.gz

{urwid-2.6.4 → urwid-2.6.6}/.pre-commit-config.yaml

@@ -26,13 +26,13 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.2.1
+    rev: v0.2.2
     hooks:
       - id: ruff
         args: [ --fix, --exit-non-zero-on-fix ]
 
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.35.0
+    rev: v1.35.1
     hooks:
       - id: yamllint
 

{urwid-2.6.4 → urwid-2.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: urwid
-Version: 2.6.4
+Version: 2.6.6
 Summary: A full-featured console (xterm et al.) user interface library
 Home-page: https://urwid.org/
 Author-email: Ian Ward <ian@excess.org>

{urwid-2.6.4 → urwid-2.6.6}/docs/examples/bigtext.py

@@ -34,7 +34,10 @@ if typing.TYPE_CHECKING:
     from collections.abc import Callable
 
 
-class SwitchingPadding(urwid.Padding):
+_Wrapped = typing.TypeVar("_Wrapped")
+
+
+class SwitchingPadding(urwid.Padding[_Wrapped]):
     def padding_values(self, size, focus: bool) -> tuple[int, int]:
         maxcol = size[0]
         width, _height = self.original_widget.pack(size, focus=focus)
@@ -95,7 +98,10 @@ class BigTextDisplay:
     def edit_change_event(self, widget, text: str) -> None:
         self.bigtext.set_text(text)
 
-    def setup_view(self):
+    def setup_view(self) -> tuple[
+        urwid.Frame[urwid.AttrMap[urwid.ListBox], urwid.AttrMap[urwid.Text], None],
+        urwid.Overlay[urwid.BigText, urwid.Frame[urwid.AttrMap[urwid.ListBox], urwid.AttrMap[urwid.Text], None]],
+    ]:
         fonts = urwid.get_all_fonts()
         # setup mode radio buttons
         self.font_buttons = []
@@ -143,17 +149,23 @@ class BigTextDisplay:
         col = urwid.Columns([(16, chars), fonts], 3, focus_column=1)
         bt = urwid.Pile([bt, edit], focus_item=1)
         lines = [bt, urwid.Divider(), col]
-        w = urwid.ListBox(urwid.SimpleListWalker(lines))
+        listbox = urwid.ListBox(urwid.SimpleListWalker(lines))
 
         # Frame
-        w = urwid.AttrMap(w, "body")
-        hdr = urwid.Text("Urwid BigText example program - F8 exits.")
-        hdr = urwid.AttrMap(hdr, "header")
-        w = urwid.Frame(header=hdr, body=w)
+        w = urwid.Frame(
+            body=urwid.AttrMap(listbox, "body"),
+            header=urwid.AttrMap(urwid.Text("Urwid BigText example program - F8 exits."), "header"),
+        )
 
         # Exit message
-        exit_w = urwid.BigText(("exit", " Quit? "), exit_font)
-        exit_w = urwid.Overlay(exit_w, w, urwid.CENTER, None, urwid.MIDDLE, None)
+        exit_w = urwid.Overlay(
+            urwid.BigText(("exit", " Quit? "), exit_font),
+            w,
+            urwid.CENTER,
+            None,
+            urwid.MIDDLE,
+            None,
+        )
         return w, exit_w
 
     def main(self):

{urwid-2.6.4 → urwid-2.6.6}/docs/examples/real_browse.py

@@ -274,7 +274,9 @@ class DirectoryBrowser:
         self.listbox.offset_rows = 1
         self.footer = urwid.AttrMap(urwid.Text(self.footer_text), "foot")
         self.view = urwid.Frame(
-            urwid.AttrMap(self.listbox, "body"), header=urwid.AttrMap(self.header, "head"), footer=self.footer
+            urwid.AttrMap(self.listbox, "body"),
+            header=urwid.AttrMap(self.header, "head"),
+            footer=self.footer,
         )
 
     def main(self) -> None:

{urwid-2.6.4 → urwid-2.6.6}/examples/bigtext.py

@@ -34,7 +34,10 @@ if typing.TYPE_CHECKING:
     from collections.abc import Callable
 
 
-class SwitchingPadding(urwid.Padding):
+_Wrapped = typing.TypeVar("_Wrapped")
+
+
+class SwitchingPadding(urwid.Padding[_Wrapped]):
     def padding_values(self, size, focus: bool) -> tuple[int, int]:
         maxcol = size[0]
         width, _height = self.original_widget.pack(size, focus=focus)
@@ -95,7 +98,10 @@ class BigTextDisplay:
     def edit_change_event(self, widget, text: str) -> None:
         self.bigtext.set_text(text)
 
-    def setup_view(self):
+    def setup_view(self) -> tuple[
+        urwid.Frame[urwid.AttrMap[urwid.ListBox], urwid.AttrMap[urwid.Text], None],
+        urwid.Overlay[urwid.BigText, urwid.Frame[urwid.AttrMap[urwid.ListBox], urwid.AttrMap[urwid.Text], None]],
+    ]:
         fonts = urwid.get_all_fonts()
         # setup mode radio buttons
         self.font_buttons = []
@@ -143,17 +149,23 @@ class BigTextDisplay:
         col = urwid.Columns([(16, chars), fonts], 3, focus_column=1)
         bt = urwid.Pile([bt, edit], focus_item=1)
         lines = [bt, urwid.Divider(), col]
-        w = urwid.ListBox(urwid.SimpleListWalker(lines))
+        listbox = urwid.ListBox(urwid.SimpleListWalker(lines))
 
         # Frame
-        w = urwid.AttrMap(w, "body")
-        hdr = urwid.Text("Urwid BigText example program - F8 exits.")
-        hdr = urwid.AttrMap(hdr, "header")
-        w = urwid.Frame(header=hdr, body=w)
+        w = urwid.Frame(
+            body=urwid.AttrMap(listbox, "body"),
+            header=urwid.AttrMap(urwid.Text("Urwid BigText example program - F8 exits."), "header"),
+        )
 
         # Exit message
-        exit_w = urwid.BigText(("exit", " Quit? "), exit_font)
-        exit_w = urwid.Overlay(exit_w, w, urwid.CENTER, None, urwid.MIDDLE, None)
+        exit_w = urwid.Overlay(
+            urwid.BigText(("exit", " Quit? "), exit_font),
+            w,
+            urwid.CENTER,
+            None,
+            urwid.MIDDLE,
+            None,
+        )
         return w, exit_w
 
     def main(self):

{urwid-2.6.4 → urwid-2.6.6}/examples/browse.py

@@ -274,7 +274,9 @@ class DirectoryBrowser:
         self.listbox.offset_rows = 1
         self.footer = urwid.AttrMap(urwid.Text(self.footer_text), "foot")
         self.view = urwid.Frame(
-            urwid.AttrMap(self.listbox, "body"), header=urwid.AttrMap(self.header, "head"), footer=self.footer
+            urwid.AttrMap(self.listbox, "body"),
+            header=urwid.AttrMap(self.header, "head"),
+            footer=self.footer,
         )
 
     def main(self) -> None:

urwid-2.6.6/pylint-requirements.txt

@@ -0,0 +1 @@
+pylint==3.1.0

{urwid-2.6.4 → urwid-2.6.6}/pyproject.toml

@@ -90,6 +90,10 @@ exclude_lines = [
 
   # Don't complain about missing debug-only code:
   "def __repr__",
+  "def __rich_repr__",
+  # own repr construct magic
+  "def _repr_words",
+  "def _repr_attrs",
 
   # Don't complain if tests don't hit defensive assertion code:
   "raise NotImplementedError",

{urwid-2.6.4 → urwid-2.6.6}/tests/test_columns.py

@@ -80,13 +80,40 @@ class ColumnsTest(unittest.TestCase):
 
         with self.subTest("FIXED only"):
             widget = urwid.Columns(((urwid.PACK, fixed_only),))
-            self.assertEqual(frozenset((urwid.FIXED,)), widget.sizing())
+            self.assertEqual(frozenset((urwid.FLOW, urwid.FIXED)), widget.sizing())
             cols, rows = 3, 3
             self.assertEqual((cols, rows), widget.pack(()))
             canvas = widget.render(())
             self.assertEqual(cols, canvas.cols())
             self.assertEqual(rows, canvas.rows())
 
+        with self.subTest("FIXED only use FLOW methods - drop & replace by solid"):
+            widget = urwid.Columns(((urwid.PACK, fixed_only),))
+            self.assertEqual(frozenset((urwid.FLOW, urwid.FIXED)), widget.sizing())
+            cols, rows = 2, 1
+            self.assertEqual((cols, rows), widget.pack((cols,)))
+            canvas = widget.render((cols,))
+            self.assertEqual(cols, canvas.cols())
+            self.assertEqual(rows, canvas.rows())
+            self.assertEqual("  ", str(canvas))
+
+        with self.subTest("FIXED only use FLOW methods - add empty space"):
+            widget = urwid.Columns(((urwid.PACK, fixed_only),))
+            self.assertEqual(frozenset((urwid.FLOW, urwid.FIXED)), widget.sizing())
+            cols, rows = 5, 3
+            self.assertEqual((cols, rows), widget.pack((cols,)))
+            canvas = widget.render((cols,))
+            self.assertEqual(cols, canvas.cols())
+            self.assertEqual(rows, canvas.rows())
+            self.assertEqual(
+                (
+                    "┌─┐  ",
+                    "│ │  ",
+                    "└─┘  ",
+                ),
+                canvas.decoded_text,
+            )
+
         with self.subTest("GIVEN BOX + FLOW/FIXED, but other widgets do not support box"):
             widget = urwid.Columns((flow_fixed, (3, box_only)), box_columns=(1,))
             self.assertEqual(frozenset((urwid.FLOW, urwid.FIXED)), widget.sizing())
@@ -153,8 +180,7 @@ class ColumnsTest(unittest.TestCase):
             )
 
             cols, rows = 30, 1
-            with self.assertRaises(AttributeError):
-                widget.pack((cols,))
+            self.assertEqual((cols, rows), widget.pack((cols,)))
 
             canvas = widget.render((cols,))
             self.assertEqual(rows, canvas.rows())
@@ -241,6 +267,59 @@ class ColumnsTest(unittest.TestCase):
                 str(ctx.warnings[0].message),
             )
 
+    def test_pack_render_skip_widget(self):
+        widget = urwid.Columns(((0, urwid.Text("Ignore\nme")), (urwid.Text("Count"))))
+        cols, rows = 5, 1
+        self.assertEqual((cols, rows), widget.pack(()))
+        self.assertEqual((cols, rows), widget.pack((cols,)))
+        self.assertEqual("Count", str(widget.render(())))
+        self.assertEqual("Count", str(widget.render((cols,))))
+
+    def test_pack_flow_with_fixed_item(self):
+        widget = urwid.Columns(
+            (
+                (urwid.PACK, urwid.BigText("3", urwid.Thin3x3Font())),
+                (urwid.Text("Multi\nline\ntext\n???")),
+            ),
+            dividechars=1,
+        )
+        with self.subTest("Skip"):
+            self.assertEqual(3, widget.rows((3,)))
+            self.assertEqual((3, 3), widget.pack((3,)))
+            self.assertEqual(
+                (
+                    "┌─┐",
+                    " ─┤",
+                    "└─┘",
+                ),
+                widget.render((3,)).decoded_text,
+            )
+        with self.subTest("Fit all"):
+            self.assertEqual(4, widget.rows((9,)))
+            self.assertEqual((9, 4), widget.pack((9,)))
+            self.assertEqual(
+                (
+                    "┌─┐ Multi",
+                    " ─┤ line ",
+                    "└─┘ text ",
+                    "    ???  ",
+                ),
+                widget.render((9,)).decoded_text,
+            )
+        with self.subTest("Use SolidCanvas instead"):
+            self.assertEqual(1, widget.rows((2,)))
+            self.assertEqual((2, 1), widget.pack((2,)))
+            self.assertEqual(("  ",), widget.render((2,)).decoded_text)
+
+    def test_pack_render_empty_widget(self):
+        widget = urwid.Columns(())
+        self.assertEqual(frozenset((urwid.FLOW, urwid.BOX)), widget.sizing())
+        cols, rows = 10, 1
+        self.assertEqual((cols, rows), widget.pack((cols,)))
+        canvas = widget.render((cols,))
+        self.assertEqual(rows, canvas.rows())
+        self.assertEqual(("          ",), canvas.decoded_text)
+
     def test_not_a_widget(self):
         class NotAWidget:
             __slots__ = ("name", "symbol")

{urwid-2.6.4 → urwid-2.6.6}/tests/test_doctests.py

@@ -34,11 +34,11 @@ def load_tests(loader: unittest.TestLoader, tests: unittest.BaseTestSuite, ignor
         urwid.widget.widget,
         urwid.widget.widget_decoration,
         urwid.widget.wimp,
+        urwid.widget.monitored_list,
         urwid.display.common,
         urwid.display.raw,
         urwid.event_loop.main_loop,
         urwid.numedit,
-        urwid.monitored_list,
         urwid.raw_display,
         urwid.font,
         "urwid.split_repr",  # override function with same name

{urwid-2.6.4 → urwid-2.6.6}/tests/test_grid_flow.py

@@ -84,6 +84,59 @@ class GridFlowTest(unittest.TestCase):
         gf = urwid.GridFlow([], 5, 0, 0, "left")
         self.assertEqual(gf.cell_width, 5)
 
+    def test_not_fit(self):
+        """Test scenario with maxcol < cell_width (special case, warning will be produced)."""
+        widget = urwid.GridFlow(
+            [urwid.Button("first"), urwid.Button("second")],
+            5,
+            0,
+            0,
+            "left",
+        )
+        size = (3,)
+        with self.assertWarns(urwid.widget.GridFlowWarning):
+            canvas = widget.render(size)
+
+        self.assertEqual(
+            ("< f", "  i", "  r", "  s", "  t", "< s", "  e", "  c", "  o", "  n", "  d"),
+            canvas.decoded_text,
+        )
+
+    def test_multiline(self):
+        """Test widgets fit only with multiple lines"""
+        widget = urwid.GridFlow(
+            [urwid.Button("first"), urwid.Button("second")],
+            10,
+            0,
+            0,
+            "left",
+        )
+        size = (10,)
+        canvas = widget.render(size)
+        self.assertEqual(
+            ("< first  >", "< second >"),
+            canvas.decoded_text,
+        )
+
+    def test_multiline_2(self):
+        """Test widgets fit only with multiple lines"""
+        widget = urwid.GridFlow(
+            [urwid.Button("first"), urwid.Button("second"), urwid.Button("third"), urwid.Button("forth")],
+            10,
+            0,
+            0,
+            "left",
+        )
+        size = (20,)
+        canvas = widget.render(size)
+        self.assertEqual(
+            (
+                "< first  >< second >",
+                "< third  >< forth  >",
+            ),
+            canvas.decoded_text,
+        )
+
     def test_basics(self):
         repr(urwid.GridFlow([], 5, 0, 0, "left"))  # should not fail
 

urwid-2.6.6/tests/test_tree.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import typing
+import unittest
+from typing import Collection
+
+import urwid
+from urwid import TreeNode
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Hashable, Iterable
+
+
+class SelfRegisteringParent(urwid.ParentNode):
+    def __init__(
+        self,
+        value: str,
+        parent: SelfRegisteringParent | None = None,
+        key: Hashable = None,
+        depth: int | None = None,
+        children: Iterable[SelfRegisteringChild | SelfRegisteringParent] = (),
+    ) -> None:
+        super().__init__(value, parent, key, depth)
+        if parent:
+            parent.set_child_node(key, self)
+
+        self._child_keys = []
+        for child in children:
+            key = child.get_key()
+            self._children[key] = child
+            self._child_keys.append(key)
+            child.set_parent(self)
+
+    def load_child_keys(self) -> Collection[Hashable]:
+        return list(self._children)
+
+    def set_child_node(self, key: Hashable, node: TreeNode) -> None:
+        super().set_child_node(key, node)
+        self._child_keys = self.load_child_keys()
+
+    def set_parent(self, parent: SelfRegisteringParent) -> None:
+        self._parent = parent
+
+
+class SelfRegisteringChild(urwid.TreeNode):
+    def __init__(
+        self,
+        value: str,
+        parent: SelfRegisteringParent | None = None,
+        key: Hashable | None = None,
+        depth: int | None = None,
+    ) -> None:
+        super().__init__(value, parent, key, depth)
+        if parent:
+            parent.set_child_node(key, self)
+
+    def set_parent(self, parent: SelfRegisteringParent) -> None:
+        self._parent = parent
+
+
+class TestTree(unittest.TestCase):
+    def test_basic(self):
+        root = SelfRegisteringParent(
+            "root",
+            key="/",
+            children=(SelfRegisteringChild(f"child_{idx}", key=str(idx)) for idx in range(1, 4)),
+        )
+
+        widget = urwid.TreeListBox(urwid.TreeWalker(root))
+        size = (15, 5)
+        expanded = (
+            "- /: root      ",
+            "   1: child_1  ",
+            "   2: child_2  ",
+            "   3: child_3  ",
+            "               ",
+        )
+        collapsed = (
+            "+ /: root      ",
+            *(" " * size[0] for _ in range(size[1] - 1)),
+        )
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed, widget.render(size).decoded_text)
+        widget.keypress(size, "+")
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "down")
+        self.assertIs(root, widget.focus_position)
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed, widget.render(size).decoded_text)
+        widget.keypress(size, "right")
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+
+    def test_nested_behavior(self):
+        root = SelfRegisteringParent(
+            "root",
+            key="/",
+            children=(
+                SelfRegisteringParent(
+                    f"nested_{idx}",
+                    key=f"{idx}/",
+                    children=(SelfRegisteringChild(f"child_{idx}{cidx}", key=str(cidx)) for cidx in range(1, 4)),
+                )
+                for idx in range(1, 4)
+            ),
+        )
+        widget = urwid.TreeListBox(urwid.TreeWalker(root))
+        size = (18, 13)
+        expanded = (
+            "- /: root         ",
+            "   - 1/: nested_1 ",
+            "      1: child_11 ",
+            "      2: child_12 ",
+            "      3: child_13 ",
+            "   - 2/: nested_2 ",
+            "      1: child_21 ",
+            "      2: child_22 ",
+            "      3: child_23 ",
+            "   - 3/: nested_3 ",
+            "      1: child_31 ",
+            "      2: child_32 ",
+            "      3: child_33 ",
+        )
+        collapsed = (
+            "+ /: root         ",
+            *(" " * size[0] for _ in range(size[1] - 1)),
+        )
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed, widget.render(size).decoded_text)
+        widget.keypress(size, "+")
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "down")
+        widget.keypress(size, "-")
+        self.assertEqual(
+            (
+                "- /: root         ",
+                "   + 1/: nested_1 ",
+                "   - 2/: nested_2 ",
+                "      1: child_21 ",
+                "      2: child_22 ",
+                "      3: child_23 ",
+                "   - 3/: nested_3 ",
+                "      1: child_31 ",
+                "      2: child_32 ",
+                "      3: child_33 ",
+                "                  ",
+                "                  ",
+                "                  ",
+            ),
+            widget.render(size).decoded_text,
+        )
+        widget.keypress(size, "right")
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "left")
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed, widget.render(size).decoded_text)
+        widget.keypress(size, "+")
+        widget.keypress(size, "page down")
+        widget.keypress(size, "-")
+        self.assertEqual(
+            (
+                "- /: root         ",
+                "   - 1/: nested_1 ",
+                "      1: child_11 ",
+                "      2: child_12 ",
+                "      3: child_13 ",
+                "   - 2/: nested_2 ",
+                "      1: child_21 ",
+                "      2: child_22 ",
+                "      3: child_23 ",
+                "   + 3/: nested_3 ",
+                "                  ",
+                "                  ",
+                "                  ",
+            ),
+            widget.render(size).decoded_text,
+        )
+
+    def test_deep_nested_collapse_expand(self):
+        root = SelfRegisteringParent(
+            "root",
+            key="/",
+            children=(
+                SelfRegisteringParent(
+                    f"nested_{top_idx}",
+                    key=f"{top_idx}/",
+                    children=(
+                        SelfRegisteringParent(
+                            f"nested_{top_idx}{first_idx}",
+                            key=f"{first_idx}/",
+                            children=(
+                                SelfRegisteringChild(f"child_{top_idx}{first_idx}{last_idx}", key=str(last_idx))
+                                for last_idx in range(1, 3)
+                            ),
+                        )
+                        for first_idx in range(1, 3)
+                    ),
+                )
+                for top_idx in range(1, 3)
+            ),
+        )
+        widget = urwid.TreeListBox(urwid.TreeWalker(root))
+        size = (21, 15)
+        expanded = (
+            "- /: root            ",
+            "   - 1/: nested_1    ",
+            "      - 1/: nested_11",
+            "         1: child_111",
+            "         2: child_112",
+            "      - 2/: nested_12",
+            "         1: child_121",
+            "         2: child_122",
+            "   - 2/: nested_2    ",
+            "      - 1/: nested_21",
+            "         1: child_211",
+            "         2: child_212",
+            "      - 2/: nested_22",
+            "         1: child_221",
+            "         2: child_222",
+        )
+        collapsed = (
+            "+ /: root            ",
+            *(" " * size[0] for _ in range(size[1] - 1)),
+        )
+        collapsed_last = (
+            "- /: root            ",
+            "   - 1/: nested_1    ",
+            "      - 1/: nested_11",
+            "         1: child_111",
+            "         2: child_112",
+            "      - 2/: nested_12",
+            "         1: child_121",
+            "         2: child_122",
+            "   - 2/: nested_2    ",
+            "      - 1/: nested_21",
+            "         1: child_211",
+            "         2: child_212",
+            "      + 2/: nested_22",
+            "                     ",
+            "                     ",
+        )
+        self.assertEqual(expanded, widget.render(size).decoded_text)
+        widget.keypress(size, "page down")
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed_last, widget.render(size).decoded_text)
+        widget.keypress(size, "left")
+        widget.keypress(size, "-")
+        self.assertEqual(
+            (
+                "- /: root            ",
+                "   - 1/: nested_1    ",
+                "      - 1/: nested_11",
+                "         1: child_111",
+                "         2: child_112",
+                "      - 2/: nested_12",
+                "         1: child_121",
+                "         2: child_122",
+                "   + 2/: nested_2    ",
+                "                     ",
+                "                     ",
+                "                     ",
+                "                     ",
+                "                     ",
+                "                     ",
+            ),
+            widget.render(size).decoded_text,
+        )
+        widget.keypress(size, "right")
+        self.assertEqual(collapsed_last, widget.render(size).decoded_text)
+        widget.keypress(size, "home")
+        widget.keypress(size, "-")
+        self.assertEqual(collapsed, widget.render(size).decoded_text)