urwid 4.0.4__tar.gz → 4.0.6__tar.gz

{urwid-4.0.4/urwid.egg-info → urwid-4.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urwid
-Version: 4.0.4
+Version: 4.0.6
 Summary: A full-featured console (xterm et al.) user interface library
 Author-email: Ian Ward <ian@excess.org>
 License-Expression: LGPL-2.1-only

{urwid-4.0.4 → urwid-4.0.6}/docs/changelog.rst

@@ -2,6 +2,57 @@
 Changelog
 ---------
 
+Urwid 4.0.6
+===========
+
+2026-07-23
+
+Implemented protocol base classes `AbstractWidget` and internal `AbstractBoxWidget`, `AbstractFlowWidget` and `AbstractFixedWidget` for protocol based typing.
+All classes implementing `AbstractWidget` are considered valid widget (as all required APIs available).
+Container widgets as `Columns`, `Pile`, `GridFlow`, `Frame`, `Overlay` and `Padding` now declare expected APIs from widgets depends on sizing parameter in `__init__`.
+
+Bug fixes 🕷
+++++++++++++
+* Fix web display broken by token_urlsafe session ids by @2018302345 in https://github.com/urwid/urwid/pull/1195
+Documentation 🕮
+++++++++++++++++
+* Typing: fix scrollable module annotations by @penguinolog in https://github.com/urwid/urwid/pull/1194
+* Typing: introduce `AbstractWidget` abstract base class/protocol by @penguinolog in https://github.com/urwid/urwid/pull/1196
+
+
+New Contributors
+++++++++++++++++
+* @2018302345 made their first contribution in https://github.com/urwid/urwid/pull/1195
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.5...4.0.6
+
+Urwid 4.0.5
+===========
+
+2026-07-20
+
+New features 🗹
++++++++++++++++
+* Copy signal handlers before emission by @Sanjays2402 in https://github.com/urwid/urwid/pull/1187
+* Implement `_scrollbar_layout` and left click handling for `Scrollable` by @penguinolog in https://github.com/urwid/urwid/pull/1192
+Bug fixes 🕷
+++++++++++++
+* Fix rle_product for zero-len elements by @penguinolog in https://github.com/urwid/urwid/pull/1191
+Documentation 🕮
+++++++++++++++++
+* typing: fix `Filler` typing annotations by @penguinolog in https://github.com/urwid/urwid/pull/1183
+* typing: extend widget_decoration module typing coverage by @penguinolog in https://github.com/urwid/urwid/pull/1184
+* Typing: annotate and fix attr_map by @penguinolog in https://github.com/urwid/urwid/pull/1186
+Refactoring 🛠
+++++++++++++++
+* Migrate `Edit` widget to use `WidgetWrap` as base class and update methods by @penguinolog in https://github.com/urwid/urwid/pull/1180
+
+New Contributors
+++++++++++++++++
+* @Sanjays2402 made their first contribution in https://github.com/urwid/urwid/pull/1187
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.4...4.0.5
+
 Urwid 4.0.4
 ===========
 

urwid-4.0.6/ruff-requirements.txt

@@ -0,0 +1 @@
+ruff==0.15.22

{urwid-4.0.4 → urwid-4.0.6}/tests/test_columns.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import typing
 import unittest
+import warnings
 
 import urwid
 from tests.util import SelectableText
@@ -12,6 +13,85 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
 
+class NotAWidget:
+    __slots__ = ("name", "symbol")
+
+    def __init__(self, name: str, symbol: bytes) -> None:
+        self.name = name
+        self.symbol = symbol
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
+
+    def selectable(self) -> bool:
+        return False
+
+    def rows(self, max_col_row: tuple[int], focus: bool = False) -> int:
+        return 1
+
+    def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
+        maxcol = max_col_row[0]
+        line = self.symbol * maxcol
+        if len(max_col_row) == 1:
+            return urwid.TextCanvas((line,), maxcol=maxcol)
+        return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
+
+
+class ImplementWidget:
+    __slots__ = ("name", "symbol")
+
+    def sizing(self) -> frozenset[urwid.Sizing]:
+        return frozenset((urwid.BOX, urwid.FLOW))
+
+    @property
+    def base_widget(self) -> urwid.AbstractWidget:
+        return self
+
+    def __init__(self, name: str, symbol: bytes) -> None:
+        self.name = name
+        self.symbol = symbol
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
+
+    def selectable(self) -> bool:
+        return False
+
+    @property
+    def focus(self) -> None:
+        return None
+
+    def _invalidate(self) -> None:
+        pass
+
+    def rows(self, max_col_row: tuple[int], focus: bool = False) -> int:
+        return 1
+
+    def pack(self, size: typing.Any, focus: bool = False) -> tuple[int, int]:
+        return self.rows(size, focus)
+
+    def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
+        maxcol = max_col_row[0]
+        line = self.symbol * maxcol
+        if len(max_col_row) == 1:
+            return urwid.TextCanvas((line,), maxcol=maxcol)
+        return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
+
+    def keypress(self, size: tuple[int, int] | tuple[int], key: str) -> str | None:
+        return key
+
+    def mouse_event(
+        self,
+        size: tuple[int, int] | tuple[int],
+        event: str,
+        button: int,
+        col: int,
+        row: int,
+        focus: bool,
+    ) -> bool | None:
+        return False
+
+
 class ColumnsTest(unittest.TestCase):
     def test_basic_sizing(self) -> None:
         box_only = urwid.SolidFill("#")
@@ -320,29 +400,6 @@ class ColumnsTest(unittest.TestCase):
         self.assertEqual(("          ",), canvas.decoded_text)
 
     def test_not_a_widget(self):
-        class NotAWidget:
-            __slots__ = ("name", "symbol")
-
-            def __init__(self, name: str, symbol: bytes) -> None:
-                self.name = name
-                self.symbol = symbol
-
-            def __repr__(self) -> str:
-                return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
-
-            def selectable(self) -> bool:
-                return False
-
-            def rows(self, max_col_row: tuple[int], focus: bool = False) -> int:
-                return 1
-
-            def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
-                maxcol = max_col_row[0]
-                line = self.symbol * maxcol
-                if len(max_col_row) == 1:
-                    return urwid.TextCanvas((line,), maxcol=maxcol)
-                return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
-
         with self.subTest("Box"), self.assertWarns(urwid.widget.ColumnsWarning) as ctx:
             items = (NotAWidget("First", b"*"), NotAWidget("Second", b"^"))
             widget = urwid.Columns(items)
@@ -359,6 +416,35 @@ class ColumnsTest(unittest.TestCase):
             self.assertEqual(f"{items[0]!r} is not a Widget", str(ctx.warnings[0].message))
             self.assertEqual(f"{items[1]!r} is not a Widget", str(ctx.warnings[1].message))
 
+    def test_implement_widget_interface(self):
+        with (
+            warnings.catch_warnings(record=True) as collected_w,
+            self.subTest("Box"),
+        ):
+            items = (ImplementWidget("First", b"*"), ImplementWidget("Second", b"^"))
+            widget = urwid.Columns(items)
+
+            self.assertEqual(("**^^", "**^^"), widget.render((4, 2)).decoded_text)
+
+            columns_warnings = tuple(
+                warning.message for warning in collected_w if warning.category == urwid.widget.ColumnsWarning
+            )
+            self.assertTrue(len(columns_warnings) == 0, "No warnings expected")
+
+        with (
+            warnings.catch_warnings(record=True) as collected_w,
+            self.subTest("Flow"),
+        ):
+            items = (ImplementWidget("First", b"*"), ImplementWidget("Second", b"^"))
+            widget = urwid.Columns(items)
+
+            self.assertEqual(("***^^^",), widget.render((6,)).decoded_text)
+
+            columns_warnings = tuple(
+                warning.message for warning in collected_w if warning.category == urwid.widget.ColumnsWarning
+            )
+            self.assertTrue(len(columns_warnings) == 0, "No warnings expected")
+
     def test_zero_width_column(self):
         elem_1 = urwid.BoxAdapter(urwid.SolidFill("#"), 2)
         elem_2 = urwid.BoxAdapter(urwid.SolidFill("*"), 4)

{urwid-4.0.4 → urwid-4.0.6}/tests/test_graphics.py

@@ -13,7 +13,7 @@ class BarGraphTest(unittest.TestCase):
         assert rval == exp, f"{desc} expected {exp!r}, got {rval!r}"
 
     def test1(self):
-        self.bgtest("simplest", [[0]], 5, [1], 1, [(1, [(0, 1)])]),
+        self.bgtest("simplest", [[0]], 5, [1], 1, [(1, [(0, 1)])])
         self.bgtest(
             "simpler",
             [[0], [0]],

{urwid-4.0.4 → urwid-4.0.6}/tests/test_listbox.py

@@ -1965,7 +1965,7 @@ class PageDownAboveTopTest(unittest.TestCase):
         # Two-row rows so the four-item list does not fit the viewport at once.
         lb = urwid.ListBox(
             urwid.SimpleListWalker(
-                            [
+                [
                     urwid.Text("a0\nb0"),
                     SelectableText("a1\nb1"),
                     urwid.Text("a2\nb2"),

{urwid-4.0.4 → urwid-4.0.6}/tests/test_main_loop.py

@@ -22,7 +22,7 @@ class ClosingTemporaryFilesPair(typing.ContextManager[tuple[typing.TextIO, typin
     Since `sys.stdout` is TextIO, tests have to use compatible api for the proper behavior imitation.
     """
 
-    __slots__ = ("rd_s", "wr_s", "rd_f", "wr_f")
+    __slots__ = ("rd_f", "rd_s", "wr_f", "wr_s")
 
     def __init__(self) -> None:
         self.rd_s: socket.socket | None = None

{urwid-4.0.4 → urwid-4.0.6}/tests/test_overlay.py

@@ -154,7 +154,7 @@ class OverlayTest(unittest.TestCase):
             self.assertEqual(rows, canvas.rows())
 
             self.assertEqual(
-                "##########################\n" "#Flow and Fixed widget  ##\n" "##########################",
+                "##########################\n#Flow and Fixed widget  ##\n##########################",
                 str(canvas),
             )
 
@@ -182,7 +182,7 @@ class OverlayTest(unittest.TestCase):
             self.assertEqual(rows, canvas.rows())
 
             self.assertEqual(
-                "#########################\n" "#Flow and Fixed widget  #\n" "#########################",
+                "#########################\n#Flow and Fixed widget  #\n#########################",
                 str(canvas),
             )
 

{urwid-4.0.4 → urwid-4.0.6}/tests/test_pile.py

@@ -1,11 +1,96 @@
 from __future__ import annotations
 
 import unittest
+import warnings
 
 import urwid
 from tests.util import SelectableText
 
 
+class NotAWidget:
+    __slots__ = ("name", "symbol")
+
+    def __init__(self, name: str, symbol: bytes) -> None:
+        self.name = name
+        self.symbol = symbol
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
+
+    def selectable(self) -> bool:
+        return False
+
+    def pack(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> int:
+        if len(max_col_row) == 2:
+            return max_col_row
+        return max_col_row[0], self.rows(max_col_row)
+
+    def rows(self, max_col_row: tuple[int], focus=False) -> int:
+        return 1
+
+    def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
+        maxcol = max_col_row[0]
+        line = self.symbol * maxcol
+        if len(max_col_row) == 1:
+            return urwid.TextCanvas((line,), maxcol=maxcol)
+        return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
+
+
+class ImplementWidget:
+    __slots__ = ("name", "symbol")
+
+    def sizing(self) -> frozenset[urwid.Sizing]:
+        return frozenset((urwid.BOX, urwid.FLOW))
+
+    @property
+    def base_widget(self) -> urwid.AbstractWidget:
+        return self
+
+    def __init__(self, name: str, symbol: bytes) -> None:
+        self.name = name
+        self.symbol = symbol
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
+
+    def selectable(self) -> bool:
+        return False
+
+    @property
+    def focus(self) -> None:
+        return None
+
+    def _invalidate(self) -> None:
+        pass
+
+    def rows(self, max_col_row: tuple[int], focus: bool = False) -> int:
+        return 1
+
+    def pack(self, size: typing.Any, focus: bool = False) -> tuple[int, int]:
+        return self.rows(size, focus)
+
+    def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
+        maxcol = max_col_row[0]
+        line = self.symbol * maxcol
+        if len(max_col_row) == 1:
+            return urwid.TextCanvas((line,), maxcol=maxcol)
+        return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
+
+    def keypress(self, size: tuple[int, int] | tuple[int], key: str) -> str | None:
+        return key
+
+    def mouse_event(
+        self,
+        size: tuple[int, int] | tuple[int],
+        event: str,
+        button: int,
+        col: int,
+        row: int,
+        focus: bool,
+    ) -> bool | None:
+        return False
+
+
 class PileTest(unittest.TestCase):
     def test_basic_sizing(self) -> None:
         box_only = urwid.SolidFill("#")
@@ -247,34 +332,6 @@ class PileTest(unittest.TestCase):
         self.assertEqual("Cancel", widget.focus.focus.label)
 
     def test_not_a_widget(self):
-        class NotAWidget:
-            __slots__ = ("name", "symbol")
-
-            def __init__(self, name: str, symbol: bytes) -> None:
-                self.name = name
-                self.symbol = symbol
-
-            def __repr__(self) -> str:
-                return f"{self.__class__.__name__}(name={self.name!r}, symbol={self.symbol!r})"
-
-            def selectable(self) -> bool:
-                return False
-
-            def pack(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> int:
-                if len(max_col_row) == 2:
-                    return max_col_row
-                return max_col_row[0], self.rows(max_col_row)
-
-            def rows(self, max_col_row: tuple[int], focus=False) -> int:
-                return 1
-
-            def render(self, max_col_row: tuple[int, int] | tuple[int], focus: bool = False) -> urwid.Canvas:
-                maxcol = max_col_row[0]
-                line = self.symbol * maxcol
-                if len(max_col_row) == 1:
-                    return urwid.TextCanvas((line,), maxcol=maxcol)
-                return urwid.TextCanvas((line,) * max_col_row[1], maxcol=maxcol)
-
         with self.subTest("Box"), self.assertWarns(urwid.widget.PileWarning) as ctx:
             items = (NotAWidget("First", b"*"), NotAWidget("Second", b"^"))
             widget = urwid.Pile(items)
@@ -291,6 +348,35 @@ class PileTest(unittest.TestCase):
             self.assertEqual(f"{items[0]!r} is not a Widget", str(ctx.warnings[0].message))
             self.assertEqual(f"{items[1]!r} is not a Widget", str(ctx.warnings[1].message))
 
+    def test_implement_widget_interface(self):
+        with (
+            warnings.catch_warnings(record=True) as collected_w,
+            self.subTest("Box"),
+        ):
+            items = (ImplementWidget("First", b"*"), ImplementWidget("Second", b"^"))
+            widget = urwid.Pile(items)
+
+            self.assertEqual(("****", "^^^^"), widget.render((4, 2)).decoded_text)
+
+            pile_warnings = tuple(
+                warning.message for warning in collected_w if warning.category == urwid.widget.PileWarning
+            )
+            self.assertTrue(len(pile_warnings) == 0, "No warnings expected")
+
+        with (
+            warnings.catch_warnings(record=True) as collected_w,
+            self.subTest("Flow"),
+        ):
+            items = (ImplementWidget("First", b"*"), ImplementWidget("Second", b"^"))
+            widget = urwid.Pile(items)
+
+            self.assertEqual(("******", "^^^^^^"), widget.render((6,)).decoded_text)
+
+            pile_warnings = tuple(
+                warning.message for warning in collected_w if warning.category == urwid.widget.PileWarning
+            )
+            self.assertTrue(len(pile_warnings) == 0, "No warnings expected")
+
     def ktest(self, desc, contents, focus_item, key, rkey, rfocus, rpref_col):
         p = urwid.Pile(contents, focus_item)
         rval = p.keypress((20,), key)

{urwid-4.0.4 → urwid-4.0.6}/tests/test_scrollable.py

@@ -142,6 +142,72 @@ class TestScrollBarScrollable(unittest.TestCase):
 
         self.assertEqual(top_position_rendered, widget.render(reduced_size).decoded_text)
 
+    def test_mouse_left_click_scrollbar(self):
+        """Left click on the rendered scrollbar jumps to the clicked position."""
+        content = urwid.Text("\n".join(string.ascii_letters))  # 52 single-char lines
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+        scrollbar_col = reduced_size[0] - 1  # right side scrollbar
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # posmax == 52 - 5 == 47, thumb_height == 1, thumb travel == 5 - 1 == 4.
+        # Clicking the bottom row moves past the end and is clamped to posmax.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 4, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+        # Clicking the top row scrolls back to the top.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 0, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # Intermediate rows map proportionally: round(row * posmax / travel).
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 1, False))
+        self.assertEqual(12, scrollable.get_scrollpos())
+
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 3, False))
+        self.assertEqual(35, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_content_ignored(self):
+        """Left click outside of the scrollbar columns does not scroll."""
+        content = urwid.Text("\n".join(string.ascii_letters))
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # Column 0 belongs to the wrapped content, not the scrollbar.
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 0, 4, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_left_side_scrollbar(self):
+        """Left click detection honours a left-aligned scrollbar."""
+        content = urwid.Text("\n".join(string.ascii_letters))
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content), side="left")
+        scrollable = widget.original_widget
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # The scrollbar occupies column 0 when aligned to the left.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, 0, 4, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+        # A click on the content columns is ignored.
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 1, 0, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_without_scrollbar(self):
+        """Without a rendered scrollbar a left click is not handled."""
+        content = urwid.Text("a\nb")  # fits into the available height
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 2, 2, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
     def test_alt_symbols(self):
         long_content = urwid.Text(LGPL_HEADER)
         reduced_size = (40, 5)

{urwid-4.0.4 → urwid-4.0.6}/tests/test_signals.py

@@ -25,6 +25,30 @@ class SiglnalsTest(unittest.TestCase):
         edit.set_edit_text("another text")
         handler.assert_not_called()
 
+    def test_handler_mutation_during_emit(self):
+        emitter = self.EmClass()
+        calls = []
+
+        def third():
+            calls.append("third")
+
+        def first():
+            calls.append("first")
+            disconnect_signal(emitter, "test", first)
+            connect_signal(emitter, "test", third)
+
+        def second():
+            calls.append("second")
+
+        connect_signal(emitter, "test", first)
+        connect_signal(emitter, "test", second)
+
+        emit_signal(emitter, "test")
+        self.assertEqual(calls, ["first", "second"])
+
+        emit_signal(emitter, "test")
+        self.assertEqual(calls, ["first", "second", "second", "third"])
+
     @unittest.skipIf(sys.implementation.name == "pypy", "WeakRef works differently on PyPy")
     def test_weak_del(self):
         emitter = SiglnalsTest.EmClass()

{urwid-4.0.4 → urwid-4.0.6}/tests/test_widget.py

@@ -39,6 +39,58 @@ class TextTest(unittest.TestCase):
             got = urwid.Text("û").render((3,))._text
             assert got == expected, f"got: {got!r} expected: {expected!r}"
 
+    def test_empty_markup_segment_middle(self) -> None:
+        """An empty markup segment in the middle must not truncate the rendered row."""
+        widget = urwid.Text([("a", "X" * 10), ("b", ""), ("c", " END")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("a", 10), ("b", 0), ("c", 4)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_empty_markup_segment_start(self) -> None:
+        """An empty markup segment at the start must keep the whole rendered row."""
+        widget = urwid.Text([("b", ""), ("a", "X" * 10), ("c", " END")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("b", 0), ("a", 10), ("c", 4)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_empty_markup_segment_end(self) -> None:
+        """An empty markup segment at the end must keep the whole rendered row."""
+        widget = urwid.Text([("a", "X" * 10), ("c", " END"), ("b", "")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("a", 10), ("c", 4), ("b", 0)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_multiple_empty_markup_segments(self) -> None:
+        """Several consecutive empty markup segments must not drop following content."""
+        widget = urwid.Text([("a", "AB"), ("b", ""), ("c", ""), ("d", "CD")])
+
+        self.assertEqual(("ABCD", [("a", 2), ("b", 0), ("c", 0), ("d", 2)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"ABCD"], canvas.text)
+        self.assertEqual(("ABCD",), canvas.decoded_text)
+
+    def test_empty_markup_segment_render_content(self) -> None:
+        """The canvas content rows must expose the display attribute of each segment."""
+        widget = urwid.Text([("a", "X" * 10), ("b", ""), ("c", " END")])
+
+        content = list(widget.render(()).content())
+        attrs = [attr for row in content for attr, _cs, _text in row]
+        rendered = b"".join(text for row in content for _attr, _cs, text in row)
+
+        self.assertEqual(b"XXXXXXXXXX END", rendered)
+        self.assertIn("a", attrs)
+        self.assertIn("c", attrs)
+
 
 class EditTest(unittest.TestCase):
     def setUp(self):

{urwid-4.0.4 → urwid-4.0.6}/urwid/__init__.py

@@ -140,6 +140,7 @@ from .widget import (
     SPACE,
     TOP,
     WEIGHT,
+    AbstractWidget,
     Align,
     AttrMap,
     AttrMapError,
@@ -262,6 +263,7 @@ __all__: tuple[str, ...] = (
     "WEIGHT",
     "WHITE",
     "YELLOW",
+    "AbstractWidget",
     "Align",
     "AsyncioEventLoop",
     "AttrMap",