urwid 4.2.1__tar.gz → 4.2.3__tar.gz

{urwid-4.2.1 → urwid-4.2.3}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       - id: check-merge-conflict
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.16.0
+    rev: v0.16.9
     hooks:
       - id: ruff-check
         args: [ --show-fixes, --fix ]

{urwid-4.2.1/urwid.egg-info → urwid-4.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urwid
-Version: 4.2.1
+Version: 4.2.3
 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.2.3/pylint-requirements.txt

@@ -0,0 +1 @@
+pylint==4.1.1

{urwid-4.2.1 → urwid-4.2.3}/pyproject.toml

@@ -197,7 +197,6 @@ allow-dunder-method-names = [
 [tool.pylint]
 disable = [
   "arguments-differ",
-  "attribute-defined-outside-init",                   # old bad practice, fixed step-by-step
   "broad-exception-caught",
   "broad-exception-raised",
   "consider-using-assignment-expr",

{urwid-4.2.1 → urwid-4.2.3}/urwid/canvas.py

@@ -224,6 +224,8 @@ class CanvasError(Exception):
 class Canvas:
     """base class for canvases."""
 
+    __slots__ = ("__dict__", "__weakref__", "_widget_info", "coords", "shortcuts")
+
     cacheable = True
 
     _finalized_error = CanvasError(
@@ -601,6 +603,8 @@ class BlankCanvas(Canvas):
     Only works as part of a composite canvas since it doesn't know its own size.
     """
 
+    __slots__ = ()
+
     def content(
         self,
         trim_left: int = 0,
@@ -733,6 +737,7 @@ class CompositeCanvas(Canvas):
 
         # tuples that define the unfinished cviews that are part of shards following the first shard.
         super().__init__()
+        self.depends_on: Sequence[AbstractWidget] | None = None
 
         if canv is None:
             self.shards: list[tuple[int, list[_CView]]] = []

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/_posix_raw_display.py

@@ -122,6 +122,7 @@ class Screen(_raw_display_base.Screen):
         super().__init__(input, output, bracketed_paste_mode=bracketed_paste_mode, focus_reporting=focus_reporting)
         self.gpm_mev: Popen[str] | None = None
         self.gpm_event_pending: bool = False
+        self._old_termios_settings: list[typing.Any] | None = None
 
         # These store the previous signal handlers after setting ours
         self._prev_sigcont_handler: SignalHandler = None
@@ -308,7 +309,7 @@ class Screen(_raw_display_base.Screen):
         self._stop_restore_palette()
 
         fd = self._input_fileno()
-        if fd is not None and os.isatty(fd):
+        if fd is not None and os.isatty(fd) and self._old_termios_settings is not None:
             termios.tcsetattr(fd, termios.TCSAFLUSH, self._old_termios_settings)
 
         if self._old_signal_keys:

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/_raw_display_base.py

@@ -41,7 +41,7 @@ from . import escape
 from .common import UNPRINTABLE_TRANS_TABLE, UPDATE_PALETTE_ENTRY, AttrSpec, BaseScreen, RealTerminal
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Mapping, Sequence
+    from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
     from types import FrameType
 
     from typing_extensions import Literal
@@ -353,8 +353,8 @@ class Screen(BaseScreen, RealTerminal):
 
         self._partial_codes: list[int] = []
         self.modes = TermModes(bracketed_paste=bracketed_paste_mode, focus_reporting=focus_reporting)
-        self._pal_escape: dict[str | None, str] = {}
-        self._pal_attrspec: dict[str | None, AttrSpec] = {}
+        self._pal_escape: dict[Hashable, str] = {}
+        self._pal_attrspec: dict[Hashable, AttrSpec] = {}
         self._modified_palette_entries: set[int] = set()
         signals.connect_signal(self, UPDATE_PALETTE_ENTRY, self._on_update_palette_entry)
         self.term = os.environ.get("TERM", "")
@@ -423,7 +423,7 @@ class Screen(BaseScreen, RealTerminal):
 
         return None
 
-    def _on_update_palette_entry(self, name: str | None, *attrspecs: AttrSpec) -> None:
+    def _on_update_palette_entry(self, name: Hashable, *attrspecs: AttrSpec) -> None:
         # copy the attribute to a dictionary containing the escape seqences
         a: AttrSpec = attrspecs[_ATTRSPEC_INDEX_BY_COLORS[self.colors]]
         self._pal_attrspec[name] = a
@@ -1046,7 +1046,7 @@ class Screen(BaseScreen, RealTerminal):
                     run[-1:] == b" "
                     and self.back_color_erase
                     and not (
-                        isinstance(pal_a := self._pal_attrspec.get(a, a), AttrSpec)  # type: ignore[arg-type]
+                        isinstance(pal_a := self._pal_attrspec.get(a, a), AttrSpec)
                         and (pal_a.standout or pal_a.underline)
                     )
                 ):
@@ -1152,7 +1152,7 @@ class Screen(BaseScreen, RealTerminal):
 
     def _attr_to_escape(self, a: AttrSpec | str | None) -> str:
         """Convert attribute instance a to an escape sequence for the terminal."""
-        if found := self._pal_escape.get(a):  # type: ignore[arg-type]
+        if found := self._pal_escape.get(a):
             return found
         if isinstance(a, AttrSpec):
             return self._attrspec_to_escape(a)

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/common.py

@@ -34,12 +34,31 @@ from urwid import signals
 from urwid.util import StoppingContext, int_scale
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Sequence
+    from collections.abc import Callable, Hashable, Iterable, Sequence
 
     from typing_extensions import Literal, Self
 
     from urwid import Canvas
 
+    # One register_palette() item:
+    # (name, like_other_name)
+    # or the 3, 4 or 6 positional arguments of register_palette_entry().
+    # A name is any hashable value, None being the default attribute.
+    # typing.Union rather than "|": the alias is evaluated by the checkers as Python 3.9 code.
+    PaletteEntry = typing.Union[
+        tuple[Hashable, Hashable],
+        tuple[Hashable, str, str],
+        tuple[Hashable, str, str, typing.Union[str, tuple[str, ...], None]],
+        tuple[
+            Hashable,
+            str,
+            str,
+            typing.Union[str, tuple[str, ...], None],
+            typing.Optional[str],
+            typing.Optional[str],
+        ],
+    ]
+
 IS_WINDOWS = sys.platform == "win32"
 
 # for replacing unprintable bytes with '?'
@@ -1089,7 +1108,7 @@ class BaseScreen(abc.ABC, metaclass=signals.MetaSignals):
 
         self.logger = logging.getLogger(f"{self.__class__.__module__}.{self.__class__.__name__}")
 
-        self._palette: dict[str | None, tuple[AttrSpec, AttrSpec, AttrSpec, AttrSpec, AttrSpec]] = {}
+        self._palette: dict[Hashable, tuple[AttrSpec, AttrSpec, AttrSpec, AttrSpec, AttrSpec]] = {}
         self._started: bool = False
 
     @property
@@ -1170,12 +1189,7 @@ class BaseScreen(abc.ABC, metaclass=signals.MetaSignals):
         """
         return 80, 24
 
-    def register_palette(
-        self,
-        palette: Iterable[
-            tuple[str, str] | tuple[str, str, str] | tuple[str, str, str, str] | tuple[str, str, str, str, str, str]
-        ],
-    ) -> None:
+    def register_palette(self, palette: Iterable[PaletteEntry]) -> None:
         """Register a set of palette entries.
 
         :param palette: a list of (name, like_other_name) or
@@ -1204,7 +1218,7 @@ class BaseScreen(abc.ABC, metaclass=signals.MetaSignals):
 
     def register_palette_entry(
         self,
-        name: str | None,
+        name: Hashable,
         foreground: str,
         background: str,
         mono: str | tuple[str, ...] | None = None,
@@ -1213,7 +1227,7 @@ class BaseScreen(abc.ABC, metaclass=signals.MetaSignals):
     ) -> None:
         """Register a single palette entry.
 
-        :param name: new entry/attribute name
+        :param name: new entry/attribute name, any hashable value; ``None`` names the default attribute
 
         :param foreground: a string containing a comma-separated foreground
             color and settings

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/curses.py

@@ -117,6 +117,7 @@ class Screen(BaseScreen, RealTerminal):
         super().__init__()
         self.curses_pairs = [(None, None)]  # Can't be sure what pair 0 will default to
         self.has_color = False
+        self.has_default_colors = False
         self.s: curses.window | None = None
         self.cursor_state: typing.Literal["fixed"] | int | None = None
         self.prev_input_resize = 0
@@ -124,6 +125,8 @@ class Screen(BaseScreen, RealTerminal):
         self.last_bstate = 0
         self._mouse_tracking_enabled = False
         self._curses_attr_cache: dict[AttrSpec, int] = {}
+        # Holds the last drawn canvas so the canvas cache keeps its entries alive.
+        self.keep_cache_alive_link: Canvas | None = None
 
         self.register_palette_entry(None, "default", "default")
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/escape.py

@@ -41,7 +41,7 @@ if typing.TYPE_CHECKING:
 
 # NOTE: because of circular imports (urwid.util -> urwid.escape -> urwid.util)
 # from urwid.util import is_mouse_event -- will not work here
-import urwid.util  # isort: skip  # pylint: disable=wrong-import-position
+import urwid.util  # isort: skip
 
 IS_WINDOWS = sys.platform == "win32"
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/display/web.py

@@ -130,6 +130,15 @@ class Screen(BaseScreen):
         self.bright_is_bold = False  # ignored: the browser renders bold as requested
         self.has_underline = True  # ignored: the browser renders underline as requested
         self._colour_index = _COLOUR_INDEX[self.colors]
+        self.update_method = ""
+        self.last_screen: dict[tuple[tuple[AttrSpec | str | None, str] | int | None, ...], list[int]] = {}
+        self.last_screen_width = 0
+        self.pipe_name = ""
+        self.input_fd: int | None = None
+        self.input_tail = ""
+        self.content_head = ""
+        self.screen_size: tuple[int, int] | None = None
+        self.server_socket: socket.socket | None = None
         self.register_palette_entry(None, _default_foreground, _default_background)
 
     @property
@@ -216,7 +225,7 @@ class Screen(BaseScreen):
             sys.stdout.write("Status: 400 Bad Request\r\n\r\n")
             sys.exit(0)
 
-        self.last_screen: dict[tuple[tuple[AttrSpec | str | None, str] | int | None, ...], list[int]] = {}
+        self.last_screen = {}
         self.last_screen_width = 0
 
         clients = glob.glob(os.path.join(_prefs.pipe_dir, "urwid*.in"))
@@ -252,8 +261,9 @@ class Screen(BaseScreen):
         with suppress(Exception):
             self._close_connection()
         signal.signal(signal.SIGTERM, signal.SIG_DFL)
-        with suppress(Exception):
-            os.close(self.input_fd)
+        if self.input_fd is not None:
+            with suppress(Exception):
+                os.close(self.input_fd)
         self._cleanup_pipe()
         self._started = False
 
@@ -261,7 +271,7 @@ class Screen(BaseScreen):
         """Not supported for web display."""
 
     def _close_connection(self) -> None:
-        if self.update_method == "polling child":
+        if self.update_method == "polling child" and self.server_socket is not None:
             self.server_socket.settimeout(0)
             sock, _addr = self.server_socket.accept()
             sock.sendall(b"Z")
@@ -303,7 +313,7 @@ class Screen(BaseScreen):
         elif self.update_method == "polling child":
             signal.alarm(0)
             try:
-                s, _addr = self.server_socket.accept()
+                s, _addr = typing.cast("socket.socket", self.server_socket).accept()
             except socket.timeout:
                 sys.exit(0)
             send = s.sendall  # type: ignore[assignment]  # use default flags
@@ -409,7 +419,7 @@ class Screen(BaseScreen):
         if self.update_method == "polling child":
             # send empty update
             try:
-                s, _addr = self.server_socket.accept()
+                s, _addr = typing.cast("socket.socket", self.server_socket).accept()
                 s.close()
             except socket.timeout:
                 sys.exit(0)
@@ -421,7 +431,7 @@ class Screen(BaseScreen):
 
     def get_cols_rows(self) -> tuple[int, int]:
         """Return the screen size."""
-        return self.screen_size
+        return typing.cast("tuple[int, int]", self.screen_size)
 
     @typing.overload
     def get_input(self, raw_keys: Literal[False]) -> list[str]: ...
@@ -433,8 +443,9 @@ class Screen(BaseScreen):
         """Return pending input as a list."""
         pending_input = []
         resized = False
+        input_fd = typing.cast("int", self.input_fd)
         with selectors.DefaultSelector() as selector:
-            selector.register(self.input_fd, selectors.EVENT_READ)
+            selector.register(input_fd, selectors.EVENT_READ)
 
             iready = [event.fd for event, _ in selector.select(0.5)]
 
@@ -443,8 +454,8 @@ class Screen(BaseScreen):
                 return [], []
             return []
 
-        keydata = os.read(self.input_fd, MAX_READ).decode(get_encoding())
-        os.close(self.input_fd)
+        keydata = os.read(input_fd, MAX_READ).decode(get_encoding())
+        os.close(input_fd)
         self.input_fd = os.open(f"{self.pipe_name}.in", os.O_NONBLOCK | os.O_RDONLY)
         # sys.stderr.write( repr((keydata,self.input_tail))+"\n" )
         keys = keydata.split("\n")

{urwid-4.2.1 → urwid-4.2.3}/urwid/event_loop/main_loop.py

@@ -48,6 +48,7 @@ if typing.TYPE_CHECKING:
     from typing_extensions import Literal, Self
 
     from urwid.display import BaseScreen
+    from urwid.display.common import PaletteEntry
     from urwid.widget import AbstractWidget
 
     from .abstract_loop import EventLoop
@@ -143,12 +144,27 @@ class MainLoop:
         :attr:`event_loop`; whether it actually does anything still depends on :attr:`event_loop`.
     """
 
+    __slots__ = (
+        "__dict__",
+        "__weakref__",
+        "_input_filter",
+        "_pop_ups",
+        "_topmost_widget",
+        "_unhandled_input",
+        "_watch_pipes",
+        "_widget",
+        "event_loop",
+        "handle_mouse",
+        "idle_handle",
+        "logger",
+        "screen",
+        "screen_size",
+    )
+
     def __init__(
         self,
         widget: AbstractWidget,
-        palette: Iterable[
-            tuple[str, str] | tuple[str, str, str] | tuple[str, str, str, str] | tuple[str, str, str, str, str, str]
-        ] = (),
+        palette: Iterable[PaletteEntry] = (),
         screen: BaseScreen | None = None,
         handle_mouse: bool = True,
         input_filter: (
@@ -187,6 +203,7 @@ class MainLoop:
         if event_loop is None:
             event_loop = SelectEventLoop()
         self.event_loop: EventLoop = event_loop
+        self.idle_handle: typing.Any = None
 
         if hasattr(self.screen, "signal_handler_setter"):
             # Tell the screen what function it must use to set
@@ -477,7 +494,7 @@ class MainLoop:
         Only call this if you're managing the event loop yourself, after the loop stops.
         """
         self.event_loop.remove_enter_idle(self.idle_handle)
-        del self.idle_handle
+        self.idle_handle = None
         signals.disconnect_signal(self.screen, INPUT_DESCRIPTORS_CHANGED, self._reset_input_descriptors)
         typing.cast("_ExternalLoopScreen", self.screen).unhook_event_loop(self.event_loop)
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/event_loop/trio_loop.py

@@ -39,7 +39,9 @@ if sys.version_info < (3, 11):
     from exceptiongroup import BaseExceptionGroup  # pylint: disable=redefined-builtin  # backport
 
 if typing.TYPE_CHECKING:
+    import asyncio
     from collections.abc import Awaitable, Callable
+    from concurrent.futures import Executor, Future
 
     from typing_extensions import ParamSpec
 
@@ -96,6 +98,22 @@ class TrioEventLoop(EventLoop):
         self._sleep = trio.sleep
         self._wait_readable = trio.lowlevel.wait_readable
 
+    def run_in_executor(
+        self,
+        executor: Executor,
+        func: Callable[_Spec, _T],
+        *args: _Spec.args,
+        **kwargs: _Spec.kwargs,
+    ) -> Future[_T] | asyncio.Future[_T]:
+        """Raise :exc:`NotImplementedError`: use Trio's own thread API.
+
+        :raises NotImplementedError: Trio runs blocking calls in threads itself; use ``trio.to_thread.run_sync``.
+        """
+        raise NotImplementedError(
+            "Trio implements its own worker threads. Please use native API for call:\n"
+            "'await trio.to_thread.run_sync(Callable[..., T], *args)'"
+        )
+
     def alarm(
         self,
         seconds: float,

{urwid-4.2.1 → urwid-4.2.3}/urwid/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.2.1'
-__version_tuple__ = version_tuple = (4, 2, 1)
+__version__ = version = '4.2.3'
+__version_tuple__ = version_tuple = (4, 2, 3)
 
-__commit_id__ = commit_id = 'gf0dabd13b'
+__commit_id__ = commit_id = 'gbb4bfdce9'

{urwid-4.2.1 → urwid-4.2.3}/urwid/vterm.py

@@ -1377,6 +1377,7 @@ class Terminal(Widget):
         self.height: int | None = None
         self.term: TermCanvas | None = None
         self.has_focus = False
+        self.old_tios: tuple[int, int, int, int, int] | None = None
         self.terminated = False
 
     def get_cursor_coords(self, size: tuple[int, int]) -> tuple[int, int] | None:
@@ -1519,8 +1520,8 @@ class Terminal(Widget):
         if has_focus:
             self.old_tios = RealTerminal().tty_signal_keys()
             RealTerminal().tty_signal_keys(*(["undefined"] * 5))  # type: ignore[arg-type]
-        elif old_tios := getattr(self, "old_tios", ()):
-            RealTerminal().tty_signal_keys(*old_tios)  # pylint: disable=not-an-iterable
+        elif self.old_tios:
+            RealTerminal().tty_signal_keys(*self.old_tios)
 
     def render(self, size: tuple[int, int], focus: bool = False) -> TermCanvas:  # type: ignore[override]
         """Resize the terminal to *size*, read any pending child output, and return the terminal canvas."""

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/ansi_text.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 
 import typing
 
-from urwid.ansi_parser import AnsiParser
+from urwid.ansi_parser import AnsiParser, ParsedLine
 
 from .constants import Align, WrapMode
 from .text import Text
@@ -33,7 +33,6 @@ if typing.TYPE_CHECKING:
 
     from typing_extensions import Literal
 
-    from urwid.ansi_parser import ParsedLine
     from urwid.display import AttrSpec
 
 __all__ = ("ANSIText",)
@@ -93,6 +92,7 @@ class ANSIText(WidgetWrap[Text]):
         """
         self._one_line = one_line
         super().__init__(Text("", align=align, wrap=wrap))
+        self._parsed = ParsedLine("", [], previous_attr)
         self.set_ansi_text(ansi_text, previous_attr)
 
     def _repr_words(self) -> list[str]:

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/attr_map.py

@@ -67,18 +67,10 @@ class AttrMap(
         [('greeting', None, ...'hi'), ('bg', None, ...'   ')]
         """
         super().__init__(w)
-
-        if isinstance(attr_map, Mapping):
-            self.attr_map = dict(attr_map)
-        else:
-            self.attr_map = {None: attr_map}
-
-        if isinstance(focus_map, Mapping):
-            self.focus_map = dict(focus_map)
-        elif focus_map is None:
-            self.focus_map = focus_map
-        else:
-            self.focus_map = {None: focus_map}
+        self._attr_map: dict[Hashable, Hashable] = {}
+        self._focus_map: dict[Hashable, Hashable] | None = None
+        self.set_attr_map(attr_map)
+        self.set_focus_map(focus_map)
 
     def _repr_attrs(self) -> dict[str, typing.Any]:
         # only include the focus_attr when it takes effect (not None)
@@ -93,28 +85,31 @@ class AttrMap(
         # FIXME: a dictionary that detects modifications would be better
         return dict(self._attr_map)
 
-    def set_attr_map(self, attr_map: dict[Hashable, Hashable]) -> None:
+    def set_attr_map(self, attr_map: Hashable | Mapping[Hashable, Hashable]) -> None:
         """
         Set the attribute mapping dictionary {from_attr: to_attr, ...}.
 
-        Note this function does not accept a single attribute the way the
-        constructor does.  You must specify {None: attribute} instead.
+        A single attribute is stored as ``{None: attribute}``, the way the constructor does.
 
         >>> from urwid import Text
         >>> w = AttrMap(Text("hi"), None)
         >>> w.set_attr_map({"a": "b"})
         >>> w
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={'a': 'b'}>
+        >>> w.set_attr_map("c")
+        >>> w
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={None: 'c'}>
 
         :raises AttrMapError: a key or value of the mapping is not hashable.
         """
-        for from_attr, to_attr in attr_map.items():
+        mapping: dict[Hashable, Hashable] = dict(attr_map) if isinstance(attr_map, Mapping) else {None: attr_map}
+        for from_attr, to_attr in mapping.items():
             if not isinstance(from_attr, Hashable) or not isinstance(to_attr, Hashable):
                 raise AttrMapError(
                     f"{from_attr!r}:{to_attr!r} attribute mapping is invalid. Attributes must be hashable"
                 )
 
-        self._attr_map = attr_map
+        self._attr_map = mapping
         self._invalidate()
 
     attr_map = property(get_attr_map, set_attr_map)
@@ -127,33 +122,39 @@ class AttrMap(
             return dict(self._focus_map)
         return None
 
-    def set_focus_map(self, focus_map: dict[Hashable, Hashable] | None) -> None:
+    def set_focus_map(self, focus_map: Hashable | Mapping[Hashable, Hashable] | None) -> None:
         """Set the focus attribute mapping dictionary {from_attr: to_attr, ...}.
 
         If None this widget will use the attr mapping instead (no change
         when in focus).
 
-        Note this function does not accept a single attribute the way the
-        constructor does.  You must specify {None: attribute} instead.
+        A single attribute is stored as ``{None: attribute}``, the way the constructor does.
 
         >>> from urwid import Text
         >>> w = AttrMap(Text("hi"), {})
         >>> w.set_focus_map({"a": "b"})
         >>> w
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={} focus_map={'a': 'b'}>
+        >>> w.set_focus_map("c")
+        >>> w
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={} focus_map={None: 'c'}>
         >>> w.set_focus_map(None)
         >>> w
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={}>
 
         :raises AttrMapError: a key or value of the mapping is not hashable.
         """
-        if focus_map is not None:
-            for from_attr, to_attr in focus_map.items():
+        mapping: dict[Hashable, Hashable] | None
+        if focus_map is None:
+            mapping = None
+        else:
+            mapping = dict(focus_map) if isinstance(focus_map, Mapping) else {None: focus_map}
+            for from_attr, to_attr in mapping.items():
                 if not isinstance(from_attr, Hashable) or not isinstance(to_attr, Hashable):
                     raise AttrMapError(
                         f"{from_attr!r}:{to_attr!r} attribute mapping is invalid. Attributes must be hashable"
                     )
-        self._focus_map = focus_map
+        self._focus_map = mapping
         self._invalidate()
 
     focus_map = property(get_focus_map, set_focus_map)

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/attr_wrap.py

@@ -114,7 +114,7 @@ class AttrWrap(AttrMap[WrappedWidget]):
         >> w
         <AttrWrap flow widget <Divider flow widget '-'> attr='new_attr'>
         """
-        self.set_attr_map({None: attr})
+        self.set_attr_map(attr)
 
     attr = property(get_attr, set_attr)
 
@@ -138,7 +138,7 @@ class AttrWrap(AttrMap[WrappedWidget]):
         >> w
         <AttrWrap flow widget <Divider flow widget '-'> attr='old'>
         """
-        self.set_focus_map({None: focus_attr})
+        self.set_focus_map(focus_attr)
 
     focus_attr = property(get_focus_attr, set_focus_attr)
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/columns.py

@@ -275,7 +275,6 @@ class Columns(
         *box_columns* will be displayed with this calculated number of rows,
         filling the full height.
         """
-        self._selectable = False
         self._cache_column_widths: list[int] = []
         self._cache_pack_widths: dict[int, int] = {}
         super().__init__()
@@ -401,10 +400,17 @@ class Columns(
         return len(self._contents)
 
     def _contents_modified(self) -> None:
-        """Recalculate whether this widget should be selectable whenever the contents has been changed."""
-        self._selectable = any(w.selectable() for w, o in self.contents)
+        """Invalidate this widget whenever the contents has been changed."""
         self._invalidate()
 
+    def selectable(self) -> bool:
+        """Return whether any child widget is selectable.
+
+        Asked on every call rather than cached,
+        since a child such as :class:`~urwid.WidgetPlaceholder` may change its selectability after it was added.
+        """
+        return any(w.selectable() for w, _ in self.contents)
+
     def _validate_contents_modified(
         self,
         slc: tuple[int, int, int],

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/edit.py

@@ -676,6 +676,11 @@ class Edit(WidgetWrap[Text]):
         if not self._shift_view_to_cursor:
             return trans
 
+        if self._w.wrap in (WrapMode.SPACE, WrapMode.ANY):
+            # Wrapping modes grow the number of rows instead of clipping a row's width,
+            # so there is never a partially hidden row to scroll horizontally into view.
+            return trans
+
         text, _ignore = self.get_text()
         x, y = text_layout.calc_coords(text, trans, self.edit_pos + len(self.caption))
         if x < 0:
@@ -704,7 +709,13 @@ class Edit(WidgetWrap[Text]):
         (maxcol,) = size
 
         self._shift_view_to_cursor = True
-        return self.position_coords(maxcol, self.edit_pos)
+        x, y = self.position_coords(maxcol, self.edit_pos)
+        if self._w.wrap in (WrapMode.SPACE, WrapMode.ANY) and x >= maxcol:
+            # The cursor sits right after a row that is already full and entirely visible.
+            # Clamp onto its last column instead of scrolling that row out of view for a wrap
+            # that has not happened yet.
+            x = maxcol - 1
+        return x, y
 
     def position_coords(self, maxcol: int, pos: int) -> tuple[int, int]:
         """Return (*x*, *y*) coordinates for an offset into self.edit_text."""

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/grid_flow.py

@@ -475,9 +475,6 @@ class GridFlow(
         if self.v_sep:
             # remove first divider
             del p.contents[:1]
-        else:
-            # Ensure p __selectable is updated
-            p._contents_modified()  # pylint: disable=protected-access
 
         return p
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/line_box.py

@@ -192,7 +192,7 @@ class LineBox(
         middle: Columns = typing.cast("Columns", self._wrapped_widget[v_index])
         _old_widget, options = middle.contents[h_index]
         middle.contents[h_index] = (original_widget, options)  # type: ignore[assignment]
-        WidgetDecoration.original_widget.fset(self, original_widget)  # type: ignore[attr-defined]  # pylint: disable=no-member
+        WidgetDecoration.original_widget.fset(self, original_widget)  # type: ignore[attr-defined]
 
     @property
     def _w(self) -> Pile:

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/overlay.py

@@ -183,6 +183,12 @@ class Overlay(
 
         self.top_w = top_w
         self.bottom_w = bottom_w
+        self.min_width: int | None = None
+        self.min_height: int | None = None
+        self.left = 0
+        self.right = 0
+        self.top = 0
+        self.bottom = 0
 
         self.set_overlay_parameters(align, width, valign, height, min_width, min_height, left, right, top, bottom)
 

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/pile.py

@@ -223,7 +223,6 @@ class Pile(
         .. note:: If the Pile is treated as a box widget there must be at least
             one ``'weight'`` tuple in :attr:`widget_list`.
         """
-        self._selectable = False
         super().__init__()
         self._contents: MonitoredFocusList[
             tuple[
@@ -344,10 +343,17 @@ class Pile(
         return len(self._contents)
 
     def _contents_modified(self) -> None:
-        """Recalculate whether this widget should be selectable whenever the contents has been changed."""
-        self._selectable = any(w.selectable() for w, o in self.contents)
+        """Invalidate this widget whenever the contents has been changed."""
         self._invalidate()
 
+    def selectable(self) -> bool:
+        """Return whether any child widget is selectable.
+
+        Asked on every call rather than cached,
+        since a child such as :class:`~urwid.WidgetPlaceholder` may change its selectability after it was added.
+        """
+        return any(w.selectable() for w, _ in self.contents)
+
     def _validate_contents_modified(
         self,
         slc: tuple[int, int, int],

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/popup.py

@@ -129,6 +129,7 @@ class PopUpTarget(WidgetDecoration[WrappedWidget]):
         # One (widget, Overlay) entry per currently open pop-up, outermost first.
         self._pop_up_levels: list[tuple[AbstractWidget, Overlay[AbstractWidget, AbstractWidget]]] = []
         self._current_widget: AbstractWidget = self._original_widget
+        self._cache_original_canvas: Canvas | None = None
 
     def _update_overlay(self, size: tuple[int, int], focus: bool) -> None:
         """Rebuild :attr:`_current_widget` as a chain of Overlay widgets, one per open pop-up.

{urwid-4.2.1 → urwid-4.2.3}/urwid/widget/text.py

@@ -75,6 +75,8 @@ class Text(Widget):
         self._layout: text_layout.TextLayout = layout or text_layout.default_layout
         self._text: str | bytes
         self._attrib: list[tuple[Hashable, int]]
+        self._align_mode: Literal["left", "center", "right"] | Align = Align.LEFT
+        self._wrap_mode: Literal["space", "any", "clip", "ellipsis"] | WrapMode = WrapMode.SPACE
         self.set_text(markup)
         self.set_layout(align, wrap, layout)
 

{urwid-4.2.1 → urwid-4.2.3/urwid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urwid
-Version: 4.2.1
+Version: 4.2.3
 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.2.3/urwid.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "4.2.3",
+  "distance": 0,
+  "node": "gbb4bfdce968f57f77bdbd69b5ad865dc4ea956b8",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-30"
+}

urwid-4.2.1/pylint-requirements.txt

@@ -1 +0,0 @@
-pylint==4.0.9

urwid-4.2.1/urwid.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "4.2.1",
-  "distance": 0,
-  "node": "gf0dabd13b6489029422d8d7883f60e98215d811f",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-29"
-}