urwid 2.6.5__tar.gz → 2.6.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: urwid
-Version: 2.6.5
+Version: 2.6.7
 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.7}/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.7}/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.7/tests/test_main_loop.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import concurrent.futures
+import os
+import socket
+import sys
+import threading
+import typing
+import unittest.mock
+
+import urwid
+
+if typing.TYPE_CHECKING:
+    from types import TracebackType
+
+IS_WINDOWS = sys.platform == "win32"
+
+
+class ClosingTemporaryFilesPair(typing.ContextManager[typing.Tuple[typing.TextIO, typing.TextIO]]):
+    """File pair context manager that closes temporary files on exit.
+
+    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")
+
+    def __init__(self) -> None:
+        self.rd_s: socket.socket | None = None
+        self.wr_s: socket.socket | None = None
+        self.rd_f: typing.TextIO | None = None
+        self.wr_f: typing.TextIO | None = None
+
+    def __enter__(self) -> tuple[typing.TextIO, typing.TextIO]:
+        self.rd_s, self.wr_s = socket.socketpair()
+        self.rd_f = os.fdopen(self.rd_s.fileno(), "r", encoding="utf-8", closefd=False)
+        self.wr_f = os.fdopen(self.wr_s.fileno(), "w", encoding="utf-8", closefd=False)
+        return self.rd_f, self.wr_f
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Close everything explicit without waiting for garbage collected."""
+        if self.rd_f is not None and not self.rd_f.closed:
+            self.rd_f.close()
+        if self.rd_s is not None:
+            self.rd_s.close()
+        if self.wr_f is not None and not self.wr_f.closed:
+            self.wr_f.close()
+        if self.wr_s is not None:
+            self.wr_s.close()
+
+
+def stop_screen_cb(*_args, **_kwargs) -> typing.NoReturn:
+    raise urwid.ExitMainLoop
+
+
+class TestMainLoop(unittest.TestCase):
+    @unittest.skipIf(IS_WINDOWS, "selectors for pipe are not supported on Windows")
+    def test_watch_pipe(self):
+        """Test watching pipe is stopped on explicit False only."""
+        evt = threading.Event()  # We need thread synchronization
+        outcome: list[bytes] = []
+
+        def pipe_cb(data: bytes) -> typing.Any:
+            outcome.append(data)
+
+            if not evt.is_set():
+                evt.set()
+
+            if data == b"false":
+                return False
+            if data == b"true":
+                return True
+            if data == b"null":
+                return None
+            return object()
+
+        def pipe_writer(fd: int) -> None:
+            os.write(fd, b"something")
+            if evt.wait(0.1):
+                evt.clear()
+                os.write(fd, b"true")
+            if evt.wait(0.1):
+                evt.clear()
+                os.write(fd, b"null")
+            if evt.wait(0.1):
+                evt.clear()
+                os.write(fd, b"false")
+
+        with ClosingTemporaryFilesPair() as (
+            rd_r,
+            wr_r,
+        ), ClosingTemporaryFilesPair() as (
+            rd_w,
+            wr_w,
+        ), concurrent.futures.ThreadPoolExecutor(
+            max_workers=1,
+        ) as executor, unittest.mock.patch(
+            "subprocess.Popen",  # we want to be sure that nothing outside is called
+            autospec=True,
+        ):
+            evl = urwid.MainLoop(
+                urwid.SolidFill(),
+                screen=urwid.display.raw.Screen(input=rd_r, output=wr_w),  # We need screen which support mocked IO
+                handle_mouse=False,  # Less external calls - better
+            )
+            evl.set_alarm_in(1, stop_screen_cb)
+            pipe_fd = evl.watch_pipe(pipe_cb)
+            executor.submit(pipe_writer, pipe_fd)
+
+            evl.run()
+            self.assertEqual([b"something", b"true", b"null", b"false"], outcome)
+            not_removed = evl.remove_watch_pipe(pipe_fd)
+            self.assertFalse(not_removed)

{urwid-2.6.5 → urwid-2.6.7}/urwid/event_loop/main_loop.py

@@ -190,7 +190,7 @@ class MainLoop:
         else:
             self._topmost_widget = self._widget
 
-    def _set_pop_ups(self, pop_ups) -> None:
+    def _set_pop_ups(self, pop_ups: bool) -> None:
         warnings.warn(
             f"method `{self.__class__.__name__}._set_pop_ups` is deprecated, "
             f"please use `{self.__class__.__name__}.pop_ups` property",
@@ -214,7 +214,7 @@ class MainLoop:
         """
         self.logger.debug(f"Setting alarm in {sec!r} seconds with callback {callback!r}")
 
-        def cb():
+        def cb() -> None:
             callback(self, user_data)
 
         return self.event_loop.alarm(sec, cb)
@@ -236,7 +236,7 @@ class MainLoop:
         sec = tm - time.time()
         self.logger.debug(f"Setting alarm in {sec!r} seconds with callback {callback!r}")
 
-        def cb():
+        def cb() -> None:
             callback(self, user_data)
 
         return self.event_loop.alarm(sec, cb)
@@ -250,33 +250,28 @@ class MainLoop:
 
     if not IS_WINDOWS:
 
-        def watch_pipe(self, callback: Callable[[bytes], bool]) -> int:
+        def watch_pipe(self, callback: Callable[[bytes], bool | None]) -> int:
             """
             Create a pipe for use by a subprocess or thread to trigger a callback
             in the process/thread running the main loop.
 
-            :param callback: function taking one parameter to call from within
-                             the process/thread running the main loop
+            :param callback: function taking one parameter to call from within the process/thread running the main loop
             :type callback: callable
 
-            This method returns a file descriptor attached to the write end of a
-            pipe. The read end of the pipe is added to the list of files
-            :attr:`event_loop` is watching. When data is written to the pipe the
-            callback function will be called and passed a single value containing
-            data read from the pipe.
+            This method returns a file descriptor attached to the write end of a pipe.
+            The read end of the pipe is added to the list of files :attr:`event_loop` is watching.
+            When data is written to the pipe the callback function will be called
+            and passed a single value containing data read from the pipe.
 
-            This method may be used any time you want to update widgets from
-            another thread or subprocess.
+            This method may be used any time you want to update widgets from another thread or subprocess.
 
-            Data may be written to the returned file descriptor with
-            ``os.write(fd, data)``. Ensure that data is less than 512 bytes (or 4K
-            on Linux) so that the callback will be triggered just once with the
-            complete value of data passed in.
+            Data may be written to the returned file descriptor with ``os.write(fd, data)``.
+            Ensure that data is less than 512 bytes (or 4K on Linux)
+            so that the callback will be triggered just once with the complete value of data passed in.
 
-            If the callback returns ``False`` then the watch will be removed from
-            :attr:`event_loop` and the read end of the pipe will be closed. You
-            are responsible for closing the write end of the pipe with
-            ``os.close(fd)``.
+            If the callback returns ``False`` then the watch will be removed from :attr:`event_loop`
+            and the read end of the pipe will be closed.
+            You are responsible for closing the write end of the pipe with ``os.close(fd)``.
             """
             import fcntl
 
@@ -286,7 +281,7 @@ class MainLoop:
 
             def cb() -> None:
                 data = os.read(pipe_rd, PIPE_BUFFER_READ_SIZE)
-                if not callback(data):
+                if callback(data) is False:
                     self.event_loop.remove_watch_file(watch_handle)
                     os.close(pipe_rd)
 
@@ -296,9 +291,9 @@ class MainLoop:
 
         def remove_watch_pipe(self, write_fd: int) -> bool:
             """
-            Close the read end of the pipe and remove the watch created by
-            :meth:`watch_pipe`. You are responsible for closing the write end of
-            the pipe.
+            Close the read end of the pipe and remove the watch created by :meth:`watch_pipe`.
+
+            ..note:: You are responsible for closing the write end of the pipe.
 
             Returns ``True`` if the watch pipe exists, ``False`` otherwise
             """

{urwid-2.6.5 → urwid-2.6.7}/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.7'
+__version_tuple__ = version_tuple = (2, 6, 7)

{urwid-2.6.5 → urwid-2.6.7}/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.7}/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.7}/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,12 +80,45 @@ 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()
 
     def _contents_modified(
-        self, slc, new_items: Iterable[tuple[Widget, tuple[Literal["given", WHSettings.GIVEN], int]]]
+        self,
+        _slc: tuple[int, int, int],
+        new_items: Iterable[tuple[Widget, tuple[Literal["given", WHSettings.GIVEN], int]]],
     ) -> None:
         for item in new_items:
             try:
@@ -258,7 +293,7 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
             return None
         return self.contents[self.focus_position][0]
 
-    def _get_focus(self) -> Widget:
+    def _get_focus(self) -> Widget | None:
         warnings.warn(
             f"method `{self.__class__.__name__}._get_focus` is deprecated, "
             f"please use `{self.__class__.__name__}.focus` property",
@@ -446,7 +481,7 @@ class GridFlow(WidgetWrap[Pile], WidgetContainerMixin, WidgetContainerListConten
 
             # Use width == maxcol in case of maxcol < width amount
             # Columns will use empty widget in case of GIVEN width > maxcol
-            c.contents.append((w, c.options(WHSettings.GIVEN, width_amount if width_amount <= maxcol else maxcol)))
+            c.contents.append((w, c.options(WHSettings.GIVEN, min(width_amount, maxcol))))
             if (i == self.focus_position) or (not column_focused and w.selectable()):
                 c.focus_position = len(c.contents) - 1
                 column_focused = True