diff -Nru python-curtsies-0.1.22/curtsies/configfile_keynames.py python-curtsies-0.2.6/curtsies/configfile_keynames.py
--- python-curtsies-0.1.22/curtsies/configfile_keynames.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/configfile_keynames.py	2016-01-11 22:36:53.000000000 +0000
@@ -2,8 +2,6 @@
 
 In the style of bpython config files and keymap"""
 
-from .events import CURTSIES_NAMES
-
 SPECIALS = {
         'C-[': u'<ESC>',
         'C-^': u'<Ctrl-6>',
diff -Nru python-curtsies-0.1.22/curtsies/curtsieskeys.py python-curtsies-0.2.6/curtsies/curtsieskeys.py
--- python-curtsies-0.1.22/curtsies/curtsieskeys.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/curtsieskeys.py	2016-01-11 22:36:53.000000000 +0000
@@ -36,9 +36,9 @@
   (b'\x1b[1;9C',  u'<Esc+RIGHT>'),
   (b'\x1b[1;9D',  u'<Esc+LEFT>'),
 
-  (b'\x1b[1;10A', u'<Esc+Shift-LEFT>'),
-  (b'\x1b[1;10B', u'<Esc+Shift-LEFT>'),
-  (b'\x1b[1;10C', u'<Esc+Shift-LEFT>'),
+  (b'\x1b[1;10A', u'<Esc+Shift-UP>'),
+  (b'\x1b[1;10B', u'<Esc+Shift-DOWN>'),
+  (b'\x1b[1;10C', u'<Esc+Shift-RIGHT>'),
   (b'\x1b[1;10D', u'<Esc+Shift-LEFT>'),
 
   (b'\x1bOP',     u'<F1>'),
@@ -67,14 +67,33 @@
   (b'\x1b\x1b[D', u'<Esc+LEFT>'),
   (b'\x1b',       u'<ESC>'),
   (b'\x1b[1~',    u'<HOME>'),
-  (b'\x1b[2~',    u'<PADENTER>'),  #TODO untested
-  (b'\x1b[3~',    u'<PADDELETE>'), #TODO check this name
   (b'\x1b[4~',    u'<END>'),
-  (b'\x1b[5~',    u'<PAGEUP>'),
-  (b'\x1b[6~',    u'<PAGEDOWN>'),
   (b'\x1b\x1b[5~',u'<Esc+PAGEUP>'),
   (b'\x1b\x1b[6~',u'<Esc+PAGEDOWN>'),
 
   (b'\x1b[H',     u'<HOME>'),    # reported by amorozov in bpython #490
   (b'\x1b[F',     u'<END>'),     # reported by amorozov in bpython #490
+
+  # see curtsies #78 - taken from https://github.com/jquast/blessed/blob/e9ad7b85dfcbbba49010ab8c13e3a5920d81b010/blessed/keyboard.py#L409
+
+  # not fixing for back compat.
+  # (b"\x1b[1~", u'<FIND>'),       # find
+
+  (b"\x1b[2~", u'<INSERT>'),       # insert (0)
+  (b"\x1b[3~", u'<DELETE>'),       # delete (.), "Execute"
+
+  # not fixing for back compat.
+  # (b"\x1b[4~", u'<SELECT>'),       # select
+
+  (b"\x1b[5~", u'<PAGEUP>'),       # pgup   (9)
+  (b"\x1b[6~", u'<PAGEDOWN>'),     # pgdown (3)
+  (b"\x1b[7~", u'<HOME>'),         # home
+  (b"\x1b[8~", u'<END>'),          # end
+  (b"\x1b[OA", u'<UP>'),           # up     (8)
+  (b"\x1b[OB", u'<DOWN>'),         # down   (2)
+  (b"\x1b[OC", u'<RIGHT>'),        # right  (6)
+  (b"\x1b[OD", u'<LEFT>'),         # left   (4)
+  (b"\x1b[OF", u'<END>'),          # end    (1)
+  (b"\x1b[OH", u'<HOME>'),         # home   (7)
+
   ])
diff -Nru python-curtsies-0.1.22/curtsies/escseqparse.py python-curtsies-0.2.6/curtsies/escseqparse.py
--- python-curtsies-0.1.22/curtsies/escseqparse.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/escseqparse.py	2016-01-11 22:36:53.000000000 +0000
@@ -9,7 +9,9 @@
 True
 """
 
-from .termformatconstants import *
+from .termformatconstants import (FG_NUMBER_TO_COLOR, BG_NUMBER_TO_COLOR,
+                                  NUMBER_TO_STYLE, RESET_ALL, RESET_FG,
+                                  RESET_BG, STYLES)
 import re
 
 
@@ -27,15 +29,25 @@
             stuff.append(front)
         if token:
             try:
-                stuff.append(token_type(token))
-            except ValueError as e:
+                tok = token_type(token)
+                if tok:
+                    stuff.append(tok)
+            except ValueError:
                 raise ValueError("Can't parse escape sequence: %r %r %r %r" % (s, repr(front), token, repr(rest)))
         if not rest:
             break
     return stuff
 
+
 def peel_off_esc_code(s):
-    """Returns processed text, the next token, and unprocessed text"""
+    r"""Returns processed text, the next token, and unprocessed text
+
+    >>> front, d, rest = peel_off_esc_code('somestuff')
+    >>> front, rest
+    ('some', 'stuff')
+    >>> d == {'numbers': [2], 'command': 'A', 'intermed': '', 'private': '', 'csi': '\x1b[', 'seq': '\x1b[2A'}
+    True
+    """
     p = r"""(?P<front>.*?)
             (?P<seq>
                 (?P<csi>
@@ -49,8 +61,8 @@
                 (?P<intermed>""" + '[\x20-\x2f]*)' + r"""
                 (?P<command>""" + '[\x40-\x7e]))' + r"""
             (?P<rest>.*)"""
-    m1 = re.match(p, s, re.VERBOSE) #multibyte esc seq
-    m2 = re.match('(?P<front>.*?)(?P<seq>(?P<csi>)(?P<command>[\x40-\x5f]))(?P<rest>.*)', s) # 2 byte escape sequence
+    m1 = re.match(p, s, re.VERBOSE)  # multibyte esc seq
+    m2 = re.match('(?P<front>.*?)(?P<seq>(?P<csi>)(?P<command>[\x40-\x5f]))(?P<rest>.*)', s)  # 2 byte escape sequence
     if m1 and m2:
         m = m1 if len(m1.groupdict()['front']) <= len(m2.groupdict()['front']) else m2
         # choose the match which has less processed text in order to get the
@@ -64,7 +76,7 @@
         del d['front']
         del d['rest']
         if 'numbers' in d and d['numbers'].split(';'):
-            d['numbers'] = [int(x) for x in d['numbers'].split()]
+            d['numbers'] = [int(x) for x in d['numbers'].split(';')]
 
         return m.groupdict()['front'], d, m.groupdict()['rest']
     else:
@@ -81,6 +93,10 @@
         if value == RESET_ALL: return dict(dict((k, None) for k in STYLES), **{'fg':None, 'bg':None})
         if value == RESET_FG: return {'fg':None}
         if value == RESET_BG: return {'bg':None}
+
+    elif info['command'] == 'H':  # fix for bpython #76
+        return {}
+
     raise ValueError("Can't parse escape seq %r" % info)
 
 if __name__ == '__main__':
diff -Nru python-curtsies-0.1.22/curtsies/events.py python-curtsies-0.2.6/curtsies/events.py
--- python-curtsies-0.1.22/curtsies/events.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/events.py	2016-01-11 22:36:53.000000000 +0000
@@ -45,12 +45,26 @@
 CURSES_NAMES[b'\x1b[B'] = u'KEY_DOWN'
 CURSES_NAMES[b'\x1b[C'] = u'KEY_RIGHT'
 CURSES_NAMES[b'\x1b[D'] = u'KEY_LEFT'
+CURSES_NAMES[b'\x1b[F'] = u'KEY_END'           # https://github.com/bpython/bpython/issues/490
+CURSES_NAMES[b'\x1b[H'] = u'KEY_HOME'          # https://github.com/bpython/bpython/issues/490
 CURSES_NAMES[b'\x08'] = u'KEY_BACKSPACE'
-CURSES_NAMES[b'\x1b[3~'] = u'KEY_DC'
-CURSES_NAMES[b'\x1b[5~'] = u'KEY_PPAGE'
-CURSES_NAMES[b'\x1b[6~'] = u'KEY_NPAGE'
 CURSES_NAMES[b'\x1b[Z'] = u'KEY_BTAB'
-#TODO add home and end? and everything else
+
+# see curtsies #78 - taken from https://github.com/jquast/blessed/blob/e9ad7b85dfcbbba49010ab8c13e3a5920d81b010/blessed/keyboard.py#L409
+CURSES_NAMES[b'\x1b[1~'] = u'KEY_FIND'         # find
+CURSES_NAMES[b'\x1b[2~'] = u'KEY_IC'           # insert (0)
+CURSES_NAMES[b'\x1b[3~'] = u'KEY_DC'           # delete (.), "Execute"
+CURSES_NAMES[b'\x1b[4~'] = u'KEY_SELECT'       # select
+CURSES_NAMES[b'\x1b[5~'] = u'KEY_PPAGE'        # pgup   (9)
+CURSES_NAMES[b'\x1b[6~'] = u'KEY_NPAGE'        # pgdown (3)
+CURSES_NAMES[b'\x1b[7~'] = u'KEY_HOME'         # home
+CURSES_NAMES[b'\x1b[8~'] = u'KEY_END'          # end
+CURSES_NAMES[b'\x1b[OA'] = u'KEY_UP'           # up     (8)
+CURSES_NAMES[b'\x1b[OB'] = u'KEY_DOWN'         # down   (2)
+CURSES_NAMES[b'\x1b[OC'] = u'KEY_RIGHT'        # right  (6)
+CURSES_NAMES[b'\x1b[OD'] = u'KEY_LEFT'         # left   (4)
+CURSES_NAMES[b'\x1b[OF'] = u'KEY_END'          # end    (1)
+CURSES_NAMES[b'\x1b[OH'] = u'KEY_HOME'         # home   (7)
 
 KEYMAP_PREFIXES = set()
 for table in (CURSES_NAMES, CURTSIES_NAMES):
@@ -65,6 +79,13 @@
     pass
 
 class ScheduledEvent(Event):
+    """Event scheduled for a future time.
+
+    args:
+        when (float): unix time in seconds for which this event is scheduled
+
+    Custom events that occur at a specific time in the future should
+    be subclassed from ScheduledEvent."""
     def __init__(self, when):
         self.when = when
 
@@ -83,6 +104,7 @@
         return '<WindowChangeEvent>'
 
 class SigIntEvent(Event):
+    """Event signifying a SIGINT"""
     def __repr__(self):
         return "<SigInt Event>"
     @property
@@ -90,6 +112,10 @@
         return repr(self)
 
 class PasteEvent(Event):
+    """Multiple keypress events combined, likely from copy/paste.
+
+    The events attribute contains a list of keypress event strings.
+    """
     def __init__(self):
         self.events = []
     def __repr__(self):
diff -Nru python-curtsies-0.1.22/curtsies/formatstringarray.py python-curtsies-0.2.6/curtsies/formatstringarray.py
--- python-curtsies-0.1.22/curtsies/formatstringarray.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/formatstringarray.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,3 +1,4 @@
+from __future__ import unicode_literals
 """
 Format String 2D array
 2d array for compositing term-formated strings
@@ -31,6 +32,8 @@
 
 logger = logging.getLogger(__name__)
 
+#TODO check that strings used in arrays don't have tabs or spaces in them!
+
 def slicesize(s):
     return int((s.stop - s.start) / (s.step if s.step else 1))
 
@@ -42,6 +45,7 @@
     If a width is provided, raises a ValueError if any of the strings
     are of length greater than this width"""
 
+    strings = list(strings)
     if 'width' in kwargs:
         width = kwargs['width']
         del kwargs['width']
@@ -90,8 +94,8 @@
         """tuple of (len(rows, len(num_columns)) numpy-style shape"""
         return len(self.rows), self.num_columns
 
-    height = property(lambda self: len(self.rows))
-    width = property(lambda self: self.num_columns)
+    height = property(lambda self: len(self.rows), None, None, """The number of rows""")
+    width = property(lambda self: self.num_columns, None, None, """The number of columns""")
 
     def __setitem__(self, slicetuple, value):
         """Place a FSArray in a FSArray"""
@@ -127,13 +131,13 @@
                      self.rows[rowslice.stop:])
 
     def dumb_display(self):
-        """Prints rows, one per line"""
+        """Prints each row followed by a newline without regard for the terminal window size"""
         for line in self.rows:
             print(line)
 
     @classmethod
     def diff(cls, a, b, ignore_formatting=False):
-        """terminal output of diffs underlined"""
+        """Returns two FSArrays with differences underlined"""
         def underline(x): return u'\x1b[4m%s\x1b[0m' % (x,)
         def blink(x): return u'\x1b[5m%s\x1b[0m' % (x,)
         a_rows = []
diff -Nru python-curtsies-0.1.22/curtsies/formatstring.py python-curtsies-0.2.6/curtsies/formatstring.py
--- python-curtsies-0.1.22/curtsies/formatstring.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/formatstring.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,3 +1,4 @@
+from __future__ import unicode_literals
 r"""Colored strings that behave mostly like strings
 
 >>> s = fmtstr("Hey there!", 'red')
@@ -15,7 +16,7 @@
 '\x1b[31m\x1b[44mhello\x1b[49m\x1b[39m \x1b[34m\x1b[41mthere\x1b[49m\x1b[39m\x1b[32m!\x1b[39m'
 >>> fmtstr(', ').join(['a', fmtstr('b'), fmtstr('c', 'blue')])
 'a'+', '+'b'+', '+blue('c')
->>> fmtstr('hello', 'red', bold=False)
+>>> fmtstr(u'hello', u'red', bold=False)
 red('hello')
 """
 #TODO add a way to composite text without losing original formatting information
@@ -23,6 +24,7 @@
 import itertools
 import re
 import sys
+import wcwidth
 
 from .escseqparse import parse
 from .termformatconstants import (FG_COLORS, BG_COLORS, STYLES,
@@ -44,31 +46,45 @@
     'invert' :    lambda s: seq(STYLES['invert'])   +s+seq(RESET_ALL),
 }
 
+
 class FrozenDict(dict):
     """Immutable dictionary class"""
     def __setitem__(self, key, value):
         raise Exception("Cannot change value.")
     def update(self, dictlike):
         raise Exception("Cannot change value.")
+
     def extend(self, dictlike):
         return FrozenDict(itertools.chain(self.items(), dictlike.items()))
+
     def remove(self, *keys):
         return FrozenDict((k, v) for k, v in self.items() if k not in keys)
 
+
 class Chunk(object):
-    """A string with a single set of formatting attributes"""
+    """A string with a single set of formatting attributes
+
+    Subject to change, not part of the API"""
     def __init__(self, string, atts=()):
+        if not isinstance(string, unicode):
+            raise ValueError("unicode string required, got %r" % string)
         self._s = string
         self._atts = FrozenDict(atts)
 
-    s = property(lambda self: self._s) #makes self.s immutable
-
+    s = property(lambda self: self._s)  # resist changes to s and atts
     atts = property(lambda self: self._atts,
                     None, None,
                     "Attributes, e.g. {'fg': 34, 'bold': True} where 34 is the escape code for ...")
 
     def __len__(self):
-        return len(self.s)
+        return len(self._s)
+
+    @property
+    def width(self):
+        width = wcwidth.wcswidth(self._s)
+        if len(self._s) > 0 and width < 1:
+            raise ValueError("Can't calculate width of string %r" % self._s)
+        return width
 
     #TODO cache this
     @property
@@ -107,14 +123,13 @@
             if att == 'fg': return FG_NUMBER_TO_COLOR[self.atts[att]]
             elif att == 'bg': return 'on_' + BG_NUMBER_TO_COLOR[self.atts[att]]
             else: return att
-        atts_out = dict((k, v) for (k, v) in self.atts.items() if v) 
+        atts_out = dict((k, v) for (k, v) in self.atts.items() if v)
         return (''.join(pp_att(att)+'(' for att in sorted(atts_out))
-                + repr(self.s) + ')'*len(atts_out))
+                + (repr(self.s) if PY3 else repr(self.s)[1:]) + ')'*len(atts_out))
+
 
 class FmtStr(object):
-    """
-    A string whose substrings carry attributes (which may be different from one to the next).
-    """
+    """ A string whose substrings carry attributes (which may be different from one to the next).  """
     def __init__(self, *components):
         # These assertions below could be useful for debugging, but slow things down considerably
         #assert all([len(x) > 0 for x in components])
@@ -126,6 +141,7 @@
         self._unicode = None
         self._len = None
         self._s = None
+        self._width = None
 
     @classmethod
     def from_str(cls, s):
@@ -226,10 +242,12 @@
         return self.splice(string, len(self.s))
 
     def copy_with_new_atts(self, **attributes):
+        """Returns a new FmtStr with the same content but new formatting"""
         return FmtStr(*[Chunk(bfs.s, bfs.atts.extend(attributes))
                         for bfs in self.basefmtstrs])
 
     def join(self, iterable):
+        """Joins an iterable yielding strings or FmtStrs with self as separator"""
         before = []
         basefmtstrs = []
         for i, s in enumerate(iterable):
@@ -243,8 +261,12 @@
                 raise TypeError("expected str or FmtStr, %r found" % type(s))
         return FmtStr(*basefmtstrs)
 
-    #TODO make this split work like str.split
+    # TODO make this split work like str.split
     def split(self, sep=None, maxsplit=None, regex=False):
+        """Split based on seperator, optionally using a regex
+
+        Capture groups are ignored in regex, the whole pattern is matched
+        and used to split the original FmtStr."""
         if maxsplit is not None:
             raise NotImplementedError('no maxsplit yet')
         s = self.s
@@ -295,11 +317,14 @@
         self._unicode = ''.join(unicode(fs) for fs in self.basefmtstrs)
         return self._unicode
 
-    def __str__(self):
-        if self._str is not None:
+    if PY3:
+        __str__ = __unicode__
+    else:
+        def __str__(self):
+            if self._str is not None:
+                return self._str
+            self._str = str('').join(str(fs) for fs in self.basefmtstrs)
             return self._str
-        self._str = ''.join(str(fs) for fs in self.basefmtstrs)
-        return self._str
 
     def __len__(self):
         if self._len is not None:
@@ -307,6 +332,22 @@
         self._len = sum(len(fs) for fs in self.basefmtstrs)
         return self._len
 
+    @property
+    def width(self):
+        """The number of columns it would take to display this string"""
+        if self._width is not None:
+            return self._width
+        self._width = sum(fs.width for fs in self.basefmtstrs)
+        return self._width
+
+    def width_at_offset(self, n):
+        """Returns the horizontal position of character n of the string"""
+        #TODO make more efficient?
+        width = wcwidth.wcswidth(self.s[:n])
+        assert width != -1
+        return width
+
+
     def __repr__(self):
         return '+'.join(repr(fs) for fs in self.basefmtstrs)
 
@@ -357,6 +398,8 @@
 
     def __getattr__(self, att):
         # thanks to @aerenchyma/@jczett
+        if not hasattr(self.s, att):
+            raise AttributeError("No attribute %r" % (att,))
         def func_help(*args, **kwargs):
              result = getattr(self.s, att)(*args, **kwargs)
              if isinstance(result, (bytes, unicode)):
@@ -386,16 +429,37 @@
         index = normalize_slice(len(self), index)
         counter = 0
         parts = []
-        for fs in self.basefmtstrs:
-            if index.start < counter + len(fs) and index.stop > counter:
+        for chunk in self.basefmtstrs:
+            if index.start < counter + len(chunk) and index.stop > counter:
                 start = max(0, index.start - counter)
-                end = min(index.stop - counter, len(fs))
-                if end - start == len(fs):
-                    parts.append(fs)
+                end = min(index.stop - counter, len(chunk))
+                if end - start == len(chunk):
+                    parts.append(chunk)
                 else:
-                    s_part = fs.s[max(0, index.start - counter):index.stop - counter]
-                    parts.append(Chunk(s_part, fs.atts))
-            counter += len(fs)
+                    s_part = chunk.s[max(0, index.start - counter): index.stop - counter]
+                    parts.append(Chunk(s_part, chunk.atts))
+            counter += len(chunk)
+            if index.stop < counter:
+                break
+        return FmtStr(*parts) if parts else fmtstr('')
+
+    def width_aware_slice(self, index):
+        """Slice based on the number of columns it would take to display the substring"""
+        if wcwidth.wcswidth(self.s) == -1:
+            raise ValueError('bad values for width aware slicing')
+        index = normalize_slice(self.width, index)
+        counter = 0
+        parts = []
+        for chunk in self.basefmtstrs:
+            if index.start < counter + chunk.width and index.stop > counter:
+                start = max(0, index.start - counter)
+                end = min(index.stop - counter, chunk.width)
+                if end - start == chunk.width:
+                    parts.append(chunk)
+                else:
+                    s_part = width_aware_slice(chunk.s, max(0, index.start - counter), index.stop - counter)
+                    parts.append(Chunk(s_part, chunk.atts))
+            counter += chunk.width
             if index.stop < counter:
                 break
         return FmtStr(*parts) if parts else fmtstr('')
@@ -417,40 +481,40 @@
 
     def __setitem__(self, index, value):
         raise Exception("No!")
-        self._unicode = None
-        self._str = None
-        self._len = None
-        index = normalize_slice(len(self), index)
-        if isinstance(value, (bytes, unicode)):
-            value = FmtStr(Chunk(value))
-        elif not isinstance(value, FmtStr):
-            raise ValueError('Should be str or FmtStr')
-        counter = 0
-        old_basefmtstrs = self.basefmtstrs[:]
-        self.basefmtstrs = []
-        inserted = False
-        for fs in old_basefmtstrs:
-            if index.start < counter + len(fs) and index.stop > counter:
-                start = max(0, index.start - counter)
-                end = index.stop - counter
-                front = Chunk(fs.s[:start], fs.atts)
-                # stuff
-                new = value
-                back = Chunk(fs.s[end:], fs.atts)
-                if len(front) > 0:
-                    self.basefmtstrs.append(front)
-                if len(new) > 0 and not inserted:
-                    self.basefmtstrs.extend(new.basefmtstrs)
-                    inserted = True
-                if len(back) > 0:
-                    self.basefmtstrs.append(back)
-            else:
-                self.basefmtstrs.append(fs)
-            counter += len(fs)
 
     def copy(self):
         return FmtStr(*self.basefmtstrs)
 
+
+def interval_overlap(a, b, x, y):
+    """Returns by how much two intervals overlap
+
+    assumed that a <= b and x <= y"""
+    if b <= x or a >= y:
+        return 0
+    elif x <= a <= y:
+        return min(b, y) - a
+    elif x <= b <= y:
+        return b - max(a, x)
+    elif a >= x and b <= y:
+        return b - a
+    else:
+        assert False
+
+
+def width_aware_slice(s, start, end, replacement_char=u' '):
+    divides = [wcwidth.wcswidth(s, i) for i in range(len(s)+1)]
+
+    new_chunk_chars = []
+    for char, char_start, char_end in zip(s, divides[:-1], divides[1:]):
+        if char_start >= start and char_end <= end:
+            new_chunk_chars.append(char)
+        else:
+            new_chunk_chars.extend(replacement_char * interval_overlap(char_start, char_end, start, end))
+
+    return ''.join(new_chunk_chars)
+
+
 def linesplit(string, columns):
     """Returns a list of lines, split on the last possible space of each line.
 
@@ -529,20 +593,22 @@
         if kwargs['fg'] in FG_COLORS:
             kwargs['fg'] = FG_COLORS[kwargs['fg']]
         if kwargs['fg'] not in list(FG_COLORS.values()):
-            raise ValueError("Bad fg value: %s", kwargs['fg'])
+            raise ValueError("Bad fg value: %r" % kwargs['fg'])
     if 'bg' in kwargs:
         if kwargs['bg'] in BG_COLORS:
             kwargs['bg'] = BG_COLORS[kwargs['bg']]
         if kwargs['bg'] not in list(BG_COLORS.values()):
-            raise ValueError("Bad bg value: %s", kwargs['bg'])
+            raise ValueError("Bad bg value: %r" % kwargs['bg'])
     return kwargs
 
 def fmtstr(string, *args, **kwargs):
     """
     Convenience function for creating a FmtStr
 
-    >>> fmtstr('asdf', 'blue', 'on_red')
-    on_red(blue('asdf'))
+    >>> fmtstr('asdf', 'blue', 'on_red', 'bold')
+    on_red(bold(blue('asdf')))
+    >>> fmtstr('blarg', fg='blue', bg='red', bold=True)
+    on_red(bold(blue('blarg')))
     """
     atts = parse_args(args, kwargs)
     if isinstance(string, FmtStr):
diff -Nru python-curtsies-0.1.22/curtsies/__init__.py python-curtsies-0.2.6/curtsies/__init__.py
--- python-curtsies-0.1.22/curtsies/__init__.py	2016-01-11 16:33:46.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/__init__.py	2016-01-11 22:37:06.000000000 +0000
@@ -1,5 +1,5 @@
 """Terminal-formatted strings"""
-__version__='0.1.22'
+__version__='0.2.6'
 
 from .window import FullscreenWindow, CursorAwareWindow
 from .input import Input
diff -Nru python-curtsies-0.1.22/curtsies/input.py python-curtsies-0.2.6/curtsies/input.py
--- python-curtsies-0.1.22/curtsies/input.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/input.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,8 +1,4 @@
-"""
-New terminal
-"""
 
-import fcntl
 import locale
 import os
 import signal
@@ -19,35 +15,46 @@
 from .termhelpers import Nonblocking
 from . import events
 
-# note: if select doesn't work out for reading input with a timeout,
-# try a stdin read with a timeout instead?: http://stackoverflow.com/a/2918103/398212
-
 PY3 = sys.version_info[0] >= 3
 
 READ_SIZE = 1024
 assert READ_SIZE >= events.MAX_KEYPRESS_SIZE
-# if a keypress could require more bytes than we read at a time to be identified,
+# if a keypress could require more bytes than we read to be identified,
 # the paste logic that reads more data as needed might not work.
 
+
 class ReplacedSigIntHandler(object):
     def __init__(self, handler):
         self.handler = handler
+
     def __enter__(self):
         self.orig_sigint_handler = signal.getsignal(signal.SIGINT)
         signal.signal(signal.SIGINT, self.handler)
+
     def __exit__(self, type, value, traceback):
         signal.signal(signal.SIGINT, self.orig_sigint_handler)
 
+
 class Input(object):
-    """Coroutine-interface respecting keypress generator"""
-    def __init__(self, in_stream=sys.stdin, keynames='curtsies', paste_threshold=events.MAX_KEYPRESS_SIZE+1, sigint_event=False):
-        """in_stream should be standard input
-        keynames are how keypresses should be named - one of 'curtsies', 'curses', or 'plain'
-        paste_threshold is how many bytes must be read in a single read for
-          the keypresses they represent to be combined into a single paste event
+    """Keypress and control event generator"""
+    def __init__(self, in_stream=None, keynames='curtsies',
+                 paste_threshold=events.MAX_KEYPRESS_SIZE+1, sigint_event=False):
+        """Returns an Input instance.
+
+        Args:
+            in_stream (file): Defaults to sys.__stdin__
+            keynames (string): How keypresses should be named - one of
+              'curtsies', 'curses', or 'plain'.
+            paste_threshold (int): How many bytes must be read in one
+              os.read on the in_stream to trigger the keypresses they
+              represent to be combined into a single paste event
+            sigint_event (bool): Whether SIGINT signals from the OS
+              should be intercepted and returned as SigIntEvent objects
         """
+        if in_stream is None:
+            in_stream = sys.__stdin__
         self.in_stream = in_stream
-        self.unprocessed_bytes = [] # leftover from stdin, unprocessed yet
+        self.unprocessed_bytes = []  # leftover from stdin, unprocessed yet
         self.keynames = keynames
         self.paste_threshold = paste_threshold
         self.sigint_event = sigint_event
@@ -58,13 +65,20 @@
         self.queued_events = []
         self.queued_scheduled_events = []
 
-    #prospective: this could be useful for an external select loop
+    # prospective: this could be useful for an external select loop
     def fileno(self):
         return self.in_stream.fileno()
 
     def __enter__(self):
         self.original_stty = termios.tcgetattr(self.in_stream)
         tty.setcbreak(self.in_stream, termios.TCSANOW)
+
+        if sys.platform == 'darwin':
+            attrs = termios.tcgetattr(self.in_stream)
+            VDSUSP = termios.VSUSP + 1
+            attrs[-1][VDSUSP] = 0
+            termios.tcsetattr(self.in_stream, termios.TCSANOW, attrs)
+
         if self.sigint_event:
             self.orig_sigint_handler = signal.getsignal(signal.SIGINT)
             signal.signal(signal.SIGINT, self.sigint_handler)
@@ -87,19 +101,28 @@
     __next__ = next
 
     def unget_bytes(self, string):
-        """Inserts a bytestring into unprocessed bytes buffer"""
-        self.unprocessed_bytes.extend(string[i:i+1] for i in range(len(string)))
+        """Adds bytes to be internal buffer to be read
+
+        This method is for reporting bytes from an in_stream read
+        not initiated by this Input object"""
+
+        self.unprocessed_bytes.extend(string[i:i + 1]
+                                      for i in range(len(string)))
 
-    def wait_for_read_ready_or_timeout(self, timeout):
-        """Returns tuple of whether stdin has bytes to read and an event.
+    def _wait_for_read_ready_or_timeout(self, timeout):
+        """Returns tuple of whether stdin is ready to read and an event.
 
         If an event is returned, that event is more pressing than reading
-        bytes on stdin to create a keyboard input event."""
+        bytes on stdin to create a keyboard input event.
+        If stdin is ready, either there are bytes to read or a SIGTSTP
+        triggered by dsusp has been received"""
         remaining_timeout = timeout
         t0 = time.time()
         while True:
             try:
-                (rs, _, _) = select.select([self.in_stream.fileno()] + self.readers, [], [], remaining_timeout)
+                (rs, _, _) = select.select(
+                    [self.in_stream.fileno()] + self.readers,
+                    [], [], remaining_timeout)
                 if not rs:
                     return False, None
                 r = rs[0]  # if there's more than one, get it in the next loop
@@ -122,7 +145,7 @@
                     remaining_timeout = max(timeout - (time.time() - t0), 0)
 
     def send(self, timeout=None):
-        """Returns a key or None if no key pressed"""
+        """Returns an event or None if no events occur before timeout."""
         if self.sigint_event:
             with ReplacedSigIntHandler(self.sigint_handler):
                 return self._send(timeout)
@@ -131,15 +154,18 @@
 
     def _send(self, timeout):
         def find_key():
-            """Returns the keypress identified by adding unprocessed bytes, or None"""
+            """Returns keypress identified by adding unprocessed bytes or None"""
             current_bytes = []
             while self.unprocessed_bytes:
                 current_bytes.append(self.unprocessed_bytes.pop(0))
-                e = events.get_key(current_bytes, getpreferredencoding(), keynames=self.keynames, full=len(self.unprocessed_bytes)==0)
+                e = events.get_key(current_bytes,
+                                   getpreferredencoding(),
+                                   keynames=self.keynames,
+                                   full=len(self.unprocessed_bytes)==0)
                 if e is not None:
                     self.current_bytes = []
                     return e
-            if current_bytes: # incomplete keys shouldn't happen
+            if current_bytes:  # incomplete keys shouldn't happen
                 raise ValueError("Couldn't identify key sequence: %r" % self.current_bytes)
 
         if self.sigints:
@@ -150,13 +176,15 @@
             return self.queued_interrupting_events.pop(0)
 
         if self.queued_scheduled_events:
-            self.queued_scheduled_events.sort() #TODO use a data structure that inserts sorted
+            self.queued_scheduled_events.sort()  #TODO use a data structure that inserts sorted
             when, _ = self.queued_scheduled_events[0]
             if when < time.time():
-                logger.warning('popping an event! %r %r', self.queued_scheduled_events[0], self.queued_scheduled_events[1:])
+                logger.warning('popping an event! %r %r',
+                               self.queued_scheduled_events[0],
+                               self.queued_scheduled_events[1:])
                 return self.queued_scheduled_events.pop(0)[1]
             else:
-                time_until_check = min([max(0, when - time.time()), timeout], key=lambda x: sys.maxsize if x is None else x)
+                time_until_check = min(max(0, when - time.time()), timeout if timeout is not None else sys.maxsize)
         else:
             time_until_check = timeout
 
@@ -165,23 +193,28 @@
         if e is not None:
             return e
 
-        stdin_has_bytes, event = self.wait_for_read_ready_or_timeout(time_until_check)
+        stdin_ready_for_read, event = self._wait_for_read_ready_or_timeout(time_until_check)
         if event:
             return event
-        if self.queued_scheduled_events and when < time.time(): # when should always be defined
+        if self.queued_scheduled_events and when < time.time():  # when should always be defined
             # because queued_scheduled_events should not be modified during this time
-            logger.warning('popping an event! %r %r', self.queued_scheduled_events[0], self.queued_scheduled_events[1:])
+            logger.warning('popping an event! %r %r', self.queued_scheduled_events[0],
+                           self.queued_scheduled_events[1:])
             return self.queued_scheduled_events.pop(0)[1]
-        if not stdin_has_bytes:
+        if not stdin_ready_for_read:
+            return None
+
+        num_bytes = self._nonblocking_read()
+        if num_bytes == 0:
+            # thought stdin was ready, but not bytes to read is triggered
+            # when SIGTSTP was send by dsusp
             return None
 
-        num_bytes = self.nonblocking_read()
-        assert num_bytes > 0, num_bytes
         if self.paste_threshold is not None and num_bytes > self.paste_threshold:
             paste = events.PasteEvent()
             while True:
                 if len(self.unprocessed_bytes) < events.MAX_KEYPRESS_SIZE:
-                    self.nonblocking_read() # may need to read to get the rest of a keypress
+                    self._nonblocking_read()  # may need to read to get the rest of a keypress
                 e = find_key()
                 if e is None:
                     return paste
@@ -192,7 +225,7 @@
             assert e is not None
             return e
 
-    def nonblocking_read(self):
+    def _nonblocking_read(self):
         """Returns the number of characters read and adds them to self.unprocessed_bytes"""
         with Nonblocking(self.in_stream):
             if PY3:
@@ -218,7 +251,7 @@
         """Returns a callback that creates events.
 
         Returned callback function will add an event of type event_type
-        to a queue which will be checked the next time an event is requested"""
+        to a queue which will be checked the next time an event is requested."""
         def callback(**kwargs):
             self.queued_events.append(event_type(**kwargs))
         return callback
@@ -227,18 +260,18 @@
         """Returns a callback that schedules events for the future.
 
         Returned callback function will add an event of type event_type
-        to a queue which will be checked the next time an event is requested"""
+        to a queue which will be checked the next time an event is requested."""
         def callback(when, **kwargs):
             self.queued_scheduled_events.append((when, event_type(when=when, **kwargs)))
         return callback
 
     def threadsafe_event_trigger(self, event_type):
-        """Returns a callback to schedule events, interrupting event requests.
+        """Returns a callback to creates events, interrupting current event requests.
 
-        Returned callback function will add an event of type event_type
+        Returned callback function will create an event of type event_type
         which will interrupt an event request if one
         is concurrently occuring, otherwise adding the event to a queue
-        that will be checked on the next event request"""
+        that will be checked on the next event request."""
         readfd, writefd = os.pipe()
         self.readers.append(readfd)
 
diff -Nru python-curtsies-0.1.22/curtsies/window.py python-curtsies-0.2.6/curtsies/window.py
--- python-curtsies-0.1.22/curtsies/window.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/curtsies/window.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,59 +1,30 @@
-"""Classes for buffered rendering of 2D arrays of (colored) characters to the terminal
+# All windows write only unicode to the terminal -
+# that's what blessings does, so we match it.
 
-Windows provide buffered rendering of 2d arrays of (colored) charactors.
-
-FullscreenWindow will only render arrays the size of the terminal
-or smaller, and leaves no trace on exit (like top or vim). It never
-scrolls the terminal. Changing the terminal size doesn't do anything,
-but 2d array rendered needs to fit on the screen.
-
-CursorAwareWindow provides the ability to find the
-location of the cursor, and allows scrolling.
-Sigwinches can be annotated with how the terminal scroll changed
-Changing the terminal size breaks the cache, because it
-is unknown how the window size change affected scrolling / the cursor.
-Leaving the context of the window deletes everything below the cursor
-at the beginning of the its current line.
-(use scroll_down() from the last rendered line if you want to save all history)
-
-All windows write only unicode to the terminal - that's what blessings does, so
-we match it.
-"""
+from __future__ import unicode_literals
 
 import locale
 import logging
-import os
 import re
-import signal
 import sys
 
 import blessings
 
 from .formatstring import fmtstr
 from .formatstringarray import FSArray
-from .termhelpers import Cbreak, Nonblocking
-from . import events
+from .termhelpers import Cbreak
 
 logger = logging.getLogger(__name__)
 
 SCROLL_DOWN = u"\x1bD"
 FIRST_COLUMN = u"\x1b[1G"
 
-#BIG TODO!!! 
-#TODO How to get cursor position? It's a thing we need!
-#
-# Option 1: Window has a reference to the corresponding stdin
-#           For now, going to HCF when we read input that isn't a reponse to a cursor query
-#           Later will figure out how to deal with this (ungetc, use the same input gen, etc.)
-#
-# Is seems ungetc would require compiling code to install - that's a bit of a barrier
-# for something you want to install all the time like bpython
-
 
 class BaseWindow(object):
-    """ Renders 2D arrays of characters and cursor position """
-    def __init__(self, out_stream=sys.stdout, hide_cursor=True):
+    def __init__(self, out_stream=None, hide_cursor=True):
         logger.debug('-------initializing Window object %r------' % self)
+        if out_stream is None:
+            out_stream = sys.__stdout__
         self.t = blessings.Terminal(stream=out_stream, force_styling=True)
         self.out_stream = out_stream
         self.hide_cursor = hide_cursor
@@ -63,11 +34,12 @@
 
     def scroll_down(self):
         logger.debug('sending scroll down message w/ cursor on bottom line')
-        with self.t.location(x=0, y=1000000):# since scroll-down only moves the screen if cursor is at bottom
-            self.write(SCROLL_DOWN) #TODO will blessings do this?
+
+        # since scroll-down only moves the screen if cursor is at bottom
+        with self.t.location(x=0, y=1000000):
+            self.write(SCROLL_DOWN)  # TODO will blessings do this?
 
     def write(self, msg):
-        #logger.debug('writing %r' % msg)
         self.out_stream.write(msg)
         self.out_stream.flush()
 
@@ -83,22 +55,26 @@
             self.write(self.t.normal_cursor)
 
     def on_terminal_size_change(self, height, width):
+        # Changing the terminal size breaks the cache, because it
+        # is unknown how the window size change affected scrolling / the cursor
         self._last_lines_by_row = {}
         self._last_rendered_width = width
         self._last_rendered_height = height
 
-    def render_to_terminal(self, array, cursor_pos=(0,0)):
-        """Renders array to terminal"""
+    def render_to_terminal(self, array, cursor_pos=(0, 0)):
         raise NotImplemented
 
     def get_term_hw(self):
-        """Returns current terminal width and height"""
+        """Returns current terminal height and width"""
         return self.t.height, self.t.width
 
-    width  = property(lambda self: self.t.width)
-    height = property(lambda self: self.t.height)
+    width = property(lambda self: self.t.width, None, None,
+                     "The current width of the terminal window")
+    height = property(lambda self: self.t.height, None, None,
+                      "The current height of the terminal window")
 
     def array_from_text(self, msg):
+        """Returns a FSArray of the size of the window containing msg"""
         rows, columns = self.t.height, self.t.width
         return self.array_from_text_rc(msg, rows, columns)
 
@@ -132,11 +108,29 @@
 
 
 class FullscreenWindow(BaseWindow):
-    """A 2d-text rendering window that dissappears when its context is left
+    """2D-text rendering window that dissappears when its context is left
+
+    FullscreenWindow will only render arrays the size of the terminal
+    or smaller, and leaves no trace on exit (like top or vim). It never
+    scrolls the terminal. Changing the terminal size doesn't do anything,
+    but rendered arrays need to fit on the screen.
+
+    Note:
+        The context of the FullscreenWindow
+        object must be entered before calling any of its methods.
+
+        Within the context of CursorAwareWindow, refrain from writing to
+        its out_stream; cached writes will be inaccurate.
+    """
+    def __init__(self, out_stream=None, hide_cursor=True):
+        """Constructs a FullscreenWindow
 
-    Uses blessings's fullscreen capabilities"""
-    def __init__(self, out_stream=sys.stdout, hide_cursor=True):
-        BaseWindow.__init__(self, out_stream=out_stream, hide_cursor=hide_cursor)
+        Args:
+            out_stream (file): Defaults to sys.__stdout__
+            hide_cursor (bool): Hides cursor while in context
+        """
+        BaseWindow.__init__(self, out_stream=out_stream,
+                            hide_cursor=hide_cursor)
         self.fullscreen_ctx = self.t.fullscreen()
 
     def __enter__(self):
@@ -150,20 +144,28 @@
     def render_to_terminal(self, array, cursor_pos=(0, 0)):
         """Renders array to terminal and places (0-indexed) cursor
 
-        If array received is of width too small, render it anyway
-        if array received is of width too large, render the renderable portion
-        if array received is of height too small, render it anyway
-        if array received is of height too large, render the renderable portion (no scroll)
+        Args:
+            array (FSArray): Grid of styled characters to be rendered.
+
+        * If array received is of width too small, render it anyway
+        * If array received is of width too large,
+        * render the renderable portion
+        * If array received is of height too small, render it anyway
+        * If array received is of height too large,
+        * render the renderable portion (no scroll)
         """
-        #TODO there's a race condition here - these height and widths are
-        # super fresh - they might change between the array being constructed and rendered
-        # Maybe the right behavior is to throw away the render in the signal handler?
+        # TODO there's a race condition here - these height and widths are
+        # super fresh - they might change between the array being constructed
+        # and rendered
+        # Maybe the right behavior is to throw away the render
+        # in the signal handler?
         height, width = self.height, self.width
 
         for_stdout = self.fmtstr_to_stdout_xform()
         if not self.hide_cursor:
             self.write(self.t.hide_cursor)
-        if height != self._last_rendered_height or width != self._last_rendered_width:
+        if (height != self._last_rendered_height or
+                width != self._last_rendered_width):
             self.on_terminal_size_change(height, width)
 
         current_lines_by_row = {}
@@ -183,14 +185,19 @@
 
         # rows onscreen that we don't have content for
         for row in rest_of_rows:
-            if self._last_lines_by_row and row not in self._last_lines_by_row: continue
+            if self._last_lines_by_row and row not in self._last_lines_by_row:
+                continue
             self.write(self.t.move(row, 0))
             self.write(self.t.clear_eol)
             self.write(self.t.clear_bol)
             current_lines_by_row[row] = None
 
-        logger.debug('lines in last lines by row: %r' % self._last_lines_by_row.keys())
-        logger.debug('lines in current lines by row: %r' % current_lines_by_row.keys())
+        logger.debug(
+            'lines in last lines by row: %r' % self._last_lines_by_row.keys()
+        )
+        logger.debug(
+            'lines in current lines by row: %r' % current_lines_by_row.keys()
+        )
         self.write(self.t.move(*cursor_pos))
         self._last_lines_by_row = current_lines_by_row
         if not self.hide_cursor:
@@ -199,29 +206,52 @@
 
 class CursorAwareWindow(BaseWindow):
     """
+    Renders to the normal terminal screen and
+    can find the location of the cursor.
 
-    Cursor diff depends on cursor never being touched by the application
-    Only use the render_to_terminal interface for moving the cursor"""
-    def __init__(self, out_stream=sys.stdout, in_stream=sys.stdin,
-                 keep_last_line=False, hide_cursor=True, extra_bytes_callback=None):
-        """
-
-        extra_bytes_callback is a function that will be called with extra bytes
-        read from in_stream if they are inadvertantly read during a cursor_position call
+    Note:
+        The context of the CursorAwareWindow
+        object must be entered before calling any of its methods.
+
+        Within the context of CursorAwareWindow, refrain from writing to
+        its out_stream; cached writes will be inaccurate and calculating
+        cursor depends on cursor not having moved since the last render.
+        Only use the render_to_terminal interface for moving the cursor.
+    """
+    def __init__(self, out_stream=None, in_stream=None,
+                 keep_last_line=False, hide_cursor=True,
+                 extra_bytes_callback=None):
+        """Constructs a CursorAwareWindow
+
+        Args:
+            out_stream (file): Defaults to sys.__stdout__
+            in_stream (file): Defaults to sys.__stdin__
+            keep_last_line (bool): Causes the cursor to be moved down one line
+                on leaving context
+            hide_cursor (bool): Hides cursor while in context
+            extra_bytes_callback (f(bytes) -> None): Will be called with extra
+                bytes inadvertantly read in get_cursor_position(). If not
+                provided, a ValueError will be raised when this occurs.
         """
-        BaseWindow.__init__(self, out_stream=out_stream, hide_cursor=hide_cursor)
+        BaseWindow.__init__(self, out_stream=out_stream,
+                            hide_cursor=hide_cursor)
+        if in_stream is None:
+            in_stream = sys.__stdin__
         self.in_stream = in_stream
         self._last_cursor_column = None
         self._last_cursor_row = None
         self.keep_last_line = keep_last_line
         self.cbreak = Cbreak(self.in_stream)
         self.extra_bytes_callback = extra_bytes_callback
-        self.another_sigwinch = False   # whether another SIGWINCH is queued up
-        self.in_get_cursor_diff = False # in the cursor query code of cursor diff
+
+        # whether another SIGWINCH is queued up
+        self.another_sigwinch = False
+
+        # in the cursor query code of cursor diff
+        self.in_get_cursor_diff = False
 
     def __enter__(self):
-        if hasattr(self.in_stream, 'file_no'): #fake files aren't buffered, no need for cbreak
-            self.cbreak.__enter__()
+        self.cbreak.__enter__()
         self.top_usable_row, _ = self.get_cursor_position()
         self._orig_top_usable_row = self.top_usable_row
         logger.debug('initial top_usable_row: %d' % self.top_usable_row)
@@ -229,35 +259,39 @@
 
     def __exit__(self, type, value, traceback):
         if self.keep_last_line:
-            self.write(SCROLL_DOWN) # just moves cursor down if not on last line
+            # just moves cursor down if not on last line
+            self.write(SCROLL_DOWN)
 
         self.write(FIRST_COLUMN)
         self.write(self.t.clear_eos)
         self.write(self.t.clear_eol)
-        if hasattr(self.in_stream, 'file_no'): #fake files aren't buffered
-            self.cbreak.__exit__(type, value, traceback)
+        self.cbreak.__exit__(type, value, traceback)
         BaseWindow.__exit__(self, type, value, traceback)
 
     def get_cursor_position(self):
         """Returns the terminal (row, column) of the cursor
 
         0-indexed, like blessings cursor positions"""
-        in_stream = self.in_stream # TODO would this be cleaner as a parameter?
+        # TODO would this be cleaner as a parameter?
+        in_stream = self.in_stream
 
-        QUERY_CURSOR_POSITION = u"\x1b[6n"
-        self.write(QUERY_CURSOR_POSITION)
+        query_cursor_position = u"\x1b[6n"
+        self.write(query_cursor_position)
 
         def retrying_read():
             while True:
                 try:
                     c = in_stream.read(1)
                     if c == '':
-                        raise ValueError("Stream should be blocking - should't return ''. Returned %r so far", (resp,))
+                        raise ValueError("Stream should be blocking - should't"
+                                         " return ''. Returned %r so far",
+                                         (resp,))
                     return c
                 except IOError:
-                    raise ValueError('cursor get pos response read interrupted')
-                    # to find out if this ever really happens
-                    logger.debug('read interrupted, retrying')
+                    raise ValueError(
+                        'cursor get pos response read interrupted'
+                    )
+                    # find out if this ever really happens - if so, continue
 
         resp = ''
         while True:
@@ -272,22 +306,33 @@
                 extra = m.groupdict()['extra']
                 if extra:
                     if self.extra_bytes_callback:
-                        self.extra_bytes_callback(extra.encode(in_stream.encoding))
+                        self.extra_bytes_callback(
+                            extra.encode(in_stream.encoding)
+                        )
                     else:
-                        raise ValueError(("Bytes preceding cursor position query response thrown out:\n%r\n"
-                                          "Pass an extra_bytes_callback to CursorAwareWindow to prevent this") % (extra,))
-                return (row-1, col-1)
+                        raise ValueError(("Bytes preceding cursor position "
+                                          "query response thrown out:\n%r\n"
+                                          "Pass an extra_bytes_callback to "
+                                          "CursorAwareWindow to prevent this")
+                                         % (extra,))
+                return (row - 1, col - 1)
 
     def get_cursor_vertical_diff(self):
-        """Returns the how far down the cursor moved
-
-        If another get_cursor_vertical diff call is already in progress,
-        immediately returns zero.
+        """Returns the how far down the cursor moved since last render.
 
-        Does cursory querying until a SIGWINCH doesn't happen during
-        the query. Calls to the function from a signal handler COULD STILL
-        HAPPEN out of order - they just can't interrupt the actual cursor query.
+        Note:
+            If another get_cursor_vertical_diff call is already in progress,
+            immediately returns zero. (This situation is likely if
+            get_cursor_vertical_diff is called from a SIGWINCH signal
+            handler, since sigwinches can happen in rapid succession and
+            terminal emulators seem not to respond to cursor position
+            queries before the next sigwinch occurs.)
         """
+        # Probably called by a SIGWINCH handler, and therefore
+        # will do cursor querying until a SIGWINCH doesn't happen during
+        # the query. Calls to the function from a signal handler COULD STILL
+        # HAPPEN out of order -
+        # they just can't interrupt the actual cursor query.
         if self.in_get_cursor_diff:
             self.another_sigwinch = True
             return 0
@@ -302,7 +347,7 @@
                 return cursor_dy
 
     def _get_cursor_vertical_diff_once(self):
-        """Returns the how far down the cursor moved"""
+        """Returns the how far down the cursor moved."""
         old_top_usable_row = self.top_usable_row
         row, col = self.get_cursor_position()
         if self._last_cursor_row is None:
@@ -316,37 +361,49 @@
             while self.top_usable_row > 1 and cursor_dy < 0:
                 self.top_usable_row -= 1
                 cursor_dy += 1
-        logger.info('top usable row changed from %d to %d', old_top_usable_row, self.top_usable_row)
+        logger.info('top usable row changed from %d to %d', old_top_usable_row,
+                    self.top_usable_row)
         logger.info('returning cursor dy of %d from curtsies' % cursor_dy)
         self._last_cursor_row = row
         return cursor_dy
 
-    def render_to_terminal(self, array, cursor_pos=(0,0)):
-        """Renders array to terminal, returns the number of lines
-            scrolled offscreen
-        outputs:
-         -number of times scrolled
-
-        If array received is of width too small, render it anyway
-        if array received is of width too large, render it anyway
-        if array received is of height too small, render it anyway
-        if array received is of height too large, render it, scroll down,
+    def render_to_terminal(self, array, cursor_pos=(0, 0)):
+        """Renders array to terminal, returns the number of lines scrolled offscreen
+
+        Returns:
+            Number of times scrolled
+
+        Args:
+          array (FSArray): Grid of styled characters to be rendered.
+
+            If array received is of width too small, render it anyway
+
+            if array received is of width too large, render it anyway
+
+            if array received is of height too small, render it anyway
+
+            if array received is of height too large, render it, scroll down,
             and render the rest of it, then return how much we scrolled down
+
         """
         for_stdout = self.fmtstr_to_stdout_xform()
         # caching of write and tc (avoiding the self. lookups etc) made
         # no significant performance difference here
         if not self.hide_cursor:
             self.write(self.t.hide_cursor)
-        height, width = self.t.height, self.t.width #TODO race condition here?
-        if height != self._last_rendered_height or width != self._last_rendered_width:
+
+        # TODO race condition here?
+        height, width = self.t.height, self.t.width
+        if (height != self._last_rendered_height or
+                width != self._last_rendered_width):
             self.on_terminal_size_change(height, width)
 
         current_lines_by_row = {}
         rows_for_use = list(range(self.top_usable_row, height))
 
         # rows which we have content for and don't require scrolling
-        shared = min(len(array), len(rows_for_use)) #TODO rename shared
+        # TODO rename shared
+        shared = min(len(array), len(rows_for_use))
         for row, line in zip(rows_for_use[:shared], array[:shared]):
             current_lines_by_row[row] = line
             if line == self._last_lines_by_row.get(row, None):
@@ -359,32 +416,45 @@
         # rows already on screen that we don't have content for
         rest_of_lines = array[shared:]
         rest_of_rows = rows_for_use[shared:]
-        for row in rest_of_rows: # if array too small
-            if self._last_lines_by_row and row not in self._last_lines_by_row: continue
+        for row in rest_of_rows:  # if array too small
+            if self._last_lines_by_row and row not in self._last_lines_by_row:
+                continue
             self.write(self.t.move(row, 0))
             self.write(self.t.clear_eol)
-            self.write(self.t.clear_bol) #TODO probably not necessary - is first char cleared?
+            # TODO probably not necessary - is first char cleared?
+            self.write(self.t.clear_bol)
             current_lines_by_row[row] = None
 
         # lines for which we need to scroll down to render
         offscreen_scrolls = 0
-        for line in rest_of_lines: # if array too big
+        for line in rest_of_lines:  # if array too big
             self.scroll_down()
             if self.top_usable_row > 0:
                 self.top_usable_row -= 1
             else:
                 offscreen_scrolls += 1
-            current_lines_by_row = dict((k-1, v) for k, v in current_lines_by_row.items())
+            current_lines_by_row = dict(
+                (k - 1, v) for k, v in current_lines_by_row.items()
+            )
             logger.debug('new top_usable_row: %d' % self.top_usable_row)
-            self.write(self.t.move(height-1, 0)) # since scrolling moves the cursor
+            # since scrolling moves the cursor
+            self.write(self.t.move(height - 1, 0))
             self.write(for_stdout(line))
-            current_lines_by_row[height-1] = line
+            current_lines_by_row[height - 1] = line
 
-        logger.debug('lines in last lines by row: %r' % self._last_lines_by_row.keys())
-        logger.debug('lines in current lines by row: %r' % current_lines_by_row.keys())
-        self._last_cursor_row = cursor_pos[0]-offscreen_scrolls+self.top_usable_row
+        logger.debug(
+            'lines in last lines by row: %r' % self._last_lines_by_row.keys()
+        )
+        logger.debug(
+            'lines in current lines by row: %r' % current_lines_by_row.keys()
+        )
+        self._last_cursor_row = (
+            cursor_pos[0] - offscreen_scrolls + self.top_usable_row
+        )
         self._last_cursor_column = cursor_pos[1]
-        self.write(self.t.move(self._last_cursor_row, self._last_cursor_column))
+        self.write(
+            self.t.move(self._last_cursor_row, self._last_cursor_column)
+        )
         self._last_lines_by_row = current_lines_by_row
         if not self.hide_cursor:
             self.write(self.t.normal_cursor)
@@ -402,24 +472,24 @@
             while True:
                 c = input_generator.next()
                 if c == "":
-                    sys.exit() # same as raise SystemExit()
+                    sys.exit()  # same as raise SystemExit()
                 elif c == "h":
                     a = w.array_from_text("a for small array")
                 elif c == "a":
-                    a = [fmtstr(c*columns) for _ in range(rows)]
+                    a = [fmtstr(c * columns) for _ in range(rows)]
                 elif c == "s":
-                    a = [fmtstr(c*columns) for _ in range(rows-1)]
+                    a = [fmtstr(c * columns) for _ in range(rows - 1)]
                 elif c == "d":
-                    a = [fmtstr(c*columns) for _ in range(rows+1)]
+                    a = [fmtstr(c * columns) for _ in range(rows + 1)]
                 elif c == "f":
-                    a = [fmtstr(c*columns) for _ in range(rows-2)]
+                    a = [fmtstr(c * columns) for _ in range(rows - 2)]
                 elif c == "q":
-                    a = [fmtstr(c*columns) for _ in range(1)]
+                    a = [fmtstr(c * columns) for _ in range(1)]
                 elif c == "w":
-                    a = [fmtstr(c*columns) for _ in range(1)]
+                    a = [fmtstr(c * columns) for _ in range(1)]
                 elif c == "e":
-                    a = [fmtstr(c*columns) for _ in range(1)]
-                elif c == '\x0c': # ctrl-L
+                    a = [fmtstr(c * columns) for _ in range(1)]
+                elif c == '\x0c':  # ctrl-L
                     [w.write('\n') for _ in range(rows)]
                     continue
                 else:
@@ -431,12 +501,13 @@
     handler = logging.FileHandler(filename='display.log', level=logging.DEBUG)
     logging.getLogger(__name__).setLevel(logging.DEBUG)
     logging.getLogger(__name__).addHandler(handler)
-    from .termhelpers import Cbreak
     print('this should be just off-screen')
     w = FullscreenWindow(sys.stdout)
     rows, columns = w.t.height, w.t.width
     with w:
-        a = [fmtstr((('.row%r.' % (row,)) * rows)[:columns]) for row in range(rows)]
+        a = [fmtstr(
+            (('.row%r.' % (row,)) * rows)[:columns]
+        ) for row in range(rows)]
         w.render_to_terminal(a)
 
 if __name__ == '__main__':
diff -Nru python-curtsies-0.1.22/curtsies.egg-info/PKG-INFO python-curtsies-0.2.6/curtsies.egg-info/PKG-INFO
--- python-curtsies-0.1.22/curtsies.egg-info/PKG-INFO	2016-01-11 16:35:01.000000000 +0000
+++ python-curtsies-0.2.6/curtsies.egg-info/PKG-INFO	2016-01-11 22:37:58.000000000 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: curtsies
-Version: 0.1.22
+Version: 0.2.6
 Summary: Curses-like terminal wrapper, with colored strings!
 Home-page: https://github.com/thomasballinger/curtsies
 Author: Thomas Ballinger
diff -Nru python-curtsies-0.1.22/curtsies.egg-info/requires.txt python-curtsies-0.2.6/curtsies.egg-info/requires.txt
--- python-curtsies-0.1.22/curtsies.egg-info/requires.txt	2016-01-11 16:35:01.000000000 +0000
+++ python-curtsies-0.2.6/curtsies.egg-info/requires.txt	2016-01-11 22:37:58.000000000 +0000
@@ -1 +1,2 @@
 blessings>=1.5
+wcwidth>=0.1.4
diff -Nru python-curtsies-0.1.22/curtsies.egg-info/SOURCES.txt python-curtsies-0.2.6/curtsies.egg-info/SOURCES.txt
--- python-curtsies-0.1.22/curtsies.egg-info/SOURCES.txt	2016-01-11 16:35:02.000000000 +0000
+++ python-curtsies-0.2.6/curtsies.egg-info/SOURCES.txt	2016-01-11 22:37:59.000000000 +0000
@@ -31,9 +31,11 @@
 examples/demo_input_timeout.py
 examples/demo_scrolling.py
 examples/demo_window.py
+examples/fps.py
 examples/gameexample.py
 examples/initial_input.py
 examples/initial_input_with_cursor.py
+examples/quickstart.py
 examples/realtime.py
 examples/simple.py
 examples/snake.py
diff -Nru python-curtsies-0.1.22/debian/changelog python-curtsies-0.2.6/debian/changelog
--- python-curtsies-0.1.22/debian/changelog	2016-01-11 19:29:43.000000000 +0000
+++ python-curtsies-0.2.6/debian/changelog	2016-01-18 22:10:21.000000000 +0000
@@ -1,3 +1,11 @@
+python-curtsies (0.2.6-1) unstable; urgency=medium
+
+  * New upstream release.
+  * Add python(3)-wcwidth to Build-Depends.
+  * debian/patches: Removed, integrated upstream.
+
+ -- Sebastian Ramacher <sramacher@debian.org>  Mon, 18 Jan 2016 23:10:20 +0100
+
 python-curtsies (0.1.22-1) unstable; urgency=medium
 
   * New upstream release.
diff -Nru python-curtsies-0.1.22/debian/control python-curtsies-0.2.6/debian/control
--- python-curtsies-0.1.22/debian/control	2015-02-17 03:41:38.000000000 +0000
+++ python-curtsies-0.2.6/debian/control	2016-01-18 22:09:07.000000000 +0000
@@ -16,7 +16,9 @@
  python-mock,
  python3-mock,
  python-pyte,
- python3-pyte
+ python3-pyte,
+ python-wcwidth,
+ python3-wcwidth
 Standards-Version: 3.9.6
 Homepage: https://github.com/thomasballinger/curtsies
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=collab-maint/python-curtsies.git
diff -Nru python-curtsies-0.1.22/debian/patches/Check-isatty-instead.patch python-curtsies-0.2.6/debian/patches/Check-isatty-instead.patch
--- python-curtsies-0.1.22/debian/patches/Check-isatty-instead.patch	2016-01-11 19:25:41.000000000 +0000
+++ python-curtsies-0.2.6/debian/patches/Check-isatty-instead.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,20 +0,0 @@
-Description: Check isatty instead
-Author: Sebastian Ramacher <sebastian+dev@ramacher.at>
-Forwarded: https://github.com/thomasballinger/curtsies/pull/85
-
-diff --git a/tests/test_window.py b/tests/test_window.py
-index 493a483..184dea3 100644
---- a/tests/test_window.py
-+++ b/tests/test_window.py
-@@ -20,7 +20,7 @@ except ImportError:
-             return lambda x: None
- 
- 
--fds_closed = sys.stdin.closed or sys.stdout.closed
-+fds_closed = not sys.stdin.isatty() or not sys.stdout.isatty()
- 
- 
- class FakeFullscreenWindow(FullscreenWindow):
--- 
-2.7.0.rc3
-
diff -Nru python-curtsies-0.1.22/debian/patches/series python-curtsies-0.2.6/debian/patches/series
--- python-curtsies-0.1.22/debian/patches/series	2016-01-11 19:25:02.000000000 +0000
+++ python-curtsies-0.2.6/debian/patches/series	1970-01-01 00:00:00.000000000 +0000
@@ -1 +0,0 @@
-Check-isatty-instead.patch
diff -Nru python-curtsies-0.1.22/examples/chat.py python-curtsies-0.2.6/examples/chat.py
--- python-curtsies-0.1.22/examples/chat.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/examples/chat.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,3 +1,4 @@
+from __future__ import unicode_literals
 """A more realtime netcat"""
 import sys
 import select
@@ -46,13 +47,13 @@
                         e = input_generator.send(0)
                         if e == '<ESC>':
                             return
-                        elif e == '<RETURN>':
+                        elif e == '<Ctrl-j>':
                             keypresses.append('\n')
                             client.send((''.join(keypresses)).encode('latin-1'))
                             keypresses = []
                         elif e == '<SPACE>':
                             keypresses.append(' ')
-                        elif e == '<DELETE>':
+                        elif e in ('<DELETE>', '<BACKSPACE>'):
                             keypresses = keypresses[:-1]
                         elif e is not None:
                             keypresses.append(e)
diff -Nru python-curtsies-0.1.22/examples/demo_scrolling.py python-curtsies-0.2.6/examples/demo_scrolling.py
--- python-curtsies-0.1.22/examples/demo_scrolling.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/examples/demo_scrolling.py	2016-01-11 22:36:53.000000000 +0000
@@ -5,9 +5,9 @@
 
 rows, columns = '??'
 def cursor_winch():
-    global rows, columns
+    global rows, columns # instead of closure for Python 2 compatibility
     print('this should be just off-screen')
-    w = CursorAwareWindow(sys.stdout, sys.stdin, keep_last_line=True, hide_cursor=False)
+    w = CursorAwareWindow(sys.stdout, sys.stdin, keep_last_line=False, hide_cursor=False)
     def sigwinch_handler(signum, frame):
         global rows, columns
         dy = w.get_cursor_vertical_diff()
@@ -21,7 +21,9 @@
     with w:
         for e in input.Input():
             rows, columns = w.height, w.width
-            a = [fmtstr((('.%sx%s.' % (rows, columns)) * rows)[:columns]) for row in range(rows)]
+            a = [fmtstr(((u'.%sx%s.' % (rows, columns)) * rows)[:columns]) for row in range(rows)]
             w.render_to_terminal(a)
+            if e == u'<ESC>':
+                break
 if __name__ == '__main__':
     cursor_winch()
diff -Nru python-curtsies-0.1.22/examples/demo_window.py python-curtsies-0.2.6/examples/demo_window.py
--- python-curtsies-0.1.22/examples/demo_window.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/examples/demo_window.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import sys
 import signal
 import logging
diff -Nru python-curtsies-0.1.22/examples/fps.py python-curtsies-0.2.6/examples/fps.py
--- python-curtsies-0.1.22/examples/fps.py	1970-01-01 00:00:00.000000000 +0000
+++ python-curtsies-0.2.6/examples/fps.py	2016-01-11 22:36:53.000000000 +0000
@@ -0,0 +1,43 @@
+from __future__ import unicode_literals, division
+
+import time
+
+from curtsies import FullscreenWindow, Input, FSArray
+from curtsies.fmtfuncs import red, bold, green, on_blue, yellow, on_red
+import curtsies.events
+
+class Frame(curtsies.events.ScheduledEvent):
+    pass
+
+class World(object):
+    def __init__(self):
+        self.s = 'Hello'
+    def tick(self):
+        self.s += '|'
+        self.s = self.s[max(1, len(self.s)-80):]
+    def process_event(self, e):
+        self.s += str(e)
+
+def realtime(fps=15):
+    world = World()
+    dt = 1/fps
+
+    reactor = Input()
+    schedule_next_frame = reactor.scheduled_event_trigger(Frame)
+    schedule_next_frame(when=time.time())
+
+    with reactor:
+        for e in reactor:
+            if isinstance(e, Frame):
+                world.tick()
+                print(world.s)
+                when = e.when + dt
+                while when < time.time():
+                    when += dt
+                schedule_next_frame(when)
+            elif e == u'<ESC>':
+                break
+            else:
+                world.process_event(e)
+
+realtime()
diff -Nru python-curtsies-0.1.22/examples/gameexample.py python-curtsies-0.2.6/examples/gameexample.py
--- python-curtsies-0.1.22/examples/gameexample.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/examples/gameexample.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import itertools
 import sys
 
@@ -30,8 +32,8 @@
         self.width = width
         self.height = height
         n = 5
-        self.player = Entity(on_blue(green(bold('5'))), width // 2, height // 2 - 2, speed=5)
-        self.npcs = [Entity(on_blue(red('X')), i * width // (n * 2), j * height // (n * 2))
+        self.player = Entity(on_blue(green(bold(u'5'))), width // 2, height // 2 - 2, speed=5)
+        self.npcs = [Entity(on_blue(red(u'X')), i * width // (n * 2), j * height // (n * 2))
                      for i in range(1, 2*n, 2)
                      for j in range(1, 2*n, 2)]
         self.turn = 0
@@ -68,7 +70,7 @@
         self.turn += 1
         if self.turn % 20 == 0:
             self.player.speed = max(1, self.player.speed - 1)
-            self.player.display = on_blue(green(bold(str(self.player.speed))))
+            self.player.display = on_blue(green(bold(str(self.player.speed).decode('utf8'))))
 
     def get_array(self):
         a = FSArray(self.height, self.width)
diff -Nru python-curtsies-0.1.22/examples/quickstart.py python-curtsies-0.2.6/examples/quickstart.py
--- python-curtsies-0.1.22/examples/quickstart.py	1970-01-01 00:00:00.000000000 +0000
+++ python-curtsies-0.2.6/examples/quickstart.py	2016-01-11 22:36:53.000000000 +0000
@@ -0,0 +1,25 @@
+from __future__ import unicode_literals # convenient for Python 2
+import random
+
+from curtsies import FullscreenWindow, Input, FSArray
+from curtsies.fmtfuncs import red, bold, green, on_blue, yellow
+
+print(yellow('this prints normally, not to the alternate screen'))
+with FullscreenWindow() as window:
+    with Input() as input_generator:
+        msg = red(on_blue(bold('Press escape to exit')))
+        a = FSArray(window.height, window.width)
+        a[0:1, 0:msg.width] = [msg]
+        window.render_to_terminal(a)
+        for c in input_generator:
+            if c == '<ESC>':
+                break
+            elif c == '<SPACE>':
+                a = FSArray(window.height, window.width)
+            else:
+                s = repr(c)
+                row = random.choice(range(window.height))
+                column = random.choice(range(window.width-len(s)))
+                color = random.choice([red, green, on_blue, yellow])
+                a[row, column:column+len(s)] = [color(s)]
+            window.render_to_terminal(a)
diff -Nru python-curtsies-0.1.22/examples/snake.py python-curtsies-0.2.6/examples/snake.py
--- python-curtsies-0.1.22/examples/snake.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/examples/snake.py	2016-01-11 22:36:53.000000000 +0000
@@ -35,8 +35,8 @@
     def render(self):
         a = FSArray(self.height, self.width)
         for row, col in self.snake_parts:
-            a[row, col] = 'x'
-        a[self.apple[0], self.apple[1]] = 'o'
+            a[row, col] = u'x'
+        a[self.apple[0], self.apple[1]] = u'o'
         return a
 
     def tick(self, e):
@@ -55,7 +55,7 @@
             self.snake_parts.pop()
 
 def main():
-    MAX_FPS = 5
+    MAX_FPS = 20
     time_per_frame = lambda: 1. / MAX_FPS
 
     with FullscreenWindow() as window:
diff -Nru python-curtsies-0.1.22/PKG-INFO python-curtsies-0.2.6/PKG-INFO
--- python-curtsies-0.1.22/PKG-INFO	2016-01-11 16:35:02.000000000 +0000
+++ python-curtsies-0.2.6/PKG-INFO	2016-01-11 22:37:59.000000000 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: curtsies
-Version: 0.1.22
+Version: 0.2.6
 Summary: Curses-like terminal wrapper, with colored strings!
 Home-page: https://github.com/thomasballinger/curtsies
 Author: Thomas Ballinger
diff -Nru python-curtsies-0.1.22/readme.md python-curtsies-0.2.6/readme.md
--- python-curtsies-0.1.22/readme.md	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/readme.md	2016-01-11 22:36:53.000000000 +0000
@@ -1,262 +1,65 @@
 [![Build Status](https://travis-ci.org/thomasballinger/curtsies.svg?branch=master)](https://travis-ci.org/thomasballinger/curtsies)
-Curtsies: Terminal interaction w/o curses
-=========================================
-![Curtsies Logo](http://ballingt.com/assets/curtsies-tritone-small.png)
-
-Annotate portions of strings with terminal colors and formatting!
-Render that text to the terminal, and clean up afterwards!
-Get user keystrokes when they happen!
+[![Documentation Status](https://readthedocs.org/projects/curtsies/badge/?version=latest)](https://readthedocs.org/projects/curtsies/?badge=latest)
+![Curtsies Logo](http://ballingt.com/assets/curtsiestitle.png)
 
+Curtsies is a library for interacting with the terminal.
 This is what using (nearly every feature of) curtsies looks like:
 
-    import random
+```python
+from __future__ import unicode_literals # convenient for Python 2
+import random
+
+from curtsies import FullscreenWindow, Input, FSArray
+from curtsies.fmtfuncs import red, bold, green, on_blue, yellow
+
+print(yellow('this prints normally, not to the alternate screen'))
+with FullscreenWindow() as window:
+    with Input() as input_generator:
+        msg = red(on_blue(bold('Press escape to exit')))
+        a = FSArray(window.height, window.width)
+        a[0:1, 0:msg.width] = [msg]
+        for c in input_generator:
+            if c == '<ESC>':
+                break
+            elif c == '<SPACE>':
+                a = FSArray(window.height, window.width)
+            else:
+                s = repr(c).decode()
+                row = random.choice(range(window.height))
+                column = random.choice(range(window.width-len(s)))
+                color = random.choice([red, green, on_blue, yellow])
+                a[row, column:column+len(s)] = [color(s)]
+            window.render_to_terminal(a)
+```
+
+Paste it in a `something.py` file and try it out!
+
+Installation: `pip install curtsies`
+
+[Documentation](http://curtsies.readthedocs.org/en/latest/)
 
-    from curtsies import FullscreenWindow, Input, FSArray
-    from curtsies.fmtfuncs import red, bold, green, on_blue, yellow
+Primer
+------
 
-    print yellow('the following code takes over the screen')
-    with FullscreenWindow() as window:
-        print(red(on_blue(bold('Press escape to exit'))))
-        with Input() as input_generator:
-            a = FSArray(window.height, window.width)
-            for c in input_generator:
-                if c == '<ESC>':
-                    break
-                elif c == '<SPACE>':
-                    a = FSArray(window.height, window.width)
-                else:
-                    row = random.choice(range(window.height))
-                    column = random.choice(range(window.width-len(repr(c))))
-                    color = random.choice([red, green, on_blue, yellow])
-                    a[row, column:column+len(repr(c))] = [color(repr(c))]
-                window.render_to_terminal(a)
-
-There are a few main objects in curtsies you probably want to use:
-
-* [FmtStr](readme.md#fmtstr) objects are colored strings
-* [FSArray](readme.md#fsarray) objects are 2D arrays of colored text
-* [Input](readme.md#input) provides keys as they are pressed by the user
-* [FullscreenWindow](readme.md#fullscreenwindow) sets up a fullscreen environment for rendering arrays of colored text
-* [CursorAwareWindow](readme.md#cursorawarewindow) is a terminal wrapper (like curses) for rendering text to the terminal
-
-`FmtStr`
-=========
+[FmtStr](http://curtsies.readthedocs.org/en/latest/FmtStr.html) objects are strings formatted with
+colors and styles displayable in a terminal with [ANSI escape sequences](http://en.wikipedia.org/wiki/ANSI_escape_code>`_).
 
+(the import statement shown below is outdated)
 ![fmtstr example screenshot](http://i.imgur.com/7lFaxsz.png)
 
-You can use convenience functions instead:
-
-    >>> from fmtstr.fmtfuncs import *
-    >>> blue(on_red('hey')) + " " + underline("there")
-
-* `str(FmtStr)` -> escape sequence-laden text that looks cool in an ANSI-compatible terminal
-* `repr(FmtStr)` -> how to create an identical FmtStr
-* `FmtStr[3:10]` -> a new FmtStr
-* `FmtStr.upper()` (any string method) -> a new FmtStr or list of FmtStrs (str.split) or int (str.count)
-
-Other Libraries
----------------
-
-If all you need are colored strings, you've got some other great options (other wrappings of
-[ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code)):
-
-* [Blessings](https://github.com/erikrose/blessings) (`pip install blessings`)
-  As of version 0.1.0, Curtsies uses Blessings for terminal capabilities other
-  than colored output.
-* https://github.com/verigak/colors/ (`pip install colors`)
-* https://github.com/kennethreitz/clint/blob/master/clint/textui/colored.py (`pip install clint`)
-* https://pypi.python.org/pypi/termcolor (`pip install termcolor`)
-
-In all of these libraries the expression `blue('hi') + ' ' + green('there)`
-or equivalent
-evaluates to a Python string, not a colored string object. If all you plan
-to do with this string is print it, this is fine. But if you need to
-do more formatting with this colored string later, the length will be
-something like 29 instead of 9; structured formatting information is lost.
-Methods like `.ljust()` won't properly format the string for display.
-
-    >>> import blessings
-    >>> t = blessings.Terminal()
-    >>> message = term.red_on_green('Red on green?') + ' ' + term.yellow('Ick!')
-    >>> len(message)
-    41 # ?!
-    >>> message.center(50)
-    u'    \x1b[31m\x1b[42mRed on green?\x1b[m\x0f \x1b[33mIck!\x1b[m\x0f     '
-
-FmtStrs can be combined and composited to create more complicated FmtStrs,
-useful for example for building flashy terminal interfaces with overlapping
-windows/widgets than can change size and depend on each others sizes.
-One FmtStr can have several kinds of formatting applied to different parts of it.
-
-    >>> from curtsies.fmtfuncs import *
-    >>> blue('asdf') + on_red('adsf')
-    blue("asdf")+on_red("adsf")
-
-Details
--------
-
-FmtStrs allow slicing, which returns a new FmtStr object:
-
-    >>> from curtsies.fmtfuncs import *
-    >>> (blue('asdf') + on_red('adsf'))[3:7]
-    blue("f")+on_red("ads")
-
-FmtStrs are *immutable* - but you can create new ones with `splice`:
-
-    >>> from curtsies.fmtfuncs import *
-    >>> f = blue('hey there') + on_red(' Tom!')
-    >>> g.splice('ot', 1, 3)
-    >>> g
-    blue("h")+"ot"+blue(" there")+on_red(" Tom!")
-
-which can even change their length:
-
-    >>> f.splice('something longer', 2)
-    blue("h")+"something longer"+blue("ot")+blue(" there")+on_red(" Tom!")
-
-(Thanks to @OufeiDong for fixing this!)
-
-FmtStrs greedily absorb strings, but no formatting is applied
-
-    >>> from curtsies.fmtfuncs import *
-    >>> f = blue("The story so far:") + "In the beginning..."
-    >>> type(f)
-    <class curtsies.fmtstr.FmtStr>
-    >>> f
-    blue("The story so far:")+"In the beginning..."
-
-It's easy to turn ANSI terminal formatted strings into FmtStrs:
-
-    >>> from curtsies.fmtfuncs import *
-    >>> from curtsies import FmtStr
-    >>> s = str(blue('tom'))
-    >>> s
-    '\x1b[34mtom\x1b[39m'
-    >>> FmtStr.from_str(str(blue('tom')))
-    blue("tom")
-
-Using str methods on FmtStr objects
------------------------------------
-
-All sorts of string methods can be used on a FmtStr, so you can often
-use FmtStr objects where you had strings in your program before:
-
-    >>> from curtsies.fmtfuncs import *
-    >>> f = blue(underline('As you like it'))
-    >>> len(f)
-    14 
-    >>> f == underline(blue('As you like it')) + red('')
-    True
-    >>> blue(', ').join(['a', red('b')])
-    "a"+blue(", ")+red("b")
-
-If FmtStr doesn't implement a method, it tries its best to use the string
-method, which often works pretty well:
-
-    >>> from curtsies.fmtfuncs import *
-    >>> f = blue(underline('As you like it'))
-    >>> f.center(20)
-    blue(underline("   As you like it   "))
-    >>> f.count('i')
-    2
-    >>> f.endswith('it')
-    True
-    >>> f.index('you')
-    3
-    >>> f.split(' ')
-    [blue(underline("As")), blue(underline("you")), blue(underline("like")), blue(underline("it"))]
-
-But formatting information will be lost for attributes which are not the same through the whole string
-
-    >>> from curtsies.fmtfuncs import *
-    >>> f = bold(red('hi')+' '+on_blue('there'))
-    >>> f
-    bold(red('hi'))+bold(' ')+bold(on_blue('there'))
-    >>> f.center(10)
-    bold(" hi there ")
-
-`FSArray`
-=========
-
-2D array in which each line is a FmtStr.
+[FSArray](http://curtsies.readthedocs.org/en/latest/FSArray.html) objects contain multiple such strings
+with each formatted string on its own row, and FSArray
+objects can be superimposed on each other
+to build complex grids of colored and styled characters through composition.
 
+(the import statement shown below is outdated)
 ![fsarray example screenshot](http://i.imgur.com/rvTRPv1.png)
 
-Slicing works like it does with FmtStrs, but in two dimensions.
-FSArrays are *mutable*, so array assignment syntax can be used for natural
-compositing.
-
-    >>> from curtsies import FSArray, fsarray
-    >>> a = fsarray('-'*10 for _ in range(4))
-    >>> a[1:3, 3:7] = fsarray([green('msg:'),
-    ...                blue(on_green('hey!'))])
-    >>> a.dumb_display()
-    ----------
-    ---msg:---
-    ---hey!---
-    ----------
-
-`fsarray` is a convenience function returning a FSArray constructed from its arguments.
-
-`FullscreenWindow`
-==================
-
-FullscreenWindow will only render arrays the size of the terminal
-or smaller, and leaves no trace on exit (like top or vim). It never
-scrolls the terminal. Changing the terminal size doesn't do anything,
-but 2d array rendered needs to fit on the screen.
-
-`CursorAwareWindow`
-===================
-
-CursorAwareWindow provides the ability to find the
-location of the cursor, and allows scrolling.
-Sigwinches can be annotated with how the terminal scroll changed
-Changing the terminal size breaks the cache, because it
-is unknown how the window size change affected scrolling / the cursor.
-Leaving the context of the window deletes everything below the cursor
-at the beginning of the its current line.
-(use scroll_down() from the last rendered line if you want to save all history)
-
-`Input`
-=======
-
-Within the (context-manager) context of an Input generator, an in-stream
-is put in raw mode or cbreak mode, and keypresses are stored to be reported
-later.
-
-`Terminal.next()` waits for a keypress.
-To see what a given keypress is called (what unicode string is returned
-by `Terminal.next()`), try
-`python -m curtsies.terminal` and play around. Key events are unicode
-strings, but `Terminal.next()` will sometimes return event objects which
-inherit from events.Event. `Terminal` objects are
-iterable, so these events can be obtained by looping over the object.
-
-`Input` takes an optional argument for how to name
-keypress events, which is 'curtsies' by default.
-For compatibility with curses code, you can use 'curses' names,
-but note that curses doesn't have nice key names for many key combinations
-so you'll be putting up with names like `u'\xe1'` for
-option-j and `'\x86'` for ctrl-option-f.
-Pass 'plain' for this parameter to return a simple unicode representation.
-
-The events returned will be unicode strings representing single keypresses,
-or subclasses of events.Event.
-
-PasteEvent objects representing multple keystrokes in very rapid succession
-(typically because the user pasted in text, but possibly because they typed
-two keys simultaneously. How many bytes must occur together to trigger such
-an event is customizable via the paste_threshold argument to the `Input()`
-- by default it's one greater than the maximum possible keypress
-length in bytes.
-
-If `sigint_event=True` is passed to `Input()`, SIGINT signals from the
-operating system (which usually raise a KeyboardInterrupt exception)
-will be returned as `SigIntEvent()`s.
-
-To set a timeout on the blocking get, treat it like a generator and call
-`.send(timeout)`. The call will return None if no event is available.
+Such grids of characters can be rendered to the terminal in alternate screen mode
+(no history, like `Vim`, `top` etc.) by [FullscreenWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.FullscreenWindow) objects
+or normal history-preserving screen by [CursorAwareWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.CursorAwareWindow) objects.
+User keyboard input events like pressing the up arrow key are detected by an
+[Input](http://curtsies.readthedocs.org/en/latest/input.html) object.
 
 Examples
 --------
@@ -275,15 +78,12 @@
 
 * [More examples](/examples)
 
-Authors
--------
-* Thomas Ballinger
-* Fei Dong - work on making FmtStr and Chunk immutable
-* Julia Evans - help with Python 3 Conversion
-* Zach Allaun, Mary Rose Cook, Alex Clemmer - early code review of terminal.py
-* Rachel King - several bugfixes on blessings use
-* Amber Wilcox-O'Hearn - paired on a refactoring
-* Darius Bacon - lots of great code review
-* inspired by a conversation with Scott Feeney
-* Lea Albaugh - beautiful Curtsies logo
-* Nick Sweeting - fish-style history search and completion
+About
+-----
+
+* [Curtsies Documentation](http://curtsies.readthedocs.org/en/latest/)
+* Curtsies was written to for [bpython-curtsies](http://ballingt.com/2013/12/21/bpython-curtsies.html)
+* `#bpython` on irc is a good place to talk about Curtsies, but feel free
+  to open an issue if you're having a problem!
+* Thanks to the many contributors!
+* If all you need are colored strings, consider one of these [other libraries](http://curtsies.readthedocs.org/en/latest/FmtStr.html#rationale)!
diff -Nru python-curtsies-0.1.22/setup.cfg python-curtsies-0.2.6/setup.cfg
--- python-curtsies-0.1.22/setup.cfg	2016-01-11 16:35:02.000000000 +0000
+++ python-curtsies-0.2.6/setup.cfg	2016-01-11 22:37:59.000000000 +0000
@@ -1,6 +1,5 @@
 [nosetests]
 with-doctest = 1
-with-coverage = 1
 cover-package = curtsies
 cover-html = 1
 
diff -Nru python-curtsies-0.1.22/setup.py python-curtsies-0.2.6/setup.py
--- python-curtsies-0.1.22/setup.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/setup.py	2016-01-11 22:36:53.000000000 +0000
@@ -18,11 +18,13 @@
       license='MIT',
       packages=['curtsies'],
       install_requires = [
-          'blessings>=1.5'
+          'blessings>=1.5',
+          'wcwidth>=0.1.4',
       ],
       tests_require = [
           'mock',
-          'pyte'
+          'pyte',
+          'nose',
       ],
       classifiers=[
           'Development Status :: 3 - Alpha',
diff -Nru python-curtsies-0.1.22/tests/test_configfile_keynames.py python-curtsies-0.2.6/tests/test_configfile_keynames.py
--- python-curtsies-0.1.22/tests/test_configfile_keynames.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/tests/test_configfile_keynames.py	2016-01-11 22:36:53.000000000 +0000
@@ -2,7 +2,8 @@
 import unittest
 from functools import partial
 
-from curtsies.configfile_keynames import keymap, CURTSIES_NAMES
+from curtsies.configfile_keynames import keymap
+from curtsies.events import CURTSIES_NAMES
 
 class TestKeymap(unittest.TestCase):
     def config(self, mapping, curtsies):
diff -Nru python-curtsies-0.1.22/tests/test_fmtstr.py python-curtsies-0.2.6/tests/test_fmtstr.py
--- python-curtsies-0.1.22/tests/test_fmtstr.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/tests/test_fmtstr.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,36 +1,59 @@
 # -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+import sys
 import unittest
-from curtsies.formatstring import FmtStr, fmtstr, Chunk, linesplit, normalize_slice
+from curtsies.formatstring import (FmtStr, fmtstr, Chunk, linesplit,
+                                   normalize_slice, width_aware_slice)
 from curtsies.fmtfuncs import *
 from curtsies.termformatconstants import FG_COLORS
 from curtsies.formatstringarray import fsarray, FSArray, FormatStringTest
 
 try:
+    from unittest import skip
+except ImportError:
+    def skip(f):
+        return lambda self: None
+
+PY2 = sys.version_info[0] == 2
+
+try:
     unicode = unicode
 except:
     unicode = str
 
+
+def repr_without_leading_u(s):
+    assert isinstance(s, type(u''))
+    if PY2:
+        r = repr(s)
+        assert r[0] == 'u'
+        return r[1:]
+    else:
+        return repr(s)
+
+
 class TestFmtStrInitialization(unittest.TestCase):
     def test_bad(self):
         # Can't specify fg or bg color two ways
-        self.assertRaises(ValueError, fmtstr, 'hello', 'blue', {'fg':30})
-        self.assertRaises(ValueError, fmtstr, 'hello', 'on_blue', {'bg':40})
+        self.assertRaises(ValueError, fmtstr, 'hello', 'blue', {'fg': 30})
+        self.assertRaises(ValueError, fmtstr, 'hello', 'on_blue', {'bg': 40})
         # Only specific fg and bg colors are allowed
-        self.assertRaises(ValueError, fmtstr, 'hello', {'bg':30})
-        self.assertRaises(ValueError, fmtstr, 'hello', {'fg':40})
+        self.assertRaises(ValueError, fmtstr, 'hello', {'bg': 30})
+        self.assertRaises(ValueError, fmtstr, 'hello', {'fg': 40})
         # Only existing xforms can be used in kwargs
         self.assertRaises(ValueError, fmtstr, 'hello', 'make it big')
 
     def test_actual_init(self):
         FmtStr()
 
+
 class TestImmutability(unittest.TestCase):
 
     def test_fmt_strings_remain_unchanged_when_used_to_construct_other_ones(self):
         a = fmtstr('hi', 'blue')
         b = fmtstr('there', 'red')
         c = a + b
-        d = green(c)
+        green(c)
         self.assertEqual(a.shared_atts['fg'], FG_COLORS['blue'])
         self.assertEqual(b.shared_atts['fg'], FG_COLORS['red'])
 
@@ -124,7 +147,7 @@
 
     def test_copy_with_new_atts(self):
         a = fmtstr('hello')
-        b = a.copy_with_new_atts(bold = True)
+        b = a.copy_with_new_atts(bold=True)
         self.assertEqual(a.shared_atts, {})
         self.assertEqual(b.shared_atts, {'bold': True})
 
@@ -166,13 +189,18 @@
         self.assertEqual(blue('hello there').split(' '), [blue('hello'), blue('there')])
         s = blue('hello there')
         self.assertEqual(s.split(' '), [s[:5], s[6:]])
-        self.assertEqual(blue('hello   \t\n\nthere').split(), [blue('hello'), blue('there')])
 
         # split shouldn't create fmtstrs without basefmtstrs
         self.assertEqual(fmtstr('a').split('a')[0].basefmtstrs, fmtstr('').basefmtstrs)
         self.assertEqual(fmtstr('a').split('a')[1].basefmtstrs, fmtstr('').basefmtstrs)
 
         self.assertEqual((fmtstr('imp') + ' ').split('i'), [fmtstr(''), fmtstr('mp') + ' '])
+        self.assertEqual(blue('abcbd').split('b'), [blue('a'), blue('c'), blue('d')])
+
+    def test_split_with_spaces(self):
+        self.assertEqual(blue('a\nb').split(), [blue('a'), blue('b')])
+        self.assertEqual(blue('a   \t\n\nb').split(), [blue('a'), blue('b')])
+        self.assertEqual(blue('hello   \t\n\nthere').split(), [blue('hello'), blue('there')])
 
     def test_ljust_rjust(self):
         """"""
@@ -231,6 +259,7 @@
         self.assertEqual(fmtstr('hello', 'red', bold=False), red('hello'))
         self.assertEqual(fmtstr('hello', 'red', bold=True), bold(red('hello')))
 
+
 class TestDoubleUnders(unittest.TestCase):
     def test_equality(self):
         x = fmtstr("adfs")
@@ -238,6 +267,7 @@
         self.assertTrue(fmtstr("adfs"), fmtstr("adfs"))
         self.assertTrue(fmtstr("adfs", 'blue'), fmtstr("adfs", fg='blue'))
 
+
 class TestConvenience(unittest.TestCase):
     def test_fg(self):
         red('asdf')
@@ -254,19 +284,24 @@
         blink('asdf')
         self.assertTrue(True)
 
+
 class TestSlicing(unittest.TestCase):
+
     def test_index(self):
         self.assertEqual(fmtstr('Hi!', 'blue')[0], fmtstr('H', 'blue'))
         self.assertRaises(IndexError, fmtstr('Hi!', 'blue').__getitem__, 5)
+
     def test_slice(self):
         self.assertEqual(fmtstr('Hi!', 'blue')[1:2], fmtstr('i', 'blue'))
         self.assertEqual(fmtstr('Hi!', 'blue')[1:], fmtstr('i!', 'blue'))
         s = fmtstr('imp') + ' '
         self.assertEqual(s[1:], fmtstr('mp')+' ')
+        self.assertEqual(blue('a\nb')[0:1], blue('a'))
 
         # considering changing behavior so that this doens't work
         # self.assertEqual(fmtstr('Hi!', 'blue')[15:18], fmtstr('', 'blue'))
 
+
 class TestComposition(unittest.TestCase):
 
     def test_simple_composition(self):
@@ -282,26 +317,18 @@
     def test_output_type(self):
         self.assertEqual(type(str(fmtstr('hello', 'blue'))), str)
         self.assertEqual(type(unicode(fmtstr('hello', 'blue'))), unicode)
-        self.assertEqual(type(str(fmtstr(u'hello', 'blue'))), str)
-        self.assertEqual(type(unicode(fmtstr(u'hello', 'blue'))), unicode)
 
     def test_normal_chars(self):
         fmtstr('a', 'blue')
-        fmtstr(u'a', 'blue')
         str(fmtstr('a', 'blue'))
-        str(fmtstr(u'a', 'blue'))
         unicode(fmtstr('a', 'blue'))
-        unicode(fmtstr(u'a', 'blue'))
         self.assertTrue(True)
 
     def test_funny_chars(self):
         fmtstr('⁇', 'blue')
-        fmtstr(u'⁇', 'blue')
-        fmtstr(u'⁇', 'blue')
+        str(Chunk('⁇', {'fg': 'blue'}))
         str(fmtstr('⁇', 'blue'))
-        str(fmtstr(u'⁇', 'blue'))
         unicode(fmtstr('⁇', 'blue'))
-        unicode(fmtstr(u'⁇', 'blue'))
         self.assertTrue(True)
 
     def test_right_sequence_in_py3(self):
@@ -313,12 +340,12 @@
         self.assertEqual(str(full), '\x1b[31m\x1b[44mhello\x1b[49m\x1b[39m \x1b[34m\x1b[41mthere\x1b[49m\x1b[39m\x1b[32m!\x1b[39m')
 
     def test_len_of_unicode(self):
-        self.assertEqual(len(fmtstr(u'┌─')), 2)
-        lines = [u'┌─', 'an', u'┌─']
+        self.assertEqual(len(fmtstr('┌─')), 2)
+        lines = ['┌─', 'an', '┌─']
         r = fsarray(lines)
         self.assertEqual(r.shape, (3, 2))
-        self.assertEqual(len(fmtstr(fmtstr(u'┌─'))), len(fmtstr(u'┌─')))
-        self.assertEqual(fmtstr(fmtstr(u'┌─')), fmtstr(u'┌─'))
+        self.assertEqual(len(fmtstr(fmtstr('┌─'))), len(fmtstr('┌─')))
+        self.assertEqual(fmtstr(fmtstr('┌─')), fmtstr('┌─'))
         #TODO should we make this one work?
         # always coerce everything to unicode?
         #self.assertEqual(len(fmtstr('┌─')), 2)
@@ -326,40 +353,76 @@
     def test_len_of_unicode_in_fsarray(self):
 
         fsa = FSArray(3, 2)
-        fsa.rows[0] = fsa.rows[0].setslice_with_length(0, 2, u'┌─', 2)
+        fsa.rows[0] = fsa.rows[0].setslice_with_length(0, 2, '┌─', 2)
         self.assertEqual(fsa.shape, (3, 2))
-        fsa.rows[0] = fsa.rows[0].setslice_with_length(0, 2, fmtstr(u'┌─', 'blue'), 2)
+        fsa.rows[0] = fsa.rows[0].setslice_with_length(0, 2, fmtstr('┌─', 'blue'), 2)
         self.assertEqual(fsa.shape, (3, 2))
 
-
-
-        #lines = [u'┌─', 'an', u'┌─']
-        #r = fsarray(lines[:3])
-        #self.assertEqual(r.shape, (3, 2))
-        #self.assertEqual(fsarray(r).shape, (3, 2))
-        #self.assertEqual(fsarray(r[:]).shape, (3, 2))
-        #self.assertEqual(fsarray(r[:, :]).shape, (3, 2))
-
     def test_add_unicode_to_byte(self):
-        fmtstr(u'┌') + fmtstr('a')
-        fmtstr('a') + fmtstr(u'┌')
-        u'┌' + fmtstr(u'┌')
-        u'┌' + fmtstr('a')
-        fmtstr(u'┌') + u'┌'
-        fmtstr('a') + u'┌'
+        fmtstr('┌') + fmtstr('a')
+        fmtstr('a') + fmtstr('┌')
+        '┌' + fmtstr('┌')
+        '┌' + fmtstr('a')
+        fmtstr('┌') + '┌'
+        fmtstr('a') + '┌'
 
     def test_unicode_slicing(self):
-        self.assertEqual(fmtstr(u'┌adfs', 'blue')[:2], fmtstr(u'┌a', 'blue'))
-        self.assertEqual(type(fmtstr(u'┌adfs', 'blue')[:2].s), type(fmtstr(u'┌a', 'blue').s))
-        self.assertEqual(len(fmtstr(u'┌adfs', 'blue')[:2]), 2)
+        self.assertEqual(fmtstr('┌adfs', 'blue')[:2], fmtstr('┌a', 'blue'))
+        self.assertEqual(type(fmtstr('┌adfs', 'blue')[:2].s), type(fmtstr('┌a', 'blue').s))
+        self.assertEqual(len(fmtstr('┌adfs', 'blue')[:2]), 2)
 
     def test_unicode_repr(self):
-        repr(Chunk(u'–'))
-        self.assertEqual(repr(fmtstr(u'–')), repr(u'–'))
+        repr(Chunk('–'))
+        self.assertEqual(repr(fmtstr('–')), repr_without_leading_u('–'))
+
+
+class TestCharacterWidth(unittest.TestCase):
+
+    def test_doublewide_width(self):
+        self.assertEqual(len(fmtstr('Ｅ', 'blue')), 1)
+        self.assertEqual(fmtstr('Ｅ', 'blue').width, 2)
+        self.assertEqual(len(fmtstr('ｈｉ')), 2)
+        self.assertEqual(fmtstr('ｈｉ').width, 4)
+
+    def test_multi_width(self):
+        self.assertEqual(len(fmtstr('a\u0300')), 2)
+        self.assertEqual(fmtstr('a\u0300').width, 1)
+
+    def test_width_aware_slice(self):
+        self.assertEqual(fmtstr('Ｅ').width_aware_slice(slice(None, 1, None)).s, ' ')
+        self.assertEqual(fmtstr('Ｅ').width_aware_slice(slice(None, 2, None)).s, 'Ｅ')
+        self.assertEqual(fmtstr('HＥ!', 'blue').width_aware_slice(slice(1, 2, None)), fmtstr(' ', 'blue'))
+        self.assertEqual(fmtstr('HＥ!', 'blue').width_aware_slice(slice(1, 3, None)), fmtstr('Ｅ', 'blue'))
+
+    def test_width_at_offset(self):
+        self.assertEqual(fmtstr('abＥcdef').width_at_offset(0), 0)
+        self.assertEqual(fmtstr('abＥcdef').width_at_offset(2), 2)
+        self.assertEqual(fmtstr('abＥcdef').width_at_offset(3), 4)
+        self.assertEqual(fmtstr('a\u0300b\u3000c').width_at_offset(0), 0)
+        self.assertEqual(fmtstr('a\u0300b\u3000c').width_at_offset(1), 1)
+        self.assertEqual(fmtstr('a\u0300b\u3000c').width_at_offset(2), 1)
+        self.assertEqual(fmtstr('a\u0300b\u3000c').width_at_offset(3), 2)
+        self.assertEqual(len(fmtstr('a\u0300')), 2)
+        self.assertEqual(fmtstr('a\u0300').width, 1)
+
+class TestWidthHelpers(unittest.TestCase):
+
+    def test_combining_char_aware_slice(self):
+        self.assertEqual(width_aware_slice('abc', 0, 2), 'ab')
+        self.assertEqual(width_aware_slice('abc', 1, 3), 'bc')
+        self.assertEqual(width_aware_slice('abc', 0, 3), 'abc')
+        self.assertEqual(width_aware_slice('ab\u0300c', 0, 3), 'ab\u0300c')
+        self.assertEqual(width_aware_slice('ab\u0300c', 0, 2), 'ab\u0300')
+        self.assertEqual(width_aware_slice('ab\u0300c', 1, 3), 'b\u0300c')
+        self.assertEqual(width_aware_slice('ab\u0300\u0300c', 1, 3), 'b\u0300\u0300c')
+
+    def test_char_width_aware_slice(self):
+        self.assertEqual(width_aware_slice('abc', 1, 2), 'b')
+        self.assertEqual(width_aware_slice('aＥbc', 0, 4), 'aＥb')
+        self.assertEqual(width_aware_slice('aＥbc', 1, 4), 'Ｅb')
+        self.assertEqual(width_aware_slice('aＥbc', 2, 4), ' b')
+        self.assertEqual(width_aware_slice('aＥbc', 0, 2), 'a ')
 
-    def test_bad_utf8(self):
-        """FmtStrs of bytes that arne't valid utf8 even though a the output medium is shouldn't crash"""
-        str(fmtstr('\xf7'))
 
 class TestFSArray(unittest.TestCase):
     def test_no_hanging_space(self):
@@ -368,8 +431,8 @@
 
     def test_assignment_working(self):
         t = FSArray(10, 10)
-        t[2,2] = 'a'
-        t[2,2] == 'a'
+        t[2, 2] = 'a'
+        t[2, 2] == 'a'
 
     def test_normalize_slice(self):
         class SliceBuilder(object):
@@ -380,7 +443,13 @@
         self.assertEqual(normalize_slice(10, Slice[:3]), slice(0, 3, None))
         self.assertEqual(normalize_slice(11, Slice[3:]), slice(3, 11, None))
 
-class TestFSArray(FormatStringTest):
+    @skip('TODO')
+    def test_oomerror(self):
+        a = FSArray(10, 40)
+        a[2:-2, 2:-2] = fsarray(['asdf', 'zxcv'])
+
+
+class TestFSArrayWithDiff(FormatStringTest):
 
     def test_diff_testing(self):
         a = fsarray(['abc', 'def'])
diff -Nru python-curtsies-0.1.22/tests/test_input.py python-curtsies-0.2.6/tests/test_input.py
--- python-curtsies-0.1.22/tests/test_input.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/tests/test_input.py	2016-01-11 22:36:53.000000000 +0000
@@ -56,14 +56,14 @@
 
     def test_nonblocking_read(self):
         inp = Input()
-        self.assertEqual(inp.nonblocking_read(), 0)
+        self.assertEqual(inp._nonblocking_read(), 0)
 
     def test_send_paste(self):
         inp = Input()
         inp.unprocessed_bytes = []
-        inp.wait_for_read_ready_or_timeout = Mock()
-        inp.wait_for_read_ready_or_timeout.return_value = (True, None)
-        inp.nonblocking_read = Mock()
+        inp._wait_for_read_ready_or_timeout = Mock()
+        inp._wait_for_read_ready_or_timeout.return_value = (True, None)
+        inp._nonblocking_read = Mock()
         n = inp.paste_threshold + 1
 
         first_time = [True]
@@ -75,7 +75,7 @@
                 return n
             else:
                 return None
-        inp.nonblocking_read.side_effect = side_effect
+        inp._nonblocking_read.side_effect = side_effect
 
         r = inp.send(0)
         self.assertEqual(type(r), events.PasteEvent)
@@ -105,8 +105,8 @@
     def test_schedule_event_trigger_blocking(self):
         inp = Input()
         f = inp.scheduled_event_trigger(CustomScheduledEvent)
-        f(when=time.time()+.05)
-        self.assertEqual(type(inp.send(None)), CustomScheduledEvent)
+        f(when=time.time()+0.05)
+        self.assertEqual(type(next(inp)), CustomScheduledEvent)
 
     def test_threadsafe_event_trigger(self):
         inp = Input()
diff -Nru python-curtsies-0.1.22/tests/test_terminal.py python-curtsies-0.2.6/tests/test_terminal.py
--- python-curtsies-0.1.22/tests/test_terminal.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/tests/test_terminal.py	2016-01-11 22:36:53.000000000 +0000
@@ -131,6 +131,7 @@
         stdout = ScreenStdout(self.stream)
         self.window = CursorAwareWindow(out_stream=stdout,
                                         in_stream=self.screen._report_file)
+        self.window.cbreak = NopContext()
         blessings.Terminal.height = 3
         blessings.Terminal.width = 6
 
diff -Nru python-curtsies-0.1.22/tests/test_window.py python-curtsies-0.2.6/tests/test_window.py
--- python-curtsies-0.1.22/tests/test_window.py	2016-01-01 18:06:08.000000000 +0000
+++ python-curtsies-0.2.6/tests/test_window.py	2016-01-11 22:36:53.000000000 +0000
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from __future__ import unicode_literals
 import unittest
 import sys
 
@@ -19,7 +20,7 @@
             return lambda x: None
 
 
-fds_closed = sys.stdin.closed or sys.stdout.closed
+fds_closed = not sys.stdin.isatty() or not sys.stdout.isatty()
 
 
 class FakeFullscreenWindow(FullscreenWindow):