updated colorclass to v2.2.0, updated tablestream

decalage2
1 parent f3d51f29
Showing 11 changed files with 1440 additions and 831 deletions
oletools/thirdparty/colorclass/__init__.py
oletools/thirdparty/colorclass/__main__.py
oletools/thirdparty/colorclass/codes.py
oletools/thirdparty/colorclass/color.py
oletools/thirdparty/colorclass/colorclass.py
oletools/thirdparty/colorclass/core.py
oletools/thirdparty/colorclass/parse.py
oletools/thirdparty/colorclass/search.py
oletools/thirdparty/colorclass/toggles.py
oletools/thirdparty/colorclass/windows.py
oletools/thirdparty/tablestream/tablestream.py
+"""Colorful worry-free console applications for Linux, Mac OS X, and Windows.
+
+Supported natively on Linux and Mac OSX (Just Works), and on Windows it works the same if Windows.enable() is called.
+
+Gives you expected and sane results from methods like len() and .capitalize().
+
+https://github.com/Robpol86/colorclass
+https://pypi.python.org/pypi/colorclass
+"""
+
+from colorclass.codes import list_tags  # noqa
+from colorclass.color import Color  # noqa
+from colorclass.toggles import disable_all_colors  # noqa
+from colorclass.toggles import disable_if_no_tty  # noqa
+from colorclass.toggles import enable_all_colors  # noqa
+from colorclass.toggles import is_enabled  # noqa
+from colorclass.toggles import is_light  # noqa
+from colorclass.toggles import set_dark_background  # noqa
+from colorclass.toggles import set_light_background  # noqa
+from colorclass.windows import Windows  # noqa
+
+
+__all__ = (
+    'Color',
+    'disable_all_colors',
+    'enable_all_colors',
+    'is_enabled',
+    'is_light',
+    'list_tags',
+    'set_dark_background',
+    'set_light_background',
+    'Windows',
+)
+
+
+__author__ = '@Robpol86'
+__license__ = 'MIT'
+__version__ = '2.2.0'
+"""Called by "python -m". Allows package to be used as a script.
+
+Example usage:
+echo "{red}Red{/red}" |python -m colorclass
+"""
+
+from __future__ import print_function
+
+import fileinput
+import os
+
+from colorclass.color import Color
+from colorclass.toggles import disable_all_colors
+from colorclass.toggles import enable_all_colors
+from colorclass.toggles import set_dark_background
+from colorclass.toggles import set_light_background
+from colorclass.windows import Windows
+
+TRUTHY = ('true', '1', 'yes', 'on')
+
+
+if __name__ == '__main__':
+    if os.environ.get('COLOR_ENABLE', '').lower() in TRUTHY:
+        enable_all_colors()
+    elif os.environ.get('COLOR_DISABLE', '').lower() in TRUTHY:
+        disable_all_colors()
+    if os.environ.get('COLOR_LIGHT', '').lower() in TRUTHY:
+        set_light_background()
+    elif os.environ.get('COLOR_DARK', '').lower() in TRUTHY:
+        set_dark_background()
+    Windows.enable()
+    for LINE in fileinput.input():
+        print(Color(LINE))
+"""Handles mapping between color names and ANSI codes and determining auto color codes."""
+
+import sys
+from collections import Mapping
+
+BASE_CODES = {
+    '/all': 0, 'b': 1, 'f': 2, 'i': 3, 'u': 4, 'flash': 5, 'outline': 6, 'negative': 7, 'invis': 8, 'strike': 9,
+    '/b': 22, '/f': 22, '/i': 23, '/u': 24, '/flash': 25, '/outline': 26, '/negative': 27, '/invis': 28,
+    '/strike': 29, '/fg': 39, '/bg': 49,
+
+    'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37,
+
+    'bgblack': 40, 'bgred': 41, 'bggreen': 42, 'bgyellow': 43, 'bgblue': 44, 'bgmagenta': 45, 'bgcyan': 46,
+    'bgwhite': 47,
+
+    'hiblack': 90, 'hired': 91, 'higreen': 92, 'hiyellow': 93, 'hiblue': 94, 'himagenta': 95, 'hicyan': 96,
+    'hiwhite': 97,
+
+    'hibgblack': 100, 'hibgred': 101, 'hibggreen': 102, 'hibgyellow': 103, 'hibgblue': 104, 'hibgmagenta': 105,
+    'hibgcyan': 106, 'hibgwhite': 107,
+
+    'autored': None, 'autoblack': None, 'automagenta': None, 'autowhite': None, 'autoblue': None, 'autoyellow': None,
+    'autogreen': None, 'autocyan': None,
+
+    'autobgred': None, 'autobgblack': None, 'autobgmagenta': None, 'autobgwhite': None, 'autobgblue': None,
+    'autobgyellow': None, 'autobggreen': None, 'autobgcyan': None,
+
+    '/black': 39, '/red': 39, '/green': 39, '/yellow': 39, '/blue': 39, '/magenta': 39, '/cyan': 39, '/white': 39,
+    '/hiblack': 39, '/hired': 39, '/higreen': 39, '/hiyellow': 39, '/hiblue': 39, '/himagenta': 39, '/hicyan': 39,
+    '/hiwhite': 39,
+
+    '/bgblack': 49, '/bgred': 49, '/bggreen': 49, '/bgyellow': 49, '/bgblue': 49, '/bgmagenta': 49, '/bgcyan': 49,
+    '/bgwhite': 49, '/hibgblack': 49, '/hibgred': 49, '/hibggreen': 49, '/hibgyellow': 49, '/hibgblue': 49,
+    '/hibgmagenta': 49, '/hibgcyan': 49, '/hibgwhite': 49,
+
+    '/autored': 39, '/autoblack': 39, '/automagenta': 39, '/autowhite': 39, '/autoblue': 39, '/autoyellow': 39,
+    '/autogreen': 39, '/autocyan': 39,
+
+    '/autobgred': 49, '/autobgblack': 49, '/autobgmagenta': 49, '/autobgwhite': 49, '/autobgblue': 49,
+    '/autobgyellow': 49, '/autobggreen': 49, '/autobgcyan': 49,
+}
+
+
+class ANSICodeMapping(Mapping):
+    """Read-only dictionary, resolves closing tags and automatic colors. Iterates only used color tags.
+
+    :cvar bool DISABLE_COLORS: Disable colors (strip color codes).
+    :cvar bool LIGHT_BACKGROUND: Use low intensity color codes.
+    """
+
+    DISABLE_COLORS = False
+    LIGHT_BACKGROUND = False
+
+    def __init__(self, value_markup):
+        """Constructor.
+
+        :param str value_markup: String with {color} tags.
+        """
+        self.whitelist = [k for k in BASE_CODES if '{' + k + '}' in value_markup]
+
+    def __getitem__(self, item):
+        """Return value for key or None if colors are disabled.
+
+        :param str item: Key.
+
+        :return: Color code integer.
+        :rtype: int
+        """
+        if item not in self.whitelist:
+            raise KeyError(item)
+        if self.DISABLE_COLORS:
+            return None
+        return getattr(self, item, BASE_CODES[item])
+
+    def __iter__(self):
+        """Iterate dictionary."""
+        return iter(self.whitelist)
+
+    def __len__(self):
+        """Dictionary length."""
+        return len(self.whitelist)
+
+    @classmethod
+    def disable_all_colors(cls):
+        """Disable all colors. Strips any color tags or codes."""
+        cls.DISABLE_COLORS = True
+
+    @classmethod
+    def enable_all_colors(cls):
+        """Enable all colors. Strips any color tags or codes."""
+        cls.DISABLE_COLORS = False
+
+    @classmethod
+    def disable_if_no_tty(cls):
+        """Disable all colors only if there is no TTY available.
+
+        :return: True if colors are disabled, False if stderr or stdout is a TTY.
+        :rtype: bool
+        """
+        if sys.stdout.isatty() or sys.stderr.isatty():
+            return False
+        cls.disable_all_colors()
+        return True
+
+    @classmethod
+    def set_dark_background(cls):
+        """Choose dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
+        cls.LIGHT_BACKGROUND = False
+
+    @classmethod
+    def set_light_background(cls):
+        """Choose dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
+        cls.LIGHT_BACKGROUND = True
+
+    @property
+    def autoblack(self):
+        """Return automatic black foreground color depending on background color."""
+        return BASE_CODES['black' if ANSICodeMapping.LIGHT_BACKGROUND else 'hiblack']
+
+    @property
+    def autored(self):
+        """Return automatic red foreground color depending on background color."""
+        return BASE_CODES['red' if ANSICodeMapping.LIGHT_BACKGROUND else 'hired']
+
+    @property
+    def autogreen(self):
+        """Return automatic green foreground color depending on background color."""
+        return BASE_CODES['green' if ANSICodeMapping.LIGHT_BACKGROUND else 'higreen']
+
+    @property
+    def autoyellow(self):
+        """Return automatic yellow foreground color depending on background color."""
+        return BASE_CODES['yellow' if ANSICodeMapping.LIGHT_BACKGROUND else 'hiyellow']
+
+    @property
+    def autoblue(self):
+        """Return automatic blue foreground color depending on background color."""
+        return BASE_CODES['blue' if ANSICodeMapping.LIGHT_BACKGROUND else 'hiblue']
+
+    @property
+    def automagenta(self):
+        """Return automatic magenta foreground color depending on background color."""
+        return BASE_CODES['magenta' if ANSICodeMapping.LIGHT_BACKGROUND else 'himagenta']
+
+    @property
+    def autocyan(self):
+        """Return automatic cyan foreground color depending on background color."""
+        return BASE_CODES['cyan' if ANSICodeMapping.LIGHT_BACKGROUND else 'hicyan']
+
+    @property
+    def autowhite(self):
+        """Return automatic white foreground color depending on background color."""
+        return BASE_CODES['white' if ANSICodeMapping.LIGHT_BACKGROUND else 'hiwhite']
+
+    @property
+    def autobgblack(self):
+        """Return automatic black background color depending on background color."""
+        return BASE_CODES['bgblack' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgblack']
+
+    @property
+    def autobgred(self):
+        """Return automatic red background color depending on background color."""
+        return BASE_CODES['bgred' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgred']
+
+    @property
+    def autobggreen(self):
+        """Return automatic green background color depending on background color."""
+        return BASE_CODES['bggreen' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibggreen']
+
+    @property
+    def autobgyellow(self):
+        """Return automatic yellow background color depending on background color."""
+        return BASE_CODES['bgyellow' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgyellow']
+
+    @property
+    def autobgblue(self):
+        """Return automatic blue background color depending on background color."""
+        return BASE_CODES['bgblue' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgblue']
+
+    @property
+    def autobgmagenta(self):
+        """Return automatic magenta background color depending on background color."""
+        return BASE_CODES['bgmagenta' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgmagenta']
+
+    @property
+    def autobgcyan(self):
+        """Return automatic cyan background color depending on background color."""
+        return BASE_CODES['bgcyan' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgcyan']
+
+    @property
+    def autobgwhite(self):
+        """Return automatic white background color depending on background color."""
+        return BASE_CODES['bgwhite' if ANSICodeMapping.LIGHT_BACKGROUND else 'hibgwhite']
+
+
+def list_tags():
+    """List the available tags.
+
+    :return: List of 4-item tuples: opening tag, closing tag, main ansi value, closing ansi value.
+    :rtype: list
+    """
+    # Build reverse dictionary. Keys are closing tags, values are [closing ansi, opening tag, opening ansi].
+    reverse_dict = dict()
+    for tag, ansi in sorted(BASE_CODES.items()):
+        if tag.startswith('/'):
+            reverse_dict[tag] = [ansi, None, None]
+        else:
+            reverse_dict['/' + tag][1:] = [tag, ansi]
+
+    # Collapse
+    four_item_tuples = [(v[1], k, v[2], v[0]) for k, v in reverse_dict.items()]
+
+    # Sort.
+    def sorter(four_item):
+        """Sort /all /fg /bg first, then b i u flash, then auto colors, then dark colors, finally light colors.
+
+        :param iter four_item: [opening tag, closing tag, main ansi value, closing ansi value]
+
+        :return Sorting weight.
+        :rtype: int
+        """
+        if not four_item[2]:  # /all /fg /bg
+            return four_item[3] - 200
+        if four_item[2] < 10 or four_item[0].startswith('auto'):  # b f i u or auto colors
+            return four_item[2] - 100
+        return four_item[2]
+    four_item_tuples.sort(key=sorter)
+
+    return four_item_tuples
+"""Color class used by library users."""
+
+from colorclass.core import ColorStr
+
+
+class Color(ColorStr):
+    """Unicode (str in Python3) subclass with ANSI terminal text color support.
+
+    Example syntax: Color('{red}Sample Text{/red}')
+
+    Example without parsing logic: Color('{red}Sample Text{/red}', keep_tags=True)
+
+    For a list of codes, call: colorclass.list_tags()
+    """
+
+    @classmethod
+    def colorize(cls, color, string, auto=False):
+        """Color-code entire string using specified color.
+
+        :param str color: Color of string.
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        tag = '{0}{1}'.format('auto' if auto else '', color)
+        return cls('{%s}%s{/%s}' % (tag, string, tag))
+
+    @classmethod
+    def black(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('black', string, auto=auto)
+
+    @classmethod
+    def bgblack(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgblack', string, auto=auto)
+
+    @classmethod
+    def red(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('red', string, auto=auto)
+
+    @classmethod
+    def bgred(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgred', string, auto=auto)
+
+    @classmethod
+    def green(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('green', string, auto=auto)
+
+    @classmethod
+    def bggreen(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bggreen', string, auto=auto)
+
+    @classmethod
+    def yellow(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('yellow', string, auto=auto)
+
+    @classmethod
+    def bgyellow(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgyellow', string, auto=auto)
+
+    @classmethod
+    def blue(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('blue', string, auto=auto)
+
+    @classmethod
+    def bgblue(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgblue', string, auto=auto)
+
+    @classmethod
+    def magenta(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('magenta', string, auto=auto)
+
+    @classmethod
+    def bgmagenta(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgmagenta', string, auto=auto)
+
+    @classmethod
+    def cyan(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('cyan', string, auto=auto)
+
+    @classmethod
+    def bgcyan(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgcyan', string, auto=auto)
+
+    @classmethod
+    def white(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('white', string, auto=auto)
+
+    @classmethod
+    def bgwhite(cls, string, auto=False):
+        """Color-code entire string.
+
+        :param str string: String to colorize.
+        :param bool auto: Enable auto-color (dark/light terminal).
+
+        :return: Class instance for colorized string.
+        :rtype: Color
+        """
+        return cls.colorize('bgwhite', string, auto=auto)
-"""Colorful worry-free console applications for Linux, Mac OS X, and Windows.
-
-Supported natively on Linux and Mac OSX (Just Works), and on Windows it works the same if Windows.enable() is called.
-
-Gives you expected and sane results from methods like len() and .capitalize().
-
-https://github.com/Robpol86/colorclass
-https://pypi.python.org/pypi/colorclass
-"""
-
-import atexit
-from collections import Mapping
-import ctypes
-import os
-import re
-import sys
-
-if os.name == 'nt':
-    import ctypes.wintypes
-
-__author__ = '@Robpol86'
-__license__ = 'MIT'
-__version__ = '1.2.0'
-_BASE_CODES = {
-    '/all': 0, 'b': 1, 'f': 2, 'i': 3, 'u': 4, 'flash': 5, 'outline': 6, 'negative': 7, 'invis': 8, 'strike': 9,
-    '/b': 22, '/f': 22, '/i': 23, '/u': 24, '/flash': 25, '/outline': 26, '/negative': 27, '/invis': 28,
-    '/strike': 29, '/fg': 39, '/bg': 49,
-
-    'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37,
-
-    'bgblack': 40, 'bgred': 41, 'bggreen': 42, 'bgyellow': 43, 'bgblue': 44, 'bgmagenta': 45, 'bgcyan': 46,
-    'bgwhite': 47,
-
-    'hiblack': 90, 'hired': 91, 'higreen': 92, 'hiyellow': 93, 'hiblue': 94, 'himagenta': 95, 'hicyan': 96,
-    'hiwhite': 97,
-
-    'hibgblack': 100, 'hibgred': 101, 'hibggreen': 102, 'hibgyellow': 103, 'hibgblue': 104, 'hibgmagenta': 105,
-    'hibgcyan': 106, 'hibgwhite': 107,
-
-    'autored': None, 'autoblack': None, 'automagenta': None, 'autowhite': None, 'autoblue': None, 'autoyellow': None,
-    'autogreen': None, 'autocyan': None,
-
-    'autobgred': None, 'autobgblack': None, 'autobgmagenta': None, 'autobgwhite': None, 'autobgblue': None,
-    'autobgyellow': None, 'autobggreen': None, 'autobgcyan': None,
-
-    '/black': 39, '/red': 39, '/green': 39, '/yellow': 39, '/blue': 39, '/magenta': 39, '/cyan': 39, '/white': 39,
-    '/hiblack': 39, '/hired': 39, '/higreen': 39, '/hiyellow': 39, '/hiblue': 39, '/himagenta': 39, '/hicyan': 39,
-    '/hiwhite': 39,
-
-    '/bgblack': 49, '/bgred': 49, '/bggreen': 49, '/bgyellow': 49, '/bgblue': 49, '/bgmagenta': 49, '/bgcyan': 49,
-    '/bgwhite': 49, '/hibgblack': 49, '/hibgred': 49, '/hibggreen': 49, '/hibgyellow': 49, '/hibgblue': 49,
-    '/hibgmagenta': 49, '/hibgcyan': 49, '/hibgwhite': 49,
-
-    '/autored': 39, '/autoblack': 39, '/automagenta': 39, '/autowhite': 39, '/autoblue': 39, '/autoyellow': 39,
-    '/autogreen': 39, '/autocyan': 39,
-
-    '/autobgred': 49, '/autobgblack': 49, '/autobgmagenta': 49, '/autobgwhite': 49, '/autobgblue': 49,
-    '/autobgyellow': 49, '/autobggreen': 49, '/autobgcyan': 49,
-}
-_WINDOWS_CODES = {
-    '/all': -33, '/fg': -39, '/bg': -49,
-
-    'black': 0, 'red': 4, 'green': 2, 'yellow': 6, 'blue': 1, 'magenta': 5, 'cyan': 3, 'white': 7,
-
-    'bgblack': -8, 'bgred': 64, 'bggreen': 32, 'bgyellow': 96, 'bgblue': 16, 'bgmagenta': 80, 'bgcyan': 48,
-    'bgwhite': 112,
-
-    'hiblack': 8, 'hired': 12, 'higreen': 10, 'hiyellow': 14, 'hiblue': 9, 'himagenta': 13, 'hicyan': 11, 'hiwhite': 15,
-
-    'hibgblack': 128, 'hibgred': 192, 'hibggreen': 160, 'hibgyellow': 224, 'hibgblue': 144, 'hibgmagenta': 208,
-    'hibgcyan': 176, 'hibgwhite': 240,
-
-    '/black': -39, '/red': -39, '/green': -39, '/yellow': -39, '/blue': -39, '/magenta': -39, '/cyan': -39,
-    '/white': -39, '/hiblack': -39, '/hired': -39, '/higreen': -39, '/hiyellow': -39, '/hiblue': -39, '/himagenta': -39,
-    '/hicyan': -39, '/hiwhite': -39,
-
-    '/bgblack': -49, '/bgred': -49, '/bggreen': -49, '/bgyellow': -49, '/bgblue': -49, '/bgmagenta': -49,
-    '/bgcyan': -49, '/bgwhite': -49, '/hibgblack': -49, '/hibgred': -49, '/hibggreen': -49, '/hibgyellow': -49,
-    '/hibgblue': -49, '/hibgmagenta': -49, '/hibgcyan': -49, '/hibgwhite': -49,
-}
-_RE_GROUP_SEARCH = re.compile(r'(?:\033\[[\d;]+m)+')
-_RE_NUMBER_SEARCH = re.compile(r'\033\[([\d;]+)m')
-_RE_SPLIT = re.compile(r'(\033\[[\d;]+m)')
-PARENT_CLASS = type(u'')
-
-
-class _AutoCodes(Mapping):
-    """Read-only subclass of dict, resolves closing tags (based on colorclass.CODES) and automatic colors."""
-    DISABLE_COLORS = False
-    LIGHT_BACKGROUND = False
-
-    def __init__(self):
-        self.__dict = _BASE_CODES.copy()
-
-    def __getitem__(self, item):
-        if item == 'autoblack':
-            answer = self.autoblack
-        elif item == 'autored':
-            answer = self.autored
-        elif item == 'autogreen':
-            answer = self.autogreen
-        elif item == 'autoyellow':
-            answer = self.autoyellow
-        elif item == 'autoblue':
-            answer = self.autoblue
-        elif item == 'automagenta':
-            answer = self.automagenta
-        elif item == 'autocyan':
-            answer = self.autocyan
-        elif item == 'autowhite':
-            answer = self.autowhite
-        elif item == 'autobgblack':
-            answer = self.autobgblack
-        elif item == 'autobgred':
-            answer = self.autobgred
-        elif item == 'autobggreen':
-            answer = self.autobggreen
-        elif item == 'autobgyellow':
-            answer = self.autobgyellow
-        elif item == 'autobgblue':
-            answer = self.autobgblue
-        elif item == 'autobgmagenta':
-            answer = self.autobgmagenta
-        elif item == 'autobgcyan':
-            answer = self.autobgcyan
-        elif item == 'autobgwhite':
-            answer = self.autobgwhite
-        else:
-            answer = self.__dict[item]
-        return answer
-
-    def __iter__(self):
-        return iter(self.__dict)
-
-    def __len__(self):
-        return len(self.__dict)
-
-    @property
-    def autoblack(self):
-        """Returns automatic black foreground color depending on background color."""
-        return self.__dict['black' if _AutoCodes.LIGHT_BACKGROUND else 'hiblack']
-
-    @property
-    def autored(self):
-        """Returns automatic red foreground color depending on background color."""
-        return self.__dict['red' if _AutoCodes.LIGHT_BACKGROUND else 'hired']
-
-    @property
-    def autogreen(self):
-        """Returns automatic green foreground color depending on background color."""
-        return self.__dict['green' if _AutoCodes.LIGHT_BACKGROUND else 'higreen']
-
-    @property
-    def autoyellow(self):
-        """Returns automatic yellow foreground color depending on background color."""
-        return self.__dict['yellow' if _AutoCodes.LIGHT_BACKGROUND else 'hiyellow']
-
-    @property
-    def autoblue(self):
-        """Returns automatic blue foreground color depending on background color."""
-        return self.__dict['blue' if _AutoCodes.LIGHT_BACKGROUND else 'hiblue']
-
-    @property
-    def automagenta(self):
-        """Returns automatic magenta foreground color depending on background color."""
-        return self.__dict['magenta' if _AutoCodes.LIGHT_BACKGROUND else 'himagenta']
-
-    @property
-    def autocyan(self):
-        """Returns automatic cyan foreground color depending on background color."""
-        return self.__dict['cyan' if _AutoCodes.LIGHT_BACKGROUND else 'hicyan']
-
-    @property
-    def autowhite(self):
-        """Returns automatic white foreground color depending on background color."""
-        return self.__dict['white' if _AutoCodes.LIGHT_BACKGROUND else 'hiwhite']
-
-    @property
-    def autobgblack(self):
-        """Returns automatic black background color depending on background color."""
-        return self.__dict['bgblack' if _AutoCodes.LIGHT_BACKGROUND else 'hibgblack']
-
-    @property
-    def autobgred(self):
-        """Returns automatic red background color depending on background color."""
-        return self.__dict['bgred' if _AutoCodes.LIGHT_BACKGROUND else 'hibgred']
-
-    @property
-    def autobggreen(self):
-        """Returns automatic green background color depending on background color."""
-        return self.__dict['bggreen' if _AutoCodes.LIGHT_BACKGROUND else 'hibggreen']
-
-    @property
-    def autobgyellow(self):
-        """Returns automatic yellow background color depending on background color."""
-        return self.__dict['bgyellow' if _AutoCodes.LIGHT_BACKGROUND else 'hibgyellow']
-
-    @property
-    def autobgblue(self):
-        """Returns automatic blue background color depending on background color."""
-        return self.__dict['bgblue' if _AutoCodes.LIGHT_BACKGROUND else 'hibgblue']
-
-    @property
-    def autobgmagenta(self):
-        """Returns automatic magenta background color depending on background color."""
-        return self.__dict['bgmagenta' if _AutoCodes.LIGHT_BACKGROUND else 'hibgmagenta']
-
-    @property
-    def autobgcyan(self):
-        """Returns automatic cyan background color depending on background color."""
-        return self.__dict['bgcyan' if _AutoCodes.LIGHT_BACKGROUND else 'hibgcyan']
-
-    @property
-    def autobgwhite(self):
-        """Returns automatic white background color depending on background color."""
-        return self.__dict['bgwhite' if _AutoCodes.LIGHT_BACKGROUND else 'hibgwhite']
-
-
-def _pad_input(incoming):
-    """Avoid IndexError and KeyError by ignoring un-related fields.
-
-    Example: '{0}{autored}' becomes '{{0}}{autored}'.
-
-    Positional arguments:
-    incoming -- the input unicode value.
-
-    Returns:
-    Padded unicode value.
-    """
-    incoming_expanded = incoming.replace('{', '{{').replace('}', '}}')
-    for key in _BASE_CODES:
-        before, after = '{{%s}}' % key, '{%s}' % key
-        if before in incoming_expanded:
-            incoming_expanded = incoming_expanded.replace(before, after)
-    return incoming_expanded
-
-
-def _parse_input(incoming):
-    """Performs the actual conversion of tags to ANSI escaped codes.
-
-    Provides a version of the input without any colors for len() and other methods.
-
-    Positional arguments:
-    incoming -- the input unicode value.
-
-    Returns:
-    2-item tuple. First item is the parsed output. Second item is a version of the input without any colors.
-    """
-    codes = dict((k, v) for k, v in _AutoCodes().items() if '{%s}' % k in incoming)
-    color_codes = dict((k, '' if _AutoCodes.DISABLE_COLORS else '\033[{0}m'.format(v)) for k, v in codes.items())
-    incoming_padded = _pad_input(incoming)
-    output_colors = incoming_padded.format(**color_codes)
-
-    # Simplify: '{b}{red}' -> '\033[1m\033[31m' -> '\033[1;31m'
-    groups = sorted(set(_RE_GROUP_SEARCH.findall(output_colors)), key=len, reverse=True)  # Get codes, grouped adjacent.
-    groups_simplified = [[x for n in _RE_NUMBER_SEARCH.findall(i) for x in n.split(';')] for i in groups]
-    groups_compiled = ['\033[{0}m'.format(';'.join(g)) for g in groups_simplified]  # Final codes.
-    assert len(groups_compiled) == len(groups)  # For testing.
-    output_colors_simplified = output_colors
-    for i in range(len(groups)):
-        output_colors_simplified = output_colors_simplified.replace(groups[i], groups_compiled[i])
-    output_no_colors = _RE_SPLIT.sub('', output_colors_simplified)
-
-    # Strip any remaining color codes.
-    if _AutoCodes.DISABLE_COLORS:
-        output_colors_simplified = _RE_NUMBER_SEARCH.sub('', output_colors_simplified)
-
-    return output_colors_simplified, output_no_colors
-
-
-def disable_all_colors():
-    """Disable all colors. Strips any color tags or codes."""
-    _AutoCodes.DISABLE_COLORS = True
-
-
-def set_light_background():
-    """Chooses dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
-    _AutoCodes.DISABLE_COLORS = False
-    _AutoCodes.LIGHT_BACKGROUND = True
-
-
-def set_dark_background():
-    """Chooses dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
-    _AutoCodes.DISABLE_COLORS = False
-    _AutoCodes.LIGHT_BACKGROUND = False
-
-
-def list_tags():
-    """Lists the available tags.
-
-    Returns:
-    Tuple of tuples. Child tuples are four items: ('opening tag', 'closing tag', main ansi value, closing ansi value).
-    """
-    codes = _AutoCodes()
-    grouped = set([(k, '/{0}'.format(k), codes[k], codes['/{0}'.format(k)]) for k in codes if not k.startswith('/')])
-
-    # Add half-tags like /all.
-    found = [c for r in grouped for c in r[:2]]
-    missing = set([('', r[0], None, r[1]) if r[0].startswith('/') else (r[0], '', r[1], None)
-                   for r in _AutoCodes().items() if r[0] not in found])
-    grouped |= missing
-
-    # Sort.
-    payload = sorted([i for i in grouped if i[2] is None], key=lambda x: x[3])  # /all /fg /bg
-    grouped -= set(payload)
-    payload.extend(sorted([i for i in grouped if i[2] < 10], key=lambda x: x[2]))  # b i u flash
-    grouped -= set(payload)
-    payload.extend(sorted([i for i in grouped if i[0].startswith('auto')], key=lambda x: x[2]))  # auto colors
-    grouped -= set(payload)
-    payload.extend(sorted([i for i in grouped if not i[0].startswith('hi')], key=lambda x: x[2]))  # dark colors
-    grouped -= set(payload)
-    payload.extend(sorted(grouped, key=lambda x: x[2]))  # light colors
-    return tuple(payload)
-
-
-class ColorBytes(bytes):
-    """Str (bytes in Python3) subclass, .decode() overridden to return Color() instance."""
-
-    def decode(*args, **kwargs):
-        return Color(super(ColorBytes, args[0]).decode(*args[1:], **kwargs))
-
-
-class Color(PARENT_CLASS):
-    """Unicode (str in Python3) subclass with ANSI terminal text color support.
-
-    Example syntax: Color('{red}Sample Text{/red}')
-
-    For a list of codes, call: colorclass.list_tags()
-    """
-
-    @classmethod
-    def red(cls, s, auto=False):
-        return cls.colorize('red', s, auto=auto)
-
-    @classmethod
-    def bgred(cls, s, auto=False):
-        return cls.colorize('bgred', s, auto=auto)
-
-    @classmethod
-    def green(cls, s, auto=False):
-        return cls.colorize('green', s, auto=auto)
-
-    @classmethod
-    def bggreen(cls, s, auto=False):
-        return cls.colorize('bggreen', s, auto=auto)
-
-    @classmethod
-    def blue(cls, s, auto=False):
-        return cls.colorize('blue', s, auto=auto)
-
-    @classmethod
-    def bgblue(cls, s, auto=False):
-        return cls.colorize('bgblue', s, auto=auto)
-
-    @classmethod
-    def yellow(cls, s, auto=False):
-        return cls.colorize('yellow', s, auto=auto)
-
-    @classmethod
-    def bgyellow(cls, s, auto=False):
-        return cls.colorize('bgyellow', s, auto=auto)
-
-    @classmethod
-    def cyan(cls, s, auto=False):
-        return cls.colorize('cyan', s, auto=auto)
-
-    @classmethod
-    def bgcyan(cls, s, auto=False):
-        return cls.colorize('bgcyan', s, auto=auto)
-
-    @classmethod
-    def magenta(cls, s, auto=False):
-        return cls.colorize('magenta', s, auto=auto)
-
-    @classmethod
-    def bgmagenta(cls, s, auto=False):
-        return cls.colorize('bgmagenta', s, auto=auto)
-
-    @classmethod
-    def colorize(cls, color, s, auto=False):
-        tag = '{0}{1}'.format('auto' if auto else '', color)
-        return cls('{%s}%s{/%s}' % (tag, s, tag))
-
-    def __new__(cls, *args, **kwargs):
-        parent_class = cls.__bases__[0]
-        value_markup = args[0] if args else parent_class()
-        value_colors, value_no_colors = _parse_input(value_markup)
-        if args:
-            args = [value_colors] + list(args[1:])
-
-        obj = parent_class.__new__(cls, *args, **kwargs)
-        obj.value_colors, obj.value_no_colors = value_colors, value_no_colors
-        obj.has_colors = bool(_RE_NUMBER_SEARCH.match(value_colors))
-        return obj
-
-    def __len__(self):
-        return self.value_no_colors.__len__()
-
-    def capitalize(self):
-        split = _RE_SPLIT.split(self.value_colors)
-        for i in range(len(split)):
-            if _RE_SPLIT.match(split[i]):
-                continue
-            split[i] = PARENT_CLASS(split[i]).capitalize()
-        return Color().join(split)
-
-    def center(self, width, fillchar=None):
-        if fillchar is not None:
-            result = PARENT_CLASS(self.value_no_colors).center(width, fillchar)
-        else:
-            result = PARENT_CLASS(self.value_no_colors).center(width)
-        return result.replace(self.value_no_colors, self.value_colors)
-
-    def count(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).count(*args, **kwargs)
-
-    def endswith(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).endswith(*args, **kwargs)
-
-    def encode(*args, **kwargs):
-        return ColorBytes(super(Color, args[0]).encode(*args[1:], **kwargs))
-
-    def decode(*args, **kwargs):
-        return Color(super(Color, args[0]).decode(*args[1:], **kwargs))
-
-    def find(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).find(*args, **kwargs)
-
-    def format(*args, **kwargs):
-        return Color(super(Color, args[0]).format(*args[1:], **kwargs))
-
-    def index(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).index(*args, **kwargs)
-
-    def isalnum(self):
-        return PARENT_CLASS(self.value_no_colors).isalnum()
-
-    def isalpha(self):
-        return PARENT_CLASS(self.value_no_colors).isalpha()
-
-    def isdecimal(self):
-        return PARENT_CLASS(self.value_no_colors).isdecimal()
-
-    def isdigit(self):
-        return PARENT_CLASS(self.value_no_colors).isdigit()
-
-    def isnumeric(self):
-        return PARENT_CLASS(self.value_no_colors).isnumeric()
-
-    def isspace(self):
-        return PARENT_CLASS(self.value_no_colors).isspace()
-
-    def istitle(self):
-        return PARENT_CLASS(self.value_no_colors).istitle()
-
-    def isupper(self):
-        return PARENT_CLASS(self.value_no_colors).isupper()
-
-    def ljust(self, width, fillchar=None):
-        if fillchar is not None:
-            result = PARENT_CLASS(self.value_no_colors).ljust(width, fillchar)
-        else:
-            result = PARENT_CLASS(self.value_no_colors).ljust(width)
-        return result.replace(self.value_no_colors, self.value_colors)
-
-    def rfind(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).rfind(*args, **kwargs)
-
-    def rindex(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).rindex(*args, **kwargs)
-
-    def rjust(self, width, fillchar=None):
-        if fillchar is not None:
-            result = PARENT_CLASS(self.value_no_colors).rjust(width, fillchar)
-        else:
-            result = PARENT_CLASS(self.value_no_colors).rjust(width)
-        return result.replace(self.value_no_colors, self.value_colors)
-
-    def splitlines(self):
-        return [Color(l) for l in PARENT_CLASS(self.value_colors).splitlines()]
-
-    def startswith(self, *args, **kwargs):
-        return PARENT_CLASS(self.value_no_colors).startswith(*args, **kwargs)
-
-    def swapcase(self):
-        split = _RE_SPLIT.split(self.value_colors)
-        for i in range(len(split)):
-            if _RE_SPLIT.match(split[i]):
-                continue
-            split[i] = PARENT_CLASS(split[i]).swapcase()
-        return Color().join(split)
-
-    def title(self):
-        split = _RE_SPLIT.split(self.value_colors)
-        for i in range(len(split)):
-            if _RE_SPLIT.match(split[i]):
-                continue
-            split[i] = PARENT_CLASS(split[i]).title()
-        return Color().join(split)
-
-    def translate(self, table):
-        split = _RE_SPLIT.split(self.value_colors)
-        for i in range(len(split)):
-            if _RE_SPLIT.match(split[i]):
-                continue
-            split[i] = PARENT_CLASS(split[i]).translate(table)
-        return Color().join(split)
-
-    def upper(self):
-        split = _RE_SPLIT.split(self.value_colors)
-        for i in range(len(split)):
-            if _RE_SPLIT.match(split[i]):
-                continue
-            split[i] = PARENT_CLASS(split[i]).upper()
-        return Color().join(split)
-
-    def zfill(self, width):
-        if not self.value_no_colors:
-            return PARENT_CLASS().zfill(width)
-
-        split = _RE_SPLIT.split(self.value_colors)
-        filled = PARENT_CLASS(self.value_no_colors).zfill(width)
-        if len(split) == 1:
-            return filled
-
-        padding = filled.replace(self.value_no_colors, '')
-        if not split[0]:
-            split[2] = padding + split[2]
-        else:
-            split[0] = padding + split[0]
-
-        return Color().join(split)
-
-
-class Windows(object):
-    """Enable and disable Windows support for ANSI color character codes.
-
-    Call static method Windows.enable() to enable color support for the remainder of the process' lifetime.
-
-    This class is also a context manager. You can do this:
-    with Windows():
-        print(Color('{autored}Test{/autored}'))
-
-    Or this:
-    with Windows(auto_colors=True):
-        print(Color('{autored}Test{/autored}'))
-    """
-
-    @staticmethod
-    def disable():
-        """Restore sys.stderr and sys.stdout to their original objects. Resets colors to their original values."""
-        if os.name != 'nt' or not Windows.is_enabled():
-            return False
-
-        getattr(sys.stderr, '_reset_colors', lambda: False)()
-        getattr(sys.stdout, '_reset_colors', lambda: False)()
-
-        if hasattr(sys.stderr, 'ORIGINAL_STREAM'):
-            sys.stderr = getattr(sys.stderr, 'ORIGINAL_STREAM')
-        if hasattr(sys.stdout, 'ORIGINAL_STREAM'):
-            sys.stdout = getattr(sys.stdout, 'ORIGINAL_STREAM')
-
-        return True
-
-    @staticmethod
-    def is_enabled():
-        """Returns True if either stderr or stdout has colors enabled."""
-        return hasattr(sys.stderr, 'ORIGINAL_STREAM') or hasattr(sys.stdout, 'ORIGINAL_STREAM')
-
-    @staticmethod
-    def enable(auto_colors=False, reset_atexit=False):
-        """Enables color text with print() or sys.stdout.write() (stderr too).
-
-        Keyword arguments:
-        auto_colors -- automatically selects dark or light colors based on current terminal's background color. Only
-            works with {autored} and related tags.
-        reset_atexit -- resets original colors upon Python exit (in case you forget to reset it yourself with a closing
-            tag).
-        """
-        if os.name != 'nt':
-            return False
-
-        # Overwrite stream references.
-        if not hasattr(sys.stderr, 'ORIGINAL_STREAM'):
-            sys.stderr.flush()
-            sys.stderr = _WindowsStreamStdErr()
-        if not hasattr(sys.stdout, 'ORIGINAL_STREAM'):
-            sys.stdout.flush()
-            sys.stdout = _WindowsStreamStdOut()
-        if not hasattr(sys.stderr, 'ORIGINAL_STREAM') and not hasattr(sys.stdout, 'ORIGINAL_STREAM'):
-            return False
-
-        # Automatically select which colors to display.
-        bg_color = getattr(sys.stdout, 'default_bg', getattr(sys.stderr, 'default_bg', None))
-        if auto_colors and bg_color is not None:
-            set_light_background() if bg_color in (112, 96, 240, 176, 224, 208, 160) else set_dark_background()
-
-        # Reset on exit if requested.
-        if reset_atexit:
-            atexit.register(lambda: Windows.disable())
-
-        return True
-
-    def __init__(self, auto_colors=False):
-        self.auto_colors = auto_colors
-
-    def __enter__(self):
-        Windows.enable(auto_colors=self.auto_colors)
-
-    def __exit__(self, *_):
-        Windows.disable()
-
-
-class _WindowsCSBI(object):
-    """Interfaces with Windows CONSOLE_SCREEN_BUFFER_INFO API/DLL calls. Gets info for stderr and stdout.
-
-    References:
-        http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231
-        https://code.google.com/p/colorama/issues/detail?id=47.
-        pytest's py project: py/_io/terminalwriter.py.
-
-    Class variables:
-    CSBI -- ConsoleScreenBufferInfo class/struct (not instance, the class definition itself) defined in _define_csbi().
-    HANDLE_STDERR -- GetStdHandle() return integer for stderr.
-    HANDLE_STDOUT -- GetStdHandle() return integer for stdout.
-    WINDLL -- my own loaded instance of ctypes.WinDLL.
-    """
-
-    CSBI = None
-    HANDLE_STDERR = None
-    HANDLE_STDOUT = None
-    WINDLL = ctypes.LibraryLoader(getattr(ctypes, 'WinDLL', None))
-
-    @staticmethod
-    def _define_csbi():
-        """Defines structs and populates _WindowsCSBI.CSBI."""
-        if _WindowsCSBI.CSBI is not None:
-            return
-
-        class COORD(ctypes.Structure):
-            """Windows COORD structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119"""
-            _fields_ = [('X', ctypes.c_short), ('Y', ctypes.c_short)]
-
-        class SmallRECT(ctypes.Structure):
-            """Windows SMALL_RECT structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311"""
-            _fields_ = [('Left', ctypes.c_short), ('Top', ctypes.c_short), ('Right', ctypes.c_short),
-                        ('Bottom', ctypes.c_short)]
-
-        class ConsoleScreenBufferInfo(ctypes.Structure):
-            """Windows CONSOLE_SCREEN_BUFFER_INFO structure.
-            http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093
-            """
-            _fields_ = [
-                ('dwSize', COORD),
-                ('dwCursorPosition', COORD),
-                ('wAttributes', ctypes.wintypes.WORD),
-                ('srWindow', SmallRECT),
-                ('dwMaximumWindowSize', COORD)
-            ]
-
-        _WindowsCSBI.CSBI = ConsoleScreenBufferInfo
-
-    @staticmethod
-    def initialize():
-        """Initializes the WINDLL resource and populated the CSBI class variable."""
-        _WindowsCSBI._define_csbi()
-        _WindowsCSBI.HANDLE_STDERR = _WindowsCSBI.HANDLE_STDERR or _WindowsCSBI.WINDLL.kernel32.GetStdHandle(-12)
-        _WindowsCSBI.HANDLE_STDOUT = _WindowsCSBI.HANDLE_STDOUT or _WindowsCSBI.WINDLL.kernel32.GetStdHandle(-11)
-        if _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.argtypes:
-            return
-
-        _WindowsCSBI.WINDLL.kernel32.GetStdHandle.argtypes = [ctypes.wintypes.DWORD]
-        _WindowsCSBI.WINDLL.kernel32.GetStdHandle.restype = ctypes.wintypes.HANDLE
-        _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.restype = ctypes.wintypes.BOOL
-        _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.argtypes = [
-            ctypes.wintypes.HANDLE, ctypes.POINTER(_WindowsCSBI.CSBI)
-        ]
-
-    @staticmethod
-    def get_info(handle):
-        """Get information about this current console window (for Microsoft Windows only).
-
-        Raises IOError if attempt to get information fails (if there is no console window).
-
-        Don't forget to call _WindowsCSBI.initialize() once in your application before calling this method.
-
-        Positional arguments:
-        handle -- either _WindowsCSBI.HANDLE_STDERR or _WindowsCSBI.HANDLE_STDOUT.
-
-        Returns:
-        Dictionary with different integer values. Keys are:
-            buffer_width -- width of the buffer (Screen Buffer Size in cmd.exe layout tab).
-            buffer_height -- height of the buffer (Screen Buffer Size in cmd.exe layout tab).
-            terminal_width -- width of the terminal window.
-            terminal_height -- height of the terminal window.
-            bg_color -- current background color (http://msdn.microsoft.com/en-us/library/windows/desktop/ms682088).
-            fg_color -- current text color code.
-        """
-        # Query Win32 API.
-        csbi = _WindowsCSBI.CSBI()
-        try:
-            if not _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo(handle, ctypes.byref(csbi)):
-                raise IOError('Unable to get console screen buffer info from win32 API.')
-        except ctypes.ArgumentError:
-            raise IOError('Unable to get console screen buffer info from win32 API.')
-
-        # Parse data.
-        result = dict(
-            buffer_width=int(csbi.dwSize.X - 1),
-            buffer_height=int(csbi.dwSize.Y),
-            terminal_width=int(csbi.srWindow.Right - csbi.srWindow.Left),
-            terminal_height=int(csbi.srWindow.Bottom - csbi.srWindow.Top),
-            bg_color=int(csbi.wAttributes & 240),
-            fg_color=int(csbi.wAttributes % 16),
-        )
-        return result
-
-
-class _WindowsStreamStdOut(object):
-    """Replacement stream which overrides sys.stdout. When writing or printing, ANSI codes are converted.
-
-    ANSI (Linux/Unix) color codes are converted into win32 system calls, changing the next character's color before
-    printing it. Resources referenced:
-        https://github.com/tartley/colorama
-        http://www.cplusplus.com/articles/2ywTURfi/
-        http://thomasfischer.biz/python-and-windows-terminal-colors/
-        http://stackoverflow.com/questions/17125440/c-win32-console-color
-        http://www.tysos.org/svn/trunk/mono/corlib/System/WindowsConsoleDriver.cs
-        http://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python
-        http://msdn.microsoft.com/en-us/library/windows/desktop/ms682088#_win32_character_attributes
-
-    Class variables:
-    ALL_BG_CODES -- list of background Windows codes. Used to determine if requested color is foreground or background.
-    COMPILED_CODES -- 'translation' dictionary. Keys are ANSI codes (values of _BASE_CODES), values are Windows codes.
-    ORIGINAL_STREAM -- the original stream to write non-code text to.
-    WIN32_STREAM_HANDLE -- handle to the Windows stdout device. Used by other Windows functions.
-
-    Instance variables:
-    default_fg -- the foreground Windows color code at the time of instantiation.
-    default_bg -- the background Windows color code at the time of instantiation.
-    """
-
-    ALL_BG_CODES = [v for k, v in _WINDOWS_CODES.items() if k.startswith('bg') or k.startswith('hibg')]
-    COMPILED_CODES = dict((v, _WINDOWS_CODES[k]) for k, v in _BASE_CODES.items() if k in _WINDOWS_CODES)
-    ORIGINAL_STREAM = sys.stdout
-    WIN32_STREAM_HANDLE = _WindowsCSBI.HANDLE_STDOUT
-
-    def __init__(self):
-        _WindowsCSBI.initialize()
-        self.default_fg, self.default_bg = self._get_colors()
-        for attr in dir(self.ORIGINAL_STREAM):
-            if hasattr(self, attr):
-                continue
-            setattr(self, attr, getattr(self.ORIGINAL_STREAM, attr))
-
-    def __getattr__(self, item):
-        """If an attribute/function/etc is not defined in this function, retrieve the one from the original stream.
-
-        Fixes ipython arrow key presses.
-        """
-        return getattr(self.ORIGINAL_STREAM, item)
-
-    def _get_colors(self):
-        """Returns a tuple of two integers representing current colors: (foreground, background)."""
-        try:
-            csbi = _WindowsCSBI.get_info(self.WIN32_STREAM_HANDLE)
-            return csbi['fg_color'], csbi['bg_color']
-        except IOError:
-            return 7, 0
-
-    def _reset_colors(self):
-        """Sets the foreground and background colors to their original values (when class was instantiated)."""
-        self._set_color(-33)
-
-    def _set_color(self, color_code):
-        """Changes the foreground and background colors for subsequently printed characters.
-
-        Since setting a color requires including both foreground and background codes (merged), setting just the
-        foreground color resets the background color to black, and vice versa.
-
-        This function first gets the current background and foreground colors, merges in the requested color code, and
-        sets the result.
-
-        However if we need to remove just the foreground color but leave the background color the same (or vice versa)
-        such as when {/red} is used, we must merge the default foreground color with the current background color. This
-        is the reason for those negative values.
-
-        Positional arguments:
-        color_code -- integer color code from _WINDOWS_CODES.
-        """
-        # Get current color code.
-        current_fg, current_bg = self._get_colors()
-
-        # Handle special negative codes. Also determine the final color code.
-        if color_code == -39:
-            final_color_code = self.default_fg | current_bg  # Reset the foreground only.
-        elif color_code == -49:
-            final_color_code = current_fg | self.default_bg  # Reset the background only.
-        elif color_code == -33:
-            final_color_code = self.default_fg | self.default_bg  # Reset both.
-        elif color_code == -8:
-            final_color_code = current_fg  # Black background.
-        else:
-            new_is_bg = color_code in self.ALL_BG_CODES
-            final_color_code = color_code | (current_fg if new_is_bg else current_bg)
-
-        # Set new code.
-        _WindowsCSBI.WINDLL.kernel32.SetConsoleTextAttribute(self.WIN32_STREAM_HANDLE, final_color_code)
-
-    def write(self, p_str):
-        for segment in _RE_SPLIT.split(p_str):
-            if not segment:
-                # Empty string. p_str probably starts with colors so the first item is always ''.
-                continue
-            if not _RE_SPLIT.match(segment):
-                # No color codes, print regular text.
-                self.ORIGINAL_STREAM.write(segment)
-                self.ORIGINAL_STREAM.flush()
-                continue
-            for color_code in (int(c) for c in _RE_NUMBER_SEARCH.findall(segment)[0].split(';')):
-                if color_code in self.COMPILED_CODES:
-                    self._set_color(self.COMPILED_CODES[color_code])
-
-
-class _WindowsStreamStdErr(_WindowsStreamStdOut):
-    """Replacement stream which overrides sys.stderr. Subclasses _WindowsStreamStdOut."""
-
-    ORIGINAL_STREAM = sys.stderr
-    WIN32_STREAM_HANDLE = _WindowsCSBI.HANDLE_STDERR
+"""String subclass that handles ANSI color codes."""
+
+from colorclass.codes import ANSICodeMapping
+from colorclass.parse import parse_input, RE_SPLIT
+from colorclass.search import build_color_index, find_char_color
+
+PARENT_CLASS = type(u'')
+
+
+def apply_text(incoming, func):
+    """Call `func` on text portions of incoming color string.
+
+    :param iter incoming: Incoming string/ColorStr/string-like object to iterate.
+    :param func: Function to call with string portion as first and only parameter.
+
+    :return: Modified string, same class type as incoming string.
+    """
+    split = RE_SPLIT.split(incoming)
+    for i, item in enumerate(split):
+        if not item or RE_SPLIT.match(item):
+            continue
+        split[i] = func(item)
+    return incoming.__class__().join(split)
+
+
+class ColorBytes(bytes):
+    """Str (bytes in Python3) subclass, .decode() overridden to return unicode (str in Python3) subclass instance."""
+
+    def __new__(cls, *args, **kwargs):
+        """Save original class so decode() returns an instance of it."""
+        original_class = kwargs.pop('original_class')
+        combined_args = [cls] + list(args)
+        instance = bytes.__new__(*combined_args, **kwargs)
+        instance.original_class = original_class
+        return instance
+
+    def decode(self, encoding='utf-8', errors='strict'):
+        """Decode using the codec registered for encoding. Default encoding is 'utf-8'.
+
+        errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors
+        raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name
+        registered with codecs.register_error that is able to handle UnicodeDecodeErrors.
+
+        :param str encoding: Codec.
+        :param str errors: Error handling scheme.
+        """
+        original_class = getattr(self, 'original_class')
+        return original_class(super(ColorBytes, self).decode(encoding, errors))
+
+
+class ColorStr(PARENT_CLASS):
+    """Core color class."""
+
+    def __new__(cls, *args, **kwargs):
+        """Parse color markup and instantiate."""
+        keep_tags = kwargs.pop('keep_tags', False)
+
+        # Parse string.
+        value_markup = args[0] if args else PARENT_CLASS()  # e.g. '{red}test{/red}'
+        value_colors, value_no_colors = parse_input(value_markup, ANSICodeMapping.DISABLE_COLORS, keep_tags)
+        color_index = build_color_index(value_colors)
+
+        # Instantiate.
+        color_args = [cls, value_colors] + list(args[1:])
+        instance = PARENT_CLASS.__new__(*color_args, **kwargs)
+
+        # Add additional attributes and return.
+        instance.value_colors = value_colors
+        instance.value_no_colors = value_no_colors
+        instance.has_colors = value_colors != value_no_colors
+        instance.color_index = color_index
+        return instance
+
+    def __add__(self, other):
+        """Concatenate."""
+        return self.__class__(self.value_colors + other, keep_tags=True)
+
+    def __getitem__(self, item):
+        """Retrieve character."""
+        try:
+            color_pos = self.color_index[int(item)]
+        except TypeError:  # slice
+            return super(ColorStr, self).__getitem__(item)
+        return self.__class__(find_char_color(self.value_colors, color_pos), keep_tags=True)
+
+    def __iter__(self):
+        """Yield one color-coded character at a time."""
+        for color_pos in self.color_index:
+            yield self.__class__(find_char_color(self.value_colors, color_pos))
+
+    def __len__(self):
+        """Length of string without color codes (what users expect)."""
+        return self.value_no_colors.__len__()
+
+    def __mod__(self, other):
+        """String substitution (like printf)."""
+        return self.__class__(self.value_colors % other, keep_tags=True)
+
+    def __mul__(self, other):
+        """Multiply string."""
+        return self.__class__(self.value_colors * other, keep_tags=True)
+
+    def __repr__(self):
+        """Representation of a class instance (like datetime.datetime.now())."""
+        return '{name}({value})'.format(name=self.__class__.__name__, value=repr(self.value_colors))
+
+    def capitalize(self):
+        """Return a copy of the string with only its first character capitalized."""
+        return apply_text(self, lambda s: s.capitalize())
+
+    def center(self, width, fillchar=None):
+        """Return centered in a string of length width. Padding is done using the specified fill character or space.
+
+        :param int width: Length of output string.
+        :param str fillchar: Use this character instead of spaces.
+        """
+        if fillchar is not None:
+            result = self.value_no_colors.center(width, fillchar)
+        else:
+            result = self.value_no_colors.center(width)
+        return self.__class__(result.replace(self.value_no_colors, self.value_colors), keep_tags=True)
+
+    def count(self, sub, start=0, end=-1):
+        """Return the number of non-overlapping occurrences of substring sub in string[start:end].
+
+        Optional arguments start and end are interpreted as in slice notation.
+
+        :param str sub: Substring to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.count(sub, start, end)
+
+    def endswith(self, suffix, start=0, end=None):
+        """Return True if ends with the specified suffix, False otherwise.
+
+        With optional start, test beginning at that position. With optional end, stop comparing at that position.
+        suffix can also be a tuple of strings to try.
+
+        :param str suffix: Suffix to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        args = [suffix, start] + ([] if end is None else [end])
+        return self.value_no_colors.endswith(*args)
+
+    def encode(self, encoding=None, errors='strict'):
+        """Encode using the codec registered for encoding. encoding defaults to the default encoding.
+
+        errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors
+        raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any
+        other name registered with codecs.register_error that is able to handle UnicodeEncodeErrors.
+
+        :param str encoding: Codec.
+        :param str errors: Error handling scheme.
+        """
+        return ColorBytes(super(ColorStr, self).encode(encoding, errors), original_class=self.__class__)
+
+    def decode(self, encoding=None, errors='strict'):
+        """Decode using the codec registered for encoding. encoding defaults to the default encoding.
+
+        errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors
+        raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name
+        registered with codecs.register_error that is able to handle UnicodeDecodeErrors.
+
+        :param str encoding: Codec.
+        :param str errors: Error handling scheme.
+        """
+        return self.__class__(super(ColorStr, self).decode(encoding, errors), keep_tags=True)
+
+    def find(self, sub, start=None, end=None):
+        """Return the lowest index where substring sub is found, such that sub is contained within string[start:end].
+
+        Optional arguments start and end are interpreted as in slice notation.
+
+        :param str sub: Substring to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.find(sub, start, end)
+
+    def format(self, *args, **kwargs):
+        """Return a formatted version, using substitutions from args and kwargs.
+
+        The substitutions are identified by braces ('{' and '}').
+        """
+        return self.__class__(super(ColorStr, self).format(*args, **kwargs), keep_tags=True)
+
+    def index(self, sub, start=None, end=None):
+        """Like S.find() but raise ValueError when the substring is not found.
+
+        :param str sub: Substring to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.index(sub, start, end)
+
+    def isalnum(self):
+        """Return True if all characters in string are alphanumeric and there is at least one character in it."""
+        return self.value_no_colors.isalnum()
+
+    def isalpha(self):
+        """Return True if all characters in string are alphabetic and there is at least one character in it."""
+        return self.value_no_colors.isalpha()
+
+    def isdecimal(self):
+        """Return True if there are only decimal characters in string, False otherwise."""
+        return self.value_no_colors.isdecimal()
+
+    def isdigit(self):
+        """Return True if all characters in string are digits and there is at least one character in it."""
+        return self.value_no_colors.isdigit()
+
+    def isnumeric(self):
+        """Return True if there are only numeric characters in string, False otherwise."""
+        return self.value_no_colors.isnumeric()
+
+    def isspace(self):
+        """Return True if all characters in string are whitespace and there is at least one character in it."""
+        return self.value_no_colors.isspace()
+
+    def istitle(self):
+        """Return True if string is a titlecased string and there is at least one character in it.
+
+        That is uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return
+        False otherwise.
+        """
+        return self.value_no_colors.istitle()
+
+    def isupper(self):
+        """Return True if all cased characters are uppercase and there is at least one cased character in it."""
+        return self.value_no_colors.isupper()
+
+    def join(self, iterable):
+        """Return a string which is the concatenation of the strings in the iterable.
+
+        :param iterable: Join items in this iterable.
+        """
+        return self.__class__(super(ColorStr, self).join(iterable), keep_tags=True)
+
+    def ljust(self, width, fillchar=None):
+        """Return left-justified string of length width. Padding is done using the specified fill character or space.
+
+        :param int width: Length of output string.
+        :param str fillchar: Use this character instead of spaces.
+        """
+        if fillchar is not None:
+            result = self.value_no_colors.ljust(width, fillchar)
+        else:
+            result = self.value_no_colors.ljust(width)
+        return self.__class__(result.replace(self.value_no_colors, self.value_colors), keep_tags=True)
+
+    def rfind(self, sub, start=None, end=None):
+        """Return the highest index where substring sub is found, such that sub is contained within string[start:end].
+
+        Optional arguments start and end are interpreted as in slice notation.
+
+        :param str sub: Substring to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.rfind(sub, start, end)
+
+    def rindex(self, sub, start=None, end=None):
+        """Like .rfind() but raise ValueError when the substring is not found.
+
+        :param str sub: Substring to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.rindex(sub, start, end)
+
+    def rjust(self, width, fillchar=None):
+        """Return right-justified string of length width. Padding is done using the specified fill character or space.
+
+        :param int width: Length of output string.
+        :param str fillchar: Use this character instead of spaces.
+        """
+        if fillchar is not None:
+            result = self.value_no_colors.rjust(width, fillchar)
+        else:
+            result = self.value_no_colors.rjust(width)
+        return self.__class__(result.replace(self.value_no_colors, self.value_colors), keep_tags=True)
+
+    def splitlines(self, keepends=False):
+        """Return a list of the lines in the string, breaking at line boundaries.
+
+        Line breaks are not included in the resulting list unless keepends is given and True.
+
+        :param bool keepends: Include linebreaks.
+        """
+        return [self.__class__(l) for l in self.value_colors.splitlines(keepends)]
+
+    def startswith(self, prefix, start=0, end=-1):
+        """Return True if string starts with the specified prefix, False otherwise.
+
+        With optional start, test beginning at that position. With optional end, stop comparing at that position. prefix
+        can also be a tuple of strings to try.
+
+        :param str prefix: Prefix to search.
+        :param int start: Beginning position.
+        :param int end: Stop comparison at this position.
+        """
+        return self.value_no_colors.startswith(prefix, start, end)
+
+    def swapcase(self):
+        """Return a copy of the string with uppercase characters converted to lowercase and vice versa."""
+        return apply_text(self, lambda s: s.swapcase())
+
+    def title(self):
+        """Return a titlecased version of the string.
+
+        That is words start with uppercase characters, all remaining cased characters have lowercase.
+        """
+        return apply_text(self, lambda s: s.title())
+
+    def translate(self, table):
+        """Return a copy of the string, where all characters have been mapped through the given translation table.
+
+        Table must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None. Unmapped characters are left
+        untouched. Characters mapped to None are deleted.
+
+        :param table: Translation table.
+        """
+        return apply_text(self, lambda s: s.translate(table))
+
+    def upper(self):
+        """Return a copy of the string converted to uppercase."""
+        return apply_text(self, lambda s: s.upper())
+
+    def zfill(self, width):
+        """Pad a numeric string with zeros on the left, to fill a field of the specified width.
+
+        The string is never truncated.
+
+        :param int width: Length of output string.
+        """
+        if not self.value_no_colors:
+            result = self.value_no_colors.zfill(width)
+        else:
+            result = self.value_colors.replace(self.value_no_colors, self.value_no_colors.zfill(width))
+        return self.__class__(result, keep_tags=True)
+"""Parse color markup tags into ANSI escape sequences."""
+
+import re
+
+from colorclass.codes import ANSICodeMapping, BASE_CODES
+
+CODE_GROUPS = (
+    tuple(set(str(i) for i in BASE_CODES.values() if i and (40 <= i <= 49 or 100 <= i <= 109))),  # bg colors
+    tuple(set(str(i) for i in BASE_CODES.values() if i and (30 <= i <= 39 or 90 <= i <= 99))),  # fg colors
+    ('1', '22'), ('2', '22'), ('3', '23'), ('4', '24'), ('5', '25'), ('6', '26'), ('7', '27'), ('8', '28'), ('9', '29'),
+)
+RE_ANSI = re.compile(r'(\033\[([\d;]+)m)')
+RE_COMBINE = re.compile(r'\033\[([\d;]+)m\033\[([\d;]+)m')
+RE_SPLIT = re.compile(r'(\033\[[\d;]+m)')
+
+
+def prune_overridden(ansi_string):
+    """Remove color codes that are rendered ineffective by subsequent codes in one escape sequence then sort codes.
+
+    :param str ansi_string: Incoming ansi_string with ANSI color codes.
+
+    :return: Color string with pruned color sequences.
+    :rtype: str
+    """
+    multi_seqs = set(p for p in RE_ANSI.findall(ansi_string) if ';' in p[1])  # Sequences with multiple color codes.
+
+    for escape, codes in multi_seqs:
+        r_codes = list(reversed(codes.split(';')))
+
+        # Nuke everything before {/all}.
+        try:
+            r_codes = r_codes[:r_codes.index('0') + 1]
+        except ValueError:
+            pass
+
+        # Thin out groups.
+        for group in CODE_GROUPS:
+            for pos in reversed([i for i, n in enumerate(r_codes) if n in group][1:]):
+                r_codes.pop(pos)
+
+        # Done.
+        reduced_codes = ';'.join(sorted(r_codes, key=int))
+        if codes != reduced_codes:
+            ansi_string = ansi_string.replace(escape, '\033[' + reduced_codes + 'm')
+
+    return ansi_string
+
+
+def parse_input(tagged_string, disable_colors, keep_tags):
+    """Perform the actual conversion of tags to ANSI escaped codes.
+
+    Provides a version of the input without any colors for len() and other methods.
+
+    :param str tagged_string: The input unicode value.
+    :param bool disable_colors: Strip all colors in both outputs.
+    :param bool keep_tags: Skip parsing curly bracket tags into ANSI escape sequences.
+
+    :return: 2-item tuple. First item is the parsed output. Second item is a version of the input without any colors.
+    :rtype: tuple
+    """
+    codes = ANSICodeMapping(tagged_string)
+    output_colors = getattr(tagged_string, 'value_colors', tagged_string)
+
+    # Convert: '{b}{red}' -> '\033[1m\033[31m'
+    if not keep_tags:
+        for tag, replacement in (('{' + k + '}', '' if v is None else '\033[%dm' % v) for k, v in codes.items()):
+            output_colors = output_colors.replace(tag, replacement)
+
+    # Strip colors.
+    output_no_colors = RE_ANSI.sub('', output_colors)
+    if disable_colors:
+        return output_no_colors, output_no_colors
+
+    # Combine: '\033[1m\033[31m' -> '\033[1;31m'
+    while True:
+        simplified = RE_COMBINE.sub(r'\033[\1;\2m', output_colors)
+        if simplified == output_colors:
+            break
+        output_colors = simplified
+
+    # Prune: '\033[31;32;33;34;35m' -> '\033[35m'
+    output_colors = prune_overridden(output_colors)
+
+    # Deduplicate: '\033[1;mT\033[1;mE\033[1;mS\033[1;mT' -> '\033[1;mTEST'
+    previous_escape = None
+    segments = list()
+    for item in (i for i in RE_SPLIT.split(output_colors) if i):
+        if RE_SPLIT.match(item):
+            if item != previous_escape:
+                segments.append(item)
+                previous_escape = item
+        else:
+            segments.append(item)
+    output_colors = ''.join(segments)
+
+    return output_colors, output_no_colors
+"""Determine color of characters that may or may not be adjacent to ANSI escape sequences."""
+
+from colorclass.parse import RE_SPLIT
+
+
+def build_color_index(ansi_string):
+    """Build an index between visible characters and a string with invisible color codes.
+
+    :param str ansi_string: String with color codes (ANSI escape sequences).
+
+    :return: Position of visible characters in color string (indexes match non-color string).
+    :rtype: tuple
+    """
+    mapping = list()
+    color_offset = 0
+    for item in (i for i in RE_SPLIT.split(ansi_string) if i):
+        if RE_SPLIT.match(item):
+            color_offset += len(item)
+        else:
+            for _ in range(len(item)):
+                mapping.append(color_offset)
+                color_offset += 1
+    return tuple(mapping)
+
+
+def find_char_color(ansi_string, pos):
+    """Determine what color a character is in the string.
+
+    :param str ansi_string: String with color codes (ANSI escape sequences).
+    :param int pos: Position of the character in the ansi_string.
+
+    :return: Character along with all surrounding color codes.
+    :rtype: str
+    """
+    result = list()
+    position = 0  # Set to None when character is found.
+    for item in (i for i in RE_SPLIT.split(ansi_string) if i):
+        if RE_SPLIT.match(item):
+            result.append(item)
+            if position is not None:
+                position += len(item)
+        elif position is not None:
+            for char in item:
+                if position == pos:
+                    result.append(char)
+                    position = None
+                    break
+                position += 1
+    return ''.join(result)
+"""Convenience functions to enable/disable features."""
+
+from colorclass.codes import ANSICodeMapping
+
+
+def disable_all_colors():
+    """Disable all colors. Strip any color tags or codes."""
+    ANSICodeMapping.disable_all_colors()
+
+
+def enable_all_colors():
+    """Enable colors."""
+    ANSICodeMapping.enable_all_colors()
+
+
+def disable_if_no_tty():
+    """Disable all colors if there is no TTY available.
+
+    :return: True if colors are disabled, False if stderr or stdout is a TTY.
+    :rtype: bool
+    """
+    return ANSICodeMapping.disable_if_no_tty()
+
+
+def is_enabled():
+    """Are colors enabled."""
+    return not ANSICodeMapping.DISABLE_COLORS
+
+
+def set_light_background():
+    """Choose dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
+    ANSICodeMapping.set_light_background()
+
+
+def set_dark_background():
+    """Choose dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
+    ANSICodeMapping.set_dark_background()
+
+
+def is_light():
+    """Are background colors for light backgrounds."""
+    return ANSICodeMapping.LIGHT_BACKGROUND
+"""Windows console screen buffer handlers."""
+
+from __future__ import print_function
+
+import atexit
+import ctypes
+import re
+import sys
+
+from colorclass.codes import ANSICodeMapping, BASE_CODES
+from colorclass.core import RE_SPLIT
+
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+INVALID_HANDLE_VALUE = -1
+IS_WINDOWS = sys.platform == 'win32'
+RE_NUMBER_SEARCH = re.compile(r'\033\[([\d;]+)m')
+STD_ERROR_HANDLE = -12
+STD_OUTPUT_HANDLE = -11
+WINDOWS_CODES = {
+    '/all': -33, '/fg': -39, '/bg': -49,
+
+    'black': 0, 'red': 4, 'green': 2, 'yellow': 6, 'blue': 1, 'magenta': 5, 'cyan': 3, 'white': 7,
+
+    'bgblack': -8, 'bgred': 64, 'bggreen': 32, 'bgyellow': 96, 'bgblue': 16, 'bgmagenta': 80, 'bgcyan': 48,
+    'bgwhite': 112,
+
+    'hiblack': 8, 'hired': 12, 'higreen': 10, 'hiyellow': 14, 'hiblue': 9, 'himagenta': 13, 'hicyan': 11, 'hiwhite': 15,
+
+    'hibgblack': 128, 'hibgred': 192, 'hibggreen': 160, 'hibgyellow': 224, 'hibgblue': 144, 'hibgmagenta': 208,
+    'hibgcyan': 176, 'hibgwhite': 240,
+
+    '/black': -39, '/red': -39, '/green': -39, '/yellow': -39, '/blue': -39, '/magenta': -39, '/cyan': -39,
+    '/white': -39, '/hiblack': -39, '/hired': -39, '/higreen': -39, '/hiyellow': -39, '/hiblue': -39, '/himagenta': -39,
+    '/hicyan': -39, '/hiwhite': -39,
+
+    '/bgblack': -49, '/bgred': -49, '/bggreen': -49, '/bgyellow': -49, '/bgblue': -49, '/bgmagenta': -49,
+    '/bgcyan': -49, '/bgwhite': -49, '/hibgblack': -49, '/hibgred': -49, '/hibggreen': -49, '/hibgyellow': -49,
+    '/hibgblue': -49, '/hibgmagenta': -49, '/hibgcyan': -49, '/hibgwhite': -49,
+}
+
+
+class COORD(ctypes.Structure):
+    """COORD structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119."""
+
+    _fields_ = [
+        ('X', ctypes.c_short),
+        ('Y', ctypes.c_short),
+    ]
+
+
+class SmallRECT(ctypes.Structure):
+    """SMALL_RECT structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311."""
+
+    _fields_ = [
+        ('Left', ctypes.c_short),
+        ('Top', ctypes.c_short),
+        ('Right', ctypes.c_short),
+        ('Bottom', ctypes.c_short),
+    ]
+
+
+class ConsoleScreenBufferInfo(ctypes.Structure):
+    """CONSOLE_SCREEN_BUFFER_INFO structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093."""
+
+    _fields_ = [
+        ('dwSize', COORD),
+        ('dwCursorPosition', COORD),
+        ('wAttributes', ctypes.c_ushort),
+        ('srWindow', SmallRECT),
+        ('dwMaximumWindowSize', COORD)
+    ]
+
+
+def init_kernel32(kernel32=None):
+    """Load a unique instance of WinDLL into memory, set arg/return types, and get stdout/err handles.
+
+    1. Since we are setting DLL function argument types and return types, we need to maintain our own instance of
+       kernel32 to prevent overriding (or being overwritten by) user's own changes to ctypes.windll.kernel32.
+    2. While we're doing all this we might as well get the handles to STDOUT and STDERR streams.
+    3. If either stream has already been replaced set return value to INVALID_HANDLE_VALUE to indicate it shouldn't be
+       replaced.
+
+    :raise AttributeError: When called on a non-Windows platform.
+
+    :param kernel32: Optional mock kernel32 object. For testing.
+
+    :return: Loaded kernel32 instance, stderr handle (int), stdout handle (int).
+    :rtype: tuple
+    """
+    if not kernel32:
+        kernel32 = ctypes.LibraryLoader(ctypes.WinDLL).kernel32  # Load our own instance. Unique memory address.
+        kernel32.GetStdHandle.argtypes = [ctypes.c_ulong]
+        kernel32.GetStdHandle.restype = ctypes.c_void_p
+        kernel32.GetConsoleScreenBufferInfo.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ConsoleScreenBufferInfo),
+        ]
+        kernel32.GetConsoleScreenBufferInfo.restype = ctypes.c_long
+
+    # Get handles.
+    if hasattr(sys.stderr, '_original_stream'):
+        stderr = INVALID_HANDLE_VALUE
+    else:
+        stderr = kernel32.GetStdHandle(STD_ERROR_HANDLE)
+    if hasattr(sys.stdout, '_original_stream'):
+        stdout = INVALID_HANDLE_VALUE
+    else:
+        stdout = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+
+    return kernel32, stderr, stdout
+
+
+def get_console_info(kernel32, handle):
+    """Get information about this current console window.
+
+    http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231
+    https://code.google.com/p/colorama/issues/detail?id=47
+    https://bitbucket.org/pytest-dev/py/src/4617fe46/py/_io/terminalwriter.py
+
+    Windows 10 Insider since around February 2016 finally introduced support for ANSI colors. No need to replace stdout
+    and stderr streams to intercept colors and issue multiple SetConsoleTextAttribute() calls for these consoles.
+
+    :raise OSError: When GetConsoleScreenBufferInfo or GetConsoleMode API calls fail.
+
+    :param ctypes.windll.kernel32 kernel32: Loaded kernel32 instance.
+    :param int handle: stderr or stdout handle.
+
+    :return: Foreground and background colors (integers) as well as native ANSI support (bool).
+    :rtype: tuple
+    """
+    # Query Win32 API.
+    csbi = ConsoleScreenBufferInfo()  # Populated by GetConsoleScreenBufferInfo.
+    lpcsbi = ctypes.byref(csbi)
+    dword = ctypes.c_ulong()  # Populated by GetConsoleMode.
+    lpdword = ctypes.byref(dword)
+    if not kernel32.GetConsoleScreenBufferInfo(handle, lpcsbi) or not kernel32.GetConsoleMode(handle, lpdword):
+        raise ctypes.WinError()
+
+    # Parse data.
+    # buffer_width = int(csbi.dwSize.X - 1)
+    # buffer_height = int(csbi.dwSize.Y)
+    # terminal_width = int(csbi.srWindow.Right - csbi.srWindow.Left)
+    # terminal_height = int(csbi.srWindow.Bottom - csbi.srWindow.Top)
+    fg_color = csbi.wAttributes % 16
+    bg_color = csbi.wAttributes & 240
+    native_ansi = bool(dword.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+    return fg_color, bg_color, native_ansi
+
+
+def bg_color_native_ansi(kernel32, stderr, stdout):
+    """Get background color and if console supports ANSI colors natively for both streams.
+
+    :param ctypes.windll.kernel32 kernel32: Loaded kernel32 instance.
+    :param int stderr: stderr handle.
+    :param int stdout: stdout handle.
+
+    :return: Background color (int) and native ANSI support (bool).
+    :rtype: tuple
+    """
+    try:
+        if stderr == INVALID_HANDLE_VALUE:
+            raise OSError
+        bg_color, native_ansi = get_console_info(kernel32, stderr)[1:]
+    except OSError:
+        try:
+            if stdout == INVALID_HANDLE_VALUE:
+                raise OSError
+            bg_color, native_ansi = get_console_info(kernel32, stdout)[1:]
+        except OSError:
+            bg_color, native_ansi = WINDOWS_CODES['black'], False
+    return bg_color, native_ansi
+
+
+class WindowsStream(object):
+    """Replacement stream which overrides sys.stdout or sys.stderr. When writing or printing, ANSI codes are converted.
+
+    ANSI (Linux/Unix) color codes are converted into win32 system calls, changing the next character's color before
+    printing it. Resources referenced:
+        https://github.com/tartley/colorama
+        http://www.cplusplus.com/articles/2ywTURfi/
+        http://thomasfischer.biz/python-and-windows-terminal-colors/
+        http://stackoverflow.com/questions/17125440/c-win32-console-color
+        http://www.tysos.org/svn/trunk/mono/corlib/System/WindowsConsoleDriver.cs
+        http://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python
+        http://msdn.microsoft.com/en-us/library/windows/desktop/ms682088#_win32_character_attributes
+
+    :cvar list ALL_BG_CODES: List of bg Windows codes. Used to determine if requested color is foreground or background.
+    :cvar dict COMPILED_CODES: Translation dict. Keys are ANSI codes (values of BASE_CODES), values are Windows codes.
+    :ivar int default_fg: Foreground Windows color code at the time of instantiation.
+    :ivar int default_bg: Background Windows color code at the time of instantiation.
+    """
+
+    ALL_BG_CODES = [v for k, v in WINDOWS_CODES.items() if k.startswith('bg') or k.startswith('hibg')]
+    COMPILED_CODES = dict((v, WINDOWS_CODES[k]) for k, v in BASE_CODES.items() if k in WINDOWS_CODES)
+
+    def __init__(self, kernel32, stream_handle, original_stream):
+        """Constructor.
+
+        :param ctypes.windll.kernel32 kernel32: Loaded kernel32 instance.
+        :param int stream_handle: stderr or stdout handle.
+        :param original_stream: sys.stderr or sys.stdout before being overridden by this class' instance.
+        """
+        self._kernel32 = kernel32
+        self._stream_handle = stream_handle
+        self._original_stream = original_stream
+        self.default_fg, self.default_bg = self.colors
+
+    def __getattr__(self, item):
+        """If an attribute/function/etc is not defined in this function, retrieve the one from the original stream.
+
+        Fixes ipython arrow key presses.
+        """
+        return getattr(self._original_stream, item)
+
+    @property
+    def colors(self):
+        """Return the current foreground and background colors."""
+        try:
+            return get_console_info(self._kernel32, self._stream_handle)[:2]
+        except OSError:
+            return WINDOWS_CODES['white'], WINDOWS_CODES['black']
+
+    @colors.setter
+    def colors(self, color_code):
+        """Change the foreground and background colors for subsequently printed characters.
+
+        None resets colors to their original values (when class was instantiated).
+
+        Since setting a color requires including both foreground and background codes (merged), setting just the
+        foreground color resets the background color to black, and vice versa.
+
+        This function first gets the current background and foreground colors, merges in the requested color code, and
+        sets the result.
+
+        However if we need to remove just the foreground color but leave the background color the same (or vice versa)
+        such as when {/red} is used, we must merge the default foreground color with the current background color. This
+        is the reason for those negative values.
+
+        :param int color_code: Color code from WINDOWS_CODES.
+        """
+        if color_code is None:
+            color_code = WINDOWS_CODES['/all']
+
+        # Get current color code.
+        current_fg, current_bg = self.colors
+
+        # Handle special negative codes. Also determine the final color code.
+        if color_code == WINDOWS_CODES['/fg']:
+            final_color_code = self.default_fg | current_bg  # Reset the foreground only.
+        elif color_code == WINDOWS_CODES['/bg']:
+            final_color_code = current_fg | self.default_bg  # Reset the background only.
+        elif color_code == WINDOWS_CODES['/all']:
+            final_color_code = self.default_fg | self.default_bg  # Reset both.
+        elif color_code == WINDOWS_CODES['bgblack']:
+            final_color_code = current_fg  # Black background.
+        else:
+            new_is_bg = color_code in self.ALL_BG_CODES
+            final_color_code = color_code | (current_fg if new_is_bg else current_bg)
+
+        # Set new code.
+        self._kernel32.SetConsoleTextAttribute(self._stream_handle, final_color_code)
+
+    def write(self, p_str):
+        """Write to stream.
+
+        :param str p_str: string to print.
+        """
+        for segment in RE_SPLIT.split(p_str):
+            if not segment:
+                # Empty string. p_str probably starts with colors so the first item is always ''.
+                continue
+            if not RE_SPLIT.match(segment):
+                # No color codes, print regular text.
+                print(segment, file=self._original_stream, end='')
+                self._original_stream.flush()
+                continue
+            for color_code in (int(c) for c in RE_NUMBER_SEARCH.findall(segment)[0].split(';')):
+                if color_code in self.COMPILED_CODES:
+                    self.colors = self.COMPILED_CODES[color_code]
+
+
+class Windows(object):
+    """Enable and disable Windows support for ANSI color character codes.
+
+    Call static method Windows.enable() to enable color support for the remainder of the process' lifetime.
+
+    This class is also a context manager. You can do this:
+    with Windows():
+        print(Color('{autored}Test{/autored}'))
+
+    Or this:
+    with Windows(auto_colors=True):
+        print(Color('{autored}Test{/autored}'))
+    """
+
+    @classmethod
+    def disable(cls):
+        """Restore sys.stderr and sys.stdout to their original objects. Resets colors to their original values.
+
+        :return: If streams restored successfully.
+        :rtype: bool
+        """
+        # Skip if not on Windows.
+        if not IS_WINDOWS:
+            return False
+
+        # Restore default colors.
+        if hasattr(sys.stderr, '_original_stream'):
+            getattr(sys, 'stderr').color = None
+        if hasattr(sys.stdout, '_original_stream'):
+            getattr(sys, 'stdout').color = None
+
+        # Restore original streams.
+        changed = False
+        if hasattr(sys.stderr, '_original_stream'):
+            changed = True
+            sys.stderr = getattr(sys.stderr, '_original_stream')
+        if hasattr(sys.stdout, '_original_stream'):
+            changed = True
+            sys.stdout = getattr(sys.stdout, '_original_stream')
+
+        return changed
+
+    @staticmethod
+    def is_enabled():
+        """Return True if either stderr or stdout has colors enabled."""
+        return hasattr(sys.stderr, '_original_stream') or hasattr(sys.stdout, '_original_stream')
+
+    @classmethod
+    def enable(cls, auto_colors=False, reset_atexit=False):
+        """Enable color text with print() or sys.stdout.write() (stderr too).
+
+        :param bool auto_colors: Automatically selects dark or light colors based on current terminal's background
+            color. Only works with {autored} and related tags.
+        :param bool reset_atexit: Resets original colors upon Python exit (in case you forget to reset it yourself with
+            a closing tag). Does nothing on native ANSI consoles.
+
+        :return: If streams replaced successfully.
+        :rtype: bool
+        """
+        if not IS_WINDOWS:
+            return False  # Windows only.
+
+        # Get values from init_kernel32().
+        kernel32, stderr, stdout = init_kernel32()
+        if stderr == INVALID_HANDLE_VALUE and stdout == INVALID_HANDLE_VALUE:
+            return False  # No valid handles, nothing to do.
+
+        # Get console info.
+        bg_color, native_ansi = bg_color_native_ansi(kernel32, stderr, stdout)
+
+        # Set auto colors:
+        if auto_colors:
+            if bg_color in (112, 96, 240, 176, 224, 208, 160):
+                ANSICodeMapping.set_light_background()
+            else:
+                ANSICodeMapping.set_dark_background()
+
+        # Don't replace streams if ANSI codes are natively supported.
+        if native_ansi:
+            return False
+
+        # Reset on exit if requested.
+        if reset_atexit:
+            atexit.register(cls.disable)
+
+        # Overwrite stream references.
+        if stderr != INVALID_HANDLE_VALUE:
+            sys.stderr.flush()
+            sys.stderr = WindowsStream(kernel32, stderr, sys.stderr)
+        if stdout != INVALID_HANDLE_VALUE:
+            sys.stdout.flush()
+            sys.stdout = WindowsStream(kernel32, stdout, sys.stdout)
+
+        return True
+
+    def __init__(self, auto_colors=False):
+        """Constructor."""
+        self.auto_colors = auto_colors
+
+    def __enter__(self):
+        """Context manager, enables colors on Windows."""
+        self.enable(auto_colors=self.auto_colors)
+
+    def __exit__(self, *_):
+        """Context manager, disabled colors on Windows."""
+        self.disable()
@@ -48,8 +48,9 @@ License: BSD, see source code or documentation
 # 2015-11-01 v0.01 PL: - first version
 # 2016-01-01 v0.02 PL: - added styles, color support
 # 2016-04-19 v0.03 PL: - enable colorclass on Windows, fixed issue #39
+# 2016-05-25 v0.04 PL: - updated for colorclass 2.2.0 (now a package)
  
-__version__ = '0.03'
+__version__ = '0.04'
  
 #------------------------------------------------------------------------------
 # TODO:
@@ -64,7 +65,7 @@ __version__ = &#39;0.03&#39;
 import textwrap
 import sys, os
  
-from thirdparty.colorclass import colorclass
+from thirdparty import colorclass
  
 # On Windows, colorclass needs to be enabled:
 if os.name == 'nt':