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

urwid/__init__.py

@@ -150,7 +150,6 @@ from .widget import (
     BigText,
     BoxAdapter,
     BoxAdapterError,
-    BoxWidget,
     Button,
     CheckBox,
     CheckBoxError,
@@ -161,8 +160,6 @@ from .widget import (
     EditError,
     Filler,
     FillerError,
-    FixedWidget,
-    FlowWidget,
     Frame,
     FrameError,
     GraphVScale,
@@ -242,7 +239,7 @@ except ImportError:
 
 # OS Specific
 if sys.platform != "win32":
-    from .vterm import TermCanvas, TermCharset, Terminal, TermModes, TermScroller
+    from .vterm import TermCanvas, TermCharset, Terminal, TermModes
 
     # ZMQEventLoop cause interpreter crash on windows
     try:

urwid/canvas.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 import contextlib
 import dataclasses
 import typing
-import warnings
 import weakref
 from contextlib import suppress
 
@@ -40,7 +39,7 @@ from urwid.util import (
 )
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Hashable, Iterable, Sequence
+    from collections.abc import Hashable, Iterable, Iterator, Sequence
 
     from typing_extensions import Literal
 
@@ -126,7 +125,7 @@ class CanvasCache:
 
         ref = weakref.ref(canvas, cls.cleanup)
         cls._refs[ref] = (widget, wcls, size, focus)
-        cls._widgets.setdefault(widget, {})[(wcls, size, focus)] = ref
+        cls._widgets.setdefault(widget, {})[wcls, size, focus] = ref
 
     @classmethod
     def fetch(cls, widget, wcls, size, focus) -> Canvas | None:
@@ -182,7 +181,7 @@ class CanvasCache:
         if not sizes:
             return
         with suppress(KeyError):
-            del sizes[(wcls, size, focus)]
+            del sizes[wcls, size, focus]
         if not sizes:
             with contextlib.suppress(KeyError):
                 del cls._widgets[widget]
@@ -244,15 +243,6 @@ class Canvas:
     def widget_info(self):
         return self._widget_info
 
-    def _get_widget_info(self):
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._get_widget_info` is deprecated, "
-            f"please use property `{self.__class__.__name__}.widget_info`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.widget_info
-
     @property
     def text(self) -> list[bytes]:
         """
@@ -266,15 +256,6 @@ class Canvas:
         encoding = get_encoding()
         return tuple(line.decode(encoding) for line in self.text)
 
-    def _text_content(self):
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._text_content` is deprecated, "
-            f"please use property `{self.__class__.__name__}.text`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.text
-
     def content(
         self,
         trim_left: int = 0,
@@ -282,7 +263,7 @@ class Canvas:
         cols: int | None = None,
         rows: int | None = None,
         attr=None,
-    ) -> Iterable[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
+    ) -> Iterator[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
         raise NotImplementedError()
 
     def cols(self) -> int:
@@ -295,10 +276,10 @@ class Canvas:
         raise NotImplementedError()
 
     def get_cursor(self) -> tuple[int, int] | None:
-        c = self.coords.get("cursor", None)
-        if not c:
-            return None
-        return c[:2]  # trim off data part
+        if c := self.coords.get("cursor", None):
+            return c[:2]  # trim off data part
+
+        return None
 
     def set_cursor(self, c: tuple[int, int] | None) -> None:
         if self.widget_info and self.cacheable:
@@ -312,10 +293,10 @@ class Canvas:
     cursor = property(get_cursor, set_cursor)
 
     def get_pop_up(self) -> tuple[int, int, tuple[Widget, int, int]] | None:
-        c = self.coords.get("pop up", None)
-        if not c:
-            return None
-        return c
+        if c := self.coords.get("pop up", None):
+            return c
+
+        return None
 
     def set_pop_up(self, w: Widget, left: int, top: int, overlay_width: int, overlay_height: int) -> None:
         """
@@ -376,7 +357,7 @@ class TextCanvas(Canvas):
 
     def __init__(
         self,
-        text: Sequence[bytes] | None = None,
+        text: list[bytes] | None = None,
         attr: list[list[tuple[Hashable | None, int]]] | None = None,
         cs: list[list[tuple[Literal["0", "U"] | None, int]]] | None = None,
         cursor: tuple[int, int] | None = None,
@@ -477,7 +458,7 @@ class TextCanvas(Canvas):
         cols: int | None = 0,
         rows: int | None = 0,
         attr=None,
-    ) -> Iterable[tuple[object, Literal["0", "U"] | None, bytes]]:
+    ) -> Iterator[tuple[object, Literal["0", "U"] | None, bytes]]:
         """
         Return the canvas content as a list of rows where each row
         is a list of (attr, cs, text) tuples.
@@ -551,7 +532,7 @@ class BlankCanvas(Canvas):
         cols: int | None = 0,
         rows: int | None = 0,
         attr=None,
-    ) -> Iterable[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
+    ) -> Iterator[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
         """
         return (cols, rows) of spaces with default attributes.
         """
@@ -603,7 +584,7 @@ class SolidCanvas(Canvas):
         cols: int | None = None,
         rows: int | None = None,
         attr=None,
-    ) -> Iterable[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
+    ) -> Iterator[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
         if cols is None:
             cols = self.size[0]
         if rows is None:
@@ -704,7 +685,7 @@ class CompositeCanvas(Canvas):
         cols: int | None = None,
         rows: int | None = None,
         attr=None,
-    ) -> Iterable[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
+    ) -> Iterator[list[tuple[object, Literal["0", "U"] | None, bytes]]]:
         """
         Return the canvas content as a list of rows where each row
         is a list of (attr, cs, text) tuples.
@@ -808,7 +789,7 @@ class CompositeCanvas(Canvas):
 
             if right > 0:
                 new_top_cviews.append((0, 0, right, rows, None, blank_canvas))
-            shards = [(top_rows, new_top_cviews)] + shards[1:]
+            shards = [(top_rows, new_top_cviews), *shards[1:]]
 
         self.coords = self.translate_coords(left, 0)
         self.shards = shards
@@ -833,7 +814,7 @@ class CompositeCanvas(Canvas):
 
         if bottom > 0:
             if orig_shards is self.shards:
-                self.shards = self.shards[:]
+                self.shards = self.shards.copy()
             self.shards.append((bottom, [(0, 0, cols, bottom, None, blank_canvas)]))
 
     def overlay(self, other: CompositeCanvas, left: int, top: int) -> None:
@@ -902,11 +883,11 @@ class CompositeCanvas(Canvas):
             for cv in original_cviews:
                 # cv[4] == attr_map
                 if cv[4] is None:
-                    new_cviews.append(cv[:4] + (mapping,) + cv[5:])
+                    new_cviews.append((*cv[:4], mapping, *cv[5:]))
                 else:
                     combined = mapping.copy()
                     combined.update([(k, mapping.get(v, v)) for k, v in cv[4].items()])
-                    new_cviews.append(cv[:4] + (combined,) + cv[5:])
+                    new_cviews.append((*cv[:4], combined, *cv[5:]))
             shards.append((num_rows, new_cviews))
         self.shards = shards
 
@@ -1002,7 +983,7 @@ def shard_cviews_delta(cviews, other_cviews):
             continue
         # top-left-aligned cviews, compare them
         if cv[5] is other_cv[5] and cv[:5] == other_cv[:5]:
-            yield cv[:5] + (None,) + cv[6:]
+            yield (*cv[:5], None, *cv[6:])
         else:
             yield cv
         other_cols += other_cv[2]
@@ -1185,7 +1166,7 @@ def shards_join(shard_lists):
 
 
 def cview_trim_rows(cv, rows: int):
-    return cv[:3] + (rows,) + cv[4:]
+    return (*cv[:3], rows, *cv[4:])
 
 
 def cview_trim_top(cv, trim: int):
@@ -1193,11 +1174,11 @@ def cview_trim_top(cv, trim: int):
 
 
 def cview_trim_left(cv, trim: int):
-    return (cv[0] + trim, cv[1], cv[2] - trim) + cv[3:]
+    return (cv[0] + trim, cv[1], cv[2] - trim, *cv[3:])
 
 
 def cview_trim_cols(cv, cols: int):
-    return cv[:2] + (cols,) + cv[3:]
+    return (*cv[:2], cols, *cv[3:])
 
 
 def CanvasCombine(canvas_info: Iterable[tuple[Canvas, typing.Any, bool]]) -> CompositeCanvas:
@@ -1229,7 +1210,7 @@ def CanvasCombine(canvas_info: Iterable[tuple[Canvas, typing.Any, bool]]) -> Com
         row += canv.rows()
 
     if focus_index:
-        children = [children[focus_index]] + children[:focus_index] + children[focus_index + 1 :]
+        children = [children[focus_index], *children[:focus_index], *children[focus_index + 1 :]]
 
     combined_canvas.shards = shards
     combined_canvas.children = children
@@ -1295,7 +1276,7 @@ def CanvasJoin(canvas_info: Iterable[tuple[Canvas, typing.Any, bool, int]]) -> C
         col += composite_canvas.cols()
 
     if focus_item:
-        children = [children[focus_item]] + children[:focus_item] + children[focus_item + 1 :]
+        children = [children[focus_item], *children[:focus_item], *children[focus_item + 1 :]]
 
     joined_canvas.shards = shards_join(shard_lists)
     joined_canvas.children = children

urwid/command_map.py

@@ -21,9 +21,11 @@ from __future__ import annotations
 
 import enum
 import typing
-from typing import Iterator
+from collections.abc import MutableMapping
 
 if typing.TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from typing_extensions import Self
 
 
@@ -55,7 +57,7 @@ CURSOR_MAX_RIGHT = Command.MAX_RIGHT
 ACTIVATE = Command.ACTIVATE
 
 
-class CommandMap(typing.Mapping[str, typing.Union[str, Command, None]]):
+class CommandMap(MutableMapping[str, typing.Union[str, Command, None]]):
     """
     dict-like object for looking up commands from keystrokes
 
@@ -105,10 +107,10 @@ class CommandMap(typing.Mapping[str, typing.Union[str, Command, None]]):
     }
 
     def __init__(self) -> None:
-        self._command = dict(self._command_defaults)
+        self._command = self._command_defaults.copy()
 
     def restore_defaults(self) -> None:
-        self._command = dict(self._command_defaults)
+        self._command = self._command_defaults.copy()
 
     def __getitem__(self, key: str) -> str | Command | None:
         return self._command.get(key, None)

urwid/container.py

@@ -53,7 +53,7 @@ __all__ = (
 warnings.warn(
     f"{__name__!r} is not expected to be imported directly. "
     'Please use public access from "urwid" package. '
-    f"Module {__name__!r} is deprecated and will be removed in the future.",
+    f"Module {__name__!r} is deprecated and will be removed in the version 4.0.",
     DeprecationWarning,
     stacklevel=3,
 )

urwid/decoration.py

@@ -59,7 +59,7 @@ __all__ = (
 warnings.warn(
     f"{__name__!r} is not expected to be imported directly. "
     'Please use public access from "urwid" package. '
-    f"Module {__name__!r} is deprecated and will be removed in the future.",
+    f"Module {__name__!r} is deprecated and will be removed in the version 4.0.",
     DeprecationWarning,
     stacklevel=3,
 )

urwid/display/_posix_raw_display.py

@@ -56,6 +56,7 @@ class Screen(_raw_display_base.Screen):
         input: typing.TextIO = sys.stdin,  # noqa: A002  # pylint: disable=redefined-builtin
         output: typing.TextIO = sys.stdout,
         bracketed_paste_mode=False,
+        focus_reporting=False,
     ) -> None:
         """Initialize a screen that directly prints escape codes to an output
         terminal.
@@ -63,11 +64,15 @@ class Screen(_raw_display_base.Screen):
         bracketed_paste_mode -- enable bracketed paste mode in the host terminal.
             If the host terminal supports it, the application will receive `begin paste`
             and `end paste` keystrokes when the user pastes text.
+        focus_reporting -- enable focus reporting in the host terminal.
+            If the host terminal supports it, the application will receive `focus in`
+            and `focus out` keystrokes when the application gains and loses focus.
         """
         super().__init__(input, output)
         self.gpm_mev: Popen | None = None
         self.gpm_event_pending: bool = False
         self.bracketed_paste_mode = bracketed_paste_mode
+        self.focus_reporting = focus_reporting
 
         # These store the previous signal handlers after setting ours
         self._prev_sigcont_handler = None
@@ -79,7 +84,8 @@ class Screen(_raw_display_base.Screen):
             f"<{self.__class__.__name__}("
             f"input={self._term_input_file}, "
             f"output={self._term_output_file}, "
-            f"bracketed_paste_mode={self.bracketed_paste_mode})>"
+            f"bracketed_paste_mode={self.bracketed_paste_mode}, "
+            f"focus_reporting={self.focus_reporting})>"
         )
 
     def _sigwinch_handler(self, signum: int = 28, frame: FrameType | None = None) -> None:
@@ -180,6 +186,9 @@ class Screen(_raw_display_base.Screen):
         if self.bracketed_paste_mode:
             self.write(escape.ENABLE_BRACKETED_PASTE_MODE)
 
+        if self.focus_reporting:
+            self.write(escape.ENABLE_FOCUS_REPORTING)
+
         fd = self._input_fileno()
         if fd is not None and os.isatty(fd):
             self._old_termios_settings = termios.tcgetattr(fd)
@@ -207,15 +216,18 @@ class Screen(_raw_display_base.Screen):
         if self.bracketed_paste_mode:
             self.write(escape.DISABLE_BRACKETED_PASTE_MODE)
 
+        if self.focus_reporting:
+            self.write(escape.DISABLE_FOCUS_REPORTING)
+
         signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
 
         self.signal_restore()
 
+        self._stop_mouse_restore_buffer()
+
         fd = self._input_fileno()
         if fd is not None and os.isatty(fd):
-            termios.tcsetattr(fd, termios.TCSADRAIN, self._old_termios_settings)
-
-        self._stop_mouse_restore_buffer()
+            termios.tcsetattr(fd, termios.TCSAFLUSH, self._old_termios_settings)
 
         if self._old_signal_keys:
             self.tty_signal_keys(*self._old_signal_keys, fd)

urwid/display/_raw_display_base.py

@@ -172,7 +172,7 @@ class Screen(BaseScreen, RealTerminal):
         After calling this function get_input will include mouse
         click events along with keystrokes.
         """
-        enable = bool(enable)  # noqa: FURB123,RUF100
+        enable = bool(enable)
         if enable == self._mouse_tracking_enabled:
             return
 
@@ -323,8 +323,8 @@ class Screen(BaseScreen, RealTerminal):
             return []
 
         fd_list: list[socket.socket | typing.IO | int] = [self._resize_pipe_rd]
-        input_io = self._term_input_io
-        if input_io is not None:
+
+        if (input_io := self._term_input_io) is not None:
             fd_list.append(input_io)
         return fd_list
 
@@ -641,7 +641,7 @@ class Screen(BaseScreen, RealTerminal):
                 a, cs, run = row[-1]
                 if run[-1:] == b" " and self.back_color_erase and not using_standout_or_underline(a):
                     whitespace_at_end = True
-                    row = row[:-1] + [(a, cs, run.rstrip(b" "))]  # noqa: PLW2901
+                    row = [*row[:-1], (a, cs, run.rstrip(b" "))]  # noqa: PLW2901
                 elif y == maxrow - 1 and maxcol > 1:
                     row, back, ins = self._last_row(row)  # noqa: PLW2901
 
@@ -727,7 +727,10 @@ class Screen(BaseScreen, RealTerminal):
         self.screen_buf = sb
         self._screen_buf_canvas = canvas
 
-    def _last_row(self, row: list[tuple[object, Literal["0", "U"] | None, bytes]]) -> tuple[
+    def _last_row(
+        self,
+        row: list[tuple[object, Literal["0", "U"] | None, bytes]],
+    ) -> tuple[
         list[tuple[object, Literal["0", "U"] | None, bytes]],
         int,
         tuple[object, Literal["0", "U"] | None, bytes],

urwid/display/_win32_raw_display.py

@@ -94,11 +94,10 @@ class Screen(_raw_display_base.Screen):
             self._dwOriginalInMode.value | _win32.ENABLE_WINDOW_INPUT | _win32.ENABLE_VIRTUAL_TERMINAL_INPUT
         )
 
-        ok = _win32.SetConsoleMode(handle_out, dword_out_mode)
-        if not ok:
+        if not (ok := _win32.SetConsoleMode(handle_out, dword_out_mode)):
             raise RuntimeError(f"ConsoleMode set failed for output. Err: {ok!r}")
-        ok = _win32.SetConsoleMode(handle_in, dword_in_mode)
-        if not ok:
+
+        if not (ok := _win32.SetConsoleMode(handle_in, dword_in_mode)):
             raise RuntimeError(f"ConsoleMode set failed for input. Err: {ok!r}")
         self._alternate_buffer = alternate_buffer
         self._next_timeout = self.max_wait
@@ -121,11 +120,11 @@ class Screen(_raw_display_base.Screen):
 
         handle_out = _win32.GetStdHandle(_win32.STD_OUTPUT_HANDLE)
         handle_in = _win32.GetStdHandle(_win32.STD_INPUT_HANDLE)
-        ok = _win32.SetConsoleMode(handle_out, self._dwOriginalOutMode)
-        if not ok:
+
+        if not (ok := _win32.SetConsoleMode(handle_out, self._dwOriginalOutMode)):
             raise RuntimeError(f"ConsoleMode set failed for output. Err: {ok!r}")
-        ok = _win32.SetConsoleMode(handle_in, self._dwOriginalInMode)
-        if not ok:
+
+        if not (ok := _win32.SetConsoleMode(handle_in, self._dwOriginalInMode)):
             raise RuntimeError(f"ConsoleMode set failed for input. Err: {ok!r}")
 
         super()._stop()
@@ -188,10 +187,9 @@ class Screen(_raw_display_base.Screen):
 
         with selectors.DefaultSelector() as selector:
             selector.register(fd, selectors.EVENT_READ)
-            input_ready = selector.select(0)
-            while input_ready:
+
+            while selector.select(0):
                 chars.extend(self._term_input_file.recv(1024))
-                input_ready = selector.select(0)
 
             return chars
 
@@ -204,8 +202,8 @@ class Screen(_raw_display_base.Screen):
                     raise RuntimeError("Unexpected terminal output file")
                 handle = _win32.GetStdHandle(_win32.STD_OUTPUT_HANDLE)
                 info = _win32.CONSOLE_SCREEN_BUFFER_INFO()
-                ok = _win32.GetConsoleScreenBufferInfo(handle, byref(info))
-                if ok:
+
+                if _win32.GetConsoleScreenBufferInfo(handle, byref(info)):
                     # Fallback will be used in case of term size could not be determined
                     y, x = info.dwSize.Y, info.dwSize.X
 
@@ -246,11 +244,12 @@ class ReadInputThread(threading.Thread):
                     if not inp.Event.KeyEvent.bKeyDown:
                         continue
 
-                    input_data = inp.Event.KeyEvent.uChar.AsciiChar
-                    # On Windows atomic press/release of modifier keys produce phantom input with code NULL
+                    input_data = inp.Event.KeyEvent.uChar.UnicodeChar
+                    # On Windows atomic press/release of modifier keys produce phantom input with code NULL.
                     # This input cannot be decoded and should be handled as garbage.
-                    if input_data != b"\x00":
-                        self._input.send(input_data)
+                    input_bytes = input_data.encode("utf-8")
+                    if input_bytes != b"\x00":
+                        self._input.send(input_bytes)
 
                 elif inp.EventType == _win32.EventType.WINDOW_BUFFER_SIZE_EVENT:
                     self._resize()

urwid/display/common.py

@@ -361,19 +361,21 @@ def _color_desc_88(num: int) -> str:
 
 
 def _parse_color_true(desc: str) -> int | None:
-    c = _parse_color_256(desc)
-    if c is not None:
+    if (c := _parse_color_256(desc)) is not None:
         (r, g, b) = _COLOR_VALUES_256[c]
         return (r << 16) + (g << 8) + b
 
     if not desc.startswith("#"):
         return None
+
     if len(desc) == 7:
         h = desc[1:]
         return int(h, 16)
+
     if len(desc) == 4:
         h = f"0x{desc[1]}0{desc[2]}0{desc[3]}"
         return int(h, 16)
+
     return None
 
 
@@ -409,16 +411,16 @@ def _parse_color_256(desc: str) -> int | None:
 
         if desc.startswith("#") and len(desc) == 4:
             # color-cube coordinates
-            rgb = int(desc[1:], 16)
-            if rgb < 0:
-                return None
-            b, rgb = rgb % 16, rgb // 16
-            g, r = rgb % 16, rgb // 16
-            # find the closest rgb values
-            r = _CUBE_256_LOOKUP_16[r]
-            g = _CUBE_256_LOOKUP_16[g]
-            b = _CUBE_256_LOOKUP_16[b]
-            return _CUBE_START + (r * _CUBE_SIZE_256 + g) * _CUBE_SIZE_256 + b
+            if (rgb := int(desc[1:], 16)) >= 0:
+                b, rgb = rgb % 16, rgb // 16
+                g, r = rgb % 16, rgb // 16
+                # find the closest rgb values
+                r = _CUBE_256_LOOKUP_16[r]
+                g = _CUBE_256_LOOKUP_16[g]
+                b = _CUBE_256_LOOKUP_16[b]
+                return _CUBE_START + (r * _CUBE_SIZE_256 + g) * _CUBE_SIZE_256 + b
+
+            return None
 
         # Only remaining possibility is gray value
         if desc.startswith("g#"):
@@ -489,16 +491,16 @@ def _parse_color_88(desc: str) -> int | None:
 
         if desc.startswith("#") and len(desc) == 4:
             # color-cube coordinates
-            rgb = int(desc[1:], 16)
-            if rgb < 0:
-                return None
-            b, rgb = rgb % 16, rgb // 16
-            g, r = rgb % 16, rgb // 16
-            # find the closest rgb values
-            r = _CUBE_88_LOOKUP_16[r]
-            g = _CUBE_88_LOOKUP_16[g]
-            b = _CUBE_88_LOOKUP_16[b]
-            return _CUBE_START + (r * _CUBE_SIZE_88 + g) * _CUBE_SIZE_88 + b
+            if (rgb := int(desc[1:], 16)) >= 0:
+                b, rgb = rgb % 16, rgb // 16
+                g, r = rgb % 16, rgb // 16
+                # find the closest rgb values
+                r = _CUBE_88_LOOKUP_16[r]
+                g = _CUBE_88_LOOKUP_16[g]
+                b = _CUBE_88_LOOKUP_16[b]
+                return _CUBE_START + (r * _CUBE_SIZE_88 + g) * _CUBE_SIZE_88 + b
+
+            return None
 
         # Only remaining possibility is gray value
         if desc.startswith("g#"):
@@ -704,15 +706,6 @@ class AttrSpec:
             return 16
         return 1
 
-    def _colors(self) -> int:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._colors` is deprecated, "
-            f"please use property `{self.__class__.__name__}.colors`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.colors
-
     def __repr__(self) -> str:
         """
         Return an executable python representation of the AttrSpec
@@ -785,15 +778,6 @@ class AttrSpec:
             color = 0
         self.__value = (self.__value & ~_FG_MASK) | color | flags
 
-    def _foreground(self) -> str:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._foreground` is deprecated, "
-            f"please use property `{self.__class__.__name__}.foreground`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.foreground
-
     @property
     def background(self) -> str:
         """Return the background color."""
@@ -827,15 +811,6 @@ class AttrSpec:
             raise AttrSpecError(f"Unrecognised color specification in background ({background!r})")
         self.__value = (self.__value & ~_BG_MASK) | (color << _BG_SHIFT) | flags
 
-    def _background(self) -> str:
-        warnings.warn(
-            f"Method `{self.__class__.__name__}._background` is deprecated, "
-            f"please use property `{self.__class__.__name__}.background`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.background
-
     def get_rgb_values(self) -> tuple[int | None, int | None, int | None, int | None, int | None, int | None]:
         """
         Return (fg_red, fg_green, fg_blue, bg_red, bg_green, bg_blue) color
@@ -988,13 +963,9 @@ class ScreenError(Exception):
     pass
 
 
-class BaseMeta(signals.MetaSignals, abc.ABCMeta):
-    """Base metaclass for abstra"""
-
-
-class BaseScreen(metaclass=BaseMeta):
+class BaseScreen(abc.ABC, metaclass=signals.MetaSignals):
     """
-    Base class for Screen classes (raw_display.Screen, .. etc)
+    Base class for Screen classes (raw_display.Screen, ..., etc.)
     """
 
     signals: typing.ClassVar[list[str]] = [UPDATE_PALETTE_ENTRY, INPUT_DESCRIPTORS_CHANGED]

urwid/display/curses.py

@@ -124,7 +124,7 @@ class Screen(BaseScreen, RealTerminal):
         After calling this function get_input will include mouse
         click events along with keystrokes.
         """
-        enable = bool(enable)  # noqa: FURB123,RUF100
+        enable = bool(enable)
         if enable == self._mouse_tracking_enabled:
             return