def __init__(self, **options):
Formatter.__init__(self, **options)
self.token_map = {}
self.styles = []
for token, style in self.style:
#debug("formatter: {} {}".format(token, style))
try:
s = {}
if style['color']:
c, b = extract_color(style['color'])
#debug("fg color: c='{}' b='{}'".format(c, b))
s['fg_color'] = c
s['fg_bright'] = b
if style['bold']:
s['bold'] = bool(style['bold'])
if style['underline']:
s['underline'] = bool(style['underline'])
if style['bgcolor']:
c, b = extract_color(style['bgcolor'])
debug("bg color: c='{}' b='{}'".format(c, b))
s['bg_color'] = c
s['bg_bright'] = b
i = self.add_style(s) if len(s) != 0 else -1
self.token_map[token] = i
#debug("token_map: {}".format(self.token_map))
except Exception as ex:
## use default formatting
debug("error: style formatted wrong for {}: {}. Skipping...".format(token, ex))
self.token_map[token] = -1
def __init__(self, **options):
Formatter.__init__(self, **options)
#XXX distinct colors must fit, actually
if curses.can_change_color() and len(self.style) <= curses.COLORS:
# cache of registered RGB colors
colors = []
def init_color(rgb):
r, g, b = int(rgb[:2], 16), int(rgb[2:4], 16), int(rgb[4:], 16)
curses.init_color(len(colors) + 1,
r * 1000 / 255, g * 1000 / 255, b * 1000 / 255)
colors.append(rgb)
pairs = []
self.pairs = {}
self.bolds = set()
for token, style in self.style:
#XXX bg
fg = style['color'] or 'ffffff'
bg = style['bgcolor']
if fg not in colors:
init_color(fg)
if style['bold']:
self.bolds.add(token)
pair = (fg, bg)
sys.stderr.write("%r gets %r\n" % (token, pair))
if pair not in pairs:
curses.init_pair(len(pairs) + 1,
colors.index(fg)+1, -1)
pairs.append(pair)
self.pairs[token] = pairs.index(pair)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.lineseparator = options.get("lineseparator", "\n")
self.tabwidth = get_int_opt(options, "tabwidth", 4)
self.escapetable = _escape_html_table
self.escapetable[ord("\t")] = " " * self.tabwidth
self.noclasses = get_bool_opt(options, "noclasses", False)
self.classprefix = options.get("classprefix", "")
self.cssclass = options.get("cssclass", "highlight")
self.stylebg = get_bool_opt(options, "stylebg", True)
self.stylebgalternating = get_bool_opt(options, "stylebgalternating", True)
self.fontfamily = options.get("fontfamily", "Courier")
self.fontsize = options.get("fontsize", "1.2em")
self._create_stylesheet()
self.linecolwidth = options.get("linecolwidth", 3)
self.tablewidth = options.get("tablewidth", "100%")
self.showtitles = get_bool_opt(options, "showtitles", False)
self.titles = []
self.additionalstyles = options.get(
"additionalstyles",
(
AspectStyle(name=CSSCLASS_LINENO, styles=dict(bgcolor="eeeeee", borderright="eeaaaa")),
AspectStyle(name="bgcoloreven", styles=dict(bgcolor="fafafa")),
AspectStyle(name="bgcoloreven2", styles=dict(bgcolor="fdfdfd")),
AspectStyle(name="bgcolorodd", styles=dict(bgcolor="f5f5f5")),
AspectStyle(name="bgcolorodd2", styles=dict(bgcolor="f8f8f8")),
AspectStyle(name=CSSCLASS_TD_TITLE, styles=dict(bgcolor="eeaaaa", paddingleft="15px")),
),
)
self._create_additional_styles()
def __init__(self, **options):
Formatter.__init__(self, **options)
# create a dict of (start, end) tuples that wrap the
# value of a token so that we can use it in the format
# method later
self.styles = {}
# we iterate over the `_styles` attribute of a style item
# that contains the parsed style values.
for token, style in self.style:
start = end = ''
# a style item is a tuple in the following form:
# colors are readily specified in hex: 'RRGGBB'
if style['color']:
start += '<font color="#%s">' % style['color']
end = '</font>' + end
if style['bold']:
start += '<b>'
end = '</b>' + end
if style['italic']:
start += '<i>'
end = '</i>' + end
if style['underline']:
start += '<u>'
end = '</u>' + end
self.styles[token] = (start, end)
def __init__(self, **options):
Formatter.__init__(self, **options)
# create a dict of (start, end) tuples that wrap the
# value of a token so that we can use it in the format
# method later
self.styles = {}
# we iterate over the `_styles` attribute of a style item
# that contains the parsed style values.
for token, style in self.style:
start = end = ''
if style['color']:
sty = str(style['color'])
if sty == "000000": start, end = '<cstyle:py_decodes>','<cstyle:>'
if sty == "000001": start, end = '<cstyle:py_comment>','<cstyle:>'
elif sty == "000002": start, end = '<cstyle:py_keyword>','<cstyle:>'
elif sty == "000003": start, end = '<cstyle:py_name>','<cstyle:>'
elif sty == "000004": start, end = '<cstyle:py_name_func>','<cstyle:>'
elif sty == "000005": start, end = '<cstyle:py_name_class>','<cstyle:>'
elif sty == "100001": start, end = '<cstyle:py_number>','<cstyle:>'
elif sty == "100002": start, end = '<cstyle:py_builtin>','<cstyle:>'
elif sty == "100003": start, end = '<cstyle:py_builtin>','<cstyle:>'
elif sty == "100004": start, end = '<cstyle:py_operator>','<cstyle:>'
elif sty == "999999": start, end = '<cstyle:py_string>','<cstyle:>'
#else : start, end = '<cstyle:py_default>','<cstyle:>'
self.styles[token] = (start, end)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.nowrap = get_bool_opt(options, 'nowrap', False)
self.noclasses = get_bool_opt(options, 'noclasses', False)
self.classprefix = options.get('classprefix', '')
self.cssclass = options.get('cssclass', 'highlight')
self.cssstyles = options.get('cssstyles', '')
self.prestyles = options.get('prestyles', '')
self.cssfile = options.get('cssfile', '')
linenos = options.get('linenos', False)
if linenos == 'inline':
self.linenos = 2
elif linenos:
# compatibility with <= 0.7
self.linenos = 1
else:
self.linenos = 0
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
self.nobackground = get_bool_opt(options, 'nobackground', False)
self.lineseparator = options.get('lineseparator', '\n')
self.lineanchors = options.get('lineanchors', '')
self.hl_lines = set()
for lineno in get_list_opt(options, 'hl_lines', []):
try:
self.hl_lines.add(int(lineno))
except ValueError:
pass
self._class_cache = {}
self._create_stylesheet()
def __init__(self, **options):
Formatter.__init__(self, **options)
self._code = get_bool_opt(options, 'codetag', False)
self._mono = get_bool_opt(options, 'monofont', False)
self.styles = {}
self._make_styles()
def __init__(self, **options):
Formatter.__init__(self, **options)
if "fonts" in options:
self.fonts = ",".join(options["fonts"])
else:
self.fonts = ",".join(['consolas', 'lucida console', 'courier', 'monospace'])
# create a dict of (start, end) tuples that wrap the
# value of a token so that we can use it in the format
# method later
self.styles = {}
# we iterate over the `_styles` attribute of a style item
# that contains the parsed style values.
for token, style in self.style:
start = end = ''
# a style item is a tuple in the following form:
# colors are readily specified in hex: 'RRGGBB'
if style['color']:
start += '<span style="color:#%s">' % style['color']
end = '</span>' + end
if style['bold']:
start += '<b>'
end = '</b>' + end
if style['italic']:
start += '<i>'
end = '</i>' + end
if style['underline']:
start += '<u>'
end = '</u>' + end
self.styles[token] = (start, end)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.styles = {}
for token, style in self.style:
self.styles[token] = {}
if style["color"]:
self.styles[token]["color"] = Colors.rgb(*hex2rgb(style["color"]))
def __init__(self, **options):
Formatter.__init__(self, **options)
self.styles = {}
for token, style in self.style:
start_tag = close_tag = ''
if style['color']:
start_tag += '<span fgcolor="#%s">' % style['color']
close_tag = '</span>' + close_tag
if style['bold']:
start_tag += '<b>'
close_tag = '</b>' + close_tag
if style['italic']:
start_tag += '<i>'
close_tag = '</i>' + close_tag
if style['underline']:
start_tag += '<u>'
close_tag = '</u>' + close_tag
self.styles[token] = (start_tag, close_tag)
def __init__(self, **options):
"""Initialize the style types."""
Formatter.__init__(self, **options)
self.styles = {}
for token, style in self.style:
start = ''
end = ''
newline_end = '\n'
newline_start = ''
if style['color']:
start += newline_start + '<STATviewcolor=#%s>' % style['color'] + '\n'
newline_start = ''
if style['bold']:
start += newline_start + '<STATviewb>\n'
newline_start = ''
if style['italic']:
start += newline_start + '<STATviewi>\n'
newline_start = ''
if style['underline']:
start += newline_start + '<STATviewu>\n'
newline_start = ''
if style['underline']:
end = newline_end + end + '</STATviewu>\n'
newline_end = ''
if style['italic']:
end = newline_end + end + '</STATviewi>\n'
newline_end = ''
if style['bold']:
end = newline_end + end + '</STATviewb>\n'
newline_end = ''
if style['color']:
end = newline_end + end + '</STATviewcolor>\n'
newline_end = ''
self.styles[token] = (start, end)
def __init__(self, **options):
"""Extra arguments:
usebold: if false, bold will be ignored and always off
default: True
usebg: if false, background color will always be 'default'
default: True
defaultfg: the default color to use for the foreground, used
if the style does not specify.
This is in curses format, e.g. curses.COLOR_BLACK.
Use -1 for the terminal default, -2 for the pygments style default.
default: -1 (terminal default)
defaultbg: the default color to use for the background, used in blank
space, and behind normal text when usebg = False or when
the style does not specify a foreground color.
This is in curses format, e.g. curses.COLOR_BLACK.
Use -1 for the terminal default, -2 for the pygments style default.
default: -1 (terminal default)
colors: number of colors to use (-1 for auto, 16, 88, or 256)
default: -1 (automatic)"""
Formatter.__init__(self, **options)
self.usebold = options.get('usebold',True)
self.usebg = options.get('usebg', True)
self.defaultbg = options.get('defaultbg', -1)
self.defaultfg = options.get('defaultfg', -1)
self.colors = options.get('colors', -1)
self.style_attrs = {}
self._tokentocolorpair = {}
self._setup = False
def __init__(self, flowdocument=True, store_code_blocks=False, **options):
Formatter.__init__(self, **options)
self.flowdocument = flowdocument
self.store_code_blocks = store_code_blocks
self.linenos = 0
if flowdocument:
self.lineseparator = '\n'
else:
self.lineseparator = '<LineBreak />'
self.styles = {}
for token, style in self.style:
format_string = ''
# a style item is a tuple in the following form:
# colors are readily specified in hex: 'RRGGBB'
if style['color']:
format_string = ' Foreground="#%s"' % style['color']
if style['bold']:
format_string += ' FontWeight="Bold"'
if style['italic']:
format_string += ' FontStyle="Italic"'
if style['underline']:
# not used ?
pass
self.styles[token] = format_string
def __init__(self, **options):
Formatter.__init__(self, **options)
self.darkbg = get_choice_opt(options, 'bg',
['light', 'dark'], 'light') == 'dark'
self.colorscheme = options.get('colorscheme', None) or COMMAND_COLORS
self.linenos = options.get('linenos', False)
self._lineno = 0
def __init__(self):
Formatter.__init__(self)
self.data = []
# Create a dictionary of text styles, indexed
# by pygments token names, containing QTextCharFormat
# instances according to pygments' description
# of each style
self.styles = {}
for token, style in self.style:
qtf = QtGui.QTextCharFormat()
if style['color']:
qtf.setForeground(hex2QColor(style['color']))
if style['bgcolor']:
qtf.setBackground(hex2QColor(style['bgcolor']))
if style['bold']:
qtf.setFontWeight(QtGui.QFont.Bold)
if style['italic']:
qtf.setFontItalic(True)
if style['underline']:
qtf.setFontUnderline(True)
self.styles[str(token)] = qtf
# missing token
self.styles['Token.Literal.String.Name'] = self.styles['Token.Literal.String']
def __init__(self, color_scheme, **options):
self.f_strings = {}
for k, v in theme_map.iteritems():
self.f_strings[k] = '\x01%s' % (color_scheme[v],)
if k is Parenthesis:
# FIXME: Find a way to make this the inverse of the current
# background colour
self.f_strings[k] += 'I'
Formatter.__init__(self, **options)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.tagsfile = self._decodeifneeded(options.get('tagsfile', ''))
self.tagurlformat = self._decodeifneeded(options.get('tagurlformat', ''))
if self.tagsfile:
if not ctags:
raise RuntimeError('The "ctags" package must to be installed '
'to be able to use the "tagsfile" feature.')
self._ctags = ctags.CTags(self.tagsfile)
def __init__(self, **options):
"""
See the class docstring for explanation of options.
"""
if not pil_available:
raise PilNotAvailable(
'Python Imaging Library is required for this formatter')
Formatter.__init__(self, **options)
self.encoding = 'latin1' # let pygments.format() do the right thing
# Read the style
self.styles = dict(self.style)
if self.style.background_color is None:
self.background_color = '#fff'
else:
self.background_color = self.style.background_color
# Image options
self.image_format = get_choice_opt(
options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'],
self.default_image_format, normcase=True)
self.image_pad = get_int_opt(options, 'image_pad', 10)
self.line_pad = get_int_opt(options, 'line_pad', 2)
# The fonts
fontsize = get_int_opt(options, 'font_size', 14)
self.fonts = FontManager(options.get('font_name', ''), fontsize)
self.fontw, self.fonth = self.fonts.get_char_size()
# Line number options
self.line_number_fg = options.get('line_number_fg', '#886')
self.line_number_bg = options.get('line_number_bg', '#eed')
self.line_number_chars = get_int_opt(options,
'line_number_chars', 2)
self.line_number_bold = get_bool_opt(options,
'line_number_bold', False)
self.line_number_italic = get_bool_opt(options,
'line_number_italic', False)
self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
self.line_numbers = get_bool_opt(options, 'line_numbers', True)
self.line_number_separator = get_bool_opt(options,
'line_number_separator', True)
self.line_number_step = get_int_opt(options, 'line_number_step', 1)
self.line_number_start = get_int_opt(options, 'line_number_start', 1)
if self.line_numbers:
self.line_number_width = (self.fontw * self.line_number_chars +
self.line_number_pad * 2)
else:
self.line_number_width = 0
self.hl_lines = []
hl_lines_str = get_list_opt(options, 'hl_lines', [])
for line in hl_lines_str:
try:
self.hl_lines.append(int(line))
except ValueError:
pass
self.hl_color = options.get('hl_color',
self.style.highlight_color) or '#f90'
self.drawables = []
def __init__(self, **options):
Formatter.__init__(self, **options)
self.codename = options.get('codename', 'code')
self.escapeopen = options.get('escapeopen', '/BTEX')
self.escapeclose = options.get('escapeclose', '/ETEX')
self.commandprefix = options.get('commandprefix', 'PYG')
self.p = re.compile(r'(\s)')
self._create_stylesheet()
def __init__(self, **options):
Formatter.__init__(self, **options)
# buffer regex for tab/space splitting for block code
self.whitespace_re = re.compile(u'( {2,}|\t)', re.UNICODE)
# create a dict of (start, end) tuples that wrap the
# value of a token so that we can use it in the format
# method later
self.styles = {}
# we iterate over the `_styles` attribute of a style item
# that contains the parsed style values.
for token, style in self.style:
root_elem = None
curr_elem = None
# a style item is a tuple in the following form:
# colors are readily specified in hex: 'RRGGBB'
if style['color']:
root_elem = curr_elem = odf_create_element('text:span')
# pylint: disable=maybe-no-member
curr_elem.set_style('md2odp-TColor%s' % style['color'])
if style['bold']:
span = odf_create_element('text:span')
# pylint: disable=maybe-no-member
span.set_style('md2odp-TBold')
if root_elem is None:
root_elem = curr_elem = span
else:
curr_elem.append(span)
curr_elem = span
if style['italic']:
span = odf_create_element('text:span')
# pylint: disable=maybe-no-member
span.set_style('md2odp-TItalic')
if root_elem is None:
root_elem = curr_elem = span
else:
curr_elem.append(span)
curr_elem = span
if style['underline']:
span = odf_create_element('text:span')
# pylint: disable=maybe-no-member
span.set_style('md2odp-TUnderline')
if root_elem is None:
root_elem = curr_elem = span
else:
curr_elem.append(span)
curr_elem = span
self.styles[token] = (root_elem, curr_elem)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.darkbg = get_choice_opt(options, 'bg',
['light', 'dark'], 'light') == 'dark'
self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
self.width = options.get('width', 80)
self.verbatim = False
self.in_list = False
self.column = 1
self.last_was_nl = False
return
def __init__(self, **options):
Formatter.__init__(self, **options)
self.docclass = options.get("docclass", "article")
self.preamble = options.get("preamble", "")
self.linenos = get_bool_opt(options, "linenos", False)
self.linenostart = abs(get_int_opt(options, "linenostart", 1))
self.linenostep = abs(get_int_opt(options, "linenostep", 1))
self.verboptions = options.get("verboptions", "")
self.nobackground = get_bool_opt(options, "nobackground", False)
self.commandprefix = options.get("commandprefix", "PY")
self._create_stylecmds()
def __init__(self, **options):
Formatter.__init__(self, **options)
self.docclass = options.get('docclass', 'article')
self.preamble = options.get('preamble', '')
self.linenos = get_bool_opt(options, 'linenos', False)
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
self.verboptions = options.get('verboptions', '')
self.nobackground = get_bool_opt(options, 'nobackground', False)
self.commandprefix = options.get('commandprefix', 'PY')
self._create_stylecmds()
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._build_color_table() # build an RGB-to-256 color conversion table
self._setup_styles() # convert selected style's colors to term. colors
def __init__(self, styles):
Formatter.__init__(self)
def style_name(item):
name, style = item
if name == 'Paragraph':
style = 'SFWPParagraphStyle-%s' % str(style)
else:
style = 'SFWPCharacterStyle-%s' % str(style)
return (name, style)
self.styles = dict(map(style_name, styles.items()))
def __init__(self, **options):
Formatter.__init__(self, **options)
self.__tstyle = dict(options["style"])
try:
self.__bgcolor = options["style"].background_color
except AttributeError:
self.__bgcolor = None
# end try
self.__emit_line_numbers = options["emit_line_numbers"]
self.__line_no = options["startline"]
self.__line_step = options["line_step"]
self.__output_format = options["output_format"]
self.__new_line = True
def __init__(self, **options):
Formatter.__init__(self, **options)
self.compress = get_choice_opt(options, 'compress',
['', 'none', 'gz', 'bz2'], '')
self.error_color = options.get('error_color', None)
if self.error_color is True:
self.error_color = 'red'
if self.error_color is not None:
try:
colorize(self.error_color, '')
except KeyError:
raise ValueError("Invalid color %r specified" %
self.error_color)
def __init__(self, draw, covdata, origin, **kw):
Formatter.__init__(self, **kw)
self.draw = draw
self.covdata = covdata
self.origin = origin
#: maps Token -> r,g,b triple
self.token_color = {}
for (token, style) in self.style:
if 'color' in style and style['color']:
c = parse_color(style['color'])
self.token_color[token] = c
def __init__(self, **options):
"""
Additional options accepted:
``fontface``
Name of the font used. Could for example be ``'Courier New'``
to further specify the default which is ``'\fmodern'``. The RTF
specification claims that ``\fmodern`` are "Fixed-pitch serif
and sans serif fonts". Hope every RTF implementation thinks
the same about modern...
"""
Formatter.__init__(self, **options)
self.fontface = options.get('fontface') or ''
def __init__(self, **options):
"""Extra arguments:
usebold: if false, bold will be ignored and always off
default: True
usebg: if false, background color will always be 'default'
default: True
colors: number of colors to use (16, 88, or 256)
default: 256"""
self.usebold = options.get('usebold',True)
self.usebg = options.get('usebg', True)
colors = options.get('colors', 256)
self.style_attrs = {}
Formatter.__init__(self, **options)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.styles = {}
manager = TextPropertiesManager.getGlobalPtr()
n = 1 / 255
for token, style in self.style:
start = end = ''
if style['color']:
# hex color (#FF0000) to RGB 255 (255,0,0)
color = tuple(
int(style['color'][i:i + 2], 16) for i in (0, 2, 4))
# RGB 255 to vec4 (1,0,0,1), obsolete step?
color = (n * color[0], n * color[1], n * color[2], 1)
tp = TextProperties()
tp.setTextColor(color)
manager.setProperties(str(color), tp)
# \1tag\1 starts a TextProperties
start += '\1%s\1' % str(color)
# \2 resets TextProperties
end = str('\2' + end)
self.styles[token] = (start, end)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.docclass = options.get('docclass', 'article')
self.preamble = options.get('preamble', '')
self.linenos = get_bool_opt(options, 'linenos', False)
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
self.verboptions = options.get('verboptions', '')
self.nobackground = get_bool_opt(options, 'nobackground', False)
self.commandprefix = options.get('commandprefix', 'PY')
self.texcomments = get_bool_opt(options, 'texcomments', False)
self.mathescape = get_bool_opt(options, 'mathescape', False)
self.escapeinside = options.get('escapeinside', '')
if len(self.escapeinside) == 2:
self.left = self.escapeinside[0]
self.right = self.escapeinside[1]
else:
self.escapeinside = ''
self.envname = options.get('envname', 'Verbatim')
self._create_stylesheet()
def load_style(style):
styles = {}
formatter = Formatter(style=style)
for token, params in formatter.style:
color = parse_hex_color(params["color"]) if params["color"] else None
# Italic and underline styles aren't supported, so just use bold for them
bold = params["bold"] or params["italic"] or params["underline"]
# Save style
styles[token] = {"color": color, "bold": bold}
return styles
def __init__(self, **options):
Formatter.__init__(self, **options)
self.title = self._decodeifneeded(self.title)
# Holds fo attributes that correspond to each style type.
self.styles = {}
self.background_colour = self.style.background_color or '#ffffff'
# Iterate over the style and create a list of fo attributes that describe it.
for token, style in self.style:
atts = []
if style['color']:
atts.append('color="#%s"' % style['color'])
if style['bold']:
atts.append('font-weight="bold"')
if style['italic']:
atts.append('font-style="italic"')
if style['underline']:
atts.append('text-decoration="underline"')
# Save the attributes for this style
self.styles[token] = ' '.join(atts)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.title = self._decodeifneeded(self.title)
self.nowrap = get_bool_opt(options, 'nowrap', False)
self.noclasses = get_bool_opt(options, 'noclasses', False)
self.classprefix = options.get('classprefix', '')
self.cssclass = self._decodeifneeded(
options.get('cssclass', 'highlight'))
self.cssstyles = self._decodeifneeded(options.get('cssstyles', ''))
self.prestyles = self._decodeifneeded(options.get('prestyles', ''))
self.cssfile = self._decodeifneeded(options.get('cssfile', ''))
self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile',
False)
linenos = options.get('linenos', False)
if linenos == 'inline':
self.linenos = 2
elif linenos:
# compatibility with <= 0.7
self.linenos = 1
else:
self.linenos = 0
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
self.nobackground = get_bool_opt(options, 'nobackground', False)
self.lineseparator = options.get('lineseparator', '\n')
self.lineanchors = options.get('lineanchors', '')
self.anchorlinenos = options.get('anchorlinenos', False)
self.hl_lines = set()
for lineno in get_list_opt(options, 'hl_lines', []):
try:
self.hl_lines.add(int(lineno))
except ValueError:
pass
self._class_cache = {}
self._create_stylesheet()
def format(self, tokensource, outfile):
# hack: if the output is a terminal and has an encoding set,
# use that to avoid unicode encode problems
if (
not self.encoding
and hasattr(outfile, "encoding")
and hasattr(outfile, "isatty")
and outfile.isatty()
and sys.version_info < (3,)
):
self.encoding = outfile.encoding
pass
self.outfile = outfile
return Formatter.format(self, tokensource, outfile)
def __init__(self):
Formatter.__init__(self)
self.data = []
# Create a dictionary of text styles, indexed
# by pygments token names, containing QTextCharFormat
# instances according to pygments' description
# of each style
self.styles = {}
for token, style in self.style:
qtf = QtGui.QTextCharFormat()
if style['color']:
qtf.setForeground(hex2QColor(style['color']))
if style['bgcolor']:
qtf.setBackground(hex2QColor(style['bgcolor']))
if style['bold']:
qtf.setFontWeight(QtGui.QFont.Bold)
if style['italic']:
qtf.setFontItalic(True)
if style['underline']:
qtf.setFontUnderline(True)
self.styles[str(token)] = qtf
def __init__(self, style='default'):
Formatter.__init__(self, style=style)
self.styles = {}
for token, style in self.style:
start = []
end = []
# a style item is a tuple in the following form:
# colors are readily specified in hex: 'RRGGBB'
if style['color']:
start.append('38' + color_as_sgr(parse_sharp(style['color'])))
end.append('39')
if style['bold']:
start.append('1')
end.append('22')
if style['italic']:
start.append('3')
end.append('23')
if style['underline']:
start.append('4')
end.append('24')
if start:
start = '\033[{}m'.format(';'.join(start))
end = '\033[{}m'.format(';'.join(end))
self.styles[token] = start or '', end or ''
def __init__(self, parent):
QSyntaxHighlighter.__init__(self, parent)
self.formatter = Formatter()
self.lexer = PythonLexer()
self.style = {}
for token, style in self.formatter.style:
char_format = QTextCharFormat()
if style['color']:
char_format.setForeground(QColor("#" + style['color']))
if style['bgcolor']:
char_format.setBackground(QColor("#" + style['bgcolor']))
if style['bold']:
char_format.setFontWeight(QFont.Bold)
if style['italic']:
char_format.setFontItalic(True)
if style['underline']:
char_format.setFontUnderline(True)
char_format.setFontStyleHint(QFont.Monospace)
self.style[token] = char_format
def __init__(self, presentation, **options):
Formatter.__init__(self, **options)
self.presentation = presentation
def __init__(self, **options):
Formatter.__init__(self, **options)
self.darkbg = get_choice_opt(options, 'bg', ['light', 'dark'],
'light') == 'dark'
self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
def __init__(self, **options):
Formatter.__init__(self, **options)
if self.encoding is not None and self.encoding != 'utf-8':
raise ValueError("Only None and utf-8 are allowed encodings.")
def __init__(self, listener, **options):
Formatter.__init__(self, **options)
self.listener = listener
self.styles = dict(self.style)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.colorscheme = (options.get("colorscheme", None)
or ASCIIMATIC_COLORS)
self.linenos = options.get("linenos", False)
def __init__(self, style):
Formatter.__init__(self)
self.style = style
def __init__(subself, **options): # noqa: N805, E501 # pylint: disable=no-self-argument
Formatter.__init__(subself, **options)
subself.current_line = ""
subself.current_attr = []
subself.lineno = 1
def format(self, tokensource, outfile):
self.encoding = outfile.encoding
return Formatter.format(self, tokensource, outfile)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.colorscheme = get_colorscheme()
def __init__(self):
Formatter.__init__(self)
self._annotation_list = []
def __init__(subself, **options): # noqa: N805
Formatter.__init__(subself, **options)
subself.current_line = ""
subself.current_attr = []
subself.lineno = 1
def __init__(self, **options):
Formatter.__init__(self, **options)
#if self.encoding != 'utf-8':
# print >>sys.stderr, "NOTICE: Forcing encoding to utf-8, as all Pygments source is"
if self.encoding is not None and self.encoding != 'utf-8':
raise ValueError("Only None and utf-u are allowed encodings.")
def __init__(self, **options):
Formatter.__init__(self, **options)
self.title = self._decodeifneeded(self.title)
# 语言
self.language = self._decodeifneeded(options.get('language', ''))
self.nowrap = get_bool_opt(options, 'nowrap', False)
self.noclasses = get_bool_opt(options, 'noclasses', False)
self.classprefix = options.get('classprefix', '')
self.cssclass = self._decodeifneeded(
options.get('cssclass', 'highlight'))
self.cssstyles = self._decodeifneeded(options.get('cssstyles', ''))
self.prestyles = self._decodeifneeded(options.get('prestyles', ''))
self.cssfile = self._decodeifneeded(options.get('cssfile', ''))
self.noclobber_cssfile = get_bool_opt(options, 'noclobber_cssfile',
False)
self.tagsfile = self._decodeifneeded(options.get('tagsfile', ''))
self.tagurlformat = self._decodeifneeded(
options.get('tagurlformat', ''))
self.filename = self._decodeifneeded(options.get('filename', ''))
# 关于ul和li添加的属性
# 一开始就显示行号
self.shownum = get_bool_opt(options, 'shownum', True)
# 代码是否折行，默认为True
self.linefeed = get_bool_opt(options, 'linefeed', True)
# ul自定义的class，默认为ul-wrap
self.ulclass = self._decodeifneeded(
options.get('ulclass', 'highlight-ul'))
# ul自定义的style
self.ulstyles = self._decodeifneeded(options.get('ulstyles', ''))
# 需要行号的ul的class，默认为numbered
self.ulnumclass = self._decodeifneeded(
options.get('ulnumclass', 'numbered'))
# li自定义的class，默认为li-wrap
self.liclass = self._decodeifneeded(options.get('liclass', 'li-wrap'))
# li自定义的style
self.listyles = self._decodeifneeded(options.get('listyles', ''))
# 需要行号的li的class，默认为numbered，该选项用在并不是所有行都需要行号的情况下
self.linumclass = self._decodeifneeded(
options.get('linumclass', 'numbered'))
# 检查ctags相关，这里的ctags是import的
if self.tagsfile:
if not ctags:
raise RuntimeError('The "ctags" package must to be installed '
'to be able to use the "tagsfile" feature.')
# 生成ctags
self._ctags = ctags.CTags(self.tagsfile)
# 行号模式
linenos = 'ul' # options.get('linenos', 'ul')
if linenos == 'inline':
self.linenos = 2 # inline为2
elif linenos == 'ul':
self.linenos = 3 # ul为3
elif linenos == 'table':
# compatibility with <= 0.7
self.linenos = 1
else:
self.linenos = 0 # 如果没有指定默认为0
# 获取各种选项
self.linenostart = abs(get_int_opt(options, 'linenostart', 1))
self.linenostep = abs(get_int_opt(options, 'linenostep', 1))
self.linenospecial = abs(get_int_opt(options, 'linenospecial', 0))
self.nobackground = get_bool_opt(options, 'nobackground', False)
self.lineseparator = options.get('lineseparator', '\n')
self.lineanchors = options.get('lineanchors', '')
self.linespans = options.get('linespans', '')
self.anchorlinenos = options.get('anchorlinenos', False)
self.hl_lines = set()
# 高亮行号存起来
hl_lines = self._decodeifneeded(options.get('hl_lines', '{}'))
self.hl_line_nums = []
try:
self.hl_lines = json.loads(hl_lines)
for index, color in self.hl_lines.items():
try:
self.hl_line_nums.append(int(index))
except ValueError:
pass
except Exception:
if isinstance(hl_lines, (str, )):
self.hl_lines = hl_lines.split()
elif isinstance(hl_lines, (list, tuple)):
self.hl_lines = list(hl_lines)
else:
raise ValueError(
'Invalid type `hl_lines`; you must give a list or json serialize value'
)
self.hl_line_nums = [int(x) for x in self.hl_lines]
# 生成style样式
self._create_stylesheet()
def __init__(self, **options):
Formatter.__init__(self, **options)
self.show_line_numbers = get_bool_opt(options, 'show_line_numbers',
True)
self.first_line_number = abs(
get_int_opt(options, 'first_line_number', 1))
def __init__(self, **options):
Formatter.__init__(self, **options)
self.compress = get_choice_opt(options, 'compress',
['', 'none', 'gz', 'bz2'], '')
def __init__(self, **options):
Formatter.__init__(self, **options)
def __init__(self, color_scheme, **options):
self.f_strings = {}
for k, v in color_scheme.iteritems():
self.f_strings[k] = '\x01%s' % (v, )
Formatter.__init__(self, **options)
def __init__(self, **options):
Formatter.__init__(self, **options)
self.styles = {}
for token, style in self.style:
self.styles[token] = style
self.output = []
def format(self, tokensource, outfile):
return Formatter.format(self, tokensource, outfile)