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

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
 
@@ -211,7 +211,7 @@ class Screen(BaseScreen, RealTerminal):
         Restore the screen.
         """
 
-    def write(self, data):
+    def write(self, data: str) -> None:
         """Write some data to the terminal.
 
         You may wish to override this if you're using something other than
@@ -219,7 +219,7 @@ class Screen(BaseScreen, RealTerminal):
         """
         self._term_output_file.write(data)
 
-    def flush(self):
+    def flush(self) -> None:
         """Flush the output buffer.
 
         You may wish to override this if you're using something other than
@@ -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
 
@@ -352,7 +352,11 @@ class Screen(BaseScreen, RealTerminal):
 
     _input_timeout = None
 
-    def _make_legacy_input_wrapper(self, event_loop, callback):
+    def _make_legacy_input_wrapper(
+        self,
+        event_loop: EventLoop,
+        callback: Callable[[list[str], list[int]], typing.Any],
+    ) -> Callable[[], None]:
         """
         Support old Screen classes that still have a get_input_nonblocking and expect it to work.
         """
@@ -641,7 +645,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 +731,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],
@@ -783,9 +790,9 @@ class Screen(BaseScreen, RealTerminal):
         >>> s = Screen()
         >>> s.set_terminal_properties(colors=256)
         >>> a2e = s._attrspec_to_escape
-        >>> a2e(s.AttrSpec('brown', 'dark green'))
+        >>> a2e(s.AttrSpec("brown", "dark green"))
         '\\x1b[0;33;42m'
-        >>> a2e(s.AttrSpec('#fea,underline', '#d0d'))
+        >>> a2e(s.AttrSpec("#fea,underline", "#d0d"))
         '\\x1b[0;38;5;229;4;48;5;164m'
         """
         if self.term == "fbterm":
@@ -870,9 +877,8 @@ class Screen(BaseScreen, RealTerminal):
 
     def reset_default_terminal_palette(self) -> None:
         """
-        Attempt to set the terminal palette to default values as taken
-        from xterm.  Uses number of colors from current
-        set_terminal_properties() screen setting.
+        Attempt to set the terminal palette to default values as taken from xterm.
+        Uses a number of colors from the current set_terminal_properties() screen setting.
         """
         if self.colors == 1:
             return
@@ -895,9 +901,8 @@ class Screen(BaseScreen, RealTerminal):
         """
         entries - list of (index, red, green, blue) tuples.
 
-        Attempt to set part of the terminal palette (this does not work
-        on all terminals.)  The changes are sent as a single escape
-        sequence so they should all take effect at the same time.
+        Attempt to set part of the terminal palette (this does not work on all terminals.)
+        The changes are sent as a single escape sequence so they should all take effect at the same time.
 
         0 <= index < 256 (some terminals will only have 16 or 88 colors)
         0 <= red, green, blue < 256

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
 
 
@@ -387,13 +389,13 @@ def _parse_color_256(desc: str) -> int | None:
 
     Returns None if desc is invalid.
 
-    >>> _parse_color_256('h142')
+    >>> _parse_color_256("h142")
     142
-    >>> _parse_color_256('#f00')
+    >>> _parse_color_256("#f00")
     196
-    >>> _parse_color_256('g100')
+    >>> _parse_color_256("g100")
     231
-    >>> _parse_color_256('g#80')
+    >>> _parse_color_256("g#80")
     244
     """
     if len(desc) > 4:
@@ -409,21 +411,21 @@ 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#"):
             # hex value 00..ff
-            gray = int(desc[2:], 16)
+            gray = int(desc[2:], 16)  # noqa: FURB166
             if gray < 0 or gray > 255:
                 return None
             gray = _GRAY_256_LOOKUP[gray]
@@ -464,14 +466,14 @@ def _parse_color_88(desc: str) -> int | None:
 
     Returns None if desc is invalid.
 
-    >>> _parse_color_88('h142')
-    >>> _parse_color_88('h42')
+    >>> _parse_color_88("h142")
+    >>> _parse_color_88("h42")
     42
-    >>> _parse_color_88('#f00')
+    >>> _parse_color_88("#f00")
     64
-    >>> _parse_color_88('g100')
+    >>> _parse_color_88("g100")
     79
-    >>> _parse_color_88('g#80')
+    >>> _parse_color_88("g#80")
     83
     """
     if len(desc) == 7:
@@ -489,21 +491,21 @@ 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#"):
             # hex value 00..ff
-            gray = int(desc[2:], 16)
+            gray = int(desc[2:], 16)  # noqa: FURB166
             if gray < 0 or gray > 255:
                 return None
             gray = _GRAY_88_LOOKUP[gray]
@@ -580,13 +582,13 @@ class AttrSpec:
                    values are only usable with 88, 256, or 2**24 colors.  With
                    1 color only the foreground settings may be used.
 
-        >>> AttrSpec('dark red', 'light gray', 16)
+        >>> AttrSpec("dark red", "light gray", 16)
         AttrSpec('dark red', 'light gray')
-        >>> AttrSpec('yellow, underline, bold', 'dark blue')
+        >>> AttrSpec("yellow, underline, bold", "dark blue")
         AttrSpec('yellow,bold,underline', 'dark blue')
-        >>> AttrSpec('#ddb', '#004', 256) # closest colors will be found
+        >>> AttrSpec("#ddb", "#004", 256)  # closest colors will be found
         AttrSpec('#dda', '#006')
-        >>> AttrSpec('#ddb', '#004', 88)
+        >>> AttrSpec("#ddb", "#004", 88)
         AttrSpec('#ccc', '#000', colors=88)
         """
         if colors not in {1, 16, 88, 256, 2**24}:
@@ -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
@@ -775,7 +768,7 @@ class AttrSpec:
             else:
                 scolor = _parse_color_256(_true_to_256(part) or part)
                 flags |= _FG_HIGH_COLOR
-            # _parse_color_*() return None for unrecognised colors
+            # _parse_color_*() return None for unrecognized colors
             if scolor is None:
                 raise AttrSpecError(f"Unrecognised color specification {part!r} in foreground ({foreground!r})")
             if color is not None:
@@ -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
@@ -845,9 +820,9 @@ class AttrSpec:
         If the foreground or background is 'default' then all their compenents
         will be returned as None.
 
-        >>> AttrSpec('yellow', '#ccf', colors=88).get_rgb_values()
+        >>> AttrSpec("yellow", "#ccf", colors=88).get_rgb_values()
         (255, 255, 0, 205, 205, 255)
-        >>> AttrSpec('default', 'g92').get_rgb_values()
+        >>> AttrSpec("default", "g92").get_rgb_values()
         (None, None, None, 238, 238, 238)
         """
         if not (self.foreground_basic or self.foreground_high or self.foreground_true):
@@ -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]
@@ -1040,7 +1011,7 @@ class BaseScreen(metaclass=BaseMeta):
     def _stop(self) -> None:
         pass
 
-    def run_wrapper(self, fn, *args, **kwargs):
+    def run_wrapper(self, fn, *args, **kwargs) -> None:
         """Start the screen, call a function, then stop the screen.  Extra
         arguments are passed to `start`.
 

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
 
@@ -563,9 +563,7 @@ class Screen(BaseScreen, RealTerminal):
 
         logger.debug(f"Drawing screen with size {size!r}")
 
-        y = -1
-        for row in canvas.content():
-            y += 1
+        for y, row in enumerate(canvas.content()):
             try:
                 self.s.move(y, 0)
             except curses.error:
@@ -596,7 +594,7 @@ class Screen(BaseScreen, RealTerminal):
                             raise TypeError(seg)
                         self.s.addstr(seg.decode(util.get_encoding()))
                 except curses.error:
-                    # it's ok to get out of the
+                    # it's OK to get out of the
                     # screen on the lower right
                     if y != rows - 1 or nr != len(row) - 1:
                         # perhaps screen size changed

urwid/display/escape.py

@@ -32,7 +32,7 @@ from collections.abc import MutableMapping, Sequence
 from urwid import str_util
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Collection, Iterable
+    from collections.abc import Iterable
 
 # NOTE: because of circular imports (urwid.util -> urwid.escape -> urwid.util)
 # from urwid.util import is_mouse_event -- will not work here
@@ -85,6 +85,8 @@ input_sequences = [
     ("[F", "end"),
     ("[G", "5"),
     ("[H", "home"),
+    ("[I", "focus in"),
+    ("[O", "focus out"),
     ("[1~", "home"),
     ("[2~", "insert"),
     ("[3~", "delete"),
@@ -214,10 +216,10 @@ class KeyqueueTrie:
         root[ord(s)] = result
 
     def get(self, keys, more_available: bool):
-        result = self.get_recurse(self.data, keys, more_available)
-        if not result:
-            result = self.read_cursor_position(keys, more_available)
-        return result
+        if result := self.get_recurse(self.data, keys, more_available):
+            return result
+
+        return self.read_cursor_position(keys, more_available)
 
     def get_recurse(
         self,
@@ -225,7 +227,7 @@ class KeyqueueTrie:
             MutableMapping[int, str | MutableMapping[int, str | MutableMapping[int, str]]]
             | typing.Literal["mouse", "sgrmouse"]
         ),
-        keys: Collection[int],
+        keys: Sequence[int],
         more_available: bool,
     ):
         if not isinstance(root, MutableMapping):
@@ -245,7 +247,11 @@ class KeyqueueTrie:
             return None
         return self.get_recurse(root[keys[0]], keys[1:], more_available)
 
-    def read_mouse_info(self, keys: Collection[int], more_available: bool):
+    def read_mouse_info(
+        self,
+        keys: Sequence[int],
+        more_available: bool,
+    ) -> tuple[tuple[str, int, int, int], Sequence[int]] | None:
         if len(keys) < 3:
             if more_available:
                 raise MoreInputRequired()
@@ -284,7 +290,11 @@ class KeyqueueTrie:
 
         return ((f"{prefix}mouse {action}", button, x, y), keys[3:])
 
-    def read_sgrmouse_info(self, keys: Collection[int], more_available: bool):
+    def read_sgrmouse_info(
+        self,
+        keys: Sequence[int],
+        more_available: bool,
+    ) -> tuple[tuple[str, int, int, int], Sequence[int]] | None:
         # Helpful links:
         # https://stackoverflow.com/questions/5966903/how-to-get-mousemove-and-mouseclick-in-bash
         # http://invisible-island.net/xterm/ctlseqs/ctlseqs.pdf
@@ -343,7 +353,11 @@ class KeyqueueTrie:
 
         return ((f"{prefix}mouse {action}", button, x, y), keys[pos_m + 1 :])
 
-    def read_cursor_position(self, keys, more_available: bool):
+    def read_cursor_position(
+        self,
+        keys: Sequence[int],
+        more_available: bool,
+    ) -> tuple[tuple[str, int, int], Sequence[int]] | None:
         """
         Interpret cursor position information being sent by the
         user's terminal.  Returned as ('cursor position', x, y)
@@ -538,9 +552,7 @@ def process_keyqueue(codes: Sequence[int], more_available: bool) -> tuple[list[s
     if code != 27:
         return [f"<{code:d}>"], codes[1:]
 
-    result = input_trie.get(codes[1:], more_available)
-
-    if result is not None:
+    if (result := input_trie.get(codes[1:], more_available)) is not None:
         result, remaining_codes = result
         return [result], remaining_codes
 
@@ -551,7 +563,7 @@ def process_keyqueue(codes: Sequence[int], more_available: bool) -> tuple[list[s
             return ["esc", *run], remaining_codes
         if run[0] == "esc" or run[0].find("meta ") >= 0:
             return ["esc", *run], remaining_codes
-        return [f"meta {run[0]}"] + run[1:], remaining_codes
+        return [f"meta {run[0]}", *run[1:]], remaining_codes
 
     return ["esc"], codes[1:]
 
@@ -574,6 +586,9 @@ RESTORE_NORMAL_BUFFER = f"{ESC}[?1049l"
 ENABLE_BRACKETED_PASTE_MODE = f"{ESC}[?2004h"
 DISABLE_BRACKETED_PASTE_MODE = f"{ESC}[?2004l"
 
+ENABLE_FOCUS_REPORTING = f"{ESC}[?1004h"
+DISABLE_FOCUS_REPORTING = f"{ESC}[?1004l"
+
 # RESET_SCROLL_REGION = ESC+"[;r"
 # RESET = ESC+"c"
 

urwid/display/lcd.py

@@ -125,8 +125,8 @@ class CFLCDScreen(LCDScreen, abc.ABC):
 
     @classmethod
     def get_crc(cls, buf: Iterable[int]) -> bytes:
-        # This seed makes the output of this shift based algorithm match
-        # the table based algorithm. The center 16 bits of the 32-bit
+        # This seed makes the output of this shift-based algorithm match
+        # the table-based algorithm. The center 16 bits of the 32-bit
         # "newCRC" are used for the CRC. The MSB of the lower byte is used
         # to see what bit was shifted out of the center 16 bit CRC
         # accumulator ("carry flag analog");
@@ -218,10 +218,9 @@ class CFLCDScreen(LCDScreen, abc.ABC):
             raise cls.MoreDataRequired
 
         data_end = 2 + packet_len
-        crc = cls.get_crc(data[:data_end])
-        pcrc = data[data_end : data_end + 2]
-        if crc != pcrc:
-            raise cls.InvalidPacket("CRC doesn't match")
+        if (crc := cls.get_crc(data[:data_end])) != (packet_crc := data[data_end : data_end + 2]):
+            raise cls.InvalidPacket(f"CRC doesn't match ({crc=}, {packet_crc=})")
+
         return command, data[2:data_end], data[data_end + 2 :]
 
 
@@ -230,7 +229,7 @@ class KeyRepeatSimulator:
     Provide simulated repeat key events when given press and
     release events.
 
-    If two or more keys are pressed disable repeating until all
+    If two or more keys are pressed, disable repeating until all
     keys are released.
     """
 
@@ -287,7 +286,7 @@ class CF635Screen(CFLCDScreen):
     20x4 character display + cursor
     no foreground/background colors or settings supported
 
-    see CGROM for list of close unicode matches to characters available
+    see CGROM for a list of close Unicode matches to characters available
 
     6 button input
     up, down, left, right, enter (check mark), exit (cross)
@@ -401,8 +400,7 @@ class CF635Screen(CFLCDScreen):
 
             packet = self._read_packet()
 
-        next_repeat = self.key_repeat.next_event()
-        if next_repeat:
+        if next_repeat := self.key_repeat.next_event():
             timeout, key = next_repeat
             if not timeout:
                 data_input.append(key)