urwid 4.0.6__tar.gz → 4.0.7__tar.gz

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

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

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

@@ -2,6 +2,23 @@
 Changelog
 ---------
 
+Urwid 4.0.7
+===========
+
+2026-07-24
+
+Bug fixes 🕷
+++++++++++++
+* Fix encoding handling by web display by @penguinolog in https://github.com/urwid/urwid/pull/1201
+Documentation 🕮
+++++++++++++++++
+* Typing: annotate `MainLoop` and `signals` by @penguinolog in https://github.com/urwid/urwid/pull/1199
+* Typing: fix `ListBox` expected widget API by @penguinolog in https://github.com/urwid/urwid/pull/1200
+* Typing: partial annotation for `treetools` by @penguinolog in https://github.com/urwid/urwid/pull/1197
+
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.6...4.0.7
+
 Urwid 4.0.6
 ===========
 

{urwid-4.0.6 → urwid-4.0.7}/docs/examples/graph.py

@@ -276,7 +276,7 @@ class GraphView(urwid.WidgetWrap):
     def exit_program(self, w) -> typing.NoReturn:
         raise urwid.ExitMainLoop()
 
-    def graph_controls(self):
+    def graph_controls(self) -> urwid.ListBox[int]:
         modes = self.controller.get_modes()
         # setup mode radio buttons
         self.mode_buttons = []

{urwid-4.0.6 → urwid-4.0.7}/docs/examples/real_browse.py

@@ -132,7 +132,7 @@ class DirectoryWidget(FlagFileWidget):
         return node.get_key()
 
 
-class FileNode(urwid.TreeNode):
+class FileNode(urwid.TreeNode[str]):
     """Metadata storage for individual files"""
 
     def __init__(self, path: str, parent: urwid.ParentNode | None = None) -> None:

{urwid-4.0.6 → urwid-4.0.7}/docs/examples/real_edit.py

@@ -38,7 +38,7 @@ import typing
 import urwid
 
 
-class LineWalker(urwid.ListWalker):
+class LineWalker(urwid.ListWalker[int, urwid.Edit]):
     """ListWalker-compatible class for lazily reading file contents."""
 
     def __init__(self, name: str) -> None:

{urwid-4.0.6 → urwid-4.0.7}/examples/browse.py

@@ -132,7 +132,7 @@ class DirectoryWidget(FlagFileWidget):
         return node.get_key()
 
 
-class FileNode(urwid.TreeNode):
+class FileNode(urwid.TreeNode[str]):
     """Metadata storage for individual files"""
 
     def __init__(self, path: str, parent: urwid.ParentNode | None = None) -> None:

{urwid-4.0.6 → urwid-4.0.7}/examples/calc.py

@@ -225,7 +225,7 @@ class ParentEdit(urwid.Edit):
         return key
 
 
-class CellWalker(urwid.ListWalker):
+class CellWalker(urwid.ListWalker[tuple[int, int], urwid.Divider | urwid.AttrMap[urwid.IntEdit] | urwid.Text]):
     def __init__(self, content: Iterable[Cell]) -> None:
         self.content = urwid.MonitoredList(content)
         self.content.set_modified_callback(self._modified)

{urwid-4.0.6 → urwid-4.0.7}/examples/edit.py

@@ -38,7 +38,7 @@ import typing
 import urwid
 
 
-class LineWalker(urwid.ListWalker):
+class LineWalker(urwid.ListWalker[int, urwid.Edit]):
     """ListWalker-compatible class for lazily reading file contents."""
 
     def __init__(self, name: str) -> None:

{urwid-4.0.6 → urwid-4.0.7}/examples/fib.py

@@ -37,7 +37,7 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
 
-class FibonacciWalker(urwid.ListWalker):
+class FibonacciWalker(urwid.ListWalker[tuple[int, int], urwid.Text]):
     """ListWalker-compatible class for browsing fibonacci set.
 
     positions returned are (value at position-1, value at position) tuples.

{urwid-4.0.6 → urwid-4.0.7}/examples/graph.py

@@ -276,7 +276,7 @@ class GraphView(urwid.WidgetWrap):
     def exit_program(self, w) -> typing.NoReturn:
         raise urwid.ExitMainLoop()
 
-    def graph_controls(self):
+    def graph_controls(self) -> urwid.ListBox[int]:
         modes = self.controller.get_modes()
         # setup mode radio buttons
         self.mode_buttons = []

{urwid-4.0.6 → urwid-4.0.7}/examples/treesample.py

@@ -55,14 +55,14 @@ class ExampleTreeWidget(urwid.TreeWidget):
         return self.get_node().get_value()["name"]
 
 
-class ExampleNode(urwid.TreeNode):
+class ExampleNode(urwid.TreeNode[str | None]):
     """Data storage object for leaf nodes"""
 
     def load_widget(self) -> ExampleTreeWidget:
         return ExampleTreeWidget(self)
 
 
-class ExampleParentNode(urwid.ParentNode):
+class ExampleParentNode(urwid.ParentNode[SampleTree]):
     """Data storage object for interior/parent nodes"""
 
     def load_widget(self) -> ExampleTreeWidget:

{urwid-4.0.6 → urwid-4.0.7}/pyproject.toml

@@ -289,6 +289,14 @@ disable_error_code = [
   "union-attr", # chacking for started state before each operation if too expensive
 ]
 [[tool.mypy.overrides]]
+module = "urwid.widget.constants"
+disable_error_code = [
+  # False positive: plain-string `Literal`s (e.g. "relative") are reported as overlapping
+  # sibling `str`-based enums (`Align`/`VAlign`) in the size/alignment overloads, even though
+  # the underlying values are disjoint. The public API must accept both string and enum forms.
+  "overload-overlap",
+]
+[[tool.mypy.overrides]]
 module = [ "gi.*", "serial.*", "trio.*" ]
 ignore_missing_imports = true
 

{urwid-4.0.6 → urwid-4.0.7}/urwid/display/web.py

@@ -38,6 +38,7 @@ import sys
 import tempfile
 import typing
 from contextlib import suppress
+from email.message import Message
 
 from urwid.str_util import calc_text_pos, calc_width, move_next_char
 from urwid.util import StoppingContext, get_encoding
@@ -264,7 +265,7 @@ class Screen(BaseScreen):
         self._started = False
 
     def set_input_timeouts(self, *args: typing.Any) -> None:
-        pass
+        """Not supported for web display."""
 
     def _close_connection(self) -> None:
         if self.update_method == "polling child":
@@ -501,6 +502,12 @@ def is_web_request() -> bool:
     return "REQUEST_METHOD" in os.environ
 
 
+def _request_charset() -> str:
+    content_type = Message()
+    content_type["content-type"] = os.environ.get("CONTENT_TYPE", "")
+    return content_type.get_content_charset() or "utf-8"
+
+
 def handle_short_request() -> bool:
     """
     Handle short requests such as passing keystrokes to the application
@@ -541,16 +548,23 @@ def handle_short_request() -> bool:
 
     if os.environ.get("HTTP_X_URWID_METHOD", None) == "polling":
         # this is a screen update request
-        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         try:
-            s.connect(os.path.join(_prefs.pipe_dir, f"urwid_{urwid_id}.update"))
-            data = f"Content-type: text/plain\r\n\r\n{s.recv(BUF_SZ).decode('utf-8')}"
-            while data:
-                sys.stdout.write(data)
-                data = s.recv(BUF_SZ).decode("utf-8")
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+                s.connect(os.path.join(_prefs.pipe_dir, f"urwid_{urwid_id}.update"))
+                chunks = []
+                while data := s.recv(BUF_SZ):
+                    chunks.append(data)
         except OSError:
             sys.stdout.write("Status: 404 Not Found\r\n\r\n")
             return True
+
+        try:
+            decoded = b"".join(chunks).decode("utf-8")
+        except UnicodeDecodeError:
+            sys.stdout.write("Status: 502 Bad Gateway\r\n\r\n")
+            return True
+
+        sys.stdout.write(f"Content-type: text/plain; charset=utf-8\r\n\r\n{decoded}")
         return True
 
     # this is a keyboard input request
@@ -560,10 +574,17 @@ def handle_short_request() -> bool:
         sys.stdout.write("Status: 404 Not Found\r\n\r\n")
         return True
 
-    # FIXME: use the correct encoding based on the request
-    keydata = sys.stdin.read(MAX_READ)
-    os.write(fd, keydata.encode("ascii"))
-    os.close(fd)
+    try:
+        try:
+            keydata = sys.stdin.read(MAX_READ)
+            encoded_keydata = keydata.encode(_request_charset())
+        except (LookupError, UnicodeError):
+            sys.stdout.write("Status: 400 Bad Request\r\n\r\n")
+            return True
+        os.write(fd, encoded_keydata)
+    finally:
+        with suppress(OSError):
+            os.close(fd)
     sys.stdout.write("Content-type: text/plain\r\n\r\n")
 
     return True

{urwid-4.0.6 → urwid-4.0.7}/urwid/event_loop/main_loop.py

@@ -42,7 +42,7 @@ from .select_loop import SelectEventLoop
 if typing.TYPE_CHECKING:
     from collections.abc import Callable, Iterable
 
-    from typing_extensions import Self
+    from typing_extensions import Literal, Self
 
     from urwid.display import BaseScreen
     from urwid.widget import AbstractWidget
@@ -51,6 +51,37 @@ if typing.TYPE_CHECKING:
 
     _T = typing.TypeVar("_T")
 
+    class _ExternalLoopScreen(typing.Protocol):
+        """Screen able to drive an external event loop (e.g. raw_display / curses screens).
+
+        These members are not part of :class:`BaseScreen`;
+        :class:`MainLoop` only uses them after guarding with ``hasattr``
+        (or after :meth:`MainLoop.start` raised :exc:`CantUseExternalLoop`),
+        so accessing them through this protocol via ``cast`` is safe.
+        """
+
+        signal_handler_setter: Callable[..., typing.Any]
+
+        def hook_event_loop(
+            self,
+            event_loop: EventLoop,
+            callback: Callable[[list[str | tuple[str, int, int, int]], list[int]], typing.Any],
+        ) -> None: ...
+
+        def unhook_event_loop(self, event_loop: EventLoop) -> None: ...
+
+        def get_input(self, raw_keys: Literal[True]) -> tuple[list[str | tuple[str, int, int, int]], list[int]]: ...
+
+        def set_input_timeouts(self, max_wait: float | None = ...) -> None: ...
+
+    class _EventLoopWithAlarmsStore(typing.Protocol):
+        """Event loop that supports alarms storage (like :class:`SelectEventLoop`).
+
+        Not all event loops support alarms storage.
+        """
+
+        _alarms: list[tuple[float, int, Callable[[], typing.Any]]]
+
 
 IS_WINDOWS = sys.platform == "win32"
 PIPE_BUFFER_READ_SIZE = 4096  # can expect this much on Linux, so try for that
@@ -116,7 +147,9 @@ class MainLoop:
         ] = (),
         screen: BaseScreen | None = None,
         handle_mouse: bool = True,
-        input_filter: Callable[[list[str | tuple[str, int, int, int]], list[int]], list[str]] | None = None,
+        input_filter: (
+            Callable[[list[str | tuple[str, int, int, int]], list[int]], list[str | tuple[str, int, int, int]]] | None
+        ) = None,
         unhandled_input: Callable[[str | tuple[str, int, int, int]], bool | None] | None = None,
         event_loop: EventLoop | None = None,
         pop_ups: bool = False,
@@ -149,7 +182,7 @@ class MainLoop:
         if hasattr(self.screen, "signal_handler_setter"):
             # Tell the screen what function it must use to set
             # signal handlers
-            self.screen.signal_handler_setter = self.event_loop.set_signal_handler
+            typing.cast("_ExternalLoopScreen", self.screen).signal_handler_setter = self.event_loop.set_signal_handler
 
         self._watch_pipes: dict[int, tuple[Callable[[], typing.Any], int]] = {}
 
@@ -164,7 +197,7 @@ class MainLoop:
     @widget.setter
     def widget(self, widget: AbstractWidget) -> None:
         self._widget = widget
-        if self.pop_ups:
+        if self.pop_ups and hasattr(self._topmost_widget, "original_widget"):
             self._topmost_widget.original_widget = self._widget
         else:
             self._topmost_widget = self._widget
@@ -181,7 +214,12 @@ class MainLoop:
         else:
             self._topmost_widget = self._widget
 
-    def set_alarm_in(self, sec: float, callback: Callable[[Self, _T], typing.Any], user_data: _T = None):
+    def set_alarm_in(
+        self,
+        sec: float,
+        callback: Callable[[Self, _T | None], typing.Any],
+        user_data: _T | None = None,
+    ) -> typing.Any:
         """
         Schedule an alarm in *sec* seconds that will call *callback* from the
         within the :meth:`run` method.
@@ -201,7 +239,12 @@ class MainLoop:
 
         return self.event_loop.alarm(sec, cb)
 
-    def set_alarm_at(self, tm: float, callback: Callable[[Self, _T], typing.Any], user_data: _T = None):
+    def set_alarm_at(
+        self,
+        tm: float,
+        callback: Callable[[Self, _T | None], typing.Any],
+        user_data: _T | None = None,
+    ) -> typing.Any:
         """
         Schedule an alarm at *tm* time that will call *callback* from the
         within the :meth:`run` function. Returns a handle that may be passed to
@@ -223,7 +266,7 @@ class MainLoop:
 
         return self.event_loop.alarm(sec, cb)
 
-    def remove_alarm(self, handle) -> bool:
+    def remove_alarm(self, handle: typing.Any) -> bool:
         """
         Remove an alarm. Return ``True`` if *handle* was found, ``False``
         otherwise.
@@ -289,7 +332,7 @@ class MainLoop:
             os.close(pipe_rd)
             return True
 
-    def watch_file(self, fd: int, callback: Callable[[], typing.Any]):
+    def watch_file(self, fd: int, callback: Callable[[], typing.Any]) -> typing.Any:
         """
         Call *callback* when *fd* has some data to read. No parameters are
         passed to callback.
@@ -299,7 +342,7 @@ class MainLoop:
         self.logger.debug(f"Setting watch file descriptor {fd!r} with {callback!r}")
         return self.event_loop.watch_file(fd, callback)
 
-    def remove_watch_file(self, handle) -> bool:
+    def remove_watch_file(self, handle: typing.Any) -> bool:
         """
         Remove a watch file. Returns ``True`` if the watch file
         exists, ``False`` otherwise.
@@ -399,13 +442,14 @@ class MainLoop:
         self.event_loop.remove_enter_idle(self.idle_handle)
         del self.idle_handle
         signals.disconnect_signal(self.screen, INPUT_DESCRIPTORS_CHANGED, self._reset_input_descriptors)
-        self.screen.unhook_event_loop(self.event_loop)
+        typing.cast("_ExternalLoopScreen", self.screen).unhook_event_loop(self.event_loop)
 
         self.screen.stop()
 
     def _reset_input_descriptors(self) -> None:
-        self.screen.unhook_event_loop(self.event_loop)
-        self.screen.hook_event_loop(self.event_loop, self._update)
+        screen = typing.cast("_ExternalLoopScreen", self.screen)
+        screen.unhook_event_loop(self.event_loop)
+        screen.hook_event_loop(self.event_loop, self._update)
 
     def _run(self) -> None:
         try:
@@ -456,23 +500,26 @@ class MainLoop:
         # pylint: disable=protected-access  # special case for alarms handling
         self.logger.debug(f"Starting screen {self.screen!r} event loop")
 
-        next_alarm = None
+        screen = typing.cast("_ExternalLoopScreen", self.screen)
+        event_loop = typing.cast("_EventLoopWithAlarmsStore", self.event_loop)
+
+        next_alarm: tuple[float, int, Callable[[], typing.Any]] | None = None
 
         while True:
             self.draw_screen()
 
-            if not next_alarm and self.event_loop._alarms:
-                next_alarm = heapq.heappop(self.event_loop._alarms)
+            if not next_alarm and event_loop._alarms:
+                next_alarm = heapq.heappop(event_loop._alarms)
 
             keys: list[str | tuple[str, int, int, int]] = []
             raw: list[int] = []
             while not keys:
                 if next_alarm:
                     sec = max(0.0, next_alarm[0] - time.time())
-                    self.screen.set_input_timeouts(sec)
+                    screen.set_input_timeouts(sec)
                 else:
-                    self.screen.set_input_timeouts(None)
-                keys, raw = self.screen.get_input(True)
+                    screen.set_input_timeouts(None)
+                keys, raw = screen.get_input(True)
                 if not keys and next_alarm and next_alarm[0] - time.time() <= 0:
                     break
 
@@ -485,8 +532,8 @@ class MainLoop:
                 _tm, _tie_break, callback = next_alarm
                 callback()
 
-                if self.event_loop._alarms:
-                    next_alarm = heapq.heappop(self.event_loop._alarms)
+                if event_loop._alarms:
+                    next_alarm = heapq.heappop(event_loop._alarms)
                 else:
                     next_alarm = None
 

{urwid-4.0.6 → urwid-4.0.7}/urwid/signals.py

@@ -55,7 +55,7 @@ class MetaSignals(abc.ABCMeta):
 def setdefaultattr(obj: typing.Any, name: str, value: _T) -> _T:
     # like dict.setdefault() for object attributes
     if hasattr(obj, name):
-        return getattr(obj, name)  # type: ignore[no-any-return]
+        return getattr(obj, name)
     setattr(obj, name, value)
     return value
 
@@ -69,6 +69,15 @@ class Key:
     __slots__ = ()
 
 
+if typing.TYPE_CHECKING:
+    # ``weak_args`` (converted to weakrefs) and ``user_args`` as prepared by ``_prepare_user_args``.
+    _UserArgs = tuple[Collection[weakref.ReferenceType], Collection[typing.Any]]
+    # A single connected handler: (key, callback, deprecated user_arg, prepared args).
+    _SignalHandler = tuple[Key, Callable[..., typing.Any], typing.Any, _UserArgs]
+    # Per-sender storage attached to ``obj`` under ``Signals._signal_attr``.
+    _SignalStore = dict[Hashable, list[_SignalHandler]]
+
+
 class Signals:
     _signal_attr = "_urwid_signals"  # attribute to attach to signal senders
 
@@ -89,7 +98,7 @@ class Signals:
 
     def connect(
         self,
-        obj,
+        obj: typing.Any,
         name: Hashable,
         callback: Callable[..., typing.Any],
         user_arg: typing.Any = None,
@@ -180,7 +189,8 @@ class Signals:
         # Just generate an arbitrary (but unique) key
         key = Key()
 
-        handlers = setdefaultattr(obj, self._signal_attr, {}).setdefault(name, [])
+        signals: _SignalStore = setdefaultattr(obj, self._signal_attr, {})
+        handlers = signals.setdefault(name, [])
 
         # Remove the signal handler when any of the weakref'd arguments
         # are garbage collected. Note that this means that the handlers
@@ -216,7 +226,7 @@ class Signals:
 
     def disconnect(
         self,
-        obj,
+        obj: typing.Any,
         name: Hashable,
         callback: Callable[..., typing.Any],
         user_arg: typing.Any = None,
@@ -242,7 +252,7 @@ class Signals:
         If the callback is not connected or already disconnected, this
         function will simply do nothing.
         """
-        signals = setdefaultattr(obj, self._signal_attr, {})
+        signals: _SignalStore = setdefaultattr(obj, self._signal_attr, {})
         if name not in signals:
             return None
 
@@ -258,7 +268,7 @@ class Signals:
                 return self.disconnect_by_key(obj, name, h[0])
         return None
 
-    def disconnect_by_key(self, obj, name: Hashable, key: Key) -> None:
+    def disconnect_by_key(self, obj: typing.Any, name: Hashable, key: Key) -> None:
         """
         :param obj: the object to disconnect the signal from
         :type obj: object
@@ -275,10 +285,11 @@ class Signals:
         If the callback is not connected or already disconnected, this
         function will simply do nothing.
         """
-        handlers = setdefaultattr(obj, self._signal_attr, {}).get(name, [])
+        signals: _SignalStore = setdefaultattr(obj, self._signal_attr, {})
+        handlers = signals.get(name, [])
         handlers[:] = [h for h in handlers if h[0] is not key]
 
-    def emit(self, obj, name: Hashable, *args: typing.Any) -> bool:
+    def emit(self, obj: typing.Any, name: Hashable, *args: typing.Any) -> bool:
         """
         :param obj: the object sending a signal
         :type obj: object

{urwid-4.0.6 → urwid-4.0.7}/urwid/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.0.6'
-__version_tuple__ = version_tuple = (4, 0, 6)
+__version__ = version = '4.0.7'
+__version_tuple__ = version_tuple = (4, 0, 7)
 
-__commit_id__ = commit_id = 'g046c400ea'
+__commit_id__ = commit_id = 'g7c32ae3ff'

{urwid-4.0.6 → urwid-4.0.7}/urwid/widget/constants.py

@@ -246,14 +246,17 @@ def normalize_width(
     if width doesn't match a valid alignment.
     """
     if width in {WHSettings.CLIP, WHSettings.PACK}:
-        return (WHSettings(width), None)
+        return (typing.cast("Literal[WHSettings.CLIP, WHSettings.PACK]", WHSettings(width)), None)
 
     if isinstance(width, int):
         return (WHSettings.GIVEN, width)
 
     if isinstance(width, tuple) and len(width) == 2 and width[0] in {WHSettings.RELATIVE, WHSettings.WEIGHT}:
         width_type, width_amount = width
-        return (WHSettings(width_type), width_amount)
+        return typing.cast(
+            "tuple[Literal[WHSettings.RELATIVE], int] | tuple[Literal[WHSettings.WEIGHT], int | float]",
+            (WHSettings(width_type), width_amount),
+        )
 
     raise err(
         f"width value {width!r} is not one of"
@@ -310,7 +313,7 @@ def simplify_width(
     Inverse of normalize_width.
     """
     if width_type in {WHSettings.CLIP, WHSettings.PACK}:
-        return WHSettings(width_type)
+        return typing.cast("Literal[WHSettings.CLIP, WHSettings.PACK]", WHSettings(width_type))
 
     if not isinstance(width_amount, int):
         raise TypeError(width_amount)
@@ -318,7 +321,10 @@ def simplify_width(
     if width_type == WHSettings.GIVEN:
         return width_amount
 
-    return (WHSettings(width_type), width_amount)
+    return typing.cast(
+        "tuple[Literal[WHSettings.RELATIVE], int] | tuple[Literal[WHSettings.WEIGHT], int | float]",
+        (WHSettings(width_type), width_amount),
+    )
 
 
 @typing.overload
@@ -373,7 +379,10 @@ def normalize_height(
         return (WHSettings.PACK, None)
 
     if isinstance(height, tuple) and len(height) == 2 and height[0] in {WHSettings.RELATIVE, WHSettings.WEIGHT}:
-        return (WHSettings(height[0]), height[1])
+        return typing.cast(
+            "tuple[Literal[WHSettings.RELATIVE], int] | tuple[Literal[WHSettings.WEIGHT], int | float]",
+            (WHSettings(height[0]), height[1]),
+        )
 
     if isinstance(height, int):
         return (WHSettings.GIVEN, height)
@@ -444,7 +453,7 @@ def simplify_height(
     Inverse of normalize_height.
     """
     if height_type in {WHSettings.FLOW, WHSettings.PACK}:
-        return WHSettings(height_type)
+        return typing.cast("Literal[WHSettings.FLOW, WHSettings.PACK]", WHSettings(height_type))
 
     if not isinstance(height_amount, int):
         raise TypeError(height_amount)
@@ -452,7 +461,10 @@ def simplify_height(
     if height_type == WHSettings.GIVEN:
         return height_amount
 
-    return (WHSettings(height_type), height_amount)
+    return typing.cast(
+        "tuple[Literal[WHSettings.RELATIVE], int] | tuple[Literal[WHSettings.WEIGHT], int | float]",
+        (WHSettings(height_type), height_amount),
+    )
 
 
 @dataclasses.dataclass(frozen=True)

{urwid-4.0.6 → urwid-4.0.7}/urwid/widget/filler.py

@@ -342,7 +342,7 @@ class Filler(WidgetDecoration[WrappedWidget]):
 def calculate_top_bottom_filler(
     maxrow: int,
     valign_type: Literal["top", "middle", "bottom", "relative", WHSettings.RELATIVE] | VAlign,
-    valign_amount: int,
+    valign_amount: int | None,
     height_type: Literal["given", "relative", "clip", WHSettings.GIVEN, WHSettings.RELATIVE, WHSettings.CLIP],
     height_amount: int,
     min_height: int | None,
@@ -380,6 +380,9 @@ def calculate_top_bottom_filler(
     >>> ctbf(20, "relative", 30, "relative", 60, 14, 0, 0)
     (2, 4)
     """
+    if valign_type == WHSettings.RELATIVE and valign_amount is None:
+        raise TypeError("valign_amount must be specified when valign_type is relative")
+
     if height_type == WHSettings.RELATIVE:
         maxheight = max(maxrow - top - bottom, 0)
         height = int_scale(height_amount, 101, maxheight + 1)
@@ -388,7 +391,9 @@ def calculate_top_bottom_filler(
     else:
         height = height_amount
 
-    valign = {VAlign.TOP: 0, VAlign.MIDDLE: 50, VAlign.BOTTOM: 100}.get(valign_type, valign_amount)
+    valign: int = {VAlign.TOP: 0, VAlign.MIDDLE: 50, VAlign.BOTTOM: 100}.get(  # type: ignore[assignment]
+        valign_type, valign_amount
+    )  # relative + None already filtered above
 
     # add the remainder of top/bottom to the filler
     filler = maxrow - height - top - bottom