Bug 754469 - Part 1 - Add blessings Python package 1.3 for terminal interactions
☠☠ backed out by 75312a3da3a6 ☠ ☠
authorGregory Szorc <gps@mozilla.com>
Fri, 01 Jun 2012 21:30:22 +0200
changeset 95568 df2e1b2959d337bd071266e95ee59958619ddb21
parent 95567 d37a99fa625388e37bbee98b1949aa5f2eab6f77
child 95569 424a40f751dafd84d619a38e5a5a10a45a2148f7
push id22819
push usereakhgari@mozilla.com
push dateSat, 02 Jun 2012 18:40:08 +0000
treeherdermozilla-central@f4a7c1a1f514 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs754469
milestone15.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 754469 - Part 1 - Add blessings Python package 1.3 for terminal interactions
build/pylib/blessings/LICENSE
build/pylib/blessings/MANIFEST.in
build/pylib/blessings/PKG-INFO
build/pylib/blessings/README.rst
build/pylib/blessings/blessings.egg-info/PKG-INFO
build/pylib/blessings/blessings.egg-info/SOURCES.txt
build/pylib/blessings/blessings.egg-info/dependency_links.txt
build/pylib/blessings/blessings.egg-info/top_level.txt
build/pylib/blessings/blessings/__init__.py
build/pylib/blessings/blessings/tests.py
build/pylib/blessings/setup.cfg
build/pylib/blessings/setup.py
build/pylib/blessings/tox.ini
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2011 Erik Rose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/MANIFEST.in
@@ -0,0 +1,3 @@
+include README.rst
+include LICENSE
+include tox.ini
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/PKG-INFO
@@ -0,0 +1,426 @@
+Metadata-Version: 1.0
+Name: blessings
+Version: 1.3
+Summary: A thin, practical wrapper around terminal formatting, positioning, and more
+Home-page: https://github.com/erikrose/blessings
+Author: Erik Rose
+Author-email: erikrose@grinchcentral.com
+License: MIT
+Description: =========
+        Blessings
+        =========
+        
+        Coding with Blessings looks like this... ::
+        
+            from blessings import Terminal
+        
+            t = Terminal()
+        
+            print t.bold('Hi there!')
+            print t.bold_red_on_bright_green('It hurts my eyes!')
+        
+            with t.location(0, t.height - 1):
+                print 'This is at the bottom.'
+        
+        Or, for byte-level control, you can drop down and play with raw terminal
+        capabilities::
+        
+            print '{t.bold}All your {t.red}bold and red base{t.normal}'.format(t=t)
+            print t.wingo(2)
+        
+        The Pitch
+        =========
+        
+        Blessings lifts several of curses_' limiting assumptions, and it makes your
+        code pretty, too:
+        
+        * Use styles, color, and maybe a little positioning without clearing the whole
+          screen first.
+        * Leave more than one screenful of scrollback in the buffer after your program
+          exits, like a well-behaved command-line app should.
+        * Get rid of all those noisy, C-like calls to ``tigetstr`` and ``tparm``, so
+          your code doesn't get crowded out by terminal bookkeeping.
+        * Act intelligently when somebody redirects your output to a file, omitting the
+          terminal control codes the user doesn't want to see (optional).
+        
+        .. _curses: http://docs.python.org/library/curses.html
+        
+        Before And After
+        ----------------
+        
+        Without Blessings, this is how you'd print some underlined text at the bottom
+        of the screen::
+        
+            from curses import tigetstr, setupterm, tparm
+            from fcntl import ioctl
+            from os import isatty
+            import struct
+            import sys
+            from termios import TIOCGWINSZ
+        
+            # If we want to tolerate having our output piped to other commands or
+            # files without crashing, we need to do all this branching:
+            if hasattr(sys.stdout, 'fileno') and isatty(sys.stdout.fileno()):
+                setupterm()
+                sc = tigetstr('sc')
+                cup = tigetstr('cup')
+                rc = tigetstr('rc')
+                underline = tigetstr('smul')
+                normal = tigetstr('sgr0')
+            else:
+                sc = cup = rc = underline = normal = ''
+            print sc  # Save cursor position.
+            if cup:
+                # tigetnum('lines') doesn't always update promptly, hence this:
+                height = struct.unpack('hhhh', ioctl(0, TIOCGWINSZ, '\000' * 8))[0]
+                print tparm(cup, height - 1, 0)  # Move cursor to bottom.
+            print 'This is {under}underlined{normal}!'.format(under=underline,
+                                                              normal=normal)
+            print rc  # Restore cursor position.
+        
+        Phew! That was long and full of incomprehensible trash! Let's try it again,
+        this time with Blessings::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            with term.location(0, term.height - 1):
+                print 'This is', term.underline('pretty!')
+        
+        Much better.
+        
+        What It Provides
+        ================
+        
+        Blessings provides just one top-level object: ``Terminal``. Instantiating a
+        ``Terminal`` figures out whether you're on a terminal at all and, if so, does
+        any necessary terminal setup. After that, you can proceed to ask it all sorts
+        of things about the terminal. Terminal terminal terminal.
+        
+        Simple Formatting
+        -----------------
+        
+        Lots of handy formatting codes ("capabilities" in low-level parlance) are
+        available as attributes on a ``Terminal``. For example::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print 'I am ' + term.bold + 'bold' + term.normal + '!'
+        
+        You can also use them as wrappers so you don't have to say ``normal``
+        afterward::
+        
+            print 'I am', term.bold('bold') + '!'
+        
+        Or, if you want fine-grained control while maintaining some semblance of
+        brevity, you can combine it with Python's string formatting, which makes
+        attributes easy to access::
+        
+            print 'All your {t.red}base {t.underline}are belong to us{t.normal}'.format(t=term)
+        
+        Simple capabilities of interest include...
+        
+        * ``bold``
+        * ``reverse``
+        * ``underline``
+        * ``no_underline`` (which turns off underlining)
+        * ``blink``
+        * ``normal`` (which turns off everything, even colors)
+        * ``clear_eol`` (clear to the end of the line)
+        * ``clear_bol`` (clear to beginning of line)
+        * ``clear_eos`` (clear to end of screen)
+        
+        Here are a few more which are less likely to work on all terminals:
+        
+        * ``dim``
+        * ``italic`` and ``no_italic``
+        * ``shadow`` and ``no_shadow``
+        * ``standout`` and ``no_standout``
+        * ``subscript`` and ``no_subscript``
+        * ``superscript`` and ``no_superscript``
+        * ``flash`` (which flashes the screen once)
+        
+        Note that, while the inverse of ``underline`` is ``no_underline``, the only way
+        to turn off ``bold`` or ``reverse`` is ``normal``, which also cancels any
+        custom colors. This is because there's no way to tell the terminal to undo
+        certain pieces of formatting, even at the lowest level.
+        
+        You might notice that the above aren't the typical incomprehensible terminfo
+        capability names; we alias a few of the harder-to-remember ones for
+        readability. However, you aren't limited to these: you can reference any
+        string-returning capability listed on the `terminfo man page`_ by the name
+        under the "Cap-name" column: for example, ``term.rum``.
+        
+        .. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+        
+        Color
+        -----
+        
+        16 colors, both foreground and background, are available as easy-to-remember
+        attributes::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.red + term.on_green + 'Red on green? Ick!' + term.normal
+            print term.bright_red + term.on_bright_blue + 'This is even worse!' + term.normal
+        
+        You can also call them as wrappers, which sets everything back to normal at the
+        end::
+        
+            print term.red_on_green('Red on green? Ick!')
+            print term.yellow('I can barely see it.')
+        
+        The available colors are...
+        
+        * ``black``
+        * ``red``
+        * ``green``
+        * ``yellow``
+        * ``blue``
+        * ``magenta``
+        * ``cyan``
+        * ``white``
+        
+        You can set the background color instead of the foreground by prepending
+        ``on_``, as in ``on_blue``. There is also a ``bright`` version of each color:
+        for example, ``on_bright_blue``.
+        
+        There is also a numerical interface to colors, which takes an integer from
+        0-15::
+        
+            term.color(5) + 'Hello' + term.normal
+            term.on_color(3) + 'Hello' + term.normal
+        
+            term.color(5)('Hello')
+            term.on_color(3)('Hello')
+        
+        If some color is unsupported (for instance, if only the normal colors are
+        available, not the bright ones), trying to use it will, on most terminals, have
+        no effect: the foreground and background colors will stay as they were. You can
+        get fancy and do different things depending on the supported colors by checking
+        `number_of_colors`_.
+        
+        .. _`number_of_colors`: http://packages.python.org/blessings/#blessings.Terminal.number_of_colors
+        
+        Compound Formatting
+        -------------------
+        
+        If you want to do lots of crazy formatting all at once, you can just mash it
+        all together::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.bold_underline_green_on_yellow + 'Woo' + term.normal
+        
+        Or you can use your newly coined attribute as a wrapper, which implicitly sets
+        everything back to normal afterward::
+        
+            print term.bold_underline_green_on_yellow('Woo')
+        
+        This compound notation comes in handy if you want to allow users to customize
+        the formatting of your app: just have them pass in a format specifier like
+        "bold_green" on the command line, and do a quick ``getattr(term,
+        that_option)('Your text')`` when you do your formatting.
+        
+        I'd be remiss if I didn't credit couleur_, where I probably got the idea for
+        all this mashing.
+        
+        .. _couleur: http://pypi.python.org/pypi/couleur
+        
+        Parametrized Capabilities
+        -------------------------
+        
+        Some capabilities take parameters. Rather than making you dig up ``tparm()``
+        all the time, we simply make such capabilities into callable strings. You can
+        pass the parameters right in::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.move(10, 1)
+        
+        Here are some of interest:
+        
+        ``move``
+          Position the cursor elsewhere. Parameters are y coordinate, then x
+          coordinate.
+        ``move_x``
+          Move the cursor to the given column.
+        ``move_y``
+          Move the cursor to the given row.
+        
+        You can also reference any other string-returning capability listed on the
+        `terminfo man page`_ by its name under the "Cap-name" column.
+        
+        .. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+        
+        Height and Width
+        ----------------
+        
+        It's simple to get the height and width of the terminal, in characters::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            height = term.height
+            width = term.width
+        
+        These are newly updated each time you ask for them, so they're safe to use from
+        SIGWINCH handlers.
+        
+        Temporary Repositioning
+        -----------------------
+        
+        Sometimes you need to flit to a certain location, print something, and then
+        return: for example, when updating a progress bar at the bottom of the screen.
+        ``Terminal`` provides a context manager for doing this concisely::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            with term.location(0, term.height - 1):
+                print 'Here is the bottom.'
+            print 'This is back where I came from.'
+        
+        Parameters to ``location()`` are ``x`` and then ``y``, but you can also pass
+        just one of them, leaving the other alone. For example... ::
+        
+            with term.location(y=10):
+                print 'We changed just the row.'
+        
+        If you want to reposition permanently, see ``move``, in an example above.
+        
+        Pipe Savvy
+        ----------
+        
+        If your program isn't attached to a terminal, like if it's being piped to
+        another command or redirected to a file, all the capability attributes on
+        ``Terminal`` will return empty strings. You'll get a nice-looking file without
+        any formatting codes gumming up the works.
+        
+        If you want to override this--like if you anticipate your program being piped
+        through ``less -r``, which handles terminal escapes just fine--pass
+        ``force_styling=True`` to the ``Terminal`` constructor.
+        
+        In any case, there is an ``is_a_tty`` attribute on ``Terminal`` that lets you
+        see whether the attached stream seems to be a terminal. If it's false, you
+        might refrain from drawing progress bars and other frippery, since you're
+        apparently headed into a pipe::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            if term.is_a_tty:
+                with term.location(0, term.height - 1):
+                    print 'Progress: [=======>   ]'
+            print term.bold('Important stuff')
+        
+        Shopping List
+        =============
+        
+        There are decades of legacy tied up in terminal interaction, so attention to
+        detail and behavior in edge cases make a difference. Here are some ways
+        Blessings has your back:
+        
+        * Uses the terminfo database so it works with any terminal type
+        * Provides up-to-the-moment terminal height and width, so you can respond to
+          terminal size changes (SIGWINCH signals). (Most other libraries query the
+          ``COLUMNS`` and ``LINES`` environment variables or the ``cols`` or ``lines``
+          terminal capabilities, which don't update promptly, if at all.)
+        * Avoids making a mess if the output gets piped to a non-terminal
+        * Works great with standard Python string templating
+        * Provides convenient access to all terminal capabilities, not just a sugared
+          few
+        * Outputs to any file-like object, not just stdout
+        * Keeps a minimum of internal state, so you can feel free to mix and match with
+          calls to curses or whatever other terminal libraries you like
+        
+        Blessings does not provide...
+        
+        * Native color support on the Windows command prompt. However, it should work
+          when used in concert with colorama_.
+        
+        .. _colorama: http://pypi.python.org/pypi/colorama/0.2.4
+        
+        Bugs
+        ====
+        
+        Bugs or suggestions? Visit the `issue tracker`_.
+        
+        .. _`issue tracker`: https://github.com/erikrose/blessings/issues/new
+        
+        License
+        =======
+        
+        Blessings is under the MIT License. See the LICENSE file.
+        
+        Version History
+        ===============
+        
+        1.3
+          * Add ``number_of_colors``, which tells you how many colors the terminal
+            supports.
+          * Made ``color(n)`` and ``on_color(n)`` callable to wrap a string, like the
+            named colors can. Also, make them both fall back to the ``setf`` and
+            ``setb`` capabilities (like the named colors do) if the ANSI ``setaf`` and
+            ``setab`` aren't available.
+          * Allow ``color`` attr to act as an unparametrized string, not just a
+            callable.
+          * Make ``height`` and ``width`` examine any passed-in stream before falling
+            back to stdout. (This rarely if ever affects actual behavior; it's mostly
+            philosophical.)
+          * Make caching simpler and slightly more efficient.
+          * Get rid of a reference cycle between Terminals and FormattingStrings.
+          * Update docs to reflect that terminal addressing (as in ``location()``) is
+            0-based.
+        
+        1.2
+          * Added support for Python 3! We need 3.2.3 or greater, because the curses
+            library couldn't decide whether to accept strs or bytes before that
+            (http://bugs.python.org/issue10570).
+          * Everything that comes out of the library is now unicode. This lets us
+            support Python 3 without making a mess of the code, and Python 2 should
+            continue to work unless you were testing types (and badly). Please file a
+            bug if this causes trouble for you.
+          * Changed to the MIT License for better world domination.
+          * Added Sphinx docs.
+        
+        1.1
+          * Added nicely named attributes for colors.
+          * Introduced compound formatting.
+          * Added wrapper behavior for styling and colors.
+          * Let you force capabilities to be non-empty, even if the output stream is
+            not a terminal.
+          * Added the ``is_a_tty`` attribute for telling whether the output stream is a
+            terminal.
+          * Sugared the remaining interesting string capabilities.
+          * Let ``location()`` operate on just an x *or* y coordinate.
+        
+        1.0
+          * Extracted Blessings from nose-progressive, my `progress-bar-having,
+            traceback-shortcutting, rootin', tootin' testrunner`_. It provided the
+            tootin' functionality.
+        
+        .. _`progress-bar-having, traceback-shortcutting, rootin', tootin' testrunner`: http://pypi.python.org/pypi/nose-progressive/
+        
+Keywords: terminal,tty,curses,ncurses,formatting,style,color,console
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: Console :: Curses
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Terminals
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/README.rst
@@ -0,0 +1,399 @@
+=========
+Blessings
+=========
+
+Coding with Blessings looks like this... ::
+
+    from blessings import Terminal
+
+    t = Terminal()
+
+    print t.bold('Hi there!')
+    print t.bold_red_on_bright_green('It hurts my eyes!')
+
+    with t.location(0, t.height - 1):
+        print 'This is at the bottom.'
+
+Or, for byte-level control, you can drop down and play with raw terminal
+capabilities::
+
+    print '{t.bold}All your {t.red}bold and red base{t.normal}'.format(t=t)
+    print t.wingo(2)
+
+The Pitch
+=========
+
+Blessings lifts several of curses_' limiting assumptions, and it makes your
+code pretty, too:
+
+* Use styles, color, and maybe a little positioning without clearing the whole
+  screen first.
+* Leave more than one screenful of scrollback in the buffer after your program
+  exits, like a well-behaved command-line app should.
+* Get rid of all those noisy, C-like calls to ``tigetstr`` and ``tparm``, so
+  your code doesn't get crowded out by terminal bookkeeping.
+* Act intelligently when somebody redirects your output to a file, omitting the
+  terminal control codes the user doesn't want to see (optional).
+
+.. _curses: http://docs.python.org/library/curses.html
+
+Before And After
+----------------
+
+Without Blessings, this is how you'd print some underlined text at the bottom
+of the screen::
+
+    from curses import tigetstr, setupterm, tparm
+    from fcntl import ioctl
+    from os import isatty
+    import struct
+    import sys
+    from termios import TIOCGWINSZ
+
+    # If we want to tolerate having our output piped to other commands or
+    # files without crashing, we need to do all this branching:
+    if hasattr(sys.stdout, 'fileno') and isatty(sys.stdout.fileno()):
+        setupterm()
+        sc = tigetstr('sc')
+        cup = tigetstr('cup')
+        rc = tigetstr('rc')
+        underline = tigetstr('smul')
+        normal = tigetstr('sgr0')
+    else:
+        sc = cup = rc = underline = normal = ''
+    print sc  # Save cursor position.
+    if cup:
+        # tigetnum('lines') doesn't always update promptly, hence this:
+        height = struct.unpack('hhhh', ioctl(0, TIOCGWINSZ, '\000' * 8))[0]
+        print tparm(cup, height - 1, 0)  # Move cursor to bottom.
+    print 'This is {under}underlined{normal}!'.format(under=underline,
+                                                      normal=normal)
+    print rc  # Restore cursor position.
+
+Phew! That was long and full of incomprehensible trash! Let's try it again,
+this time with Blessings::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    with term.location(0, term.height - 1):
+        print 'This is', term.underline('pretty!')
+
+Much better.
+
+What It Provides
+================
+
+Blessings provides just one top-level object: ``Terminal``. Instantiating a
+``Terminal`` figures out whether you're on a terminal at all and, if so, does
+any necessary terminal setup. After that, you can proceed to ask it all sorts
+of things about the terminal. Terminal terminal terminal.
+
+Simple Formatting
+-----------------
+
+Lots of handy formatting codes ("capabilities" in low-level parlance) are
+available as attributes on a ``Terminal``. For example::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    print 'I am ' + term.bold + 'bold' + term.normal + '!'
+
+You can also use them as wrappers so you don't have to say ``normal``
+afterward::
+
+    print 'I am', term.bold('bold') + '!'
+
+Or, if you want fine-grained control while maintaining some semblance of
+brevity, you can combine it with Python's string formatting, which makes
+attributes easy to access::
+
+    print 'All your {t.red}base {t.underline}are belong to us{t.normal}'.format(t=term)
+
+Simple capabilities of interest include...
+
+* ``bold``
+* ``reverse``
+* ``underline``
+* ``no_underline`` (which turns off underlining)
+* ``blink``
+* ``normal`` (which turns off everything, even colors)
+* ``clear_eol`` (clear to the end of the line)
+* ``clear_bol`` (clear to beginning of line)
+* ``clear_eos`` (clear to end of screen)
+
+Here are a few more which are less likely to work on all terminals:
+
+* ``dim``
+* ``italic`` and ``no_italic``
+* ``shadow`` and ``no_shadow``
+* ``standout`` and ``no_standout``
+* ``subscript`` and ``no_subscript``
+* ``superscript`` and ``no_superscript``
+* ``flash`` (which flashes the screen once)
+
+Note that, while the inverse of ``underline`` is ``no_underline``, the only way
+to turn off ``bold`` or ``reverse`` is ``normal``, which also cancels any
+custom colors. This is because there's no way to tell the terminal to undo
+certain pieces of formatting, even at the lowest level.
+
+You might notice that the above aren't the typical incomprehensible terminfo
+capability names; we alias a few of the harder-to-remember ones for
+readability. However, you aren't limited to these: you can reference any
+string-returning capability listed on the `terminfo man page`_ by the name
+under the "Cap-name" column: for example, ``term.rum``.
+
+.. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+
+Color
+-----
+
+16 colors, both foreground and background, are available as easy-to-remember
+attributes::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    print term.red + term.on_green + 'Red on green? Ick!' + term.normal
+    print term.bright_red + term.on_bright_blue + 'This is even worse!' + term.normal
+
+You can also call them as wrappers, which sets everything back to normal at the
+end::
+
+    print term.red_on_green('Red on green? Ick!')
+    print term.yellow('I can barely see it.')
+
+The available colors are...
+
+* ``black``
+* ``red``
+* ``green``
+* ``yellow``
+* ``blue``
+* ``magenta``
+* ``cyan``
+* ``white``
+
+You can set the background color instead of the foreground by prepending
+``on_``, as in ``on_blue``. There is also a ``bright`` version of each color:
+for example, ``on_bright_blue``.
+
+There is also a numerical interface to colors, which takes an integer from
+0-15::
+
+    term.color(5) + 'Hello' + term.normal
+    term.on_color(3) + 'Hello' + term.normal
+
+    term.color(5)('Hello')
+    term.on_color(3)('Hello')
+
+If some color is unsupported (for instance, if only the normal colors are
+available, not the bright ones), trying to use it will, on most terminals, have
+no effect: the foreground and background colors will stay as they were. You can
+get fancy and do different things depending on the supported colors by checking
+`number_of_colors`_.
+
+.. _`number_of_colors`: http://packages.python.org/blessings/#blessings.Terminal.number_of_colors
+
+Compound Formatting
+-------------------
+
+If you want to do lots of crazy formatting all at once, you can just mash it
+all together::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    print term.bold_underline_green_on_yellow + 'Woo' + term.normal
+
+Or you can use your newly coined attribute as a wrapper, which implicitly sets
+everything back to normal afterward::
+
+    print term.bold_underline_green_on_yellow('Woo')
+
+This compound notation comes in handy if you want to allow users to customize
+the formatting of your app: just have them pass in a format specifier like
+"bold_green" on the command line, and do a quick ``getattr(term,
+that_option)('Your text')`` when you do your formatting.
+
+I'd be remiss if I didn't credit couleur_, where I probably got the idea for
+all this mashing.
+
+.. _couleur: http://pypi.python.org/pypi/couleur
+
+Parametrized Capabilities
+-------------------------
+
+Some capabilities take parameters. Rather than making you dig up ``tparm()``
+all the time, we simply make such capabilities into callable strings. You can
+pass the parameters right in::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    print term.move(10, 1)
+
+Here are some of interest:
+
+``move``
+  Position the cursor elsewhere. Parameters are y coordinate, then x
+  coordinate.
+``move_x``
+  Move the cursor to the given column.
+``move_y``
+  Move the cursor to the given row.
+
+You can also reference any other string-returning capability listed on the
+`terminfo man page`_ by its name under the "Cap-name" column.
+
+.. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+
+Height and Width
+----------------
+
+It's simple to get the height and width of the terminal, in characters::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    height = term.height
+    width = term.width
+
+These are newly updated each time you ask for them, so they're safe to use from
+SIGWINCH handlers.
+
+Temporary Repositioning
+-----------------------
+
+Sometimes you need to flit to a certain location, print something, and then
+return: for example, when updating a progress bar at the bottom of the screen.
+``Terminal`` provides a context manager for doing this concisely::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    with term.location(0, term.height - 1):
+        print 'Here is the bottom.'
+    print 'This is back where I came from.'
+
+Parameters to ``location()`` are ``x`` and then ``y``, but you can also pass
+just one of them, leaving the other alone. For example... ::
+
+    with term.location(y=10):
+        print 'We changed just the row.'
+
+If you want to reposition permanently, see ``move``, in an example above.
+
+Pipe Savvy
+----------
+
+If your program isn't attached to a terminal, like if it's being piped to
+another command or redirected to a file, all the capability attributes on
+``Terminal`` will return empty strings. You'll get a nice-looking file without
+any formatting codes gumming up the works.
+
+If you want to override this--like if you anticipate your program being piped
+through ``less -r``, which handles terminal escapes just fine--pass
+``force_styling=True`` to the ``Terminal`` constructor.
+
+In any case, there is an ``is_a_tty`` attribute on ``Terminal`` that lets you
+see whether the attached stream seems to be a terminal. If it's false, you
+might refrain from drawing progress bars and other frippery, since you're
+apparently headed into a pipe::
+
+    from blessings import Terminal
+
+    term = Terminal()
+    if term.is_a_tty:
+        with term.location(0, term.height - 1):
+            print 'Progress: [=======>   ]'
+    print term.bold('Important stuff')
+
+Shopping List
+=============
+
+There are decades of legacy tied up in terminal interaction, so attention to
+detail and behavior in edge cases make a difference. Here are some ways
+Blessings has your back:
+
+* Uses the terminfo database so it works with any terminal type
+* Provides up-to-the-moment terminal height and width, so you can respond to
+  terminal size changes (SIGWINCH signals). (Most other libraries query the
+  ``COLUMNS`` and ``LINES`` environment variables or the ``cols`` or ``lines``
+  terminal capabilities, which don't update promptly, if at all.)
+* Avoids making a mess if the output gets piped to a non-terminal
+* Works great with standard Python string templating
+* Provides convenient access to all terminal capabilities, not just a sugared
+  few
+* Outputs to any file-like object, not just stdout
+* Keeps a minimum of internal state, so you can feel free to mix and match with
+  calls to curses or whatever other terminal libraries you like
+
+Blessings does not provide...
+
+* Native color support on the Windows command prompt. However, it should work
+  when used in concert with colorama_.
+
+.. _colorama: http://pypi.python.org/pypi/colorama/0.2.4
+
+Bugs
+====
+
+Bugs or suggestions? Visit the `issue tracker`_.
+
+.. _`issue tracker`: https://github.com/erikrose/blessings/issues/new
+
+License
+=======
+
+Blessings is under the MIT License. See the LICENSE file.
+
+Version History
+===============
+
+1.3
+  * Add ``number_of_colors``, which tells you how many colors the terminal
+    supports.
+  * Made ``color(n)`` and ``on_color(n)`` callable to wrap a string, like the
+    named colors can. Also, make them both fall back to the ``setf`` and
+    ``setb`` capabilities (like the named colors do) if the ANSI ``setaf`` and
+    ``setab`` aren't available.
+  * Allow ``color`` attr to act as an unparametrized string, not just a
+    callable.
+  * Make ``height`` and ``width`` examine any passed-in stream before falling
+    back to stdout. (This rarely if ever affects actual behavior; it's mostly
+    philosophical.)
+  * Make caching simpler and slightly more efficient.
+  * Get rid of a reference cycle between Terminals and FormattingStrings.
+  * Update docs to reflect that terminal addressing (as in ``location()``) is
+    0-based.
+
+1.2
+  * Added support for Python 3! We need 3.2.3 or greater, because the curses
+    library couldn't decide whether to accept strs or bytes before that
+    (http://bugs.python.org/issue10570).
+  * Everything that comes out of the library is now unicode. This lets us
+    support Python 3 without making a mess of the code, and Python 2 should
+    continue to work unless you were testing types (and badly). Please file a
+    bug if this causes trouble for you.
+  * Changed to the MIT License for better world domination.
+  * Added Sphinx docs.
+
+1.1
+  * Added nicely named attributes for colors.
+  * Introduced compound formatting.
+  * Added wrapper behavior for styling and colors.
+  * Let you force capabilities to be non-empty, even if the output stream is
+    not a terminal.
+  * Added the ``is_a_tty`` attribute for telling whether the output stream is a
+    terminal.
+  * Sugared the remaining interesting string capabilities.
+  * Let ``location()`` operate on just an x *or* y coordinate.
+
+1.0
+  * Extracted Blessings from nose-progressive, my `progress-bar-having,
+    traceback-shortcutting, rootin', tootin' testrunner`_. It provided the
+    tootin' functionality.
+
+.. _`progress-bar-having, traceback-shortcutting, rootin', tootin' testrunner`: http://pypi.python.org/pypi/nose-progressive/
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings.egg-info/PKG-INFO
@@ -0,0 +1,426 @@
+Metadata-Version: 1.0
+Name: blessings
+Version: 1.3
+Summary: A thin, practical wrapper around terminal formatting, positioning, and more
+Home-page: https://github.com/erikrose/blessings
+Author: Erik Rose
+Author-email: erikrose@grinchcentral.com
+License: MIT
+Description: =========
+        Blessings
+        =========
+        
+        Coding with Blessings looks like this... ::
+        
+            from blessings import Terminal
+        
+            t = Terminal()
+        
+            print t.bold('Hi there!')
+            print t.bold_red_on_bright_green('It hurts my eyes!')
+        
+            with t.location(0, t.height - 1):
+                print 'This is at the bottom.'
+        
+        Or, for byte-level control, you can drop down and play with raw terminal
+        capabilities::
+        
+            print '{t.bold}All your {t.red}bold and red base{t.normal}'.format(t=t)
+            print t.wingo(2)
+        
+        The Pitch
+        =========
+        
+        Blessings lifts several of curses_' limiting assumptions, and it makes your
+        code pretty, too:
+        
+        * Use styles, color, and maybe a little positioning without clearing the whole
+          screen first.
+        * Leave more than one screenful of scrollback in the buffer after your program
+          exits, like a well-behaved command-line app should.
+        * Get rid of all those noisy, C-like calls to ``tigetstr`` and ``tparm``, so
+          your code doesn't get crowded out by terminal bookkeeping.
+        * Act intelligently when somebody redirects your output to a file, omitting the
+          terminal control codes the user doesn't want to see (optional).
+        
+        .. _curses: http://docs.python.org/library/curses.html
+        
+        Before And After
+        ----------------
+        
+        Without Blessings, this is how you'd print some underlined text at the bottom
+        of the screen::
+        
+            from curses import tigetstr, setupterm, tparm
+            from fcntl import ioctl
+            from os import isatty
+            import struct
+            import sys
+            from termios import TIOCGWINSZ
+        
+            # If we want to tolerate having our output piped to other commands or
+            # files without crashing, we need to do all this branching:
+            if hasattr(sys.stdout, 'fileno') and isatty(sys.stdout.fileno()):
+                setupterm()
+                sc = tigetstr('sc')
+                cup = tigetstr('cup')
+                rc = tigetstr('rc')
+                underline = tigetstr('smul')
+                normal = tigetstr('sgr0')
+            else:
+                sc = cup = rc = underline = normal = ''
+            print sc  # Save cursor position.
+            if cup:
+                # tigetnum('lines') doesn't always update promptly, hence this:
+                height = struct.unpack('hhhh', ioctl(0, TIOCGWINSZ, '\000' * 8))[0]
+                print tparm(cup, height - 1, 0)  # Move cursor to bottom.
+            print 'This is {under}underlined{normal}!'.format(under=underline,
+                                                              normal=normal)
+            print rc  # Restore cursor position.
+        
+        Phew! That was long and full of incomprehensible trash! Let's try it again,
+        this time with Blessings::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            with term.location(0, term.height - 1):
+                print 'This is', term.underline('pretty!')
+        
+        Much better.
+        
+        What It Provides
+        ================
+        
+        Blessings provides just one top-level object: ``Terminal``. Instantiating a
+        ``Terminal`` figures out whether you're on a terminal at all and, if so, does
+        any necessary terminal setup. After that, you can proceed to ask it all sorts
+        of things about the terminal. Terminal terminal terminal.
+        
+        Simple Formatting
+        -----------------
+        
+        Lots of handy formatting codes ("capabilities" in low-level parlance) are
+        available as attributes on a ``Terminal``. For example::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print 'I am ' + term.bold + 'bold' + term.normal + '!'
+        
+        You can also use them as wrappers so you don't have to say ``normal``
+        afterward::
+        
+            print 'I am', term.bold('bold') + '!'
+        
+        Or, if you want fine-grained control while maintaining some semblance of
+        brevity, you can combine it with Python's string formatting, which makes
+        attributes easy to access::
+        
+            print 'All your {t.red}base {t.underline}are belong to us{t.normal}'.format(t=term)
+        
+        Simple capabilities of interest include...
+        
+        * ``bold``
+        * ``reverse``
+        * ``underline``
+        * ``no_underline`` (which turns off underlining)
+        * ``blink``
+        * ``normal`` (which turns off everything, even colors)
+        * ``clear_eol`` (clear to the end of the line)
+        * ``clear_bol`` (clear to beginning of line)
+        * ``clear_eos`` (clear to end of screen)
+        
+        Here are a few more which are less likely to work on all terminals:
+        
+        * ``dim``
+        * ``italic`` and ``no_italic``
+        * ``shadow`` and ``no_shadow``
+        * ``standout`` and ``no_standout``
+        * ``subscript`` and ``no_subscript``
+        * ``superscript`` and ``no_superscript``
+        * ``flash`` (which flashes the screen once)
+        
+        Note that, while the inverse of ``underline`` is ``no_underline``, the only way
+        to turn off ``bold`` or ``reverse`` is ``normal``, which also cancels any
+        custom colors. This is because there's no way to tell the terminal to undo
+        certain pieces of formatting, even at the lowest level.
+        
+        You might notice that the above aren't the typical incomprehensible terminfo
+        capability names; we alias a few of the harder-to-remember ones for
+        readability. However, you aren't limited to these: you can reference any
+        string-returning capability listed on the `terminfo man page`_ by the name
+        under the "Cap-name" column: for example, ``term.rum``.
+        
+        .. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+        
+        Color
+        -----
+        
+        16 colors, both foreground and background, are available as easy-to-remember
+        attributes::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.red + term.on_green + 'Red on green? Ick!' + term.normal
+            print term.bright_red + term.on_bright_blue + 'This is even worse!' + term.normal
+        
+        You can also call them as wrappers, which sets everything back to normal at the
+        end::
+        
+            print term.red_on_green('Red on green? Ick!')
+            print term.yellow('I can barely see it.')
+        
+        The available colors are...
+        
+        * ``black``
+        * ``red``
+        * ``green``
+        * ``yellow``
+        * ``blue``
+        * ``magenta``
+        * ``cyan``
+        * ``white``
+        
+        You can set the background color instead of the foreground by prepending
+        ``on_``, as in ``on_blue``. There is also a ``bright`` version of each color:
+        for example, ``on_bright_blue``.
+        
+        There is also a numerical interface to colors, which takes an integer from
+        0-15::
+        
+            term.color(5) + 'Hello' + term.normal
+            term.on_color(3) + 'Hello' + term.normal
+        
+            term.color(5)('Hello')
+            term.on_color(3)('Hello')
+        
+        If some color is unsupported (for instance, if only the normal colors are
+        available, not the bright ones), trying to use it will, on most terminals, have
+        no effect: the foreground and background colors will stay as they were. You can
+        get fancy and do different things depending on the supported colors by checking
+        `number_of_colors`_.
+        
+        .. _`number_of_colors`: http://packages.python.org/blessings/#blessings.Terminal.number_of_colors
+        
+        Compound Formatting
+        -------------------
+        
+        If you want to do lots of crazy formatting all at once, you can just mash it
+        all together::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.bold_underline_green_on_yellow + 'Woo' + term.normal
+        
+        Or you can use your newly coined attribute as a wrapper, which implicitly sets
+        everything back to normal afterward::
+        
+            print term.bold_underline_green_on_yellow('Woo')
+        
+        This compound notation comes in handy if you want to allow users to customize
+        the formatting of your app: just have them pass in a format specifier like
+        "bold_green" on the command line, and do a quick ``getattr(term,
+        that_option)('Your text')`` when you do your formatting.
+        
+        I'd be remiss if I didn't credit couleur_, where I probably got the idea for
+        all this mashing.
+        
+        .. _couleur: http://pypi.python.org/pypi/couleur
+        
+        Parametrized Capabilities
+        -------------------------
+        
+        Some capabilities take parameters. Rather than making you dig up ``tparm()``
+        all the time, we simply make such capabilities into callable strings. You can
+        pass the parameters right in::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            print term.move(10, 1)
+        
+        Here are some of interest:
+        
+        ``move``
+          Position the cursor elsewhere. Parameters are y coordinate, then x
+          coordinate.
+        ``move_x``
+          Move the cursor to the given column.
+        ``move_y``
+          Move the cursor to the given row.
+        
+        You can also reference any other string-returning capability listed on the
+        `terminfo man page`_ by its name under the "Cap-name" column.
+        
+        .. _`terminfo man page`: http://www.manpagez.com/man/5/terminfo/
+        
+        Height and Width
+        ----------------
+        
+        It's simple to get the height and width of the terminal, in characters::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            height = term.height
+            width = term.width
+        
+        These are newly updated each time you ask for them, so they're safe to use from
+        SIGWINCH handlers.
+        
+        Temporary Repositioning
+        -----------------------
+        
+        Sometimes you need to flit to a certain location, print something, and then
+        return: for example, when updating a progress bar at the bottom of the screen.
+        ``Terminal`` provides a context manager for doing this concisely::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            with term.location(0, term.height - 1):
+                print 'Here is the bottom.'
+            print 'This is back where I came from.'
+        
+        Parameters to ``location()`` are ``x`` and then ``y``, but you can also pass
+        just one of them, leaving the other alone. For example... ::
+        
+            with term.location(y=10):
+                print 'We changed just the row.'
+        
+        If you want to reposition permanently, see ``move``, in an example above.
+        
+        Pipe Savvy
+        ----------
+        
+        If your program isn't attached to a terminal, like if it's being piped to
+        another command or redirected to a file, all the capability attributes on
+        ``Terminal`` will return empty strings. You'll get a nice-looking file without
+        any formatting codes gumming up the works.
+        
+        If you want to override this--like if you anticipate your program being piped
+        through ``less -r``, which handles terminal escapes just fine--pass
+        ``force_styling=True`` to the ``Terminal`` constructor.
+        
+        In any case, there is an ``is_a_tty`` attribute on ``Terminal`` that lets you
+        see whether the attached stream seems to be a terminal. If it's false, you
+        might refrain from drawing progress bars and other frippery, since you're
+        apparently headed into a pipe::
+        
+            from blessings import Terminal
+        
+            term = Terminal()
+            if term.is_a_tty:
+                with term.location(0, term.height - 1):
+                    print 'Progress: [=======>   ]'
+            print term.bold('Important stuff')
+        
+        Shopping List
+        =============
+        
+        There are decades of legacy tied up in terminal interaction, so attention to
+        detail and behavior in edge cases make a difference. Here are some ways
+        Blessings has your back:
+        
+        * Uses the terminfo database so it works with any terminal type
+        * Provides up-to-the-moment terminal height and width, so you can respond to
+          terminal size changes (SIGWINCH signals). (Most other libraries query the
+          ``COLUMNS`` and ``LINES`` environment variables or the ``cols`` or ``lines``
+          terminal capabilities, which don't update promptly, if at all.)
+        * Avoids making a mess if the output gets piped to a non-terminal
+        * Works great with standard Python string templating
+        * Provides convenient access to all terminal capabilities, not just a sugared
+          few
+        * Outputs to any file-like object, not just stdout
+        * Keeps a minimum of internal state, so you can feel free to mix and match with
+          calls to curses or whatever other terminal libraries you like
+        
+        Blessings does not provide...
+        
+        * Native color support on the Windows command prompt. However, it should work
+          when used in concert with colorama_.
+        
+        .. _colorama: http://pypi.python.org/pypi/colorama/0.2.4
+        
+        Bugs
+        ====
+        
+        Bugs or suggestions? Visit the `issue tracker`_.
+        
+        .. _`issue tracker`: https://github.com/erikrose/blessings/issues/new
+        
+        License
+        =======
+        
+        Blessings is under the MIT License. See the LICENSE file.
+        
+        Version History
+        ===============
+        
+        1.3
+          * Add ``number_of_colors``, which tells you how many colors the terminal
+            supports.
+          * Made ``color(n)`` and ``on_color(n)`` callable to wrap a string, like the
+            named colors can. Also, make them both fall back to the ``setf`` and
+            ``setb`` capabilities (like the named colors do) if the ANSI ``setaf`` and
+            ``setab`` aren't available.
+          * Allow ``color`` attr to act as an unparametrized string, not just a
+            callable.
+          * Make ``height`` and ``width`` examine any passed-in stream before falling
+            back to stdout. (This rarely if ever affects actual behavior; it's mostly
+            philosophical.)
+          * Make caching simpler and slightly more efficient.
+          * Get rid of a reference cycle between Terminals and FormattingStrings.
+          * Update docs to reflect that terminal addressing (as in ``location()``) is
+            0-based.
+        
+        1.2
+          * Added support for Python 3! We need 3.2.3 or greater, because the curses
+            library couldn't decide whether to accept strs or bytes before that
+            (http://bugs.python.org/issue10570).
+          * Everything that comes out of the library is now unicode. This lets us
+            support Python 3 without making a mess of the code, and Python 2 should
+            continue to work unless you were testing types (and badly). Please file a
+            bug if this causes trouble for you.
+          * Changed to the MIT License for better world domination.
+          * Added Sphinx docs.
+        
+        1.1
+          * Added nicely named attributes for colors.
+          * Introduced compound formatting.
+          * Added wrapper behavior for styling and colors.
+          * Let you force capabilities to be non-empty, even if the output stream is
+            not a terminal.
+          * Added the ``is_a_tty`` attribute for telling whether the output stream is a
+            terminal.
+          * Sugared the remaining interesting string capabilities.
+          * Let ``location()`` operate on just an x *or* y coordinate.
+        
+        1.0
+          * Extracted Blessings from nose-progressive, my `progress-bar-having,
+            traceback-shortcutting, rootin', tootin' testrunner`_. It provided the
+            tootin' functionality.
+        
+        .. _`progress-bar-having, traceback-shortcutting, rootin', tootin' testrunner`: http://pypi.python.org/pypi/nose-progressive/
+        
+Keywords: terminal,tty,curses,ncurses,formatting,style,color,console
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: Console :: Curses
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Terminals
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings.egg-info/SOURCES.txt
@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+README.rst
+setup.py
+tox.ini
+blessings/__init__.py
+blessings/tests.py
+blessings.egg-info/PKG-INFO
+blessings.egg-info/SOURCES.txt
+blessings.egg-info/dependency_links.txt
+blessings.egg-info/top_level.txt
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings.egg-info/dependency_links.txt
@@ -0,0 +1,1 @@
+
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings.egg-info/top_level.txt
@@ -0,0 +1,1 @@
+blessings
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings/__init__.py
@@ -0,0 +1,450 @@
+from collections import defaultdict
+import curses
+from curses import tigetstr, tigetnum, setupterm, tparm
+from fcntl import ioctl
+try:
+    from io import UnsupportedOperation as IOUnsupportedOperation
+except ImportError:
+    class IOUnsupportedOperation(Exception):
+        """A dummy exception to take the place of Python 3's ``io.UnsupportedOperation`` in Python 2"""
+        pass
+import os
+from os import isatty, environ
+from platform import python_version_tuple
+import struct
+import sys
+from termios import TIOCGWINSZ
+
+
+if ('3', '0', '0') <= python_version_tuple() < ('3', '2', '2+'):  # Good till 3.2.10
+    # Python 3.x < 3.2.3 has a bug in which tparm() erroneously takes a string.
+    raise ImportError('Blessings needs Python 3.2.3 or greater for Python 3 '
+                      'support due to http://bugs.python.org/issue10570.')
+
+
+__all__ = ['Terminal']
+
+
+class Terminal(object):
+    """An abstraction around terminal capabilities
+
+    Unlike curses, this doesn't require clearing the screen before doing
+    anything, and it's friendlier to use. It keeps the endless calls to
+    ``tigetstr()`` and ``tparm()`` out of your code, and it acts intelligently
+    when somebody pipes your output to a non-terminal.
+
+    Instance attributes:
+
+      ``stream``
+        The stream the terminal outputs to. It's convenient to pass the stream
+        around with the terminal; it's almost always needed when the terminal
+        is and saves sticking lots of extra args on client functions in
+        practice.
+      ``is_a_tty``
+        Whether ``stream`` appears to be a terminal. You can examine this value
+        to decide whether to draw progress bars or other frippery.
+
+    """
+    def __init__(self, kind=None, stream=None, force_styling=False):
+        """Initialize the terminal.
+
+        If ``stream`` is not a tty, I will default to returning an empty
+        Unicode string for all capability values, so things like piping your
+        output to a file won't strew escape sequences all over the place. The
+        ``ls`` command sets a precedent for this: it defaults to columnar
+        output when being sent to a tty and one-item-per-line when not.
+
+        :arg kind: A terminal string as taken by ``setupterm()``. Defaults to
+            the value of the ``TERM`` environment variable.
+        :arg stream: A file-like object representing the terminal. Defaults to
+            the original value of stdout, like ``curses.initscr()`` does.
+        :arg force_styling: Whether to force the emission of capabilities, even
+            if we don't seem to be in a terminal. This comes in handy if users
+            are trying to pipe your output through something like ``less -r``,
+            which supports terminal codes just fine but doesn't appear itself
+            to be a terminal. Just expose a command-line option, and set
+            ``force_styling`` based on it. Terminal initialization sequences
+            will be sent to ``stream`` if it has a file descriptor and to
+            ``sys.__stdout__`` otherwise. (``setupterm()`` demands to send them
+            somewhere, and stdout is probably where the output is ultimately
+            headed. If not, stderr is probably bound to the same terminal.)
+
+        """
+        if stream is None:
+            stream = sys.__stdout__
+        try:
+            stream_descriptor = (stream.fileno() if hasattr(stream, 'fileno')
+                                                 and callable(stream.fileno)
+                                 else None)
+        except IOUnsupportedOperation:
+            stream_descriptor = None
+
+        self.is_a_tty = stream_descriptor is not None and isatty(stream_descriptor)
+        self._does_styling = self.is_a_tty or force_styling
+
+        # The desciptor to direct terminal initialization sequences to.
+        # sys.__stdout__ seems to always have a descriptor of 1, even if output
+        # is redirected.
+        self._init_descriptor = (sys.__stdout__.fileno()
+                                 if stream_descriptor is None
+                                 else stream_descriptor)
+        if self._does_styling:
+            # Make things like tigetstr() work. Explicit args make setupterm()
+            # work even when -s is passed to nosetests. Lean toward sending
+            # init sequences to the stream if it has a file descriptor, and
+            # send them to stdout as a fallback, since they have to go
+            # somewhere.
+            setupterm(kind or environ.get('TERM', 'unknown'),
+                      self._init_descriptor)
+
+        self.stream = stream
+
+    # Sugary names for commonly-used capabilities, intended to help avoid trips
+    # to the terminfo man page and comments in your code:
+    _sugar = dict(
+        # Don't use "on" or "bright" as an underscore-separated chunk in any of
+        # these (e.g. on_cology or rock_on) so we don't interfere with
+        # __getattr__.
+        save='sc',
+        restore='rc',
+
+        clear_eol='el',
+        clear_bol='el1',
+        clear_eos='ed',
+        position='cup',  # deprecated
+        move='cup',
+        move_x='hpa',
+        move_y='vpa',
+
+        reset_colors='op',  # oc doesn't work on my OS X terminal.
+
+        normal='sgr0',
+        reverse='rev',
+        # 'bold' is just 'bold'. Similarly...
+        # blink
+        # dim
+        # flash
+        italic='sitm',
+        no_italic='ritm',
+        shadow='sshm',
+        no_shadow='rshm',
+        standout='smso',
+        no_standout='rmso',
+        subscript='ssubm',
+        no_subscript='rsubm',
+        superscript='ssupm',
+        no_superscript='rsupm',
+        underline='smul',
+        no_underline='rmul')
+
+    def __getattr__(self, attr):
+        """Return parametrized terminal capabilities, like bold.
+
+        For example, you can say ``term.bold`` to get the string that turns on
+        bold formatting and ``term.normal`` to get the string that turns it off
+        again. Or you can take a shortcut: ``term.bold('hi')`` bolds its
+        argument and sets everything to normal afterward. You can even combine
+        things: ``term.bold_underline_red_on_bright_green('yowzers!')``.
+
+        For a parametrized capability like ``cup``, pass the parameters too:
+        ``some_term.cup(line, column)``.
+
+        ``man terminfo`` for a complete list of capabilities.
+
+        Return values are always Unicode.
+
+        """
+        resolution = self._resolve_formatter(attr) if self._does_styling else NullCallableString()
+        setattr(self, attr, resolution)  # Cache capability codes.
+        return resolution
+
+    @property
+    def height(self):
+        """The height of the terminal in characters
+
+        If no stream or a stream not representing a terminal was passed in at
+        construction, return the dimension of the controlling terminal so
+        piping to things that eventually display on the terminal (like ``less
+        -R``) work. If a stream representing a terminal was passed in, return
+        the dimensions of that terminal. If there somehow is no controlling
+        terminal, return ``None``. (Thus, you should check that ``is_a_tty`` is
+        true before doing any math on the result.)
+
+        """
+        return self._height_and_width()[0]
+
+    @property
+    def width(self):
+        """The width of the terminal in characters
+
+        See ``height()`` for some corner cases.
+
+        """
+        return self._height_and_width()[1]
+
+    def _height_and_width(self):
+        """Return a tuple of (terminal height, terminal width)."""
+        # tigetnum('lines') and tigetnum('cols') update only if we call
+        # setupterm() again.
+        for descriptor in self._init_descriptor, sys.__stdout__:
+            try:
+                return struct.unpack('hhhh', ioctl(descriptor, TIOCGWINSZ, '\000' * 8))[0:2]
+            except IOError:
+                pass
+        return None, None  # Should never get here
+
+    def location(self, x=None, y=None):
+        """Return a context manager for temporarily moving the cursor.
+
+        Move the cursor to a certain position on entry, let you print stuff
+        there, then return the cursor to its original position::
+
+            term = Terminal()
+            with term.location(2, 5):
+                print 'Hello, world!'
+                for x in xrange(10):
+                    print 'I can do it %i times!' % x
+
+        Specify ``x`` to move to a certain column, ``y`` to move to a certain
+        row, or both.
+
+        """
+        return Location(self, x, y)
+
+    @property
+    def color(self):
+        """Return a capability that sets the foreground color.
+
+        The capability is unparametrized until called and passed a number
+        (0-15), at which point it returns another string which represents a
+        specific color change. This second string can further be called to
+        color a piece of text and set everything back to normal afterward.
+
+        :arg num: The number, 0-15, of the color
+
+        """
+        return ParametrizingString(self._foreground_color, self.normal)
+
+    @property
+    def on_color(self):
+        """Return a capability that sets the background color.
+
+        See ``color()``.
+
+        """
+        return ParametrizingString(self._background_color, self.normal)
+
+    @property
+    def number_of_colors(self):
+        """Return the number of colors the terminal supports.
+
+        Common values are 0, 8, 16, 88, and 256.
+
+        Though the underlying capability returns -1 when there is no color
+        support, we return 0. This lets you test more Pythonically::
+
+            if term.number_of_colors:
+                ...
+
+        We also return 0 if the terminal won't tell us how many colors it
+        supports, which I think is rare.
+
+        """
+        # This is actually the only remotely useful numeric capability. We
+        # don't name it after the underlying capability, because we deviate
+        # slightly from its behavior, and we might someday wish to give direct
+        # access to it.
+        colors = tigetnum('colors')  # Returns -1 if no color support, -2 if no such cap.
+        #self.__dict__['colors'] = ret  # Cache it. It's not changing. (Doesn't work.)
+        return colors if colors >= 0 else 0
+
+    def _resolve_formatter(self, attr):
+        """Resolve a sugary or plain capability name, color, or compound formatting function name into a callable capability."""
+        if attr in COLORS:
+            return self._resolve_color(attr)
+        elif attr in COMPOUNDABLES:
+            # Bold, underline, or something that takes no parameters
+            return self._formatting_string(self._resolve_capability(attr))
+        else:
+            formatters = split_into_formatters(attr)
+            if all(f in COMPOUNDABLES for f in formatters):
+                # It's a compound formatter, like "bold_green_on_red". Future
+                # optimization: combine all formatting into a single escape
+                # sequence.
+                return self._formatting_string(
+                    u''.join(self._resolve_formatter(s) for s in formatters))
+            else:
+                return ParametrizingString(self._resolve_capability(attr))
+
+    def _resolve_capability(self, atom):
+        """Return a terminal code for a capname or a sugary name, or an empty Unicode.
+
+        The return value is always Unicode, because otherwise it is clumsy
+        (especially in Python 3) to concatenate with real (Unicode) strings.
+
+        """
+        code = tigetstr(self._sugar.get(atom, atom))
+        if code:
+            # We can encode escape sequences as UTF-8 because they never
+            # contain chars > 127, and UTF-8 never changes anything within that
+            # range..
+            return code.decode('utf-8')
+        return u''
+
+    def _resolve_color(self, color):
+        """Resolve a color like red or on_bright_green into a callable capability."""
+        # TODO: Does curses automatically exchange red and blue and cyan and
+        # yellow when a terminal supports setf/setb rather than setaf/setab?
+        # I'll be blasted if I can find any documentation. The following
+        # assumes it does.
+        color_cap = (self._background_color if 'on_' in color else
+                     self._foreground_color)
+        # curses constants go up to only 7, so add an offset to get at the
+        # bright colors at 8-15:
+        offset = 8 if 'bright_' in color else 0
+        base_color = color.rsplit('_', 1)[-1]
+        return self._formatting_string(
+            color_cap(getattr(curses, 'COLOR_' + base_color.upper()) + offset))
+
+    @property
+    def _foreground_color(self):
+        return self.setaf or self.setf
+
+    @property
+    def _background_color(self):
+        return self.setab or self.setb
+
+    def _formatting_string(self, formatting):
+        """Return a new ``FormattingString`` which implicitly receives my notion of "normal"."""
+        return FormattingString(formatting, self.normal)
+
+
+def derivative_colors(colors):
+    """Return the names of valid color variants, given the base colors."""
+    return set([('on_' + c) for c in colors] +
+               [('bright_' + c) for c in colors] +
+               [('on_bright_' + c) for c in colors])
+
+
+COLORS = set(['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'])
+COLORS.update(derivative_colors(COLORS))
+COMPOUNDABLES = (COLORS |
+                 set(['bold', 'underline', 'reverse', 'blink', 'dim', 'italic',
+                      'shadow', 'standout', 'subscript', 'superscript']))
+
+
+class ParametrizingString(unicode):
+    """A Unicode string which can be called to parametrize it as a terminal capability"""
+    def __new__(cls, formatting, normal=None):
+        """Instantiate.
+
+        :arg normal: If non-None, indicates that, once parametrized, this can
+            be used as a ``FormattingString``. The value is used as the
+            "normal" capability.
+
+        """
+        new = unicode.__new__(cls, formatting)
+        new._normal = normal
+        return new
+
+    def __call__(self, *args):
+        try:
+            # Re-encode the cap, because tparm() takes a bytestring in Python
+            # 3. However, appear to be a plain Unicode string otherwise so
+            # concats work.
+            parametrized = tparm(self.encode('utf-8'), *args).decode('utf-8')
+            return (parametrized if self._normal is None else
+                    FormattingString(parametrized, self._normal))
+        except curses.error:
+            # Catch "must call (at least) setupterm() first" errors, as when
+            # running simply `nosetests` (without progressive) on nose-
+            # progressive. Perhaps the terminal has gone away between calling
+            # tigetstr and calling tparm.
+            return u''
+        except TypeError:
+            # If the first non-int (i.e. incorrect) arg was a string, suggest
+            # something intelligent:
+            if len(args) == 1 and isinstance(args[0], basestring):
+                raise TypeError(
+                    'A native or nonexistent capability template received '
+                    '%r when it was expecting ints. You probably misspelled a '
+                    'formatting call like bright_red_on_white(...).' % args)
+            else:
+                # Somebody passed a non-string; I don't feel confident
+                # guessing what they were trying to do.
+                raise
+
+
+class FormattingString(unicode):
+    """A Unicode string which can be called upon a piece of text to wrap it in formatting"""
+    def __new__(cls, formatting, normal):
+        new = unicode.__new__(cls, formatting)
+        new._normal = normal
+        return new
+
+    def __call__(self, text):
+        """Return a new string that is ``text`` formatted with my contents.
+
+        At the beginning of the string, I prepend the formatting that is my
+        contents. At the end, I append the "normal" sequence to set everything
+        back to defaults. The return value is always a Unicode.
+
+        """
+        return self + text + self._normal
+
+
+class NullCallableString(unicode):
+    """A dummy class to stand in for ``FormattingString`` and ``ParametrizingString``
+
+    A callable bytestring that returns an empty Unicode when called with an int
+    and the arg otherwise. We use this when there is no tty and so all
+    capabilities are blank.
+
+    """
+    def __new__(cls):
+        new = unicode.__new__(cls, u'')
+        return new
+
+    def __call__(self, arg):
+        if isinstance(arg, int):
+            return u''
+        return arg  # TODO: Force even strs in Python 2.x to be unicodes? Nah. How would I know what encoding to use to convert it?
+
+
+def split_into_formatters(compound):
+    """Split a possibly compound format string into segments.
+
+    >>> split_into_formatters('bold_underline_bright_blue_on_red')
+    ['bold', 'underline', 'bright_blue', 'on_red']
+
+    """
+    merged_segs = []
+    # These occur only as prefixes, so they can always be merged:
+    mergeable_prefixes = ['on', 'bright', 'on_bright']
+    for s in compound.split('_'):
+        if merged_segs and merged_segs[-1] in mergeable_prefixes:
+            merged_segs[-1] += '_' + s
+        else:
+            merged_segs.append(s)
+    return merged_segs
+
+
+class Location(object):
+    """Context manager for temporarily moving the cursor"""
+    def __init__(self, term, x=None, y=None):
+        self.x, self.y = x, y
+        self.term = term
+
+    def __enter__(self):
+        """Save position and move to the requested column, row, or both."""
+        self.term.stream.write(self.term.save)  # save position
+        if self.x and self.y:
+            self.term.stream.write(self.term.move(self.y, self.x))
+        elif self.x:
+            self.term.stream.write(self.term.move_x(self.x))
+        elif self.y:
+            self.term.stream.write(self.term.move_y(self.y))
+
+    def __exit__(self, type, value, tb):
+        """Restore original cursor position."""
+        self.term.stream.write(self.term.restore)
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/blessings/tests.py
@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""Automated tests (as opposed to human-verified test patterns)
+
+It was tempting to mock out curses to get predictable output from ``tigetstr``,
+but there are concrete integration-testing benefits in not doing so. For
+instance, ``tigetstr`` changed its return type in Python 3.2.3. So instead, we
+simply create all our test ``Terminal`` instances with a known terminal type.
+All we require from the host machine is that a standard terminfo definition of
+xterm-256color exists.
+
+"""
+from __future__ import with_statement  # Make 2.5-compatible
+from curses import tigetstr, tparm
+from functools import partial
+from StringIO import StringIO
+import sys
+
+from nose import SkipTest
+from nose.tools import eq_
+
+# This tests that __all__ is correct, since we use below everything that should
+# be imported:
+from blessings import *
+
+
+TestTerminal = partial(Terminal, kind='xterm-256color')
+
+
+def unicode_cap(cap):
+    """Return the result of ``tigetstr`` except as Unicode."""
+    return tigetstr(cap).decode('utf-8')
+
+
+def unicode_parm(cap, *parms):
+    """Return the result of ``tparm(tigetstr())`` except as Unicode."""
+    return tparm(tigetstr(cap), *parms).decode('utf-8')
+
+
+def test_capability():
+    """Check that a capability lookup works.
+
+    Also test that Terminal grabs a reasonable default stream. This test
+    assumes it will be run from a tty.
+
+    """
+    t = TestTerminal()
+    sc = unicode_cap('sc')
+    eq_(t.save, sc)
+    eq_(t.save, sc)  # Make sure caching doesn't screw it up.
+
+
+def test_capability_without_tty():
+    """Assert capability templates are '' when stream is not a tty."""
+    t = TestTerminal(stream=StringIO())
+    eq_(t.save, u'')
+    eq_(t.red, u'')
+
+
+def test_capability_with_forced_tty():
+    """If we force styling, capabilities had better not (generally) be empty."""
+    t = TestTerminal(stream=StringIO(), force_styling=True)
+    eq_(t.save, unicode_cap('sc'))
+
+
+def test_parametrization():
+    """Test parametrizing a capability."""
+    eq_(TestTerminal().cup(3, 4), unicode_parm('cup', 3, 4))
+
+
+def height_and_width():
+    """Assert that ``height_and_width()`` returns ints."""
+    t = TestTerminal()  # kind shouldn't matter.
+    assert isinstance(int, t.height)
+    assert isinstance(int, t.width)
+
+
+def test_stream_attr():
+    """Make sure Terminal exposes a ``stream`` attribute that defaults to something sane."""
+    eq_(Terminal().stream, sys.__stdout__)
+
+
+def test_location():
+    """Make sure ``location()`` does what it claims."""
+    t = TestTerminal(stream=StringIO(), force_styling=True)
+
+    with t.location(3, 4):
+        t.stream.write(u'hi')
+
+    eq_(t.stream.getvalue(), unicode_cap('sc') +
+                             unicode_parm('cup', 4, 3) +
+                             u'hi' +
+                             unicode_cap('rc'))
+
+
+def test_horizontal_location():
+    """Make sure we can move the cursor horizontally without changing rows."""
+    t = TestTerminal(stream=StringIO(), force_styling=True)
+    with t.location(x=5):
+        pass
+    eq_(t.stream.getvalue(), unicode_cap('sc') +
+                             unicode_parm('hpa', 5) +
+                             unicode_cap('rc'))
+
+
+def test_null_fileno():
+    """Make sure ``Terminal`` works when ``fileno`` is ``None``.
+
+    This simulates piping output to another program.
+
+    """
+    out = StringIO()
+    out.fileno = None
+    t = TestTerminal(stream=out)
+    eq_(t.save, u'')
+
+
+def test_mnemonic_colors():
+    """Make sure color shortcuts work."""
+    def color(num):
+        return unicode_parm('setaf', num)
+
+    def on_color(num):
+        return unicode_parm('setab', num)
+
+    # Avoid testing red, blue, yellow, and cyan, since they might someday
+    # change depending on terminal type.
+    t = TestTerminal()
+    eq_(t.white, color(7))
+    eq_(t.green, color(2))  # Make sure it's different than white.
+    eq_(t.on_black, on_color(0))
+    eq_(t.on_green, on_color(2))
+    eq_(t.bright_black, color(8))
+    eq_(t.bright_green, color(10))
+    eq_(t.on_bright_black, on_color(8))
+    eq_(t.on_bright_green, on_color(10))
+
+
+def test_callable_numeric_colors():
+    """``color(n)`` should return a formatting wrapper."""
+    t = TestTerminal()
+    eq_(t.color(5)('smoo'), t.magenta + 'smoo' + t.normal)
+    eq_(t.color(5)('smoo'), t.color(5) + 'smoo' + t.normal)
+    eq_(t.on_color(2)('smoo'), t.on_green + 'smoo' + t.normal)
+    eq_(t.on_color(2)('smoo'), t.on_color(2) + 'smoo' + t.normal)
+
+
+def test_null_callable_numeric_colors():
+    """``color(n)`` should be a no-op on null terminals."""
+    t = TestTerminal(stream=StringIO())
+    eq_(t.color(5)('smoo'), 'smoo')
+    eq_(t.on_color(6)('smoo'), 'smoo')
+
+
+def test_naked_color_cap():
+    """``term.color`` should return a stringlike capability."""
+    t = TestTerminal()
+    eq_(t.color + '', t.setaf + '')
+
+
+def test_number_of_colors_without_tty():
+    """``number_of_colors`` should return 0 when there's no tty."""
+    # Hypothesis: once setupterm() has run and decided the tty supports 256
+    # colors, it never changes its mind.
+    raise SkipTest
+
+    t = TestTerminal(stream=StringIO())
+    eq_(t.number_of_colors, 0)
+    t = TestTerminal(stream=StringIO(), force_styling=True)
+    eq_(t.number_of_colors, 0)
+
+
+def test_number_of_colors_with_tty():
+    """``number_of_colors`` should work."""
+    t = TestTerminal()
+    eq_(t.number_of_colors, 256)
+
+
+def test_formatting_functions():
+    """Test crazy-ass formatting wrappers, both simple and compound."""
+    t = TestTerminal()
+    # By now, it should be safe to use sugared attributes. Other tests test those.
+    eq_(t.bold(u'hi'), t.bold + u'hi' + t.normal)
+    eq_(t.green('hi'), t.green + u'hi' + t.normal)  # Plain strs for Python 2.x
+    # Test some non-ASCII chars, probably not necessary:
+    eq_(t.bold_green(u'boö'), t.bold + t.green + u'boö' + t.normal)
+    eq_(t.bold_underline_green_on_red('boo'),
+        t.bold + t.underline + t.green + t.on_red + u'boo' + t.normal)
+    # Don't spell things like this:
+    eq_(t.on_bright_red_bold_bright_green_underline('meh'),
+        t.on_bright_red + t.bold + t.bright_green + t.underline + u'meh' + t.normal)
+
+
+def test_formatting_functions_without_tty():
+    """Test crazy-ass formatting wrappers when there's no tty."""
+    t = TestTerminal(stream=StringIO())
+    eq_(t.bold(u'hi'), u'hi')
+    eq_(t.green('hi'), u'hi')
+    # Test non-ASCII chars, no longer really necessary:
+    eq_(t.bold_green(u'boö'), u'boö')
+    eq_(t.bold_underline_green_on_red('loo'), u'loo')
+    eq_(t.on_bright_red_bold_bright_green_underline('meh'), u'meh')
+
+
+def test_nice_formatting_errors():
+    """Make sure you get nice hints if you misspell a formatting wrapper."""
+    t = TestTerminal()
+    try:
+        t.bold_misspelled('hey')
+    except TypeError, e:
+        assert 'probably misspelled' in e.args[0]
+
+    try:
+        t.bold_misspelled(u'hey')  # unicode
+    except TypeError, e:
+        assert 'probably misspelled' in e.args[0]
+
+    try:
+        t.bold_misspelled(None)  # an arbitrary non-string
+    except TypeError, e:
+        assert 'probably misspelled' not in e.args[0]
+
+    try:
+        t.bold_misspelled('a', 'b')  # >1 string arg
+    except TypeError, e:
+        assert 'probably misspelled' not in e.args[0]
+
+
+def test_init_descriptor_always_initted():
+    """We should be able to get a height and width even on no-tty Terminals."""
+    t = Terminal(stream=StringIO())
+    eq_(type(t.height), int)
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/setup.cfg
@@ -0,0 +1,5 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+tag_svn_revision = 0
+
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/setup.py
@@ -0,0 +1,42 @@
+import sys
+
+from setuptools import setup, find_packages
+
+
+extra_setup = {}
+if sys.version_info >= (3,):
+    extra_setup['use_2to3'] = True
+
+setup(
+    name='blessings',
+    version='1.3',
+    description='A thin, practical wrapper around terminal formatting, positioning, and more',
+    long_description=open('README.rst').read(),
+    author='Erik Rose',
+    author_email='erikrose@grinchcentral.com',
+    license='MIT',
+    packages=find_packages(exclude=['ez_setup']),
+    tests_require=['Nose'],
+    url='https://github.com/erikrose/blessings',
+    include_package_data=True,
+    classifiers=[
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Console',
+        'Environment :: Console :: Curses',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: POSIX',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.5',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.2',
+        'Topic :: Software Development :: Libraries',
+        'Topic :: Software Development :: User Interfaces',
+        'Topic :: Terminals'
+        ],
+    keywords=['terminal', 'tty', 'curses', 'ncurses', 'formatting', 'style', 'color', 'console'],
+    **extra_setup
+)
new file mode 100644
--- /dev/null
+++ b/build/pylib/blessings/tox.ini
@@ -0,0 +1,7 @@
+[tox]
+envlist = py25, py26, py27, py32
+
+[testenv]
+commands = nosetests blessings
+deps = nose
+changedir = .tox  # So Python 3 runs don't pick up incompatible, un-2to3'd source from the cwd