urwid 2.6.5__tar.gz → 2.6.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: urwid
-Version: 2.6.5
+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.5 → 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.5 → 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.5 → urwid-2.6.6}/urwid/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.6.5'
-__version_tuple__ = version_tuple = (2, 6, 5)
+__version__ = version = '2.6.6'
+__version_tuple__ = version_tuple = (2, 6, 6)

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/columns.py

@@ -7,6 +7,7 @@ from itertools import chain, repeat
 import urwid
 from urwid.canvas import Canvas, CanvasJoin, CompositeCanvas, SolidCanvas
 from urwid.command_map import Command
+from urwid.split_repr import remove_defaults
 from urwid.util import is_mouse_press
 
 from .constants import Align, Sizing, WHSettings
@@ -15,7 +16,7 @@ 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,43 +67,43 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         # BOX-only widget
         >>> Columns((SolidFill("#"),))
-        <Columns box widget with 1 item>
+        <Columns box widget (1 item)>
 
         # BOX-only widget with "get height from max"
         >>> Columns((SolidFill("#"),), box_columns=(0,))
-        <Columns box widget with 1 item>
+        <Columns box widget (1 item)>
 
         # FLOW-only
         >>> Columns((Edit(),))
-        <Columns selectable flow widget with 1 item>
+        <Columns selectable flow widget (1 item)>
 
         # FLOW allowed by "box_columns"
         >>> Columns((Edit(), SolidFill("#")), box_columns=(1,))
-        <Columns selectable flow widget with 2 items>
+        <Columns selectable flow widget (2 items) focus_column=0>
 
         # FLOW/FIXED
         >>> Columns((Text("T"),))
-        <Columns fixed/flow widget with 1 item>
+        <Columns fixed/flow widget (1 item)>
 
         # GIVEN BOX only -> BOX only
         >>> Columns(((5, SolidFill("#")),), box_columns=(0,))
-        <Columns box widget with 1 item>
+        <Columns box widget (1 item)>
 
         # No FLOW - BOX only
         >>> Columns(((5, SolidFill("#")), SolidFill("*")), box_columns=(0, 1))
-        <Columns box widget with 2 items>
+        <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 with 1 item>
+        <Columns fixed/flow widget (1 item)>
 
         # Invalid sizing combination -> use fallback settings (and produce warning)
         >>> Columns(((WHSettings.PACK, SolidFill("#")),))
-        <Columns box/flow widget with 1 item>
+        <Columns box/flow widget (1 item)>
 
         # Special case: empty columns widget sizing is impossible to calculate
         >>> Columns(())
-        <Columns box/flow widget without contents>
+        <Columns box/flow widget ()>
         """
         if not self.contents:
             return frozenset((urwid.BOX, urwid.FLOW))
@@ -183,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:
@@ -289,10 +291,50 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
     def _repr_words(self) -> list[str]:
         if len(self.contents) > 1:
-            return [*super()._repr_words(), f"with {len(self.contents)} items"]
-        if self.contents:
-            return [*super()._repr_words(), "with 1 item"]
-        return [*super()._repr_words(), "without contents"]
+            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:
         """
@@ -904,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:
@@ -1135,14 +1183,10 @@ class Columns(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         see :meth:`Widget.rows` for details
         """
-        widths = self.column_widths(size, focus)
-
-        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
+        _, heights, _ = self.get_column_sizes(size, focus)
+        if heights:
+            return max(1, *heights)
+        return 1
 
     def keypress(
         self,

{urwid-2.6.5 → urwid-2.6.6}/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
@@ -89,6 +90,22 @@ class Frame(Widget, WidgetContainerMixin, typing.Generic[BodyWidget, HeaderWidge
         _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) -> HeaderWidget:
         return self._header

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/grid_flow.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import typing
 import warnings
 
+from urwid.split_repr import remove_defaults
+
 from .columns import Columns
 from .constants import Align, Sizing, WHSettings
 from .container import WidgetContainerListContentsMixin, WidgetContainerMixin
@@ -13,7 +15,7 @@ from .pile import Pile
 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
 
@@ -78,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()

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/overlay.py

@@ -4,6 +4,7 @@ import typing
 import warnings
 
 from urwid.canvas import CanvasOverlay, CompositeCanvas
+from urwid.split_repr import remove_defaults
 
 from .constants import (
     RELATIVE_100,
@@ -330,8 +331,67 @@ class Overlay(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin, ty
             f"min_height={self.min_height!r}"
         )
 
-    def _repr_words(self) -> list[str]:
-        return [*super()._repr_words(), f"top={self.top_w!r}", f"bottom={self.bottom_w!r}"]
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        attrs = {
+            **super()._repr_attrs(),
+            "top_w": self.top_w,
+            "bottom_w": self.bottom_w,
+            "align": self.align,
+            "width": self.width,
+            "valign": self.valign,
+            "height": self.height,
+            "min_width": self.min_width,
+            "min_height": self.min_height,
+            "left": self.left,
+            "right": self.right,
+            "top": self.top,
+            "bottom": self.bottom,
+        }
+        return remove_defaults(attrs, Overlay.__init__)
+
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "top", self.top_w
+        yield "bottom", self.bottom_w
+        yield "align", self.align
+        yield "width", self.width
+        yield "valign", self.valign
+        yield "height", self.height
+        yield "min_width", self.min_width
+        yield "min_height", self.min_height
+        yield "left", self.left
+        yield "right", self.right
+        yield "top", self.top
+        yield "bottom", self.bottom
+
+    @property
+    def align(self) -> Align | tuple[Literal[WHSettings.RELATIVE], int]:
+        return simplify_align(self.align_type, self.align_amount)
+
+    @property
+    def width(
+        self,
+    ) -> (
+        Literal[WHSettings.CLIP, WHSettings.PACK]
+        | int
+        | tuple[Literal[WHSettings.RELATIVE], int]
+        | tuple[Literal[WHSettings.WEIGHT], int | float]
+    ):
+        return simplify_width(self.width_type, self.width_amount)
+
+    @property
+    def valign(self) -> VAlign | tuple[Literal[WHSettings.RELATIVE], int]:
+        return simplify_valign(self.valign_type, self.valign_amount)
+
+    @property
+    def height(
+        self,
+    ) -> (
+        int
+        | Literal[WHSettings.FLOW, WHSettings.PACK]
+        | tuple[Literal[WHSettings.RELATIVE], int]
+        | tuple[Literal[WHSettings.WEIGHT], int | float]
+    ):
+        return simplify_height(self.height_type, self.height_amount)
 
     @staticmethod
     def options(

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/padding.py

@@ -20,6 +20,8 @@ from .constants import (
 from .widget_decoration import WidgetDecoration, WidgetError, WidgetWarning
 
 if typing.TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from typing_extensions import Literal
 
 WrappedWidget = typing.TypeVar("WrappedWidget")
@@ -184,6 +186,14 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
         }
         return remove_defaults(attrs, Padding.__init__)
 
+    def __rich_repr__(self) -> Iterator[tuple[str | None, typing.Any] | typing.Any]:
+        yield "w", self.original_widget
+        yield "align", self.align
+        yield "width", self.width
+        yield "min_width", self.min_width
+        yield "left", self.left
+        yield "right", self.right
+
     @property
     def align(
         self,

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/pile.py

@@ -6,6 +6,7 @@ from itertools import chain, repeat
 
 from urwid.canvas import CanvasCombine, CompositeCanvas, SolidCanvas
 from urwid.command_map import Command
+from urwid.split_repr import remove_defaults
 from urwid.util import is_mouse_press
 
 from .constants import Sizing, WHSettings
@@ -14,7 +15,7 @@ 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
 
@@ -58,39 +59,39 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         # BOX-only widget
         >>> Pile((SolidFill("#"),))
-        <Pile box widget with 1 item>
+        <Pile box widget (1 item)>
 
         # GIVEN BOX -> BOX/FLOW
         >>> Pile(((10, SolidFill("#")),))
-        <Pile box/flow widget with 1 item>
+        <Pile box/flow widget (1 item)>
 
         # FLOW-only
         >>> Pile((ProgressBar(None, None),))
-        <Pile flow widget with 1 item>
+        <Pile flow widget (1 item)>
 
         # FIXED -> FIXED
         >>> Pile(((WHSettings.PACK, BigText("0", font)),))
-        <Pile fixed widget with 1 item>
+        <Pile fixed widget (1 item)>
 
         # FLOW/FIXED -> FLOW/FIXED
         >>> Pile(((WHSettings.PACK, Text("text")),))
-        <Pile fixed/flow widget with 1 item>
+        <Pile fixed/flow widget (1 item)>
 
         # FLOW + FIXED widgets -> FLOW/FIXED
         >>> Pile((ProgressBar(None, None), (WHSettings.PACK, BigText("0", font))))
-        <Pile fixed/flow widget with 2 items>
+        <Pile fixed/flow widget (2 items) focus_item=0>
 
         # GIVEN BOX + FIXED widgets -> BOX/FLOW/FIXED (GIVEN BOX allows overriding its height & allows any width)
         >>> Pile(((10, SolidFill("#")), (WHSettings.PACK, BigText("0", font))))
-        <Pile widget with 2 items>
+        <Pile widget (2 items) focus_item=0>
 
         # Invalid sizing combination -> use fallback settings (and produce warning)
         >>> Pile(((WHSettings.WEIGHT, 1, BigText("0", font)),))
-        <Pile box/flow widget with 1 item>
+        <Pile box/flow widget (1 item)>
 
         # Special case: empty pile widget sizing is impossible to calculate
         >>> Pile(())
-        <Pile box/flow widget without contents>
+        <Pile box/flow widget ()>
         """
         if not self.contents:
             return frozenset((Sizing.BOX, Sizing.FLOW))
@@ -233,10 +234,40 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
     def _repr_words(self) -> list[str]:
         if len(self.contents) > 1:
-            return [*super()._repr_words(), f"with {len(self.contents)} items"]
-        if self.contents:
-            return [*super()._repr_words(), "with 1 item"]
-        return [*super()._repr_words(), "without contents"]
+            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(), "focus_item": self.focus_position if len(self._contents) > 1 else None}
+        return remove_defaults(attrs, Pile.__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]
+        ] = []
+
+        for w_instance, (sizing, amount) in self._contents:
+            if sizing == WHSettings.GIVEN:
+                widget_list.append((amount, w_instance))
+            elif sizing == WHSettings.PACK:
+                widget_list.append((WHSettings.PACK, w_instance))
+            elif sizing == WHSettings.WEIGHT:
+                if amount == 1:
+                    widget_list.append(w_instance)
+                else:
+                    widget_list.append((WHSettings.WEIGHT, amount, w_instance))
+
+        yield "widget_list", widget_list
+        yield "focus_item", self.focus_position if self._contents else None
+
+    def __len__(self) -> int:
+        return len(self._contents)
 
     def _contents_modified(self) -> None:
         """Recalculate whether this widget should be selectable whenever the contents has been changed."""

{urwid-2.6.5 → urwid-2.6.6}/urwid/widget/widget.py

@@ -391,7 +391,7 @@ class Widget(metaclass=WidgetMeta):
         """
         if not size:
             if Sizing.FIXED in self.sizing():
-                raise NotImplementedError("Fixed widgets must override Widget.pack()")
+                raise NotImplementedError(f"{self!r} must override Widget.pack()")
             raise WidgetError(f"Cannot pack () size, this is not a fixed widget: {self!r}")
 
         if len(size) == 1:

{urwid-2.6.5 → urwid-2.6.6}/urwid.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: urwid
-Version: 2.6.5
+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>