Upgrade to Python 3.10+

Author: sebastinas

curtsies/escseqparse.py

@@ -41,7 +41,7 @@ def remove_ansi(s: str) -> str:
     return re.sub(r"(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]", "", s)
 
 
-def parse(s: str) -> list[Union[str, dict[str, Union[str, bool, None]]]]:
+def parse(s: str) -> list[str | dict[str, str | bool | None]]:
     r"""
     Returns a list of strings or format dictionaries to describe the strings.
 
@@ -52,7 +52,7 @@ def parse(s: str) -> list[Union[str, dict[str, Union[str, bool, None]]]]:
     >>> parse("\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m")
     [{'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}]
     """
-    stuff: list[Union[str, dict[str, Union[str, bool, None]]]] = []
+    stuff: list[str | dict[str, str | bool | None]] = []
     rest = s
     while True:
         front, token, rest = peel_off_esc_code(rest)
@@ -73,7 +73,7 @@ def parse(s: str) -> list[Union[str, dict[str, Union[str, bool, None]]]]:
     return stuff
 
 
-def peel_off_esc_code(s: str) -> tuple[str, Optional[Token], str]:
+def peel_off_esc_code(s: str) -> tuple[str, Token | None, str]:
     r"""Returns processed text, the next token, and unprocessed text
 
     >>> front, d, rest = peel_off_esc_code('somestuff')
@@ -125,12 +125,12 @@ def peel_off_esc_code(s: str) -> tuple[str, Optional[Token], str]:
         return s, None, ""
 
 
-def token_type(info: Token) -> Optional[list[dict[str, Union[str, bool, None]]]]:
+def token_type(info: Token) -> list[dict[str, str | bool | None]] | None:
     if info["command"] == "m":
         # The default action for ESC[m is to act like ESC[0m
         # Ref: https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
         values = cast(list[int], info["numbers"]) if len(info["numbers"]) else [0]
-        tokens: list[dict[str, Union[str, bool, None]]] = []
+        tokens: list[dict[str, str | bool | None]] = []
         for value in values:
             if value in FG_NUMBER_TO_COLOR:
                 tokens.append({"fg": FG_NUMBER_TO_COLOR[value]})

curtsies/events.py

@@ -105,9 +105,7 @@ def __init__(self, when: float) -> None:
 
 
 class WindowChangeEvent(Event):
-    def __init__(
-        self, rows: int, columns: int, cursor_dy: Optional[int] = None
-    ) -> None:
+    def __init__(self, rows: int, columns: int, cursor_dy: int | None = None) -> None:
         self.rows = rows
         self.columns = columns
         self.cursor_dy = cursor_dy
@@ -202,7 +200,7 @@ def get_key(
     encoding: str,
     keynames: Keynames = Keynames.CURTSIES,
     full: bool = False,
-) -> Optional[str]:
+) -> str | None:
     """Return key pressed from bytes_ or None
 
     Return a key name or None meaning it's an incomplete sequence of bytes
@@ -281,7 +279,7 @@ def could_be_unfinished_utf8(seq: bytes) -> bool:
     )
 
 
-def pp_event(seq: Union[Event, str]) -> Union[str, bytes]:
+def pp_event(seq: Event | str) -> str | bytes:
     """Returns pretty representation of an Event or keypress"""
 
     if isinstance(seq, Event):
@@ -290,7 +288,7 @@ def pp_event(seq: Union[Event, str]) -> Union[str, bytes]:
     # Get the original sequence back if seq is a pretty name already
     rev_curses = {v: k for k, v in CURSES_NAMES.items()}
     rev_curtsies = {v: k for k, v in CURTSIES_NAMES.items()}
-    bytes_seq: Optional[bytes] = None
+    bytes_seq: bytes | None = None
     if seq in rev_curses:
         bytes_seq = rev_curses[seq]
     elif seq in rev_curtsies:
@@ -303,7 +301,7 @@ def pp_event(seq: Union[Event, str]) -> Union[str, bytes]:
     return repr(seq).lstrip("u")[1:-1]
 
 
-def curtsies_name(seq: bytes) -> Union[str, bytes]:
+def curtsies_name(seq: bytes) -> str | bytes:
     return CURTSIES_NAMES.get(seq, seq)
 
 

curtsies/formatstring.py

@@ -25,7 +25,6 @@
 from itertools import chain
 from typing import (
     Any,
-    Callable,
     Dict,
     List,
     Optional,
@@ -34,7 +33,7 @@
     cast,
     no_type_check,
 )
-from collections.abc import Iterable, Iterator, Mapping, MutableMapping
+from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping
 
 from .escseqparse import parse, remove_ansi
 from .termformatconstants import (
@@ -59,21 +58,21 @@
 }
 
 two_arg_xforms: Mapping[str, Callable[[str, int], str]] = {
-    "fg": lambda s, v: "{}{}{}".format(seq(v), s, seq(RESET_FG)),
+    "fg": lambda s, v: f"{seq(v)}{s}{seq(RESET_FG)}",
     "bg": lambda s, v: seq(v) + s + seq(RESET_BG),
 }
 
 
 class FrozenAttributes(dict[str, Union[int, bool]]):
     """Immutable dictionary class for format string attributes"""
 
-    def __setitem__(self, key: str, value: Union[int, bool]) -> None:
+    def __setitem__(self, key: str, value: int | bool) -> None:
         raise Exception("Cannot change value.")
 
     def update(self, *args: Any, **kwds: Any) -> None:
         raise Exception("Cannot change value.")
 
-    def extend(self, dictlike: Mapping[str, Union[int, bool]]) -> "FrozenAttributes":
+    def extend(self, dictlike: Mapping[str, int | bool]) -> "FrozenAttributes":
         return FrozenAttributes(chain(self.items(), dictlike.items()))
 
     def remove(self, *keys: str) -> "FrozenAttributes":
@@ -103,9 +102,7 @@ class Chunk:
 
     Subject to change, not part of the API"""
 
-    def __init__(
-        self, string: str, atts: Optional[Mapping[str, Union[int, bool]]] = None
-    ):
+    def __init__(self, string: str, atts: Mapping[str, int | bool] | None = None):
         if not isinstance(string, str):
             raise ValueError("unicode string required, got %r" % string)
         self._s = string
@@ -212,7 +209,7 @@ def reinit(self, chunk: Chunk) -> None:
             divides.append(divides[-1] + wcwidth(c))
         self.divides = divides
 
-    def request(self, max_width: int) -> Optional[tuple[int, Chunk]]:
+    def request(self, max_width: int) -> tuple[int, Chunk] | None:
         """Requests a sub-chunk of max_width or shorter. Returns None if no chunks left."""
         if max_width < 1:
             raise ValueError("requires positive integer max_width")
@@ -279,10 +276,10 @@ def __init__(self, *components: Chunk) -> None:
         self.chunks = list(components)
 
         # caching these leads to a significant speedup
-        self._unicode: Optional[str] = None
-        self._len: Optional[int] = None
-        self._s: Optional[str] = None
-        self._width: Optional[int] = None
+        self._unicode: str | None = None
+        self._len: int | None = None
+        self._s: str | None = None
+        self._width: int | None = None
 
     @staticmethod
     def from_str(s: str) -> "FmtStr":
@@ -349,7 +346,7 @@ def setslice_with_length(
         return result
 
     def splice(
-        self, new_str: Union[str, "FmtStr"], start: int, end: Optional[int] = None
+        self, new_str: Union[str, "FmtStr"], start: int, end: int | None = None
     ) -> "FmtStr":
         """Returns a new FmtStr with the input string spliced into the
         the original FmtStr at start and end.
@@ -401,7 +398,7 @@ def splice(
     def append(self, string: Union[str, "FmtStr"]) -> "FmtStr":
         return self.splice(string, len(self.s))
 
-    def copy_with_new_atts(self, **attributes: Union[bool, int]) -> "FmtStr":
+    def copy_with_new_atts(self, **attributes: bool | int) -> "FmtStr":
         """Returns a new FmtStr with the same content but new formatting"""
 
         return FmtStr(
@@ -426,8 +423,8 @@ def join(self, iterable: Iterable[Union[str, "FmtStr"]]) -> "FmtStr":
     # TODO make this split work like str.split
     def split(
         self,
-        sep: Optional[str] = None,
-        maxsplit: Optional[int] = None,
+        sep: str | None = None,
+        maxsplit: int | None = None,
         regex: bool = False,
     ) -> list["FmtStr"]:
         """Split based on separator, optionally using a regex.
@@ -462,7 +459,7 @@ def splitlines(self, keepends: bool = False) -> list["FmtStr"]:
 
     # proxying to the string via __getattr__ is insufficient
     # because we shouldn't drop foreground or formatting info
-    def ljust(self, width: int, fillchar: Optional[str] = None) -> "FmtStr":
+    def ljust(self, width: int, fillchar: str | None = None) -> "FmtStr":
         """S.ljust(width[, fillchar]) -> string
 
         If a fillchar is provided, less formatting information will be preserved
@@ -477,7 +474,7 @@ def ljust(self, width: int, fillchar: Optional[str] = None) -> "FmtStr":
             uniform = self.new_with_atts_removed("bg")
             return uniform + fmtstr(to_add, **self.shared_atts) if to_add else uniform
 
-    def rjust(self, width: int, fillchar: Optional[str] = None) -> "FmtStr":
+    def rjust(self, width: int, fillchar: str | None = None) -> "FmtStr":
         """S.rjust(width[, fillchar]) -> string
 
         If a fillchar is provided, less formatting information will be preserved
@@ -557,7 +554,7 @@ def __mul__(self, other: int) -> "FmtStr":
     # TODO ensure empty FmtStr isn't a problem
 
     @property
-    def shared_atts(self) -> dict[str, Union[int, bool]]:
+    def shared_atts(self) -> dict[str, int | bool]:
         """Gets atts shared among all nonzero length component Chunks"""
         # TODO cache this, could get ugly for large FmtStrs
         atts = {}
@@ -611,7 +608,7 @@ def s(self) -> str:
         self._s = "".join(fs.s for fs in self.chunks)
         return self._s
 
-    def __getitem__(self, index: Union[int, slice]) -> "FmtStr":
+    def __getitem__(self, index: int | slice) -> "FmtStr":
         index = normalize_slice(len(self), index)
         counter = 0
         parts = []
@@ -631,7 +628,7 @@ def __getitem__(self, index: Union[int, slice]) -> "FmtStr":
                 break
         return FmtStr(*parts) if parts else fmtstr("")
 
-    def width_aware_slice(self, index: Union[int, slice]) -> "FmtStr":
+    def width_aware_slice(self, index: int | slice) -> "FmtStr":
         """Slice based on the number of columns it would take to display the substring."""
         if wcswidth(self.s, None) == -1:
             raise ValueError("bad values for width aware slicing")
@@ -687,7 +684,7 @@ def _width_aware_splitlines(self, columns: int) -> Iterator["FmtStr"]:
         if chunks_of_line:
             yield FmtStr(*chunks_of_line)
 
-    def _getitem_normalized(self, index: Union[int, slice]) -> "FmtStr":
+    def _getitem_normalized(self, index: int | slice) -> "FmtStr":
         """Builds the more compact fmtstrs by using fromstr( of the control sequences)"""
         index = normalize_slice(len(self), index)
         counter = 0
@@ -749,7 +746,7 @@ def width_aware_slice(s: str, start: int, end: int, replacement_char: str = " ")
     return "".join(new_chunk_chars)
 
 
-def linesplit(string: Union[str, FmtStr], columns: int) -> list[FmtStr]:
+def linesplit(string: str | FmtStr, columns: int) -> list[FmtStr]:
     """Returns a list of lines, split on the last possible space of each line.
 
     Split spaces will be removed. Whitespaces will be normalized to one space.
@@ -794,7 +791,7 @@ def linesplit(string: Union[str, FmtStr], columns: int) -> list[FmtStr]:
     return lines
 
 
-def normalize_slice(length: int, index: Union[int, slice]) -> slice:
+def normalize_slice(length: int, index: int | slice) -> slice:
     "Fill in the Nones in a slice."
     is_int = False
     if isinstance(index, int):
@@ -818,8 +815,8 @@ def normalize_slice(length: int, index: Union[int, slice]) -> slice:
 
 def parse_args(
     args: tuple[str, ...],
-    kwargs: MutableMapping[str, Union[int, bool, str]],
-) -> MutableMapping[str, Union[int, bool]]:
+    kwargs: MutableMapping[str, int | bool | str],
+) -> MutableMapping[str, int | bool]:
     """Returns a kwargs dictionary by turning args into kwargs"""
     if "style" in kwargs:
         args += (cast(str, kwargs["style"]),)
@@ -855,7 +852,7 @@ def parse_args(
     return cast(MutableMapping[str, Union[int, bool]], kwargs)
 
 
-def fmtstr(string: Union[str, FmtStr], *args: Any, **kwargs: Any) -> FmtStr:
+def fmtstr(string: str | FmtStr, *args: Any, **kwargs: Any) -> FmtStr:
     """
     Convenience function for creating a FmtStr
 

curtsies/formatstringarray.py

@@ -72,14 +72,12 @@ def __getitem__(self, slicetuple: slice) -> list[FmtStr]:
         pass
 
     @overload
-    def __getitem__(
-        self, slicetuple: tuple[Union[slice, int], Union[slice, int]]
-    ) -> list[FmtStr]:
+    def __getitem__(self, slicetuple: tuple[slice | int, slice | int]) -> list[FmtStr]:
         pass
 
     def __getitem__(
-        self, slicetuple: Union[int, slice, tuple[Union[int, slice], Union[int, slice]]]
-    ) -> Union[FmtStr, list[FmtStr]]:
+        self, slicetuple: int | slice | tuple[int | slice, int | slice]
+    ) -> FmtStr | list[FmtStr]:
         if isinstance(slicetuple, int):
             if slicetuple < 0:
                 slicetuple = len(self.rows) - slicetuple
@@ -250,8 +248,8 @@ def blink(x: str) -> str:
 
 
 def fsarray(
-    strings: Sequence[Union[FmtStr, str]],
-    width: Optional[int] = None,
+    strings: Sequence[FmtStr | str],
+    width: int | None = None,
     *args: Any,
     **kwargs: Any,
 ) -> FSArray:
@@ -283,7 +281,7 @@ def fsarray(
     return arr
 
 
-def simple_format(x: Union[FSArray, Sequence[FmtStr]]) -> str:
+def simple_format(x: FSArray | Sequence[FmtStr]) -> str:
     return "\n".join(str(l) for l in x)