urwid 2.6.15__py3-none-any.whl → 3.0.0__py3-none-any.whl

urwid/widget/padding.py

@@ -215,24 +215,6 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
         self._align_type, self._align_amount = normalize_align(align, PaddingError)
         self._invalidate()
 
-    def _get_align(self) -> Literal["left", "center", "right"] | tuple[Literal["relative"], int]:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._get_align` is deprecated, "
-            f"please use property `{self.__class__.__name__}.align`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.align
-
-    def _set_align(self, align: Literal["left", "center", "right"] | tuple[Literal["relative"], int]) -> None:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._set_align` is deprecated, "
-            f"please use property `{self.__class__.__name__}.align`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.align = align
-
     @property
     def width(
         self,
@@ -261,24 +243,6 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
         self._width_type, self._width_amount = normalize_width(width, PaddingError)
         self._invalidate()
 
-    def _get_width(self) -> Literal["clip", "pack"] | int | tuple[Literal["relative"], int]:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._get_width` is deprecated, "
-            f"please use property `{self.__class__.__name__}.width`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.width
-
-    def _set_width(self, width: Literal["clip", "pack"] | int | tuple[Literal["relative"], int]) -> None:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._set_width` is deprecated, "
-            f"please use property `{self.__class__.__name__}.width`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.width = width
-
     def pack(
         self,
         size: tuple[()] | tuple[int] | tuple[int, int] = (),
@@ -339,9 +303,9 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
                     PaddingWarning,
                     stacklevel=3,
                 )
-            canv = self._original_widget.render((maxcol,) + size[1:], focus)
+            canv = self._original_widget.render((maxcol, *size[1:]), focus)
         elif self._width_type == WHSettings.GIVEN:
-            canv = self._original_widget.render((self._width_amount,) + size[1:], focus)
+            canv = self._original_widget.render((self._width_amount, *size[1:]), focus)
         else:
             canv = self._original_widget.render((), focus)
 
@@ -439,7 +403,7 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
         """Pass keypress to self._original_widget."""
         left, right = self.padding_values(size, True)
         if size:
-            maxvals = (size[0] - left - right,) + size[1:]
+            maxvals = (size[0] - left - right, *size[1:])
             return self._original_widget.keypress(maxvals, key)
         return self._original_widget.keypress((), key)
 
@@ -450,18 +414,17 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
 
         left, right = self.padding_values(size, True)
         if size:
-            maxvals = (size[0] - left - right,) + size[1:]
+            maxvals = (size[0] - left - right, *size[1:])
             if maxvals[0] == 0:
                 return None
         else:
             maxvals = ()
 
-        coords = self._original_widget.get_cursor_coords(maxvals)
-        if coords is None:
-            return None
+        if (coords := self._original_widget.get_cursor_coords(maxvals)) is not None:
+            x, y = coords
+            return x + left, y
 
-        x, y = coords
-        return x + left, y
+        return None
 
     def move_cursor_to_coords(
         self,
@@ -479,7 +442,7 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
         left, right = self.padding_values(size, True)
         if size:
             maxcol = size[0]
-            maxvals = (maxcol - left - right,) + size[1:]
+            maxvals = (maxcol - left - right, *size[1:])
         else:
             maxcol = self.pack((), True)[0]
             maxvals = ()
@@ -511,7 +474,7 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
             maxcol = size[0]
             if col < left or col >= maxcol - right:
                 return False
-            maxvals = (maxcol - left - right,) + size[1:]
+            maxvals = (maxcol - left - right, *size[1:])
         else:
             maxvals = ()
 
@@ -524,7 +487,7 @@ class Padding(WidgetDecoration[WrappedWidget], typing.Generic[WrappedWidget]):
 
         left, right = self.padding_values(size, True)
         if size:
-            maxvals = (size[0] - left - right,) + size[1:]
+            maxvals = (size[0] - left - right, *size[1:])
         else:
             maxvals = ()
 

urwid/widget/pile.py

@@ -135,8 +135,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
             if not flag & box_flow_fixed:
                 warnings.warn(
-                    f"Sizing combination of widget {idx} not supported: "
-                    f"{size_kind.name} {'|'.join(w_sizing).upper()}",
+                    f"Sizing combination of widget {idx} not supported: {size_kind.name} {'|'.join(w_sizing).upper()}",
                     PileWarning,
                     stacklevel=3,
                 )
@@ -302,8 +301,9 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             standard container property :attr:`contents`.
         """
         warnings.warn(
-            "only for backwards compatibility. You should use the new standard container property `contents`",
-            PendingDeprecationWarning,
+            "only for backwards compatibility. You should use the new standard container property `contents`."
+            "API will be removed in version 5.0.",
+            DeprecationWarning,
             stacklevel=2,
         )
         ml = MonitoredList(w for w, t in self.contents)
@@ -325,7 +325,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 chain(self.contents, repeat((None, (WHSettings.WEIGHT, 1)))),
             )
         ]
-        if focus_position < len(widgets):  # pylint: disable=consider-using-max-builtin  # pylint bug
+        if focus_position < len(widgets):
             self.focus_position = focus_position
 
     @property
@@ -337,8 +337,9 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             standard container property :attr:`contents`.
         """
         warnings.warn(
-            "only for backwards compatibility. You should use the new standard container property `contents`",
-            PendingDeprecationWarning,
+            "only for backwards compatibility. You should use the new standard container property `contents`."
+            "API will be removed in version 5.0.",
+            DeprecationWarning,
             stacklevel=2,
         )
         ml = MonitoredList(
@@ -356,8 +357,9 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
     @item_types.setter
     def item_types(self, item_types):
         warnings.warn(
-            "only for backwards compatibility. You should use the new standard container property `contents`",
-            PendingDeprecationWarning,
+            "only for backwards compatibility. You should use the new standard container property `contents`."
+            "API will be removed in version 5.0.",
+            DeprecationWarning,
             stacklevel=2,
         )
         focus_position = self.focus_position
@@ -365,7 +367,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             (w, ({Sizing.FIXED: WHSettings.GIVEN, Sizing.FLOW: WHSettings.PACK}.get(new_t, new_t), new_height))
             for ((new_t, new_height), (w, options)) in zip(item_types, self.contents)
         ]
-        if focus_position < len(item_types):  # pylint: disable=consider-using-max-builtin  # pylint bug
+        if focus_position < len(item_types):
             self.focus_position = focus_position
 
     @property
@@ -468,17 +470,6 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 return
         raise ValueError(f"Widget not found in Pile contents: {item!r}")
 
-    def _get_focus(self) -> Widget:
-        warnings.warn(
-            f"method `{self.__class__.__name__}._get_focus` is deprecated, "
-            f"please use `{self.__class__.__name__}.focus` property",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        if not self.contents:
-            return None
-        return self.contents[self.focus_position][0]
-
     def get_focus(self) -> Widget | None:
         """
         Return the widget in focus, for backwards compatibility.  You may
@@ -487,8 +478,9 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """
         warnings.warn(
             "for backwards compatibility."
-            "You may also use the new standard container property .focus to get the child widget in focus.",
-            PendingDeprecationWarning,
+            "You may also use the new standard container property .focus to get the child widget in focus."
+            "API will be removed in version 5.0.",
+            DeprecationWarning,
             stacklevel=2,
         )
         if not self.contents:
@@ -498,8 +490,9 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
     def set_focus(self, item: Widget | int) -> None:
         warnings.warn(
             "for backwards compatibility."
-            "You may also use the new standard container property .focus to get the child widget in focus.",
-            PendingDeprecationWarning,
+            "You may also use the new standard container property .focus to get the child widget in focus."
+            "API will be removed in version 5.0.",
+            DeprecationWarning,
             stacklevel=2,
         )
         if isinstance(item, int):
@@ -516,7 +509,8 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         warnings.warn(
             "only for backwards compatibility."
             "You should use the new standard container properties "
-            "`focus` and `focus_position` to get the child widget in focus or modify the focus position.",
+            "`focus` and `focus_position` to get the child widget in focus or modify the focus position."
+            "API will be removed in version 4.0.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -527,7 +521,8 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         warnings.warn(
             "only for backwards compatibility."
             "You should use the new standard container properties "
-            "`focus` and `focus_position` to get the child widget in focus or modify the focus position.",
+            "`focus` and `focus_position` to get the child widget in focus or modify the focus position."
+            "API will be removed in version 4.0.",
             DeprecationWarning,
             stacklevel=2,
         )
@@ -557,36 +552,6 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             raise IndexError(f"No Pile child widget at position {position}").with_traceback(exc.__traceback__) from exc
         self.contents.focus = position
 
-    def _get_focus_position(self) -> int | None:
-        warnings.warn(
-            f"method `{self.__class__.__name__}._get_focus_position` is deprecated, "
-            f"please use `{self.__class__.__name__}.focus_position` property",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        if not self.contents:
-            raise IndexError("No focus_position, Pile is empty")
-        return self.contents.focus
-
-    def _set_focus_position(self, position: int) -> None:
-        """
-        Set the widget in focus.
-
-        position -- index of child widget to be made focus
-        """
-        warnings.warn(
-            f"method `{self.__class__.__name__}._set_focus_position` is deprecated, "
-            f"please use `{self.__class__.__name__}.focus_position` property",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        try:
-            if position < 0 or position >= len(self.contents):
-                raise IndexError(f"No Pile child widget at position {position}")
-        except TypeError as exc:
-            raise IndexError(f"No Pile child widget at position {position}").with_traceback(exc.__traceback__) from exc
-        self.contents.focus = position
-
     def get_pref_col(self, size: tuple[()] | tuple[int] | tuple[int, int]) -> int | None:
         """Return the preferred column for the cursor, or None."""
         if not self.selectable():
@@ -609,6 +574,12 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """
         Return a size appropriate for passing to self.contents[i][0].render
         """
+        warnings.warn(
+            "get_item_size is going to be deprecated and can be removed soon."
+            "This method is not used by the urwid codebase and `get_rows_sizes` is used for the similar purposes.",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
         _w, (f, height) = self.contents[i]
         if f == WHSettings.PACK:
             if not size:
@@ -637,6 +608,10 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         self,
         focus: bool = False,
     ) -> tuple[Sequence[int], Sequence[int], Sequence[tuple[int] | tuple[()]]]:
+        """Get rows widths, heights and render size parameters
+
+        Fixed case expect widget sizes calculation with several cycles for unknown height cases.
+        """
         if not self.contents:
             return (), (), ()
 
@@ -728,6 +703,55 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
             tuple(w_h_args[idx] for idx in range(len(w_h_args))),
         )
 
+    def _get_flow_rows_sizes(
+        self,
+        size: tuple[int],
+        focus: bool = False,
+    ) -> tuple[Sequence[int], Sequence[int], Sequence[tuple[int] | tuple[()]]]:
+        """Get rows widths, heights and render size parameters
+
+        Flow case is the simplest one: minimum cycles in the logic and no widgets manipulation.
+        Here we can make some shortcuts
+        """
+        maxcol = size[0]
+        if not self.contents:
+            return (maxcol,), (0,), ()
+
+        widths: Sequence[int] = (maxcol,) * len(self.contents)
+        heights: list[int] = []
+        w_h_args: list[tuple[int, int] | tuple[int] | tuple[()]] = []
+        focus_position = self.focus_position
+
+        for i, (w, (f, height)) in enumerate(self.contents):
+            if isinstance(w, Widget):
+                w_sizing = w.sizing()
+            else:
+                warnings.warn(f"{w!r} is not a Widget", PileWarning, stacklevel=3)
+                w_sizing = frozenset((Sizing.FLOW, Sizing.BOX))
+
+            focused = focus and i == focus_position
+
+            if f == WHSettings.GIVEN:
+                heights.append(height)
+                w_h_args.append((maxcol, height))
+            elif Sizing.FLOW in w_sizing:
+                heights.append(w.rows((maxcol,), focus=focused))
+                w_h_args.append((maxcol,))
+            elif Sizing.FIXED in w_sizing and f == WHSettings.PACK:
+                heights.append(w.pack((), focused)[1])
+                w_h_args.append(())
+            else:
+                warnings.warn(
+                    f"Unusual widget {i} sizing {w_sizing} for {f.upper()}). "
+                    f"Assuming wrong sizing and using {Sizing.FLOW.upper()} for height calculation",
+                    PileWarning,
+                    stacklevel=3,
+                )
+                heights.append(w.rows((maxcol,), focus=focused))
+                w_h_args.append((maxcol,))
+
+        return (widths, tuple(heights), tuple(w_h_args))
+
     def get_rows_sizes(
         self,
         size: tuple[int, int] | tuple[int] | tuple[()],
@@ -736,13 +760,20 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         """Get rows widths, heights and render size parameters"""
         if not size:
             return self._get_fixed_rows_sizes(focus=focus)
+        if len(size) == 1:
+            return self._get_flow_rows_sizes(size, focus=focus)
 
-        maxcol = size[0]
-        item_rows = None
+        maxcol, maxrow = size
+        if not self.contents:
+            return (maxcol,), (maxrow,), ()
 
-        widths: list[int] = []
-        heights: list[int] = []
-        w_h_args: list[tuple[int, int] | tuple[int] | tuple[()]] = []
+        remaining: int = maxrow
+
+        widths: Sequence[int] = (maxcol,) * len(self.contents)
+        heights: dict[int, int] = {}
+        weighted: dict[int, int] = {}
+        w_h_args: dict[int, tuple[int, int] | tuple[int] | tuple[()]] = {}
+        focus_position = self.focus_position
 
         for i, (w, (f, height)) in enumerate(self.contents):
             if isinstance(w, Widget):
@@ -751,12 +782,12 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 warnings.warn(f"{w!r} is not a Widget", PileWarning, stacklevel=3)
                 w_sizing = frozenset((Sizing.FLOW, Sizing.BOX))
 
-            item_focus = focus and self.focus == w
-            widths.append(maxcol)
+            focused = focus and i == focus_position
 
             if f == WHSettings.GIVEN:
-                heights.append(height)
-                w_h_args.append((maxcol, height))
+                heights[i] = height
+                w_h_args[i] = (maxcol, height)
+                remaining -= height
             elif f == WHSettings.PACK or len(size) == 1:
                 if Sizing.FLOW in w_sizing:
                     w_h_arg: tuple[int] | tuple[()] = (maxcol,)
@@ -771,16 +802,72 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                     )
                     w_h_arg = (maxcol,)
 
-                heights.append(w.pack(w_h_arg, item_focus)[1])
-                w_h_args.append(w_h_arg)
+                item_height = w.pack(w_h_arg, focused)[1]
+                heights[i] = item_height
+                w_h_args[i] = w_h_arg
+                remaining -= item_height
+            elif height:
+                weighted[i] = height
             else:
-                if item_rows is None:
-                    item_rows = self.get_item_rows(size, focus)
-                rows = item_rows[i]
-                heights.append(rows)
-                w_h_args.append((maxcol, rows))
+                heights[i] = 0
+                w_h_args[i] = (maxcol, 0)  # zero-weighted items treated as ('given', 0)
+
+        sum_weight = sum(weighted.values())
+        if remaining <= 0 and focus_position in weighted:
+            # We need to hide some widgets: focused part will be not displayed by default
+            # At this place we have to operate also negative "remaining" to be sure that widget really fit
+            before = []
+            after = []
+            for idx, height in heights.items():
+                if height:
+                    if idx < focus_position:
+                        before.append(idx)
+                    else:
+                        after.append(idx)
+
+            # Try to move to the center
+            offset = len(before) - len(after)
+            if not offset:
+                indexes = (element for pair in zip(after[::-1], before) for element in pair)
+            elif offset > 0:
+                indexes = (
+                    *before[:offset],
+                    *(element for pair in zip(after[::-1], before[offset:]) for element in pair),
+                )
+            else:
+                indexes = (
+                    *after[-1 : offset - 1 : -1],
+                    *(element for pair in zip(after[offset - 1 :: -1], before) for element in pair),
+                )
+
+            for idx in indexes:
+                height, heights[idx] = heights[idx], 0
+                remaining += height
+                if remaining > 0:
+                    break
+
+        remaining = max(remaining, 0)
+
+        for idx in sorted(weighted, key=lambda idx: (idx != focus_position, idx)):
+            # We have to sort weighted items way that focused widget will gain render priority
+            if remaining == 0:
+                rows = 0
+            else:
+                rows = int(float(remaining) * weighted[idx] / sum_weight + 0.5)
+                if not rows and idx == focus_position:
+                    # Special case: we have to force as minimum 1 row for focused widget to prevent broken behaviour
+                    rows = 1
+                remaining -= rows
+                sum_weight -= weighted[idx]
 
-        return (tuple(widths), tuple(heights), tuple(w_h_args))
+            heights[idx] = rows
+            w_h_args[idx] = (maxcol, rows)
+
+        return (
+            widths,
+            tuple(heights[idx] for idx in range(len(heights))),
+            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]:
         """Get packed sized for widget."""
@@ -789,74 +876,12 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         widths, heights, _ = self.get_rows_sizes(size, focus)
         return (max(widths), sum(heights))
 
-    def get_item_rows(self, size: tuple[()] | tuple[int] | tuple[int, int], focus: bool) -> list[int]:
-        """
-        Return a list of the number of rows used by each widget in self.contents
-        """
-        remaining = None
-        maxcol = size[0]
-        if len(size) == 2:
-            remaining = size[1]
-
-        rows_numbers = []
+    def get_item_rows(self, size: tuple[int] | tuple[int, int], focus: bool) -> list[int]:
+        """A list of the number of rows used by each widget in self.contents.
 
-        if remaining is None:
-            # pile is a flow widget
-            for i, (w, (f, height)) in enumerate(self.contents):
-                if isinstance(w, Widget):
-                    w_sizing = w.sizing()
-                else:
-                    warnings.warn(f"{w!r} is not a Widget", PileWarning, stacklevel=3)
-                    w_sizing = frozenset((Sizing.FLOW, Sizing.BOX))
-
-                focused = focus and self.focus == w
-
-                if f == WHSettings.GIVEN:
-                    rows_numbers.append(height)
-                elif Sizing.FLOW in w_sizing:
-                    rows_numbers.append(w.rows((maxcol,), focus=focused))
-                elif Sizing.FIXED in w_sizing and f == WHSettings.PACK:
-                    rows_numbers.append(w.pack((), focused)[0])
-                else:
-                    warnings.warn(
-                        f"Unusual widget {i} sizing {w_sizing} for {f.upper()}). "
-                        f"Assuming wrong sizing and using {Sizing.FLOW.upper()} for height calculation",
-                        PileWarning,
-                        stacklevel=3,
-                    )
-                    rows_numbers.append(w.rows((maxcol,), focus=focused))
-            return rows_numbers
-
-        # pile is a box widget
-        # do an extra pass to calculate rows for each widget
-        wtotal = 0
-        for w, (f, height) in self.contents:
-            if f == WHSettings.PACK:
-                rows = w.rows((maxcol,), focus=focus and self.focus == w)
-                rows_numbers.append(rows)
-                remaining -= rows
-            elif f == WHSettings.GIVEN:
-                rows_numbers.append(height)
-                remaining -= height
-            elif height:
-                rows_numbers.append(None)
-                wtotal += height
-            else:
-                rows_numbers.append(0)  # zero-weighted items treated as ('given', 0)
-
-        if wtotal == 0:
-            raise PileError("No weighted widgets found for Pile treated as a box widget")
-
-        remaining = max(remaining, 0)
-
-        for i, (_w, (_f, height)) in enumerate(self.contents):
-            li = rows_numbers[i]
-            if li is None:
-                rows = int(float(remaining) * height / wtotal + 0.5)
-                rows_numbers[i] = rows
-                remaining -= rows
-                wtotal -= height
-        return rows_numbers
+        This method is a normally used only by `get_item_size` for the BOX case..
+        """
+        return list(self.get_rows_sizes(size, focus)[1])
 
     def render(
         self,
@@ -876,7 +901,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
                 combinelist.append((canv, i, item_focus))
 
         if not combinelist:
-            return SolidCanvas(" ", size[0], (size[1:] + (0,))[0])
+            return SolidCanvas(" ", size[0], (*size[1:], 0)[0])
 
         out = CanvasCombine(combinelist)
         if len(size) == 2 and size[1] != out.rows():
@@ -894,18 +919,17 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
 
         i = self.focus_position
         _widths, heights, size_args = self.get_rows_sizes(size, focus=True)
-        coords = self.focus.get_cursor_coords(size_args[i])
+        if (coords := self.focus.get_cursor_coords(size_args[i])) is not None:
+            x, y = coords
+            if i > 0:
+                y += sum(heights[:i])
 
-        if coords is None:
-            return None
-        x, y = coords
-        if i > 0:
-            for r in heights[:i]:
-                y += r
-        return x, y
+            return x, y
 
-    def rows(self, size: tuple[int] | tuple[int, int], focus: bool = False) -> int:
-        return sum(self.get_item_rows(size, focus))
+        return None
+
+    def rows(self, size: tuple[int], focus: bool = False) -> int:
+        return sum(self.get_rows_sizes(size, focus)[1])
 
     def keypress(self, size: tuple[()] | tuple[int] | tuple[int, int], key: str) -> str | None:
         """Pass the keypress to the widget in focus.
@@ -955,8 +979,7 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         if not hasattr(self.focus, "get_pref_col"):
             return
 
-        pref_col = self.focus.get_pref_col(w_size)
-        if pref_col is not None:
+        if (pref_col := self.focus.get_pref_col(w_size)) is not None:
             self.pref_col = pref_col
 
     def move_cursor_to_coords(
@@ -982,10 +1005,8 @@ class Pile(Widget, WidgetContainerMixin, WidgetContainerListContentsMixin):
         if not w.selectable():
             return False
 
-        if hasattr(w, "move_cursor_to_coords"):
-            rval = w.move_cursor_to_coords(w_size, col, row - wrow)
-            if rval is False:
-                return False
+        if hasattr(w, "move_cursor_to_coords") and w.move_cursor_to_coords(w_size, col, row - wrow) is False:
+            return False
 
         self.focus_position = i
         return True

urwid/widget/popup.py

@@ -98,8 +98,8 @@ class PopUpTarget(WidgetDecoration[WrappedWidget]):
     def _update_overlay(self, size: tuple[int, int], focus: bool) -> None:
         canv = self._original_widget.render(size, focus=focus)
         self._cache_original_canvas = canv  # imperfect performance hack
-        pop_up = canv.get_pop_up()
-        if pop_up:
+
+        if pop_up := canv.get_pop_up():
             left, top, (w, overlay_width, overlay_height) = pop_up
             if self._pop_up != w:
                 self._pop_up = w

urwid/widget/progress_bar.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import typing
-import warnings
 
 from .constants import BAR_SYMBOLS, Align, Sizing, WrapMode
 from .text import Text
 from .widget import Widget
 
 if typing.TYPE_CHECKING:
+    from collections.abc import Hashable
+
     from urwid.canvas import TextCanvas
 
 
@@ -18,7 +19,14 @@ class ProgressBar(Widget):
 
     text_align = Align.CENTER
 
-    def __init__(self, normal, complete, current: int = 0, done: int = 100, satt=None):
+    def __init__(
+        self,
+        normal: Hashable | None,
+        complete: Hashable | None,
+        current: int = 0,
+        done: int = 100,
+        satt: Hashable | None = None,
+    ) -> None:
         """
         :param normal: display attribute for incomplete part of progress bar
         :param complete: display attribute for complete part of progress bar
@@ -86,15 +94,6 @@ class ProgressBar(Widget):
         self._done = done
         self._invalidate()
 
-    def _set_done(self, done):
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._set_done` is deprecated, "
-            f"please use property `{self.__class__.__name__}.done`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.done = done
-
     def rows(self, size: tuple[int], focus: bool = False) -> int:
         return 1