Peter M. Groen / oletools

Browse Code »

Commit 1577d688ac355fcf2c62214c8f104835376e96b9

Authored by Philippe Lagadec 2016-02-07 16:18:48 +0100

1 parent c5566974

added colorclass into thirdparty folder

Inline Side-by-side

Showing 3 changed files with 850 additions and 0 deletions

oletools/thirdparty/colorclass/LICENSE.txt 0 → 100644

View file @1577d68

	1	+The MIT License (MIT)
	2	+
	3	+Copyright (c) 2014 Robpol86
	4	+
	5	+Permission is hereby granted, free of charge, to any person obtaining a copy
	6	+of this software and associated documentation files (the "Software"), to deal
	7	+in the Software without restriction, including without limitation the rights
	8	+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	9	+copies of the Software, and to permit persons to whom the Software is
	10	+furnished to do so, subject to the following conditions:
	11	+
	12	+The above copyright notice and this permission notice shall be included in all
	13	+copies or substantial portions of the Software.
	14	+
	15	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	21	+SOFTWARE.
...	...

oletools/thirdparty/colorclass/__init__.py 0 → 100644

View file @1577d68

oletools/thirdparty/colorclass/colorclass.py 0 → 100644

View file @1577d68

	1	+"""Colorful worry-free console applications for Linux, Mac OS X, and Windows.
	2	+
	3	+Supported natively on Linux and Mac OSX (Just Works), and on Windows it works the same if Windows.enable() is called.
	4	+
	5	+Gives you expected and sane results from methods like len() and .capitalize().
	6	+
	7	+https://github.com/Robpol86/colorclass
	8	+https://pypi.python.org/pypi/colorclass
	9	+"""
	10	+
	11	+import atexit
	12	+from collections import Mapping
	13	+import ctypes
	14	+import os
	15	+import re
	16	+import sys
	17	+
	18	+if os.name == 'nt':
	19	+ import ctypes.wintypes
	20	+
	21	+__author__ = '@Robpol86'
	22	+__license__ = 'MIT'
	23	+__version__ = '1.2.0'
	24	+_BASE_CODES = {
	25	+ '/all': 0, 'b': 1, 'f': 2, 'i': 3, 'u': 4, 'flash': 5, 'outline': 6, 'negative': 7, 'invis': 8, 'strike': 9,
	26	+ '/b': 22, '/f': 22, '/i': 23, '/u': 24, '/flash': 25, '/outline': 26, '/negative': 27, '/invis': 28,
	27	+ '/strike': 29, '/fg': 39, '/bg': 49,
	28	+
	29	+ 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37,
	30	+
	31	+ 'bgblack': 40, 'bgred': 41, 'bggreen': 42, 'bgyellow': 43, 'bgblue': 44, 'bgmagenta': 45, 'bgcyan': 46,
	32	+ 'bgwhite': 47,
	33	+
	34	+ 'hiblack': 90, 'hired': 91, 'higreen': 92, 'hiyellow': 93, 'hiblue': 94, 'himagenta': 95, 'hicyan': 96,
	35	+ 'hiwhite': 97,
	36	+
	37	+ 'hibgblack': 100, 'hibgred': 101, 'hibggreen': 102, 'hibgyellow': 103, 'hibgblue': 104, 'hibgmagenta': 105,
	38	+ 'hibgcyan': 106, 'hibgwhite': 107,
	39	+
	40	+ 'autored': None, 'autoblack': None, 'automagenta': None, 'autowhite': None, 'autoblue': None, 'autoyellow': None,
	41	+ 'autogreen': None, 'autocyan': None,
	42	+
	43	+ 'autobgred': None, 'autobgblack': None, 'autobgmagenta': None, 'autobgwhite': None, 'autobgblue': None,
	44	+ 'autobgyellow': None, 'autobggreen': None, 'autobgcyan': None,
	45	+
	46	+ '/black': 39, '/red': 39, '/green': 39, '/yellow': 39, '/blue': 39, '/magenta': 39, '/cyan': 39, '/white': 39,
	47	+ '/hiblack': 39, '/hired': 39, '/higreen': 39, '/hiyellow': 39, '/hiblue': 39, '/himagenta': 39, '/hicyan': 39,
	48	+ '/hiwhite': 39,
	49	+
	50	+ '/bgblack': 49, '/bgred': 49, '/bggreen': 49, '/bgyellow': 49, '/bgblue': 49, '/bgmagenta': 49, '/bgcyan': 49,
	51	+ '/bgwhite': 49, '/hibgblack': 49, '/hibgred': 49, '/hibggreen': 49, '/hibgyellow': 49, '/hibgblue': 49,
	52	+ '/hibgmagenta': 49, '/hibgcyan': 49, '/hibgwhite': 49,
	53	+
	54	+ '/autored': 39, '/autoblack': 39, '/automagenta': 39, '/autowhite': 39, '/autoblue': 39, '/autoyellow': 39,
	55	+ '/autogreen': 39, '/autocyan': 39,
	56	+
	57	+ '/autobgred': 49, '/autobgblack': 49, '/autobgmagenta': 49, '/autobgwhite': 49, '/autobgblue': 49,
	58	+ '/autobgyellow': 49, '/autobggreen': 49, '/autobgcyan': 49,
	59	+}
	60	+_WINDOWS_CODES = {
	61	+ '/all': -33, '/fg': -39, '/bg': -49,
	62	+
	63	+ 'black': 0, 'red': 4, 'green': 2, 'yellow': 6, 'blue': 1, 'magenta': 5, 'cyan': 3, 'white': 7,
	64	+
	65	+ 'bgblack': -8, 'bgred': 64, 'bggreen': 32, 'bgyellow': 96, 'bgblue': 16, 'bgmagenta': 80, 'bgcyan': 48,
	66	+ 'bgwhite': 112,
	67	+
	68	+ 'hiblack': 8, 'hired': 12, 'higreen': 10, 'hiyellow': 14, 'hiblue': 9, 'himagenta': 13, 'hicyan': 11, 'hiwhite': 15,
	69	+
	70	+ 'hibgblack': 128, 'hibgred': 192, 'hibggreen': 160, 'hibgyellow': 224, 'hibgblue': 144, 'hibgmagenta': 208,
	71	+ 'hibgcyan': 176, 'hibgwhite': 240,
	72	+
	73	+ '/black': -39, '/red': -39, '/green': -39, '/yellow': -39, '/blue': -39, '/magenta': -39, '/cyan': -39,
	74	+ '/white': -39, '/hiblack': -39, '/hired': -39, '/higreen': -39, '/hiyellow': -39, '/hiblue': -39, '/himagenta': -39,
	75	+ '/hicyan': -39, '/hiwhite': -39,
	76	+
	77	+ '/bgblack': -49, '/bgred': -49, '/bggreen': -49, '/bgyellow': -49, '/bgblue': -49, '/bgmagenta': -49,
	78	+ '/bgcyan': -49, '/bgwhite': -49, '/hibgblack': -49, '/hibgred': -49, '/hibggreen': -49, '/hibgyellow': -49,
	79	+ '/hibgblue': -49, '/hibgmagenta': -49, '/hibgcyan': -49, '/hibgwhite': -49,
	80	+}
	81	+_RE_GROUP_SEARCH = re.compile(r'(?:\033\[[\d;]+m)+')
	82	+_RE_NUMBER_SEARCH = re.compile(r'\033\[([\d;]+)m')
	83	+_RE_SPLIT = re.compile(r'(\033\[[\d;]+m)')
	84	+PARENT_CLASS = type(u'')
	85	+
	86	+
	87	+class _AutoCodes(Mapping):
	88	+ """Read-only subclass of dict, resolves closing tags (based on colorclass.CODES) and automatic colors."""
	89	+ DISABLE_COLORS = False
	90	+ LIGHT_BACKGROUND = False
	91	+
	92	+ def __init__(self):
	93	+ self.__dict = _BASE_CODES.copy()
	94	+
	95	+ def __getitem__(self, item):
	96	+ if item == 'autoblack':
	97	+ answer = self.autoblack
	98	+ elif item == 'autored':
	99	+ answer = self.autored
	100	+ elif item == 'autogreen':
	101	+ answer = self.autogreen
	102	+ elif item == 'autoyellow':
	103	+ answer = self.autoyellow
	104	+ elif item == 'autoblue':
	105	+ answer = self.autoblue
	106	+ elif item == 'automagenta':
	107	+ answer = self.automagenta
	108	+ elif item == 'autocyan':
	109	+ answer = self.autocyan
	110	+ elif item == 'autowhite':
	111	+ answer = self.autowhite
	112	+ elif item == 'autobgblack':
	113	+ answer = self.autobgblack
	114	+ elif item == 'autobgred':
	115	+ answer = self.autobgred
	116	+ elif item == 'autobggreen':
	117	+ answer = self.autobggreen
	118	+ elif item == 'autobgyellow':
	119	+ answer = self.autobgyellow
	120	+ elif item == 'autobgblue':
	121	+ answer = self.autobgblue
	122	+ elif item == 'autobgmagenta':
	123	+ answer = self.autobgmagenta
	124	+ elif item == 'autobgcyan':
	125	+ answer = self.autobgcyan
	126	+ elif item == 'autobgwhite':
	127	+ answer = self.autobgwhite
	128	+ else:
	129	+ answer = self.__dict[item]
	130	+ return answer
	131	+
	132	+ def __iter__(self):
	133	+ return iter(self.__dict)
	134	+
	135	+ def __len__(self):
	136	+ return len(self.__dict)
	137	+
	138	+ @property
	139	+ def autoblack(self):
	140	+ """Returns automatic black foreground color depending on background color."""
	141	+ return self.__dict['black' if _AutoCodes.LIGHT_BACKGROUND else 'hiblack']
	142	+
	143	+ @property
	144	+ def autored(self):
	145	+ """Returns automatic red foreground color depending on background color."""
	146	+ return self.__dict['red' if _AutoCodes.LIGHT_BACKGROUND else 'hired']
	147	+
	148	+ @property
	149	+ def autogreen(self):
	150	+ """Returns automatic green foreground color depending on background color."""
	151	+ return self.__dict['green' if _AutoCodes.LIGHT_BACKGROUND else 'higreen']
	152	+
	153	+ @property
	154	+ def autoyellow(self):
	155	+ """Returns automatic yellow foreground color depending on background color."""
	156	+ return self.__dict['yellow' if _AutoCodes.LIGHT_BACKGROUND else 'hiyellow']
	157	+
	158	+ @property
	159	+ def autoblue(self):
	160	+ """Returns automatic blue foreground color depending on background color."""
	161	+ return self.__dict['blue' if _AutoCodes.LIGHT_BACKGROUND else 'hiblue']
	162	+
	163	+ @property
	164	+ def automagenta(self):
	165	+ """Returns automatic magenta foreground color depending on background color."""
	166	+ return self.__dict['magenta' if _AutoCodes.LIGHT_BACKGROUND else 'himagenta']
	167	+
	168	+ @property
	169	+ def autocyan(self):
	170	+ """Returns automatic cyan foreground color depending on background color."""
	171	+ return self.__dict['cyan' if _AutoCodes.LIGHT_BACKGROUND else 'hicyan']
	172	+
	173	+ @property
	174	+ def autowhite(self):
	175	+ """Returns automatic white foreground color depending on background color."""
	176	+ return self.__dict['white' if _AutoCodes.LIGHT_BACKGROUND else 'hiwhite']
	177	+
	178	+ @property
	179	+ def autobgblack(self):
	180	+ """Returns automatic black background color depending on background color."""
	181	+ return self.__dict['bgblack' if _AutoCodes.LIGHT_BACKGROUND else 'hibgblack']
	182	+
	183	+ @property
	184	+ def autobgred(self):
	185	+ """Returns automatic red background color depending on background color."""
	186	+ return self.__dict['bgred' if _AutoCodes.LIGHT_BACKGROUND else 'hibgred']
	187	+
	188	+ @property
	189	+ def autobggreen(self):
	190	+ """Returns automatic green background color depending on background color."""
	191	+ return self.__dict['bggreen' if _AutoCodes.LIGHT_BACKGROUND else 'hibggreen']
	192	+
	193	+ @property
	194	+ def autobgyellow(self):
	195	+ """Returns automatic yellow background color depending on background color."""
	196	+ return self.__dict['bgyellow' if _AutoCodes.LIGHT_BACKGROUND else 'hibgyellow']
	197	+
	198	+ @property
	199	+ def autobgblue(self):
	200	+ """Returns automatic blue background color depending on background color."""
	201	+ return self.__dict['bgblue' if _AutoCodes.LIGHT_BACKGROUND else 'hibgblue']
	202	+
	203	+ @property
	204	+ def autobgmagenta(self):
	205	+ """Returns automatic magenta background color depending on background color."""
	206	+ return self.__dict['bgmagenta' if _AutoCodes.LIGHT_BACKGROUND else 'hibgmagenta']
	207	+
	208	+ @property
	209	+ def autobgcyan(self):
	210	+ """Returns automatic cyan background color depending on background color."""
	211	+ return self.__dict['bgcyan' if _AutoCodes.LIGHT_BACKGROUND else 'hibgcyan']
	212	+
	213	+ @property
	214	+ def autobgwhite(self):
	215	+ """Returns automatic white background color depending on background color."""
	216	+ return self.__dict['bgwhite' if _AutoCodes.LIGHT_BACKGROUND else 'hibgwhite']
	217	+
	218	+
	219	+def _pad_input(incoming):
	220	+ """Avoid IndexError and KeyError by ignoring un-related fields.
	221	+
	222	+ Example: '{0}{autored}' becomes '{{0}}{autored}'.
	223	+
	224	+ Positional arguments:
	225	+ incoming -- the input unicode value.
	226	+
	227	+ Returns:
	228	+ Padded unicode value.
	229	+ """
	230	+ incoming_expanded = incoming.replace('{', '{{').replace('}', '}}')
	231	+ for key in _BASE_CODES:
	232	+ before, after = '{{%s}}' % key, '{%s}' % key
	233	+ if before in incoming_expanded:
	234	+ incoming_expanded = incoming_expanded.replace(before, after)
	235	+ return incoming_expanded
	236	+
	237	+
	238	+def _parse_input(incoming):
	239	+ """Performs the actual conversion of tags to ANSI escaped codes.
	240	+
	241	+ Provides a version of the input without any colors for len() and other methods.
	242	+
	243	+ Positional arguments:
	244	+ incoming -- the input unicode value.
	245	+
	246	+ Returns:
	247	+ 2-item tuple. First item is the parsed output. Second item is a version of the input without any colors.
	248	+ """
	249	+ codes = dict((k, v) for k, v in _AutoCodes().items() if '{%s}' % k in incoming)
	250	+ color_codes = dict((k, '' if _AutoCodes.DISABLE_COLORS else '\033[{0}m'.format(v)) for k, v in codes.items())
	251	+ incoming_padded = _pad_input(incoming)
	252	+ output_colors = incoming_padded.format(**color_codes)
	253	+
	254	+ # Simplify: '{b}{red}' -> '\033[1m\033[31m' -> '\033[1;31m'
	255	+ groups = sorted(set(_RE_GROUP_SEARCH.findall(output_colors)), key=len, reverse=True) # Get codes, grouped adjacent.
	256	+ groups_simplified = [[x for n in _RE_NUMBER_SEARCH.findall(i) for x in n.split(';')] for i in groups]
	257	+ groups_compiled = ['\033[{0}m'.format(';'.join(g)) for g in groups_simplified] # Final codes.
	258	+ assert len(groups_compiled) == len(groups) # For testing.
	259	+ output_colors_simplified = output_colors
	260	+ for i in range(len(groups)):
	261	+ output_colors_simplified = output_colors_simplified.replace(groups[i], groups_compiled[i])
	262	+ output_no_colors = _RE_SPLIT.sub('', output_colors_simplified)
	263	+
	264	+ # Strip any remaining color codes.
	265	+ if _AutoCodes.DISABLE_COLORS:
	266	+ output_colors_simplified = _RE_NUMBER_SEARCH.sub('', output_colors_simplified)
	267	+
	268	+ return output_colors_simplified, output_no_colors
	269	+
	270	+
	271	+def disable_all_colors():
	272	+ """Disable all colors. Strips any color tags or codes."""
	273	+ _AutoCodes.DISABLE_COLORS = True
	274	+
	275	+
	276	+def set_light_background():
	277	+ """Chooses dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
	278	+ _AutoCodes.DISABLE_COLORS = False
	279	+ _AutoCodes.LIGHT_BACKGROUND = True
	280	+
	281	+
	282	+def set_dark_background():
	283	+ """Chooses dark colors for all 'auto'-prefixed codes for readability on light backgrounds."""
	284	+ _AutoCodes.DISABLE_COLORS = False
	285	+ _AutoCodes.LIGHT_BACKGROUND = False
	286	+
	287	+
	288	+def list_tags():
	289	+ """Lists the available tags.
	290	+
	291	+ Returns:
	292	+ Tuple of tuples. Child tuples are four items: ('opening tag', 'closing tag', main ansi value, closing ansi value).
	293	+ """
	294	+ codes = _AutoCodes()
	295	+ grouped = set([(k, '/{0}'.format(k), codes[k], codes['/{0}'.format(k)]) for k in codes if not k.startswith('/')])
	296	+
	297	+ # Add half-tags like /all.
	298	+ found = [c for r in grouped for c in r[:2]]
	299	+ missing = set([('', r[0], None, r[1]) if r[0].startswith('/') else (r[0], '', r[1], None)
	300	+ for r in _AutoCodes().items() if r[0] not in found])
	301	+ grouped \|= missing
	302	+
	303	+ # Sort.
	304	+ payload = sorted([i for i in grouped if i[2] is None], key=lambda x: x[3]) # /all /fg /bg
	305	+ grouped -= set(payload)
	306	+ payload.extend(sorted([i for i in grouped if i[2] < 10], key=lambda x: x[2])) # b i u flash
	307	+ grouped -= set(payload)
	308	+ payload.extend(sorted([i for i in grouped if i[0].startswith('auto')], key=lambda x: x[2])) # auto colors
	309	+ grouped -= set(payload)
	310	+ payload.extend(sorted([i for i in grouped if not i[0].startswith('hi')], key=lambda x: x[2])) # dark colors
	311	+ grouped -= set(payload)
	312	+ payload.extend(sorted(grouped, key=lambda x: x[2])) # light colors
	313	+ return tuple(payload)
	314	+
	315	+
	316	+class ColorBytes(bytes):
	317	+ """Str (bytes in Python3) subclass, .decode() overridden to return Color() instance."""
	318	+
	319	+ def decode(args, *kwargs):
	320	+ return Color(super(ColorBytes, args[0]).decode(args[1:], *kwargs))
	321	+
	322	+
	323	+class Color(PARENT_CLASS):
	324	+ """Unicode (str in Python3) subclass with ANSI terminal text color support.
	325	+
	326	+ Example syntax: Color('{red}Sample Text{/red}')
	327	+
	328	+ For a list of codes, call: colorclass.list_tags()
	329	+ """
	330	+
	331	+ @classmethod
	332	+ def red(cls, s, auto=False):
	333	+ return cls.colorize('red', s, auto=auto)
	334	+
	335	+ @classmethod
	336	+ def bgred(cls, s, auto=False):
	337	+ return cls.colorize('bgred', s, auto=auto)
	338	+
	339	+ @classmethod
	340	+ def green(cls, s, auto=False):
	341	+ return cls.colorize('green', s, auto=auto)
	342	+
	343	+ @classmethod
	344	+ def bggreen(cls, s, auto=False):
	345	+ return cls.colorize('bggreen', s, auto=auto)
	346	+
	347	+ @classmethod
	348	+ def blue(cls, s, auto=False):
	349	+ return cls.colorize('blue', s, auto=auto)
	350	+
	351	+ @classmethod
	352	+ def bgblue(cls, s, auto=False):
	353	+ return cls.colorize('bgblue', s, auto=auto)
	354	+
	355	+ @classmethod
	356	+ def yellow(cls, s, auto=False):
	357	+ return cls.colorize('yellow', s, auto=auto)
	358	+
	359	+ @classmethod
	360	+ def bgyellow(cls, s, auto=False):
	361	+ return cls.colorize('bgyellow', s, auto=auto)
	362	+
	363	+ @classmethod
	364	+ def cyan(cls, s, auto=False):
	365	+ return cls.colorize('cyan', s, auto=auto)
	366	+
	367	+ @classmethod
	368	+ def bgcyan(cls, s, auto=False):
	369	+ return cls.colorize('bgcyan', s, auto=auto)
	370	+
	371	+ @classmethod
	372	+ def magenta(cls, s, auto=False):
	373	+ return cls.colorize('magenta', s, auto=auto)
	374	+
	375	+ @classmethod
	376	+ def bgmagenta(cls, s, auto=False):
	377	+ return cls.colorize('bgmagenta', s, auto=auto)
	378	+
	379	+ @classmethod
	380	+ def colorize(cls, color, s, auto=False):
	381	+ tag = '{0}{1}'.format('auto' if auto else '', color)
	382	+ return cls('{%s}%s{/%s}' % (tag, s, tag))
	383	+
	384	+ def __new__(cls, args, *kwargs):
	385	+ parent_class = cls.__bases__[0]
	386	+ value_markup = args[0] if args else parent_class()
	387	+ value_colors, value_no_colors = _parse_input(value_markup)
	388	+ if args:
	389	+ args = [value_colors] + list(args[1:])
	390	+
	391	+ obj = parent_class.__new__(cls, args, *kwargs)
	392	+ obj.value_colors, obj.value_no_colors = value_colors, value_no_colors
	393	+ obj.has_colors = bool(_RE_NUMBER_SEARCH.match(value_colors))
	394	+ return obj
	395	+
	396	+ def __len__(self):
	397	+ return self.value_no_colors.__len__()
	398	+
	399	+ def capitalize(self):
	400	+ split = _RE_SPLIT.split(self.value_colors)
	401	+ for i in range(len(split)):
	402	+ if _RE_SPLIT.match(split[i]):
	403	+ continue
	404	+ split[i] = PARENT_CLASS(split[i]).capitalize()
	405	+ return Color().join(split)
	406	+
	407	+ def center(self, width, fillchar=None):
	408	+ if fillchar is not None:
	409	+ result = PARENT_CLASS(self.value_no_colors).center(width, fillchar)
	410	+ else:
	411	+ result = PARENT_CLASS(self.value_no_colors).center(width)
	412	+ return result.replace(self.value_no_colors, self.value_colors)
	413	+
	414	+ def count(self, args, *kwargs):
	415	+ return PARENT_CLASS(self.value_no_colors).count(args, *kwargs)
	416	+
	417	+ def endswith(self, args, *kwargs):
	418	+ return PARENT_CLASS(self.value_no_colors).endswith(args, *kwargs)
	419	+
	420	+ def encode(args, *kwargs):
	421	+ return ColorBytes(super(Color, args[0]).encode(args[1:], *kwargs))
	422	+
	423	+ def decode(args, *kwargs):
	424	+ return Color(super(Color, args[0]).decode(args[1:], *kwargs))
	425	+
	426	+ def find(self, args, *kwargs):
	427	+ return PARENT_CLASS(self.value_no_colors).find(args, *kwargs)
	428	+
	429	+ def format(args, *kwargs):
	430	+ return Color(super(Color, args[0]).format(args[1:], *kwargs))
	431	+
	432	+ def index(self, args, *kwargs):
	433	+ return PARENT_CLASS(self.value_no_colors).index(args, *kwargs)
	434	+
	435	+ def isalnum(self):
	436	+ return PARENT_CLASS(self.value_no_colors).isalnum()
	437	+
	438	+ def isalpha(self):
	439	+ return PARENT_CLASS(self.value_no_colors).isalpha()
	440	+
	441	+ def isdecimal(self):
	442	+ return PARENT_CLASS(self.value_no_colors).isdecimal()
	443	+
	444	+ def isdigit(self):
	445	+ return PARENT_CLASS(self.value_no_colors).isdigit()
	446	+
	447	+ def isnumeric(self):
	448	+ return PARENT_CLASS(self.value_no_colors).isnumeric()
	449	+
	450	+ def isspace(self):
	451	+ return PARENT_CLASS(self.value_no_colors).isspace()
	452	+
	453	+ def istitle(self):
	454	+ return PARENT_CLASS(self.value_no_colors).istitle()
	455	+
	456	+ def isupper(self):
	457	+ return PARENT_CLASS(self.value_no_colors).isupper()
	458	+
	459	+ def ljust(self, width, fillchar=None):
	460	+ if fillchar is not None:
	461	+ result = PARENT_CLASS(self.value_no_colors).ljust(width, fillchar)
	462	+ else:
	463	+ result = PARENT_CLASS(self.value_no_colors).ljust(width)
	464	+ return result.replace(self.value_no_colors, self.value_colors)
	465	+
	466	+ def rfind(self, args, *kwargs):
	467	+ return PARENT_CLASS(self.value_no_colors).rfind(args, *kwargs)
	468	+
	469	+ def rindex(self, args, *kwargs):
	470	+ return PARENT_CLASS(self.value_no_colors).rindex(args, *kwargs)
	471	+
	472	+ def rjust(self, width, fillchar=None):
	473	+ if fillchar is not None:
	474	+ result = PARENT_CLASS(self.value_no_colors).rjust(width, fillchar)
	475	+ else:
	476	+ result = PARENT_CLASS(self.value_no_colors).rjust(width)
	477	+ return result.replace(self.value_no_colors, self.value_colors)
	478	+
	479	+ def splitlines(self):
	480	+ return [Color(l) for l in PARENT_CLASS(self.value_colors).splitlines()]
	481	+
	482	+ def startswith(self, args, *kwargs):
	483	+ return PARENT_CLASS(self.value_no_colors).startswith(args, *kwargs)
	484	+
	485	+ def swapcase(self):
	486	+ split = _RE_SPLIT.split(self.value_colors)
	487	+ for i in range(len(split)):
	488	+ if _RE_SPLIT.match(split[i]):
	489	+ continue
	490	+ split[i] = PARENT_CLASS(split[i]).swapcase()
	491	+ return Color().join(split)
	492	+
	493	+ def title(self):
	494	+ split = _RE_SPLIT.split(self.value_colors)
	495	+ for i in range(len(split)):
	496	+ if _RE_SPLIT.match(split[i]):
	497	+ continue
	498	+ split[i] = PARENT_CLASS(split[i]).title()
	499	+ return Color().join(split)
	500	+
	501	+ def translate(self, table):
	502	+ split = _RE_SPLIT.split(self.value_colors)
	503	+ for i in range(len(split)):
	504	+ if _RE_SPLIT.match(split[i]):
	505	+ continue
	506	+ split[i] = PARENT_CLASS(split[i]).translate(table)
	507	+ return Color().join(split)
	508	+
	509	+ def upper(self):
	510	+ split = _RE_SPLIT.split(self.value_colors)
	511	+ for i in range(len(split)):
	512	+ if _RE_SPLIT.match(split[i]):
	513	+ continue
	514	+ split[i] = PARENT_CLASS(split[i]).upper()
	515	+ return Color().join(split)
	516	+
	517	+ def zfill(self, width):
	518	+ if not self.value_no_colors:
	519	+ return PARENT_CLASS().zfill(width)
	520	+
	521	+ split = _RE_SPLIT.split(self.value_colors)
	522	+ filled = PARENT_CLASS(self.value_no_colors).zfill(width)
	523	+ if len(split) == 1:
	524	+ return filled
	525	+
	526	+ padding = filled.replace(self.value_no_colors, '')
	527	+ if not split[0]:
	528	+ split[2] = padding + split[2]
	529	+ else:
	530	+ split[0] = padding + split[0]
	531	+
	532	+ return Color().join(split)
	533	+
	534	+
	535	+class Windows(object):
	536	+ """Enable and disable Windows support for ANSI color character codes.
	537	+
	538	+ Call static method Windows.enable() to enable color support for the remainder of the process' lifetime.
	539	+
	540	+ This class is also a context manager. You can do this:
	541	+ with Windows():
	542	+ print(Color('{autored}Test{/autored}'))
	543	+
	544	+ Or this:
	545	+ with Windows(auto_colors=True):
	546	+ print(Color('{autored}Test{/autored}'))
	547	+ """
	548	+
	549	+ @staticmethod
	550	+ def disable():
	551	+ """Restore sys.stderr and sys.stdout to their original objects. Resets colors to their original values."""
	552	+ if os.name != 'nt' or not Windows.is_enabled():
	553	+ return False
	554	+
	555	+ getattr(sys.stderr, '_reset_colors', lambda: False)()
	556	+ getattr(sys.stdout, '_reset_colors', lambda: False)()
	557	+
	558	+ if hasattr(sys.stderr, 'ORIGINAL_STREAM'):
	559	+ sys.stderr = getattr(sys.stderr, 'ORIGINAL_STREAM')
	560	+ if hasattr(sys.stdout, 'ORIGINAL_STREAM'):
	561	+ sys.stdout = getattr(sys.stdout, 'ORIGINAL_STREAM')
	562	+
	563	+ return True
	564	+
	565	+ @staticmethod
	566	+ def is_enabled():
	567	+ """Returns True if either stderr or stdout has colors enabled."""
	568	+ return hasattr(sys.stderr, 'ORIGINAL_STREAM') or hasattr(sys.stdout, 'ORIGINAL_STREAM')
	569	+
	570	+ @staticmethod
	571	+ def enable(auto_colors=False, reset_atexit=False):
	572	+ """Enables color text with print() or sys.stdout.write() (stderr too).
	573	+
	574	+ Keyword arguments:
	575	+ auto_colors -- automatically selects dark or light colors based on current terminal's background color. Only
	576	+ works with {autored} and related tags.
	577	+ reset_atexit -- resets original colors upon Python exit (in case you forget to reset it yourself with a closing
	578	+ tag).
	579	+ """
	580	+ if os.name != 'nt':
	581	+ return False
	582	+
	583	+ # Overwrite stream references.
	584	+ if not hasattr(sys.stderr, 'ORIGINAL_STREAM'):
	585	+ sys.stderr.flush()
	586	+ sys.stderr = _WindowsStreamStdErr()
	587	+ if not hasattr(sys.stdout, 'ORIGINAL_STREAM'):
	588	+ sys.stdout.flush()
	589	+ sys.stdout = _WindowsStreamStdOut()
	590	+ if not hasattr(sys.stderr, 'ORIGINAL_STREAM') and not hasattr(sys.stdout, 'ORIGINAL_STREAM'):
	591	+ return False
	592	+
	593	+ # Automatically select which colors to display.
	594	+ bg_color = getattr(sys.stdout, 'default_bg', getattr(sys.stderr, 'default_bg', None))
	595	+ if auto_colors and bg_color is not None:
	596	+ set_light_background() if bg_color in (112, 96, 240, 176, 224, 208, 160) else set_dark_background()
	597	+
	598	+ # Reset on exit if requested.
	599	+ if reset_atexit:
	600	+ atexit.register(lambda: Windows.disable())
	601	+
	602	+ return True
	603	+
	604	+ def __init__(self, auto_colors=False):
	605	+ self.auto_colors = auto_colors
	606	+
	607	+ def __enter__(self):
	608	+ Windows.enable(auto_colors=self.auto_colors)
	609	+
	610	+ def __exit__(self, *_):
	611	+ Windows.disable()
	612	+
	613	+
	614	+class _WindowsCSBI(object):
	615	+ """Interfaces with Windows CONSOLE_SCREEN_BUFFER_INFO API/DLL calls. Gets info for stderr and stdout.
	616	+
	617	+ References:
	618	+ http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231
	619	+ https://code.google.com/p/colorama/issues/detail?id=47.
	620	+ pytest's py project: py/_io/terminalwriter.py.
	621	+
	622	+ Class variables:
	623	+ CSBI -- ConsoleScreenBufferInfo class/struct (not instance, the class definition itself) defined in _define_csbi().
	624	+ HANDLE_STDERR -- GetStdHandle() return integer for stderr.
	625	+ HANDLE_STDOUT -- GetStdHandle() return integer for stdout.
	626	+ WINDLL -- my own loaded instance of ctypes.WinDLL.
	627	+ """
	628	+
	629	+ CSBI = None
	630	+ HANDLE_STDERR = None
	631	+ HANDLE_STDOUT = None
	632	+ WINDLL = ctypes.LibraryLoader(getattr(ctypes, 'WinDLL', None))
	633	+
	634	+ @staticmethod
	635	+ def _define_csbi():
	636	+ """Defines structs and populates _WindowsCSBI.CSBI."""
	637	+ if _WindowsCSBI.CSBI is not None:
	638	+ return
	639	+
	640	+ class COORD(ctypes.Structure):
	641	+ """Windows COORD structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119"""
	642	+ _fields_ = [('X', ctypes.c_short), ('Y', ctypes.c_short)]
	643	+
	644	+ class SmallRECT(ctypes.Structure):
	645	+ """Windows SMALL_RECT structure. http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311"""
	646	+ _fields_ = [('Left', ctypes.c_short), ('Top', ctypes.c_short), ('Right', ctypes.c_short),
	647	+ ('Bottom', ctypes.c_short)]
	648	+
	649	+ class ConsoleScreenBufferInfo(ctypes.Structure):
	650	+ """Windows CONSOLE_SCREEN_BUFFER_INFO structure.
	651	+ http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093
	652	+ """
	653	+ _fields_ = [
	654	+ ('dwSize', COORD),
	655	+ ('dwCursorPosition', COORD),
	656	+ ('wAttributes', ctypes.wintypes.WORD),
	657	+ ('srWindow', SmallRECT),
	658	+ ('dwMaximumWindowSize', COORD)
	659	+ ]
	660	+
	661	+ _WindowsCSBI.CSBI = ConsoleScreenBufferInfo
	662	+
	663	+ @staticmethod
	664	+ def initialize():
	665	+ """Initializes the WINDLL resource and populated the CSBI class variable."""
	666	+ _WindowsCSBI._define_csbi()
	667	+ _WindowsCSBI.HANDLE_STDERR = _WindowsCSBI.HANDLE_STDERR or _WindowsCSBI.WINDLL.kernel32.GetStdHandle(-12)
	668	+ _WindowsCSBI.HANDLE_STDOUT = _WindowsCSBI.HANDLE_STDOUT or _WindowsCSBI.WINDLL.kernel32.GetStdHandle(-11)
	669	+ if _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.argtypes:
	670	+ return
	671	+
	672	+ _WindowsCSBI.WINDLL.kernel32.GetStdHandle.argtypes = [ctypes.wintypes.DWORD]
	673	+ _WindowsCSBI.WINDLL.kernel32.GetStdHandle.restype = ctypes.wintypes.HANDLE
	674	+ _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.restype = ctypes.wintypes.BOOL
	675	+ _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo.argtypes = [
	676	+ ctypes.wintypes.HANDLE, ctypes.POINTER(_WindowsCSBI.CSBI)
	677	+ ]
	678	+
	679	+ @staticmethod
	680	+ def get_info(handle):
	681	+ """Get information about this current console window (for Microsoft Windows only).
	682	+
	683	+ Raises IOError if attempt to get information fails (if there is no console window).
	684	+
	685	+ Don't forget to call _WindowsCSBI.initialize() once in your application before calling this method.
	686	+
	687	+ Positional arguments:
	688	+ handle -- either _WindowsCSBI.HANDLE_STDERR or _WindowsCSBI.HANDLE_STDOUT.
	689	+
	690	+ Returns:
	691	+ Dictionary with different integer values. Keys are:
	692	+ buffer_width -- width of the buffer (Screen Buffer Size in cmd.exe layout tab).
	693	+ buffer_height -- height of the buffer (Screen Buffer Size in cmd.exe layout tab).
	694	+ terminal_width -- width of the terminal window.
	695	+ terminal_height -- height of the terminal window.
	696	+ bg_color -- current background color (http://msdn.microsoft.com/en-us/library/windows/desktop/ms682088).
	697	+ fg_color -- current text color code.
	698	+ """
	699	+ # Query Win32 API.
	700	+ csbi = _WindowsCSBI.CSBI()
	701	+ try:
	702	+ if not _WindowsCSBI.WINDLL.kernel32.GetConsoleScreenBufferInfo(handle, ctypes.byref(csbi)):
	703	+ raise IOError('Unable to get console screen buffer info from win32 API.')
	704	+ except ctypes.ArgumentError:
	705	+ raise IOError('Unable to get console screen buffer info from win32 API.')
	706	+
	707	+ # Parse data.
	708	+ result = dict(
	709	+ buffer_width=int(csbi.dwSize.X - 1),
	710	+ buffer_height=int(csbi.dwSize.Y),
	711	+ terminal_width=int(csbi.srWindow.Right - csbi.srWindow.Left),
	712	+ terminal_height=int(csbi.srWindow.Bottom - csbi.srWindow.Top),
	713	+ bg_color=int(csbi.wAttributes & 240),
	714	+ fg_color=int(csbi.wAttributes % 16),
	715	+ )
	716	+ return result
	717	+
	718	+
	719	+class _WindowsStreamStdOut(object):
	720	+ """Replacement stream which overrides sys.stdout. When writing or printing, ANSI codes are converted.
	721	+
	722	+ ANSI (Linux/Unix) color codes are converted into win32 system calls, changing the next character's color before
	723	+ printing it. Resources referenced:
	724	+ https://github.com/tartley/colorama
	725	+ http://www.cplusplus.com/articles/2ywTURfi/
	726	+ http://thomasfischer.biz/python-and-windows-terminal-colors/
	727	+ http://stackoverflow.com/questions/17125440/c-win32-console-color
	728	+ http://www.tysos.org/svn/trunk/mono/corlib/System/WindowsConsoleDriver.cs
	729	+ http://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python
	730	+ http://msdn.microsoft.com/en-us/library/windows/desktop/ms682088#_win32_character_attributes
	731	+
	732	+ Class variables:
	733	+ ALL_BG_CODES -- list of background Windows codes. Used to determine if requested color is foreground or background.
	734	+ COMPILED_CODES -- 'translation' dictionary. Keys are ANSI codes (values of _BASE_CODES), values are Windows codes.
	735	+ ORIGINAL_STREAM -- the original stream to write non-code text to.
	736	+ WIN32_STREAM_HANDLE -- handle to the Windows stdout device. Used by other Windows functions.
	737	+
	738	+ Instance variables:
	739	+ default_fg -- the foreground Windows color code at the time of instantiation.
	740	+ default_bg -- the background Windows color code at the time of instantiation.
	741	+ """
	742	+
	743	+ ALL_BG_CODES = [v for k, v in _WINDOWS_CODES.items() if k.startswith('bg') or k.startswith('hibg')]
	744	+ COMPILED_CODES = dict((v, _WINDOWS_CODES[k]) for k, v in _BASE_CODES.items() if k in _WINDOWS_CODES)
	745	+ ORIGINAL_STREAM = sys.stdout
	746	+ WIN32_STREAM_HANDLE = _WindowsCSBI.HANDLE_STDOUT
	747	+
	748	+ def __init__(self):
	749	+ _WindowsCSBI.initialize()
	750	+ self.default_fg, self.default_bg = self._get_colors()
	751	+ for attr in dir(self.ORIGINAL_STREAM):
	752	+ if hasattr(self, attr):
	753	+ continue
	754	+ setattr(self, attr, getattr(self.ORIGINAL_STREAM, attr))
	755	+
	756	+ def __getattr__(self, item):
	757	+ """If an attribute/function/etc is not defined in this function, retrieve the one from the original stream.
	758	+
	759	+ Fixes ipython arrow key presses.
	760	+ """
	761	+ return getattr(self.ORIGINAL_STREAM, item)
	762	+
	763	+ def _get_colors(self):
	764	+ """Returns a tuple of two integers representing current colors: (foreground, background)."""
	765	+ try:
	766	+ csbi = _WindowsCSBI.get_info(self.WIN32_STREAM_HANDLE)
	767	+ return csbi['fg_color'], csbi['bg_color']
	768	+ except IOError:
	769	+ return 7, 0
	770	+
	771	+ def _reset_colors(self):
	772	+ """Sets the foreground and background colors to their original values (when class was instantiated)."""
	773	+ self._set_color(-33)
	774	+
	775	+ def _set_color(self, color_code):
	776	+ """Changes the foreground and background colors for subsequently printed characters.
	777	+
	778	+ Since setting a color requires including both foreground and background codes (merged), setting just the
	779	+ foreground color resets the background color to black, and vice versa.
	780	+
	781	+ This function first gets the current background and foreground colors, merges in the requested color code, and
	782	+ sets the result.
	783	+
	784	+ However if we need to remove just the foreground color but leave the background color the same (or vice versa)
	785	+ such as when {/red} is used, we must merge the default foreground color with the current background color. This
	786	+ is the reason for those negative values.
	787	+
	788	+ Positional arguments:
	789	+ color_code -- integer color code from _WINDOWS_CODES.
	790	+ """
	791	+ # Get current color code.
	792	+ current_fg, current_bg = self._get_colors()
	793	+
	794	+ # Handle special negative codes. Also determine the final color code.
	795	+ if color_code == -39:
	796	+ final_color_code = self.default_fg \| current_bg # Reset the foreground only.
	797	+ elif color_code == -49:
	798	+ final_color_code = current_fg \| self.default_bg # Reset the background only.
	799	+ elif color_code == -33:
	800	+ final_color_code = self.default_fg \| self.default_bg # Reset both.
	801	+ elif color_code == -8:
	802	+ final_color_code = current_fg # Black background.
	803	+ else:
	804	+ new_is_bg = color_code in self.ALL_BG_CODES
	805	+ final_color_code = color_code \| (current_fg if new_is_bg else current_bg)
	806	+
	807	+ # Set new code.
	808	+ _WindowsCSBI.WINDLL.kernel32.SetConsoleTextAttribute(self.WIN32_STREAM_HANDLE, final_color_code)
	809	+
	810	+ def write(self, p_str):
	811	+ for segment in _RE_SPLIT.split(p_str):
	812	+ if not segment:
	813	+ # Empty string. p_str probably starts with colors so the first item is always ''.
	814	+ continue
	815	+ if not _RE_SPLIT.match(segment):
	816	+ # No color codes, print regular text.
	817	+ self.ORIGINAL_STREAM.write(segment)
	818	+ self.ORIGINAL_STREAM.flush()
	819	+ continue
	820	+ for color_code in (int(c) for c in _RE_NUMBER_SEARCH.findall(segment)[0].split(';')):
	821	+ if color_code in self.COMPILED_CODES:
	822	+ self._set_color(self.COMPILED_CODES[color_code])
	823	+
	824	+
	825	+class _WindowsStreamStdErr(_WindowsStreamStdOut):
	826	+ """Replacement stream which overrides sys.stderr. Subclasses _WindowsStreamStdOut."""
	827	+
	828	+ ORIGINAL_STREAM = sys.stderr
	829	+ WIN32_STREAM_HANDLE = _WindowsCSBI.HANDLE_STDERR
...	...