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

urwid/signals.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 import abc
 import itertools
 import typing
-import warnings
 import weakref
 
 if typing.TYPE_CHECKING:
@@ -99,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
@@ -133,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.
@@ -149,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
@@ -167,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, ()):
@@ -195,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)
@@ -209,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)
@@ -303,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

@@ -36,6 +36,16 @@ _byte_encoding: Literal["utf8", "narrow", "wide"] = "narrow"
 
 
 def get_char_width(char: str) -> Literal[0, 1, 2]:
+    """
+    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
 
@@ -43,8 +53,37 @@ def get_char_width(char: str) -> Literal[0, 1, 2]:
 
 
 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]:
@@ -157,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
 
@@ -198,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
@@ -225,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"
@@ -250,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
@@ -259,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
@@ -277,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
@@ -297,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
 

urwid/util.py

@@ -510,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

urwid/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '3.0.3'
-__version_tuple__ = version_tuple = (3, 0, 3)
+__version__ = version = '3.0.5'
+__version_tuple__ = version_tuple = (3, 0, 5)
 
 __commit_id__ = commit_id = None

urwid/vterm.py

@@ -1418,8 +1418,8 @@ class TermCanvas(Canvas):
         if self.scrolling_up == 0:
             yield from self.term
         else:
-            buf = self.scrollback_buffer + self.term
-            yield from buf[-(self.height + self.scrolling_up) : -self.scrolling_up]
+            viewport_range = slice(-(self.height + self.scrolling_up), -self.scrolling_up)
+            yield from (*self.scrollback_buffer, *self.term)[viewport_range]
 
     def content_delta(self, other: Canvas):
         if other is self:

urwid/widget/attr_map.py

@@ -42,19 +42,19 @@ class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[Wra
         :type focus_map: display attribute or dict
 
         >>> from urwid import Divider, Edit, Text
-        >>> AttrMap(Divider(u"!"), 'bright')
+        >>> AttrMap(Divider("!"), "bright")
         <AttrMap flow widget <Divider flow widget '!'> attr_map={None: 'bright'}>
-        >>> AttrMap(Edit(), 'notfocus', 'focus').attr_map
+        >>> AttrMap(Edit(), "notfocus", "focus").attr_map
         {None: 'notfocus'}
-        >>> AttrMap(Edit(), 'notfocus', 'focus').focus_map
+        >>> AttrMap(Edit(), "notfocus", "focus").focus_map
         {None: 'focus'}
         >>> size = (5,)
-        >>> am = AttrMap(Text(u"hi"), 'greeting', 'fgreet')
-        >>> next(am.render(size, focus=False).content()) # ... = b in Python 3
+        >>> am = AttrMap(Text("hi"), "greeting", "fgreet")
+        >>> next(am.render(size, focus=False).content())  # ... = b in Python 3
         [('greeting', None, ...'hi   ')]
         >>> next(am.render(size, focus=True).content())
         [('fgreet', None, ...'hi   ')]
-        >>> am2 = AttrMap(Text(('word', u"hi")), {'word':'greeting', None:'bg'})
+        >>> am2 = AttrMap(Text(("word", "hi")), {"word": "greeting", None: "bg"})
         >>> am2
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={'word': 'greeting', None: 'bg'}>
         >>> next(am2.render(size).content())
@@ -94,8 +94,8 @@ class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[Wra
         constructor does.  You must specify {None: attribute} instead.
 
         >>> from urwid import Text
-        >>> w = AttrMap(Text(u"hi"), None)
-        >>> w.set_attr_map({'a':'b'})
+        >>> w = AttrMap(Text("hi"), None)
+        >>> w.set_attr_map({"a": "b"})
         >>> w
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={'a': 'b'}>
         """
@@ -129,8 +129,8 @@ class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[Wra
         constructor does.  You must specify {None: attribute} instead.
 
         >>> from urwid import Text
-        >>> w = AttrMap(Text(u"hi"), {})
-        >>> w.set_focus_map({'a':'b'})
+        >>> w = AttrMap(Text("hi"), {})
+        >>> w.set_focus_map({"a": "b"})
         >>> w
         <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={} focus_map={'a': 'b'}>
         >>> w.set_focus_map(None)

urwid/widget/attr_wrap.py

@@ -25,12 +25,12 @@ class AttrWrap(AttrMap):
         new code should use AttrMap instead.
 
         >>> from urwid import Divider, Edit, Text
-        >>> AttrWrap(Divider(u"!"), 'bright')
+        >>> AttrWrap(Divider("!"), "bright")
         <AttrWrap flow widget <Divider flow widget '!'> attr='bright'>
-        >>> AttrWrap(Edit(), 'notfocus', 'focus')
+        >>> AttrWrap(Edit(), "notfocus", "focus")
         <AttrWrap selectable flow widget <Edit selectable flow widget '' edit_pos=0> attr='notfocus' focus_attr='focus'>
         >>> size = (5,)
-        >>> aw = AttrWrap(Text(u"hi"), 'greeting', 'fgreet')
+        >>> aw = AttrWrap(Text("hi"), "greeting", "fgreet")
         >>> next(aw.render(size, focus=False).content())
         [('greeting', None, ...'hi   ')]
         >>> next(aw.render(size, focus=True).content())

urwid/widget/big_text.py

@@ -78,9 +78,6 @@ class BigText(Widget):
                     c.fill_attr(a)
                 o.append((c, None, False, width))
 
-            else:
-                # ignore invalid characters
-                continue
         if o:
             canv = CanvasJoin(o)
         else:

urwid/widget/box_adapter.py

@@ -32,7 +32,7 @@ class BoxAdapter(WidgetDecoration[WrappedWidget]):
         :type height: int
 
         >>> from urwid import SolidFill
-        >>> BoxAdapter(SolidFill(u"x"), 5) # 5-rows of x's
+        >>> BoxAdapter(SolidFill("x"), 5)  # 5-rows of x's
         <BoxAdapter flow widget <SolidFill box widget 'x'> height=5>
         """
         if hasattr(box_widget, "sizing") and Sizing.BOX not in box_widget.sizing():
@@ -71,7 +71,7 @@ class BoxAdapter(WidgetDecoration[WrappedWidget]):
         Return the predetermined height (behave like a flow widget)
 
         >>> from urwid import SolidFill
-        >>> BoxAdapter(SolidFill(u"x"), 5).rows((20,))
+        >>> BoxAdapter(SolidFill("x"), 5).rows((20,))
         5
         """
         return self.height

urwid/widget/divider.py

@@ -59,9 +59,9 @@ class Divider(Widget):
 
         >>> Divider()
         <Divider flow widget>
-        >>> Divider(u'-')
+        >>> Divider("-")
         <Divider flow widget '-'>
-        >>> Divider(u'x', 1, 2)
+        >>> Divider("x", 1, 2)
         <Divider flow widget 'x' bottom=2 top=1>
         """
         super().__init__()
@@ -86,7 +86,7 @@ class Divider(Widget):
 
         >>> Divider().rows((10,))
         1
-        >>> Divider(u'x', 1, 2).rows((10,))
+        >>> Divider("x", 1, 2).rows((10,))
         4
         """
         (_maxcol,) = size
@@ -100,11 +100,11 @@ class Divider(Widget):
         """
         Render the divider as a canvas and return it.
 
-        >>> Divider().render((10,)).text # ... = b in Python 3
+        >>> Divider().render((10,)).text  # ... = b in Python 3
         [...'          ']
-        >>> Divider(u'-', top=1).render((10,)).text
+        >>> Divider("-", top=1).render((10,)).text
         [...'          ', ...'----------']
-        >>> Divider(u'x', bottom=2).render((5,)).text
+        >>> Divider("x", bottom=2).render((5,)).text
         [...'xxxxx', ...'     ', ...'     ']
         """
         (maxcol,) = size