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

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)
@@ -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
@@ -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,7 +1,6 @@
 from __future__ import annotations
 
 import typing
-import warnings
 
 from .constants import BAR_SYMBOLS, Align, Sizing, WrapMode
 from .text import Text
@@ -95,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
 

urwid/widget/scrollable.py

@@ -25,8 +25,6 @@ import contextlib
 import enum
 import typing
 
-from typing_extensions import Protocol, runtime_checkable
-
 from .constants import BOX_SYMBOLS, SHADE_SYMBOLS, Sizing
 from .widget_decoration import WidgetDecoration, WidgetError
 
@@ -84,8 +82,8 @@ class ScrollbarSymbols(str, enum.Enum):
     DRAWING_DOUBLE = BOX_SYMBOLS.DOUBLE.VERTICAL
 
 
-@runtime_checkable
-class WidgetProto(Protocol):
+@typing.runtime_checkable
+class WidgetProto(typing.Protocol):
     """Protocol for widget.
 
     Due to protocol cannot inherit non-protocol bases, define several obligatory Widget methods.
@@ -117,8 +115,8 @@ class WidgetProto(Protocol):
     def render(self, size: tuple[int, int], focus: bool = False) -> Canvas: ...
 
 
-@runtime_checkable
-class SupportsScroll(WidgetProto, Protocol):
+@typing.runtime_checkable
+class SupportsScroll(WidgetProto, typing.Protocol):
     """Scroll specific methods."""
 
     def get_scrollpos(self, size: tuple[int, int], focus: bool = False) -> int: ...
@@ -126,8 +124,8 @@ class SupportsScroll(WidgetProto, Protocol):
     def rows_max(self, size: tuple[int, int] | None = None, focus: bool = False) -> int: ...
 
 
-@runtime_checkable
-class SupportsRelativeScroll(WidgetProto, Protocol):
+@typing.runtime_checkable
+class SupportsRelativeScroll(WidgetProto, typing.Protocol):
     """Relative scroll-specific methods."""
 
     def require_relative_scroll(self, size: tuple[int, int], focus: bool = False) -> bool: ...
@@ -140,10 +138,7 @@ class SupportsRelativeScroll(WidgetProto, Protocol):
 def orig_iter(w: Widget) -> Iterator[Widget]:
     visited = {w}
     yield w
-    while hasattr(w, "original_widget"):
-        w = w.original_widget
-        if w in visited:
-            break
+    while (w := getattr(w, "original_widget", w)) not in visited:
         visited.add(w)
         yield w
 
@@ -194,8 +189,8 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
             first_visible = False
             for pwi, (w, _o) in enumerate(ow.contents):
                 wcanv = w.render((maxcol,))
-                wh = wcanv.rows()
-                if wh:
+
+                if wh := wcanv.rows():
                     ch += wh
 
                 if not last_hidden and ch >= self._trim_top:
@@ -235,17 +230,13 @@ class Scrollable(WidgetDecoration[WrappedWidget]):
         canv = canvas.CompositeCanvas(canv_full)
         canv_cols, canv_rows = canv.cols(), canv.rows()
 
-        if canv_cols <= maxcol:
-            pad_width = maxcol - canv_cols
-            if pad_width > 0:
-                # Canvas is narrower than available horizontal space
-                canv.pad_trim_left_right(0, pad_width)
+        if canv_cols <= maxcol and (pad_width := maxcol - canv_cols) > 0:
+            # Canvas is narrower than available horizontal space
+            canv.pad_trim_left_right(0, pad_width)
 
-        if canv_rows <= maxrow:
-            fill_height = maxrow - canv_rows
-            if fill_height > 0:
-                # Canvas is lower than available vertical space
-                canv.pad_trim_top_bottom(0, fill_height)
+        if canv_rows <= maxrow and (fill_height := maxrow - canv_rows) > 0:
+            # Canvas is lower than available vertical space
+            canv.pad_trim_top_bottom(0, fill_height)
 
         if canv_cols <= maxcol and canv_rows <= maxrow:
             # Canvas is small enough to fit without trimming
@@ -552,17 +543,18 @@ class ScrollBar(WidgetDecoration[WrappedWidget]):
                 use_relative = False
 
         if not use_relative:
-            ow_rows_max = ow_base.rows_max(size, focus)
-            if ow_rows_max <= maxrow:
+            if ow_base.rows_max(size, focus) > maxrow:
+                ow_canv = render_for_scrollbar()
+                # re-calculate using wrapped size
+                ow_rows_max = ow_base.rows_max(ow_size, focus)
+                pos = ow_base.get_scrollpos(ow_size, focus)
+                posmax = ow_rows_max - maxrow
+                thumb_weight = min(1.0, maxrow / max(1, ow_rows_max))
+
+            else:
                 # Canvas fits without scrolling - no scrollbar needed
                 return render_no_scrollbar()
 
-            ow_canv = render_for_scrollbar()
-            ow_rows_max = ow_base.rows_max(ow_size, focus)
-            pos = ow_base.get_scrollpos(ow_size, focus)
-            posmax = ow_rows_max - maxrow
-            thumb_weight = min(1.0, maxrow / max(1, ow_rows_max))
-
         # Thumb shrinks/grows according to the ratio of <number of visible lines> / <number of total lines>
         thumb_height = max(1, round(thumb_weight * maxrow))  # pylint: disable=possibly-used-before-assignment