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

urwid/__init__.py

@@ -21,7 +21,7 @@
 
 from __future__ import annotations
 
-import importlib
+import importlib.util
 import sys
 import types
 import typing
@@ -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:
@@ -268,12 +265,28 @@ _moved_warn: dict[str, str] = {
 }
 # Backward compatible lazy load without any warnings
 # Before DeprecationWarning need to start PendingDeprecationWarning process.
-_moved_no_warn: dict[str, str] = {
-    "display_common": "urwid.display.common",
-    "raw_display": "urwid.display.raw",
-    "curses_display": "urwid.display.curses",
-    "escape": "urwid.display.escape",
-}
+
+
+def lazy_import(name: str, package: str | None = None) -> types.ModuleType:
+    """Lazy import implementation from Python documentation.
+
+    Useful for cases where no warnings expected for moved modules.
+    """
+    spec = importlib.util.find_spec(name, package)
+    if not spec:
+        raise ImportError(f"No module named {name!r}")
+    if not spec.loader:
+        raise ImportError(f"Module named {name!r} is invalid")
+
+    loader = importlib.util.LazyLoader(spec.loader)
+    spec.loader = loader
+    module = importlib.util.module_from_spec(spec)
+    if not package:
+        sys.modules[name] = module
+    else:
+        sys.modules[f"{package.rstrip('.')}.{name.lstrip('.')}"] = module
+    loader.exec_module(module)
+    return module
 
 
 class _MovedModule(types.ModuleType):
@@ -296,6 +309,12 @@ class _MovedModule(types.ModuleType):
         return getattr(real_module, name)
 
 
+display_common = lazy_import("urwid.display.common")
+raw_display = lazy_import("urwid.display.raw")
+curses_display = lazy_import("urwid.display.curses")
+escape = lazy_import("urwid.display.escape")
+
+
 class _MovedModuleWarn(_MovedModule):
     """Special class to handle moved modules.
 
@@ -313,10 +332,6 @@ class _MovedModuleWarn(_MovedModule):
         return super().__getattr__(name)
 
 
-for _name, _module in _moved_no_warn.items():
-    _module_path = f"{__name__}.{_name}"
-    sys.modules[_module_path] = _MovedModule(_module_path, _module)
-
 for _name, _module in _moved_warn.items():
     _module_path = f"{__name__}.{_name}"
     sys.modules[_module_path] = _MovedModuleWarn(_module_path, _module)
@@ -328,11 +343,6 @@ def __getattr__(name: str) -> typing.Any:
     :return: attribute by name
     :raises AttributeError: attribute is not defined for lazy load
     """
-    if name in _moved_no_warn:
-        mod = importlib.import_module(_moved_no_warn[name])
-        __locals[name] = mod
-        return mod
-
     if name in _moved_warn:
         warnings.warn(
             f"{name} is moved to {_moved_warn[name]}",

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
 
@@ -85,7 +84,7 @@ class CanvasCache:
     cleanups = 0
 
     @classmethod
-    def store(cls, wcls, canvas: Canvas) -> None:
+    def store(cls, wcls: type[Widget], canvas: Canvas) -> None:
         """
         Store a weakref to canvas in the cache.
 
@@ -99,7 +98,7 @@ class CanvasCache:
             raise TypeError("Can't store canvas without widget_info")
         widget, size, focus = canvas.widget_info
 
-        def walk_depends(canv):
+        def walk_depends(canv: Canvas) -> list[Widget]:
             """
             Collect all child widgets for determining who we
             depend on.
@@ -126,10 +125,10 @@ 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:
+    def fetch(cls, widget: Widget, wcls: type[Widget], size, focus: bool) -> Canvas | None:
         """
         Return the cached canvas or None.
 
@@ -151,7 +150,7 @@ class CanvasCache:
         return canv
 
     @classmethod
-    def invalidate(cls, widget):
+    def invalidate(cls, widget: Widget) -> None:
         """
         Remove all canvases cached for widget.
         """
@@ -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]
@@ -215,7 +214,7 @@ class Canvas:
 
     def __init__(self) -> None:
         """Base Canvas class"""
-        self._widget_info = None
+        self._widget_info: tuple[Widget, tuple[[]] | tuple[int] | tuple[int, int], bool] | None = None
         self.coords: dict[str, tuple[int, int, tuple[Widget, int, int]] | tuple[int, int, None]] = {}
         self.shortcuts: dict[str, str] = {}
 
@@ -241,18 +240,9 @@ class Canvas:
         self._widget_info = widget, size, focus
 
     @property
-    def widget_info(self):
+    def widget_info(self) -> tuple[Widget, tuple[[]] | tuple[int] | tuple[int, int], bool] | None:
         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,19 +1166,19 @@ 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):
-    return (cv[0], trim + cv[1], cv[2], cv[3] - trim) + cv[4:]
+    return (cv[0], trim + cv[1], cv[2], cv[3] - trim, *cv[4:])
 
 
 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/__init__.py

@@ -2,9 +2,40 @@
 
 from __future__ import annotations
 
-import importlib
+import importlib.util
+import sys
 import typing
 
+from . import raw
+from .common import (
+    BLACK,
+    BROWN,
+    DARK_BLUE,
+    DARK_CYAN,
+    DARK_GRAY,
+    DARK_GREEN,
+    DARK_MAGENTA,
+    DARK_RED,
+    DEFAULT,
+    LIGHT_BLUE,
+    LIGHT_CYAN,
+    LIGHT_GRAY,
+    LIGHT_GREEN,
+    LIGHT_MAGENTA,
+    LIGHT_RED,
+    UPDATE_PALETTE_ENTRY,
+    WHITE,
+    YELLOW,
+    AttrSpec,
+    AttrSpecError,
+    BaseScreen,
+    RealTerminal,
+    ScreenError,
+)
+
+if typing.TYPE_CHECKING:
+    import types
+
 __all__ = (
     "BLACK",
     "BROWN",
@@ -36,33 +67,6 @@ __all__ = (
     "web",
 )
 
-from . import raw
-from .common import (
-    BLACK,
-    BROWN,
-    DARK_BLUE,
-    DARK_CYAN,
-    DARK_GRAY,
-    DARK_GREEN,
-    DARK_MAGENTA,
-    DARK_RED,
-    DEFAULT,
-    LIGHT_BLUE,
-    LIGHT_CYAN,
-    LIGHT_GRAY,
-    LIGHT_GREEN,
-    LIGHT_MAGENTA,
-    LIGHT_RED,
-    UPDATE_PALETTE_ENTRY,
-    WHITE,
-    YELLOW,
-    AttrSpec,
-    AttrSpecError,
-    BaseScreen,
-    RealTerminal,
-    ScreenError,
-)
-
 try:
     from . import curses
 
@@ -70,28 +74,29 @@ try:
 except ImportError:
     pass
 
-# Moved modules handling
-__locals: dict[str, typing.Any] = locals()  # use mutable access for pure lazy loading
 
-# Lazy load modules
-_lazy_load: frozenset[str] = frozenset(
-    (
-        "html_fragment",
-        "lcd",
-        "web",
-    )
-)
+def lazy_import(name: str, package: str | None = None) -> types.ModuleType:
+    """Lazy import implementation from Python documentation.
 
+    Useful for cases where no warnings expected for moved modules.
+    """
+    spec = importlib.util.find_spec(name, package)
+    if not spec:
+        raise ImportError(f"No module named {name!r}")
+    if not spec.loader:
+        raise ImportError(f"Module named {name!r} is invalid")
 
-def __getattr__(name: str) -> typing.Any:
-    """Get attributes lazy.
+    loader = importlib.util.LazyLoader(spec.loader)
+    spec.loader = loader
+    module = importlib.util.module_from_spec(spec)
+    if not package:
+        sys.modules[name] = module
+    else:
+        sys.modules[f"{package.rstrip('.')}.{name.lstrip('.')}"] = module
+    loader.exec_module(module)
+    return module
 
-    :return: attribute by name
-    :raises AttributeError: attribute is not defined for lazy load
-    """
-    if name in _lazy_load:
-        mod = importlib.import_module(f"{__package__}.{name}")
-        __locals[name] = mod
-        return mod
 
-    raise AttributeError(f"{name} not found in {__package__}")
+html_fragment = lazy_import(".html_fragment", __package__)
+lcd = lazy_import(".lcd", __package__)
+web = lazy_import(".web", __package__)

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:
@@ -148,7 +154,7 @@ class Screen(_raw_display_base.Screen):
         if not os.environ.get("TERM", "").lower().startswith("linux"):
             return
 
-        m = Popen(  # noqa: S603  # pylint: disable=consider-using-with
+        m = Popen(  # pylint: disable=consider-using-with
             ["/usr/bin/mev", "-e", "158"],
             stdin=PIPE,
             stdout=PIPE,
@@ -169,7 +175,7 @@ class Screen(_raw_display_base.Screen):
         """
         Initialize the screen and input mode.
 
-        alternate_buffer -- use alternate screen buffer
+        alternate_buffer -- use an alternate screen buffer
         """
         if alternate_buffer:
             self.write(escape.SWITCH_TO_ALTERNATE_BUFFER)
@@ -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)
@@ -391,8 +403,8 @@ class Screen(_raw_display_base.Screen):
         y, x = super().get_cols_rows()
         with contextlib.suppress(OSError):  # Term size could not be determined
             if hasattr(self._term_output_file, "fileno"):
-                buf = fcntl.ioctl(self._term_output_file.fileno(), termios.TIOCGWINSZ, b" " * 4)
-                y, x = struct.unpack("hh", buf)
+                buf = fcntl.ioctl(self._term_output_file.fileno(), termios.TIOCGWINSZ, b" " * 8)
+                y, x, _, _ = struct.unpack("hhhh", buf)
 
         # Provide some lightweight fallbacks in case the TIOCWINSZ doesn't
         # give sane answers