| """ |
| pygments.formatters.terminal256 |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| Formatter for 256-color terminal output with ANSI sequences. |
| |
| RGB-to-XTERM color conversion routines adapted from xterm256-conv |
| tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2) |
| by Wolfgang Frisch. |
| |
| Formatter version 1. |
| |
| :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS. |
| :license: BSD, see LICENSE for details. |
| """ |
| |
| # TODO: |
| # - Options to map style's bold/underline/italic/border attributes |
| # to some ANSI attrbutes (something like 'italic=underline') |
| # - An option to output "style RGB to xterm RGB/index" conversion table |
| # - An option to indicate that we are running in "reverse background" |
| # xterm. This means that default colors are white-on-black, not |
| # black-on-while, so colors like "white background" need to be converted |
| # to "white background, black foreground", etc... |
| |
| from pip._vendor.pygments.formatter import Formatter |
| from pip._vendor.pygments.console import codes |
| from pip._vendor.pygments.style import ansicolors |
| |
| |
| __all__ = ['Terminal256Formatter', 'TerminalTrueColorFormatter'] |
| |
| |
| class EscapeSequence: |
| def __init__(self, fg=None, bg=None, bold=False, underline=False, italic=False): |
| self.fg = fg |
| self.bg = bg |
| self.bold = bold |
| self.underline = underline |
| self.italic = italic |
| |
| def escape(self, attrs): |
| if len(attrs): |
| return "\x1b[" + ";".join(attrs) + "m" |
| return "" |
| |
| def color_string(self): |
| attrs = [] |
| if self.fg is not None: |
| if self.fg in ansicolors: |
| esc = codes[self.fg.replace('ansi','')] |
| if ';01m' in esc: |
| self.bold = True |
| # extract fg color code. |
| attrs.append(esc[2:4]) |
| else: |
| attrs.extend(("38", "5", "%i" % self.fg)) |
| if self.bg is not None: |
| if self.bg in ansicolors: |
| esc = codes[self.bg.replace('ansi','')] |
| # extract fg color code, add 10 for bg. |
| attrs.append(str(int(esc[2:4])+10)) |
| else: |
| attrs.extend(("48", "5", "%i" % self.bg)) |
| if self.bold: |
| attrs.append("01") |
| if self.underline: |
| attrs.append("04") |
| if self.italic: |
| attrs.append("03") |
| return self.escape(attrs) |
| |
| def true_color_string(self): |
| attrs = [] |
| if self.fg: |
| attrs.extend(("38", "2", str(self.fg[0]), str(self.fg[1]), str(self.fg[2]))) |
| if self.bg: |
| attrs.extend(("48", "2", str(self.bg[0]), str(self.bg[1]), str(self.bg[2]))) |
| if self.bold: |
| attrs.append("01") |
| if self.underline: |
| attrs.append("04") |
| if self.italic: |
| attrs.append("03") |
| return self.escape(attrs) |
| |
| def reset_string(self): |
| attrs = [] |
| if self.fg is not None: |
| attrs.append("39") |
| if self.bg is not None: |
| attrs.append("49") |
| if self.bold or self.underline or self.italic: |
| attrs.append("00") |
| return self.escape(attrs) |
| |
| |
| class Terminal256Formatter(Formatter): |
| """ |
| Format tokens with ANSI color sequences, for output in a 256-color |
| terminal or console. Like in `TerminalFormatter` color sequences |
| are terminated at newlines, so that paging the output works correctly. |
| |
| The formatter takes colors from a style defined by the `style` option |
| and converts them to nearest ANSI 256-color escape sequences. Bold and |
| underline attributes from the style are preserved (and displayed). |
| |
| .. versionadded:: 0.9 |
| |
| .. versionchanged:: 2.2 |
| If the used style defines foreground colors in the form ``#ansi*``, then |
| `Terminal256Formatter` will map these to non extended foreground color. |
| See :ref:`AnsiTerminalStyle` for more information. |
| |
| .. versionchanged:: 2.4 |
| The ANSI color names have been updated with names that are easier to |
| understand and align with colornames of other projects and terminals. |
| See :ref:`this table <new-ansi-color-names>` for more information. |
| |
| |
| Options accepted: |
| |
| `style` |
| The style to use, can be a string or a Style subclass (default: |
| ``'default'``). |
| |
| `linenos` |
| Set to ``True`` to have line numbers on the terminal output as well |
| (default: ``False`` = no line numbers). |
| """ |
| name = 'Terminal256' |
| aliases = ['terminal256', 'console256', '256'] |
| filenames = [] |
| |
| def __init__(self, **options): |
| Formatter.__init__(self, **options) |
| |
| self.xterm_colors = [] |
| self.best_match = {} |
| self.style_string = {} |
| |
| self.usebold = 'nobold' not in options |
| self.useunderline = 'nounderline' not in options |
| self.useitalic = 'noitalic' not in options |
| |
| self._build_color_table() # build an RGB-to-256 color conversion table |
| self._setup_styles() # convert selected style's colors to term. colors |
| |
| self.linenos = options.get('linenos', False) |
| self._lineno = 0 |
| |
| def _build_color_table(self): |
| # colors 0..15: 16 basic colors |
| |
| self.xterm_colors.append((0x00, 0x00, 0x00)) # 0 |
| self.xterm_colors.append((0xcd, 0x00, 0x00)) # 1 |
| self.xterm_colors.append((0x00, 0xcd, 0x00)) # 2 |
| self.xterm_colors.append((0xcd, 0xcd, 0x00)) # 3 |
| self.xterm_colors.append((0x00, 0x00, 0xee)) # 4 |
| self.xterm_colors.append((0xcd, 0x00, 0xcd)) # 5 |
| self.xterm_colors.append((0x00, 0xcd, 0xcd)) # 6 |
| self.xterm_colors.append((0xe5, 0xe5, 0xe5)) # 7 |
| self.xterm_colors.append((0x7f, 0x7f, 0x7f)) # 8 |
| self.xterm_colors.append((0xff, 0x00, 0x00)) # 9 |
| self.xterm_colors.append((0x00, 0xff, 0x00)) # 10 |
| self.xterm_colors.append((0xff, 0xff, 0x00)) # 11 |
| self.xterm_colors.append((0x5c, 0x5c, 0xff)) # 12 |
| self.xterm_colors.append((0xff, 0x00, 0xff)) # 13 |
| self.xterm_colors.append((0x00, 0xff, 0xff)) # 14 |
| self.xterm_colors.append((0xff, 0xff, 0xff)) # 15 |
| |
| # colors 16..232: the 6x6x6 color cube |
| |
| valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff) |
| |
| for i in range(217): |
| r = valuerange[(i // 36) % 6] |
| g = valuerange[(i // 6) % 6] |
| b = valuerange[i % 6] |
| self.xterm_colors.append((r, g, b)) |
| |
| # colors 233..253: grayscale |
| |
| for i in range(1, 22): |
| v = 8 + i * 10 |
| self.xterm_colors.append((v, v, v)) |
| |
| def _closest_color(self, r, g, b): |
| distance = 257*257*3 # "infinity" (>distance from #000000 to #ffffff) |
| match = 0 |
| |
| for i in range(0, 254): |
| values = self.xterm_colors[i] |
| |
| rd = r - values[0] |
| gd = g - values[1] |
| bd = b - values[2] |
| d = rd*rd + gd*gd + bd*bd |
| |
| if d < distance: |
| match = i |
| distance = d |
| return match |
| |
| def _color_index(self, color): |
| index = self.best_match.get(color, None) |
| if color in ansicolors: |
| # strip the `ansi/#ansi` part and look up code |
| index = color |
| self.best_match[color] = index |
| if index is None: |
| try: |
| rgb = int(str(color), 16) |
| except ValueError: |
| rgb = 0 |
| |
| r = (rgb >> 16) & 0xff |
| g = (rgb >> 8) & 0xff |
| b = rgb & 0xff |
| index = self._closest_color(r, g, b) |
| self.best_match[color] = index |
| return index |
| |
| def _setup_styles(self): |
| for ttype, ndef in self.style: |
| escape = EscapeSequence() |
| # get foreground from ansicolor if set |
| if ndef['ansicolor']: |
| escape.fg = self._color_index(ndef['ansicolor']) |
| elif ndef['color']: |
| escape.fg = self._color_index(ndef['color']) |
| if ndef['bgansicolor']: |
| escape.bg = self._color_index(ndef['bgansicolor']) |
| elif ndef['bgcolor']: |
| escape.bg = self._color_index(ndef['bgcolor']) |
| if self.usebold and ndef['bold']: |
| escape.bold = True |
| if self.useunderline and ndef['underline']: |
| escape.underline = True |
| if self.useitalic and ndef['italic']: |
| escape.italic = True |
| self.style_string[str(ttype)] = (escape.color_string(), |
| escape.reset_string()) |
| |
| def _write_lineno(self, outfile): |
| self._lineno += 1 |
| outfile.write("%s%04d: " % (self._lineno != 1 and '\n' or '', self._lineno)) |
| |
| def format(self, tokensource, outfile): |
| return Formatter.format(self, tokensource, outfile) |
| |
| def format_unencoded(self, tokensource, outfile): |
| if self.linenos: |
| self._write_lineno(outfile) |
| |
| for ttype, value in tokensource: |
| not_found = True |
| while ttype and not_found: |
| try: |
| # outfile.write( "<" + str(ttype) + ">" ) |
| on, off = self.style_string[str(ttype)] |
| |
| # Like TerminalFormatter, add "reset colors" escape sequence |
| # on newline. |
| spl = value.split('\n') |
| for line in spl[:-1]: |
| if line: |
| outfile.write(on + line + off) |
| if self.linenos: |
| self._write_lineno(outfile) |
| else: |
| outfile.write('\n') |
| |
| if spl[-1]: |
| outfile.write(on + spl[-1] + off) |
| |
| not_found = False |
| # outfile.write( '#' + str(ttype) + '#' ) |
| |
| except KeyError: |
| # ottype = ttype |
| ttype = ttype.parent |
| # outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' ) |
| |
| if not_found: |
| outfile.write(value) |
| |
| if self.linenos: |
| outfile.write("\n") |
| |
| |
| |
| class TerminalTrueColorFormatter(Terminal256Formatter): |
| r""" |
| Format tokens with ANSI color sequences, for output in a true-color |
| terminal or console. Like in `TerminalFormatter` color sequences |
| are terminated at newlines, so that paging the output works correctly. |
| |
| .. versionadded:: 2.1 |
| |
| Options accepted: |
| |
| `style` |
| The style to use, can be a string or a Style subclass (default: |
| ``'default'``). |
| """ |
| name = 'TerminalTrueColor' |
| aliases = ['terminal16m', 'console16m', '16m'] |
| filenames = [] |
| |
| def _build_color_table(self): |
| pass |
| |
| def _color_tuple(self, color): |
| try: |
| rgb = int(str(color), 16) |
| except ValueError: |
| return None |
| r = (rgb >> 16) & 0xff |
| g = (rgb >> 8) & 0xff |
| b = rgb & 0xff |
| return (r, g, b) |
| |
| def _setup_styles(self): |
| for ttype, ndef in self.style: |
| escape = EscapeSequence() |
| if ndef['color']: |
| escape.fg = self._color_tuple(ndef['color']) |
| if ndef['bgcolor']: |
| escape.bg = self._color_tuple(ndef['bgcolor']) |
| if self.usebold and ndef['bold']: |
| escape.bold = True |
| if self.useunderline and ndef['underline']: |
| escape.underline = True |
| if self.useitalic and ndef['italic']: |
| escape.italic = True |
| self.style_string[str(ttype)] = (escape.true_color_string(), |
| escape.reset_string()) |
