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

urwid/signals.py

@@ -20,16 +20,16 @@
 
 from __future__ import annotations
 
+import abc
 import itertools
 import typing
-import warnings
 import weakref
 
 if typing.TYPE_CHECKING:
     from collections.abc import Callable, Collection, Container, Hashable, Iterable
 
 
-class MetaSignals(type):
+class MetaSignals(abc.ABCMeta):
     """
     register the list of signals in the class variable signals,
     including signals in superclasses.
@@ -98,9 +98,9 @@ class Signals:
         :type name: signal name
         :param callback: the function to call when that signal is sent
         :type callback: function
-        :param user_arg: deprecated additional argument to callback (appended
-                         after the arguments passed when the signal is
-                         emitted). If None no arguments will be added.
+        :param user_arg: additional argument to callback
+                         (appended  after the arguments passed when the signal is emitted).
+                         If None no arguments will be added.
                          Don't use this argument, use user_args instead.
         :param weak_args: additional arguments passed to the callback
                           (before any arguments passed when the signal
@@ -132,11 +132,11 @@ class Signals:
         As an example of using weak_args, consider the following snippet:
 
         >>> import urwid
-        >>> debug = urwid.Text('')
+        >>> debug = urwid.Text("")
         >>> def handler(widget, newtext):
-        ...    debug.set_text("Edit widget changed to %s" % newtext)
-        >>> edit = urwid.Edit('')
-        >>> key = urwid.connect_signal(edit, 'change', handler)
+        ...     debug.set_text("Edit widget changed to %s" % newtext)
+        >>> edit = urwid.Edit("")
+        >>> key = urwid.connect_signal(edit, "change", handler)
 
         If you now build some interface using "edit" and "debug", the
         "debug" widget will show whatever you type in the "edit" widget.
@@ -148,11 +148,11 @@ class Signals:
         (it's not really a closure, since it doesn't reference any
         outside variables, so it's just a dynamic function):
 
-        >>> debug = urwid.Text('')
+        >>> debug = urwid.Text("")
         >>> def handler(weak_debug, widget, newtext):
-        ...    weak_debug.set_text("Edit widget changed to %s" % newtext)
-        >>> edit = urwid.Edit('')
-        >>> key = urwid.connect_signal(edit, 'change', handler, weak_args=[debug])
+        ...     weak_debug.set_text("Edit widget changed to %s" % newtext)
+        >>> edit = urwid.Edit("")
+        >>> key = urwid.connect_signal(edit, "change", handler, weak_args=[debug])
 
         Here the weak_debug parameter in print_debug is the value passed
         in the weak_args list to connect_signal. Note that the
@@ -166,12 +166,6 @@ class Signals:
         handler can also be disconnected by calling
         urwid.disconnect_signal, which doesn't need this key.
         """
-        if user_arg is not None:
-            warnings.warn(
-                "Don't use user_arg argument, use user_args instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
 
         sig_cls = obj.__class__
         if name not in self._supported.get(sig_cls, ()):
@@ -194,9 +188,8 @@ class Signals:
         # their callbacks) from existing.
         obj_weak = weakref.ref(obj)
 
-        def weakref_callback(weakref):  # pylint: disable=redefined-outer-name  # bad, but not changing API
-            o = obj_weak()
-            if o:
+        def weakref_callback(_ref: weakref.ReferenceType[typing.Any]) -> None:
+            if o := obj_weak():
                 self.disconnect_by_key(o, name, key)
 
         user_args = self._prepare_user_args(weak_args, user_args, weakref_callback)
@@ -208,7 +201,7 @@ class Signals:
         self,
         weak_args: Iterable[typing.Any] = (),
         user_args: Iterable[typing.Any] = (),
-        callback: Callable[..., typing.Any] | None = None,
+        callback: Callable[[weakref.ReferenceType[typing.Any]], typing.Any] | None = None,
     ) -> tuple[Collection[weakref.ReferenceType], Collection[typing.Any]]:
         # Turn weak_args into weakrefs and prepend them to user_args
         w_args = tuple(weakref.ref(w_arg, callback) for w_arg in weak_args)
@@ -302,14 +295,13 @@ class Signals:
         self,
         callback,
         user_arg: typing.Any,
-        weak_args: Collection[weakref.ReferenceType],
-        user_args: Collection[typing.Any],
+        weak_args: Iterable[weakref.ReferenceType],
+        user_args: Iterable[typing.Any],
         emit_args: Iterable[typing.Any],
     ) -> bool:
         args_to_pass = []
         for w_arg in weak_args:
-            real_arg = w_arg()
-            if real_arg is not None:
+            if (real_arg := w_arg()) is not None:
                 args_to_pass.append(real_arg)
             else:
                 # de-referenced

urwid/split_repr.py

@@ -32,15 +32,18 @@ def split_repr(self):
 
     >>> class Foo(object):
     ...     __repr__ = split_repr
+    ...
     ...     def _repr_words(self):
     ...         return ["words", "here"]
+    ...
     ...     def _repr_attrs(self):
-    ...         return {'attrs': "appear too"}
+    ...         return {"attrs": "appear too"}
     >>> Foo()
     <Foo words here attrs='appear too'>
     >>> class Bar(Foo):
     ...     def _repr_words(self):
     ...         return Foo._repr_words(self) + ["too"]
+    ...
     ...     def _repr_attrs(self):
     ...         return dict(Foo._repr_attrs(self), barttr=42)
     >>> Bar()
@@ -62,9 +65,9 @@ def normalize_repr(v):
     """
     Return dictionary repr sorted by keys, leave others unchanged
 
-    >>> normalize_repr({1:2,3:4,5:6,7:8})
+    >>> normalize_repr({1: 2, 3: 4, 5: 6, 7: 8})
     '{1: 2, 3: 4, 5: 6, 7: 8}'
-    >>> normalize_repr('foo')
+    >>> normalize_repr("foo")
     "'foo'"
     """
     if isinstance(v, dict):
@@ -88,9 +91,12 @@ def remove_defaults(d, fn):
     >>> class Foo(object):
     ...     def __init__(self, a=1, b=2):
     ...         self.values = a, b
+    ...
     ...     __repr__ = split_repr
+    ...
     ...     def _repr_words(self):
     ...         return ["object"]
+    ...
     ...     def _repr_attrs(self):
     ...         d = dict(a=self.values[0], b=self.values[1])
     ...         return remove_defaults(d, Foo.__init__)

urwid/str_util.py

@@ -29,22 +29,61 @@ import wcwidth
 if typing.TYPE_CHECKING:
     from typing_extensions import Literal
 
-SAFE_ASCII_RE = re.compile("^[ -~]*$")
-SAFE_ASCII_BYTES_RE = re.compile(b"^[ -~]*$")
+SAFE_ASCII_RE = re.compile(r"^[ -~]*$")
+SAFE_ASCII_BYTES_RE = re.compile(rb"^[ -~]*$")
 
 _byte_encoding: Literal["utf8", "narrow", "wide"] = "narrow"
 
 
 def get_char_width(char: str) -> Literal[0, 1, 2]:
-    width = wcwidth.wcwidth(char)
-    if width < 0:
-        return 0
-    return width
+    """
+    Return the screen column width for a single character.
+
+    .. deprecated:: 3.0.4
+    """
+    warnings.warn(
+        "get_char_width is deprecated in favor of wcwidth.width",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    if (width := wcwidth.wcwidth(char)) >= 0:
+        return width
+
+    return 0
 
 
 def get_width(o: int) -> Literal[0, 1, 2]:
-    """Return the screen column width for unicode ordinal o."""
-    return get_char_width(chr(o))
+    """
+    Return the screen column width for unicode ordinal o.
+
+    .. deprecated:: 3.0.4
+    """
+    warnings.warn(
+        "get_width is deprecated in favor of wcwidth.width",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    if (width := wcwidth.wcwidth(chr(o))) >= 0:
+        return width
+
+    return 0
+
+
+def _decode_grapheme_at(text: bytes, start: int, end: int) -> tuple[str, int]:
+    """
+    Decode bytes starting at `start` to get the first grapheme cluster.
+
+    :param text: UTF-8 encoded bytes
+    :param start: starting byte position
+    :param end: ending byte position
+    :returns: (grapheme_string, next_byte_position)
+
+    Assumes caller provides valid UTF-8 byte boundaries.
+    """
+    decoded = text[start:end].decode("utf-8")
+    grapheme = next(wcwidth.iter_graphemes(decoded), "")
+    grapheme_bytes = grapheme.encode("utf-8")
+    return grapheme, start + len(grapheme_bytes)
 
 
 def decode_one(text: bytes | str, pos: int) -> tuple[int, int]:
@@ -86,10 +125,9 @@ def decode_one(text: bytes | str, pos: int) -> tuple[int, int]:
     if b1 & 0xE0 == 0xC0:
         if b2 & 0xC0 != 0x80:
             return error
-        o = ((b1 & 0x1F) << 6) | (b2 & 0x3F)
-        if o < 0x80:
-            return error
-        return o, pos + 2
+        if (o := ((b1 & 0x1F) << 6) | (b2 & 0x3F)) >= 0x80:
+            return o, pos + 2
+        return error
     if lt < 3:
         return error
     if b1 & 0xF0 == 0xE0:
@@ -97,10 +135,9 @@ def decode_one(text: bytes | str, pos: int) -> tuple[int, int]:
             return error
         if b3 & 0xC0 != 0x80:
             return error
-        o = ((b1 & 0x0F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F)
-        if o < 0x800:
-            return error
-        return o, pos + 3
+        if (o := ((b1 & 0x0F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F)) >= 0x800:
+            return o, pos + 3
+        return error
     if lt < 4:
         return error
     if b1 & 0xF8 == 0xF0:
@@ -110,10 +147,9 @@ def decode_one(text: bytes | str, pos: int) -> tuple[int, int]:
             return error
         if b4 & 0xC0 != 0x80:
             return error
-        o = ((b1 & 0x07) << 18) | ((b2 & 0x3F) << 12) | ((b3 & 0x3F) << 6) | (b4 & 0x3F)
-        if o < 0x10000:
-            return error
-        return o, pos + 4
+        if (o := ((b1 & 0x07) << 18) | ((b2 & 0x3F) << 12) | ((b3 & 0x3F) << 6) | (b4 & 0x3F)) >= 0x10000:
+            return o, pos + 4
+        return error
     return error
 
 
@@ -160,23 +196,26 @@ def calc_string_text_pos(text: str, start_offs: int, end_offs: int, pref_col: in
     where start_offs is the offset into text assumed to be screen column 0
     and end_offs is the end of the range to search.
 
+    Iterates by grapheme clusters for emoji ZWJ sequences, flags,
+    combining characters, and other multi-codepoint unicode sequences.
+
     :param text: string
     :param start_offs: starting text position
     :param end_offs: ending text position
     :param pref_col: target column
     :returns: (position, actual_col)
-
-    ..note:: this method is a simplified version of `wcwidth.wcswidth` and ideally should be in wcwidth package.
     """
     if start_offs > end_offs:
         raise ValueError((start_offs, end_offs))
 
     cols = 0
-    for idx in range(start_offs, end_offs):
-        width = get_char_width(text[idx])
-        if width + cols > pref_col:
-            return idx, cols
-        cols += width
+    pos = start_offs
+    for grapheme in wcwidth.iter_graphemes(text[start_offs:end_offs]):
+        grapheme_width = wcwidth.width(grapheme, control_codes="ignore")
+        if grapheme_width + cols > pref_col:
+            return pos, cols
+        cols += grapheme_width
+        pos += len(grapheme)
 
     return end_offs, cols
 
@@ -201,16 +240,10 @@ def calc_text_pos(text: str | bytes, start_offs: int, end_offs: int, pref_col: i
         raise TypeError(text)
 
     if _byte_encoding == "utf8":
-        i = start_offs
-        sc = 0
-        while i < end_offs:
-            o, n = decode_one(text, i)
-            w = get_width(o)
-            if w + sc > pref_col:
-                return i, sc
-            i = n
-            sc += w
-        return i, sc
+        decoded = text[start_offs:end_offs].decode("utf-8")
+        str_pos, cols = calc_string_text_pos(decoded, 0, len(decoded), pref_col)
+        byte_offset = len(decoded[:str_pos].encode("utf-8"))
+        return start_offs + byte_offset, cols
 
     # "wide" and "narrow"
     i = start_offs + pref_col
@@ -228,19 +261,20 @@ def calc_width(text: str | bytes, start_offs: int, end_offs: int) -> int:
     text may be unicode or a byte string in the target _byte_encoding
 
     Some characters are wide (take two columns) and others affect the
-    previous character (take zero columns).  Use the widths table above
-    to calculate the screen column width of text[start_offs:end_offs]
+    previous character (take zero columns), while others are grouped
+    in sequence by "grapheme boundaries" (Emoji, Skin tones, flags, etc).
     """
 
     if start_offs > end_offs:
-        raise ValueError((start_offs, end_offs))
+        msg = f"{start_offs=} > {end_offs=}"
+        raise ValueError(msg)
 
     if isinstance(text, str):
-        return sum(get_char_width(char) for char in text[start_offs:end_offs])
+        return wcwidth.width(text[start_offs:end_offs], control_codes="ignore")
 
     if _byte_encoding == "utf8":
         try:
-            return sum(get_char_width(char) for char in text[start_offs:end_offs].decode("utf-8"))
+            return wcwidth.width(text[start_offs:end_offs].decode("utf-8"), control_codes="ignore")
         except UnicodeDecodeError as exc:
             warnings.warn(
                 "`calc_width` with text encoded to bytes can produce incorrect results"
@@ -253,8 +287,8 @@ def calc_width(text: str | bytes, start_offs: int, end_offs: int) -> int:
         sc = 0
         while i < end_offs:
             o, i = decode_one(text, i)
-            w = get_width(o)
-            sc += w
+            if (w := wcwidth.wcwidth(chr(o))) > 0:
+                sc += w
         return sc
     # "wide", "narrow" or all printable ASCII, just return the character count
     return end_offs - start_offs
@@ -262,17 +296,22 @@ def calc_width(text: str | bytes, start_offs: int, end_offs: int) -> int:
 
 def is_wide_char(text: str | bytes, offs: int) -> bool:
     """
-    Test if the character at offs within text is wide.
+    Test if the grapheme cluster at offs within text is wide (2 columns).
+
+    For Unicode strings, extracts the full grapheme cluster starting at offs
+    and checks if it renders as wide. This correctly handles multi-codepoint
+    graphemes like emoji ZWJ sequences and flags.
 
     text may be unicode or a byte string in the target _byte_encoding
     """
     if isinstance(text, str):
-        return get_char_width(text[offs]) == 2
+        grapheme = next(wcwidth.iter_graphemes(text[offs:]))
+        return wcwidth.width(grapheme, control_codes="ignore") == 2
     if not isinstance(text, bytes):
         raise TypeError(text)
     if _byte_encoding == "utf8":
-        o, _n = decode_one(text, offs)
-        return get_width(o) == 2
+        grapheme, _ = _decode_grapheme_at(text, offs, len(text))
+        return wcwidth.width(grapheme, control_codes="ignore") == 2
     if _byte_encoding == "wide":
         return within_double_byte(text, offs, offs) == 1
     return False
@@ -280,19 +319,23 @@ def is_wide_char(text: str | bytes, offs: int) -> bool:
 
 def move_prev_char(text: str | bytes, start_offs: int, end_offs: int) -> int:
     """
-    Return the position of the character before end_offs.
+    Return the position of the grapheme cluster before end_offs.
+
+    For Unicode strings, handle multi-codepoint, "grapheme clusters",
+    to better measure emoji ZWJ, flags, combining characters, skin tones.
     """
     if start_offs >= end_offs:
         raise ValueError((start_offs, end_offs))
     if isinstance(text, str):
-        return end_offs - 1
+        return wcwidth.grapheme_boundary_before(text, end_offs)
     if not isinstance(text, bytes):
         raise TypeError(text)
     if _byte_encoding == "utf8":
-        o = end_offs - 1
-        while text[o] & 0xC0 == 0x80:
-            o -= 1
-        return o
+        decoded = text[start_offs:end_offs].decode("utf-8")
+        str_pos = len(decoded)
+        prev_str_pos = wcwidth.grapheme_boundary_before(decoded, str_pos)
+        prefix = decoded[:prev_str_pos]
+        return start_offs + len(prefix.encode("utf-8"))
     if _byte_encoding == "wide" and within_double_byte(text, start_offs, end_offs - 1) == 2:
         return end_offs - 2
     return end_offs - 1
@@ -300,19 +343,21 @@ def move_prev_char(text: str | bytes, start_offs: int, end_offs: int) -> int:
 
 def move_next_char(text: str | bytes, start_offs: int, end_offs: int) -> int:
     """
-    Return the position of the character after start_offs.
+    Return the position of the next grapheme cluster after start_offs.
+
+    For Unicode strings, handle multi-codepoint, "grapheme clusters",
+    to better measure emoji ZWJ, flags, combining characters, skin tones.
     """
     if start_offs >= end_offs:
         raise ValueError((start_offs, end_offs))
     if isinstance(text, str):
-        return start_offs + 1
+        grapheme = next(wcwidth.iter_graphemes(text[start_offs:end_offs]))
+        return start_offs + len(grapheme)
     if not isinstance(text, bytes):
         raise TypeError(text)
     if _byte_encoding == "utf8":
-        o = start_offs + 1
-        while o < end_offs and text[o] & 0xC0 == 0x80:
-            o += 1
-        return o
+        _, next_pos = _decode_grapheme_at(text, start_offs, end_offs)
+        return next_pos
     if _byte_encoding == "wide" and within_double_byte(text, start_offs, start_offs) == 1:
         return start_offs + 2
     return start_offs + 1

urwid/text_layout.py

@@ -23,7 +23,9 @@ from __future__ import annotations
 import functools
 import typing
 
-from urwid.str_util import calc_text_pos, calc_width, get_char_width, is_wide_char, move_next_char, move_prev_char
+import wcwidth
+
+from urwid.str_util import calc_text_pos, calc_width, is_wide_char, move_next_char, move_prev_char
 from urwid.util import calc_trim_text, get_encoding
 
 if typing.TYPE_CHECKING:
@@ -44,7 +46,7 @@ def get_ellipsis_string(encoding: str) -> str:
 @functools.lru_cache(maxsize=4)
 def _get_width(string) -> int:
     """Get ellipsis character width for given encoding."""
-    return sum(get_char_width(char) for char in string)
+    return wcwidth.width(string, control_codes="ignore")
 
 
 class TextLayout:
@@ -176,7 +178,7 @@ class StandardTextLayout(TextLayout):
         self,
         text: str | bytes,
         width: int,
-        wrap: Literal["any", "space", "clip", "ellipsis"] | WrapMode,
+        wrap: Literal["clip", "ellipsis", WrapMode.CLIP, WrapMode.ELLIPSIS],
     ) -> list[list[tuple[int, int, int | bytes] | tuple[int, int | None]]]:
         """Calculate text segments for cases of a text trimmed (wrap is clip or ellipsis)."""
         segments = []
@@ -185,8 +187,8 @@ class StandardTextLayout(TextLayout):
         encoding = get_encoding()
         ellipsis_string = get_ellipsis_string(encoding)
         ellipsis_width = _get_width(ellipsis_string)
-        while width - 1 < ellipsis_width and ellipsis_string:
-            ellipsis_string = ellipsis_string[:-1]
+        if (extra := width - ellipsis_width - 1) < 0:
+            ellipsis_string = ellipsis_string[:extra]
             ellipsis_width = _get_width(ellipsis_string)
 
         ellipsis_char = ellipsis_string.encode(encoding)
@@ -236,7 +238,7 @@ class StandardTextLayout(TextLayout):
         """
         Calculate the segments of text to display given width screen columns to display them.
 
-        text - unicode text or byte string to display
+        text - Unicode text or byte string to display
         width - number of available screen columns
         wrap - wrapping mode used
 
@@ -461,7 +463,7 @@ def shift_line(
         # existing shift
         amount += segs[0][0]
         if amount:
-            return [(amount, None)] + segs[1:]
+            return [(amount, None), *segs[1:]]
         return segs[1:]
 
     if amount:
@@ -581,8 +583,7 @@ def calc_pos(
     if row < 0 or row >= len(layout):
         raise ValueError("calculate_pos: out of layout row range")
 
-    pos = calc_line_pos(text, layout[row], pref_col)
-    if pos is not None:
+    if (pos := calc_line_pos(text, layout[row], pref_col)) is not None:
         return pos
 
     rows_above = list(range(row - 1, -1, -1))
@@ -590,14 +591,14 @@ def calc_pos(
     while rows_above and rows_below:
         if rows_above:
             r = rows_above.pop(0)
-            pos = calc_line_pos(text, layout[r], pref_col)
-            if pos is not None:
+            if (pos := calc_line_pos(text, layout[r], pref_col)) is not None:
                 return pos
+
         if rows_below:
             r = rows_below.pop(0)
-            pos = calc_line_pos(text, layout[r], pref_col)
-            if pos is not None:
+            if (pos := calc_line_pos(text, layout[r], pref_col)) is not None:
                 return pos
+
     return 0
 
 

urwid/util.py

@@ -143,7 +143,7 @@ def get_encoding() -> str:
 
 
 @contextlib.contextmanager
-def set_temporary_encoding(encoding_name: str) -> Generator[None, None, None]:
+def set_temporary_encoding(encoding_name: str) -> Generator[None]:
     """Internal helper for encoding specific validation in unittests/doctests.
 
     Not exported globally.
@@ -493,24 +493,13 @@ def is_mouse_press(ev: str) -> bool:
 
 
 class MetaSuper(type):
-    """adding .__super"""
+    """Deprecated metaclass.
 
-    def __init__(cls, name: str, bases, d):
-        super().__init__(name, bases, d)
-        if hasattr(cls, f"_{name}__super"):
-            raise AttributeError("Class has same name as one of its super classes")
-
-        @property
-        def _super(self):
-            warnings.warn(
-                f"`{name}.__super` was a deprecated feature for old python versions."
-                f"Please use `super()` call instead.",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-            return super(cls, self)
+    Present only for code compatibility, all logic has been removed.
+    Please move to the last position in the class bases to allow future changes.
+    """
 
-        setattr(cls, f"_{name}__super", _super)
+    __slots__ = ()
 
 
 def int_scale(val: int, val_range: int, out_range: int) -> int:
@@ -521,7 +510,7 @@ def int_scale(val: int, val_range: int, out_range: int) -> int:
 
     >>> "%x" % int_scale(0x7, 0x10, 0x10000)
     '7777'
-    >>> "%x" % int_scale(0x5f, 0x100, 0x10)
+    >>> "%x" % int_scale(0x5F, 0x100, 0x10)
     '6'
     >>> int_scale(2, 6, 101)
     40
@@ -534,7 +523,7 @@ def int_scale(val: int, val_range: int, out_range: int) -> int:
     return num // dem
 
 
-class StoppingContext(typing.ContextManager["StoppingContext"]):
+class StoppingContext(contextlib.AbstractContextManager["StoppingContext"]):
     """Context manager that calls ``stop`` on a given object on exit.  Used to
     make the ``start`` method on `MainLoop` and `BaseScreen` optionally act as
     context managers.

urwid/version.py

@@ -1,16 +1,34 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '3.0.5'
+__version_tuple__ = version_tuple = (3, 0, 5)
 
-__version__ = version = '2.6.15'
-__version_tuple__ = version_tuple = (2, 6, 15)
+__commit_id__ = commit_id = None