def run(self): raw = u"\n".join(self.content) try: # it's always html. lexer = get_lexer_by_name("html") except ValueError: # no lexer found - use the text one instead of an exception lexer = TextLexer() formatter = HtmlFormatter(noclasses=False, style='fruity') formatted = highlight(raw, lexer, formatter) markup = """ <div class='live-example'> <div class='inner'>%s</div> <div class='closed'> <p>Example Source:</p> %s </div> </div> """ % (raw, formatted) return [nodes.raw('', markup, format='html')]
def format_codechunks(self, chunk): from pygments import highlight from pygments.lexers import PythonLexer, TextLexer, PythonConsoleLexer #from IPythonLexer import IPythonLexer from pygments.formatters import LatexFormatter chunk['content'] = highlight( chunk['content'], PythonLexer(), LatexFormatter( verboptions="frame=single,fontsize=\small, xleftmargin=0.5em")) if len(chunk['result'].strip()) > 0 and chunk['results'] == 'verbatim': if chunk['term']: chunk['result'] = highlight( chunk['result'], PythonLexer(), LatexFormatter( verboptions= "frame=single,fontsize=\small, xleftmargin=0.5em")) else: chunk['result'] = highlight( chunk['result'], TextLexer(), LatexFormatter( verboptions= "frame=leftline,fontsize=\small, xleftmargin=0.5em")) return (PwebFormatter.format_codechunks(self, chunk))
def setUp(self): self.log_printer = ListLogPrinter() self.console_printer = ConsolePrinter(print_colored=False) self.no_color = not self.console_printer.print_colored self.file_diff_dict = {} self.section = Section('t') self.local_bears = OrderedDict([('default', [SomelocalBear]), ('test', [SomelocalBear])]) self.global_bears = OrderedDict([('default', [SomeglobalBear]), ('test', [SomeglobalBear])]) self.old_open_editor_applicable = OpenEditorAction.is_applicable OpenEditorAction.is_applicable = staticmethod( lambda *args: 'OpenEditorAction cannot be applied') self.old_apply_patch_applicable = ApplyPatchAction.is_applicable ApplyPatchAction.is_applicable = staticmethod( lambda *args: 'ApplyPatchAction cannot be applied') self.lexer = TextLexer() self.lexer.add_filter( VisibleWhitespaceFilter(spaces='•', tabs=True, tabsize=SpacingHelper.DEFAULT_TAB_WIDTH))
# If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Additional stuff for the LaTeX preamble. #latex_preamble = '' # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [('index', 'mailgunrestapi', u'Mailgun REST API Documentation', [u'Mailgun Inc'], 1)] # Normally, the Pygments PHP lexer requires PHP code to be between '<?php' '?>' # delimiters. The hack below allows highlighting for PHP code which is not # between those tags. from sphinx.highlighting import lexers from pygments.lexers import PhpLexer, TextLexer lexers['php'] = PhpLexer(startinline=True) lexers['url'] = TextLexer()
for p_opt in P_opts: try: name, value = p_opt.split('=', 1) except ValueError: parsed_opts[p_opt] = True else: parsed_opts[name] = value opts.pop('-P', None) # handle ``pygmentize -N`` infn = opts.pop('-N', None) if infn is not None: try: lexer = get_lexer_for_filename(infn, **parsed_opts) except ClassNotFound, err: lexer = TextLexer() except OptionError, err: print >> sys.stderr, 'Error:', err return 1 print lexer.aliases[0] return 0 # handle ``pygmentize -S`` S_opt = opts.pop('-S', None) a_opt = opts.pop('-a', None) if S_opt is not None: f_opt = opts.pop('-f', None) if not f_opt: print >> sys.stderr, usage return 2
import sys from pygments import highlight from pygments.util import ClassNotFound from pygments.lexers import TextLexer from pygments.lexers import guess_lexer from pygments.lexers import guess_lexer_for_filename from pygments.formatters import HtmlFormatter # read stdin and decode to utf-8. ignore any unkown signs. data = sys.stdin.read().decode(encoding='utf-8', errors='ignore') filename = sys.argv[1] formatter = HtmlFormatter(encoding='utf-8', style='pastie') try: lexer = guess_lexer_for_filename(filename, data, encoding='utf-8') except ClassNotFound: # check if there is any shebang if data[0:2] == '#!': lexer = guess_lexer(data, encoding='utf-8') else: lexer = TextLexer(encoding='utf-8') except TypeError: lexer = TextLexer(encoding='utf-8') # highlight! :-) # printout pygments' css definitions as well sys.stdout.write('<style>') sys.stdout.write(formatter.get_style_defs('.highlight')) sys.stdout.write('</style>') highlight(data, lexer, formatter, outfile=sys.stdout)
from pygments.util import ClassNotFound from pygments.lexers import TextLexer from pygments.lexers import guess_lexer from pygments.lexers import guess_lexer_for_filename from pygments.formatters import HtmlFormatter sys.stdin = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8', errors='replace') sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace') data = sys.stdin.read() filename = sys.argv[1] formatter = HtmlFormatter(style='pastie') try: lexer = guess_lexer_for_filename(filename, data) except ClassNotFound: # check if there is any shebang if data[0:2] == '#!': lexer = guess_lexer(data) else: lexer = TextLexer() except TypeError: lexer = TextLexer() # highlight! :-) # printout pygments' css definitions as well sys.stdout.write('<style>') sys.stdout.write(formatter.get_style_defs('.highlight')) sys.stdout.write('</style>') sys.stdout.write(highlight(data, lexer, formatter, outfile=None))
def print_result(console_printer, section, file_diff_dict, result, file_dict, interactive=True, apply_single=False): """ Prints the result to console. :param console_printer: Object to print messages on the console. :param section: Name of section to which the result belongs. :param file_diff_dict: Dictionary containing filenames as keys and Diff objects as values. :param result: A derivative of Result. :param file_dict: A dictionary containing all files with filename as key. :param apply_single: The action that should be applied for all results. If it's not selected, has a value of False. :param interactive: Variable to check whether or not to offer the user actions interactively. """ no_color = not console_printer.print_colored if not isinstance(result, Result): logging.warning('One of the results can not be printed since it is ' 'not a valid derivative of the coala result ' 'class.') return if hasattr(section, 'name'): console_printer.print( f'**** {result.origin} [Section: {section.name}' ' | Severity: ' f'{RESULT_SEVERITY.__str__(result.severity)}] ' '****', color=RESULT_SEVERITY_COLORS[result.severity]) else: console_printer.print( f'**** {result.origin} [Section <empty> | ' 'Severity ' f'{RESULT_SEVERITY.__str__(result.severity)}]' '****', color=RESULT_SEVERITY_COLORS[result.severity]) lexer = TextLexer() result.message = highlight_text(no_color, result.message, BackgroundMessageStyle, lexer) console_printer.print(format_lines(result.message, symbol='!')) if interactive: cli_actions = CLI_ACTIONS show_patch_action = ShowPatchAction() if show_patch_action.is_applicable(result, file_dict, file_diff_dict) is True: diff_size = sum(len(diff) for diff in result.diffs.values()) if diff_size <= DIFF_EXCERPT_MAX_SIZE: show_patch_action.apply_from_section(result, file_dict, file_diff_dict, section) cli_actions = tuple(action for action in cli_actions if not isinstance(action, ShowPatchAction)) else: print_diffs_info(result.diffs, console_printer) acquire_actions_and_apply(console_printer, section, file_diff_dict, result, file_dict, cli_actions, apply_single=apply_single)
def main(args=sys.argv): """ Main command line entry point. """ # pylint: disable-msg=R0911,R0912,R0915 usage = USAGE % ((args[0], ) * 6) try: popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHgs") except getopt.GetoptError: print(usage, file=sys.stderr) return 2 opts = {} O_opts = [] P_opts = [] F_opts = [] for opt, arg in popts: if opt == '-O': O_opts.append(arg) elif opt == '-P': P_opts.append(arg) elif opt == '-F': F_opts.append(arg) opts[opt] = arg if opts.pop('-h', None) is not None: print(usage) return 0 if opts.pop('-V', None) is not None: print('Pygments version %s, (c) 2006-2014 by Georg Brandl.' % __version__) return 0 # handle ``pygmentize -L`` L_opt = opts.pop('-L', None) if L_opt is not None: if opts: print(usage, file=sys.stderr) return 2 # print version main(['', '-V']) if not args: args = ['lexer', 'formatter', 'filter', 'style'] for arg in args: _print_list(arg.rstrip('s')) return 0 # handle ``pygmentize -H`` H_opt = opts.pop('-H', None) if H_opt is not None: if opts or len(args) != 2: print(usage, file=sys.stderr) return 2 what, name = args if what not in ('lexer', 'formatter', 'filter'): print(usage, file=sys.stderr) return 2 _print_help(what, name) return 0 # parse -O options parsed_opts = _parse_options(O_opts) opts.pop('-O', None) # parse -P options for p_opt in P_opts: try: name, value = p_opt.split('=', 1) except ValueError: parsed_opts[p_opt] = True else: parsed_opts[name] = value opts.pop('-P', None) # encodings inencoding = parsed_opts.get('inencoding', parsed_opts.get('encoding')) outencoding = parsed_opts.get('outencoding', parsed_opts.get('encoding')) # handle ``pygmentize -N`` infn = opts.pop('-N', None) if infn is not None: try: lexer = get_lexer_for_filename(infn, **parsed_opts) except ClassNotFound as err: lexer = TextLexer() except OptionError as err: print('Error:', err, file=sys.stderr) return 1 print(lexer.aliases[0]) return 0 # handle ``pygmentize -S`` S_opt = opts.pop('-S', None) a_opt = opts.pop('-a', None) if S_opt is not None: f_opt = opts.pop('-f', None) if not f_opt: print(usage, file=sys.stderr) return 2 if opts or args: print(usage, file=sys.stderr) return 2 try: parsed_opts['style'] = S_opt fmter = get_formatter_by_name(f_opt, **parsed_opts) except ClassNotFound as err: print(err, file=sys.stderr) return 1 arg = a_opt or '' try: print(fmter.get_style_defs(arg)) except Exception as err: print('Error:', err, file=sys.stderr) return 1 return 0 # if no -S is given, -a is not allowed if a_opt is not None: print(usage, file=sys.stderr) return 2 # parse -F options F_opts = _parse_filters(F_opts) opts.pop('-F', None) # select formatter outfn = opts.pop('-o', None) fmter = opts.pop('-f', None) if fmter: try: fmter = get_formatter_by_name(fmter, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 if outfn: if not fmter: try: fmter = get_formatter_for_filename(outfn, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 try: outfile = open(outfn, 'wb') except Exception as err: print('Error: cannot open outfile:', err, file=sys.stderr) return 1 else: if not fmter: fmter = TerminalFormatter(**parsed_opts) if sys.version_info > (3, ): # Python 3: we have to use .buffer to get a binary stream outfile = sys.stdout.buffer else: outfile = sys.stdout # determine output encoding if not explicitly selected if not outencoding: if outfn: # output file? -> encoding pass-through fmter.encoding = inencoding else: # else use terminal encoding fmter.encoding = terminal_encoding(sys.stdout) # provide coloring under Windows, if possible if not outfn and sys.platform in ('win32', 'cygwin') and \ fmter.name in ('Terminal', 'Terminal256'): # unfortunately colorama doesn't support binary streams on Py3 if sys.version_info > (3, ): import io outfile = io.TextIOWrapper(outfile, encoding=fmter.encoding) fmter.encoding = None try: import colorama.initialise except ImportError: pass else: outfile = colorama.initialise.wrap_stream(outfile, convert=None, strip=None, autoreset=False, wrap=True) # select lexer lexer = opts.pop('-l', None) if lexer: try: lexer = get_lexer_by_name(lexer, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 # read input code code = None if args: if len(args) > 1: print(usage, file=sys.stderr) return 2 if '-s' in opts: print('Error: -s option not usable when input file specified', file=sys.stderr) return 1 infn = args[0] try: with open(infn, 'rb') as infp: code = infp.read() except Exception as err: print('Error: cannot read infile:', err, file=sys.stderr) return 1 if not inencoding: code, inencoding = guess_decode(code) # do we have to guess the lexer? if not lexer: try: lexer = get_lexer_for_filename(infn, code, **parsed_opts) except ClassNotFound as err: if '-g' in opts: try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) else: print('Error:', err, file=sys.stderr) return 1 except OptionError as err: print('Error:', err, file=sys.stderr) return 1 elif '-s' not in opts: # treat stdin as full file (-s support is later) # read code from terminal, always in binary mode since we want to # decode ourselves and be tolerant with it if sys.version_info > (3, ): # Python 3: we have to use .buffer to get a binary stream code = sys.stdin.buffer.read() else: code = sys.stdin.read() if not inencoding: code, inencoding = guess_decode_from_terminal(code, sys.stdin) # else the lexer will do the decoding if not lexer: try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) # When using the LaTeX formatter and the option `escapeinside` is # specified, we need a special lexer which collects escaped text # before running the chosen language lexer. escapeinside = parsed_opts.get('escapeinside', '') if len(escapeinside) == 2 and isinstance(fmter, LatexFormatter): left = escapeinside[0] right = escapeinside[1] lexer = LatexEmbeddedLexer(left, right, lexer) # ... and do it! try: # process filters for fname, fopts in F_opts: lexer.add_filter(fname, **fopts) if '-s' not in opts: # process whole input as per normal... highlight(code, lexer, fmter, outfile) else: if not lexer: print( 'Error: when using -s a lexer has to be selected with -l', file=sys.stderr) return 1 # line by line processing of stdin (eg: for 'tail -f')... try: while 1: if sys.version_info > (3, ): # Python 3: we have to use .buffer to get a binary stream line = sys.stdin.buffer.readline() else: line = sys.stdin.readline() if not line: break if not inencoding: line = guess_decode_from_terminal(line, sys.stdin)[0] highlight(line, lexer, fmter, outfile) if hasattr(outfile, 'flush'): outfile.flush() except KeyboardInterrupt: return 0 except Exception: import traceback info = traceback.format_exception(*sys.exc_info()) msg = info[-1].strip() if len(info) >= 3: # extract relevant file and position info msg += '\n (f%s)' % info[-2].split('\n')[0].strip()[1:] print(file=sys.stderr) print('*** Error while highlighting:', file=sys.stderr) print(msg, file=sys.stderr) return 1 return 0
def render_listing(in_name, out_name, input_folder, output_folder, folders=[], files=[]): needs_ipython_css = False if in_name and in_name.endswith('.ipynb'): # Special handling: render ipynbs in listings (Issue #1900) ipynb_compiler = self.site.plugin_manager.getPluginByName( "ipynb", "PageCompiler").plugin_object with io.open(in_name, "r", encoding="utf8") as in_file: nb_json = ipynb_compiler._nbformat_read(in_file) ipynb_raw = ipynb_compiler._compile_string(nb_json) ipynb_html = lxml.html.fromstring(ipynb_raw) # The raw HTML contains garbage (scripts and styles), we can’t leave it in code = lxml.html.tostring( ipynb_html.xpath('//*[@id="notebook"]')[0], encoding='unicode') title = os.path.basename(in_name) needs_ipython_css = True elif in_name: with open(in_name, 'r') as fd: try: lexer = get_lexer_for_filename(in_name) except: try: lexer = guess_lexer(fd.read()) except: lexer = TextLexer() fd.seek(0) code = highlight(fd.read(), lexer, utils.NikolaPygmentsHTML(in_name)) title = os.path.basename(in_name) else: code = '' title = os.path.split(os.path.dirname(out_name))[1] crumbs = utils.get_crumbs(os.path.relpath( out_name, self.kw['output_folder']), is_file=True) permalink = self.site.link( 'listing', os.path.join( input_folder, os.path.relpath( out_name[:-5], # remove '.html' os.path.join(self.kw['output_folder'], output_folder)))) if in_name: source_link = permalink[:-5] # remove '.html' else: source_link = None context = { 'code': code, 'title': title, 'crumbs': crumbs, 'permalink': permalink, 'lang': self.kw['default_lang'], 'folders': natsort.natsorted(folders, alg=natsort.ns.F | natsort.ns.IC), 'files': natsort.natsorted(files, alg=natsort.ns.F | natsort.ns.IC), 'description': title, 'source_link': source_link, 'pagekind': ['listing'], } if needs_ipython_css: # If someone does not have ipynb posts and only listings, we # need to enable ipynb CSS for ipynb listings. context['needs_ipython_css'] = True self.site.render_template('listing.tmpl', out_name, context)
def plain(self, code, hl_lines): formatter = PlainHtmlFormatter() lexer = TextLexer() # TODO: make highlighting work for plain return highlight(code, lexer, formatter)
def main(args=sys.argv): """ Main command line entry point. """ # pylint: disable-msg=R0911,R0912,R0915 usage = USAGE % ((args[0],) * 6) if sys.platform in ['win32', 'cygwin']: try: # Provide coloring under Windows, if possible import colorama colorama.init() except ImportError: pass try: popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHg") except getopt.GetoptError as err: print(usage, file=sys.stderr) return 2 opts = {} O_opts = [] P_opts = [] F_opts = [] for opt, arg in popts: if opt == '-O': O_opts.append(arg) elif opt == '-P': P_opts.append(arg) elif opt == '-F': F_opts.append(arg) opts[opt] = arg if not opts and not args: print(usage) return 0 if opts.pop('-h', None) is not None: print(usage) return 0 if opts.pop('-V', None) is not None: print('Pygments version %s, (c) 2006-2013 by Georg Brandl.' % __version__) return 0 # handle ``pygmentize -L`` L_opt = opts.pop('-L', None) if L_opt is not None: if opts: print(usage, file=sys.stderr) return 2 # print version main(['', '-V']) if not args: args = ['lexer', 'formatter', 'filter', 'style'] for arg in args: _print_list(arg.rstrip('s')) return 0 # handle ``pygmentize -H`` H_opt = opts.pop('-H', None) if H_opt is not None: if opts or len(args) != 2: print(usage, file=sys.stderr) return 2 what, name = args if what not in ('lexer', 'formatter', 'filter'): print(usage, file=sys.stderr) return 2 _print_help(what, name) return 0 # parse -O options parsed_opts = _parse_options(O_opts) opts.pop('-O', None) # parse -P options for p_opt in P_opts: try: name, value = p_opt.split('=', 1) except ValueError: parsed_opts[p_opt] = True else: parsed_opts[name] = value opts.pop('-P', None) # handle ``pygmentize -N`` infn = opts.pop('-N', None) if infn is not None: try: lexer = get_lexer_for_filename(infn, **parsed_opts) except ClassNotFound as err: lexer = TextLexer() except OptionError as err: print('Error:', err, file=sys.stderr) return 1 print(lexer.aliases[0]) return 0 # handle ``pygmentize -S`` S_opt = opts.pop('-S', None) a_opt = opts.pop('-a', None) if S_opt is not None: f_opt = opts.pop('-f', None) if not f_opt: print(usage, file=sys.stderr) return 2 if opts or args: print(usage, file=sys.stderr) return 2 try: parsed_opts['style'] = S_opt fmter = get_formatter_by_name(f_opt, **parsed_opts) except ClassNotFound as err: print(err, file=sys.stderr) return 1 arg = a_opt or '' try: print(fmter.get_style_defs(arg)) except Exception as err: print('Error:', err, file=sys.stderr) return 1 return 0 # if no -S is given, -a is not allowed if a_opt is not None: print(usage, file=sys.stderr) return 2 # parse -F options F_opts = _parse_filters(F_opts) opts.pop('-F', None) # select formatter outfn = opts.pop('-o', None) fmter = opts.pop('-f', None) if fmter: try: fmter = get_formatter_by_name(fmter, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 if outfn: if not fmter: try: fmter = get_formatter_for_filename(outfn, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 try: outfile = open(outfn, 'wb') except Exception as err: print('Error: cannot open outfile:', err, file=sys.stderr) return 1 else: if not fmter: fmter = TerminalFormatter(**parsed_opts) outfile = sys.stdout # select lexer lexer = opts.pop('-l', None) if lexer: try: lexer = get_lexer_by_name(lexer, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 if args: if len(args) > 1: print(usage, file=sys.stderr) return 2 infn = args[0] try: code = open(infn, 'rb').read() except Exception as err: print('Error: cannot read infile:', err, file=sys.stderr) return 1 if not lexer: try: lexer = get_lexer_for_filename(infn, code, **parsed_opts) except ClassNotFound as err: if '-g' in opts: try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) else: print('Error:', err, file=sys.stderr) return 1 except OptionError as err: print('Error:', err, file=sys.stderr) return 1 else: if '-g' in opts: code = sys.stdin.read() try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) elif not lexer: print('Error: no lexer name given and reading ' + \ 'from stdin (try using -g or -l <lexer>)', file=sys.stderr) return 2 else: code = sys.stdin.read() # No encoding given? Use latin1 if output file given, # stdin/stdout encoding otherwise. # (This is a compromise, I'm not too happy with it...) if 'encoding' not in parsed_opts and 'outencoding' not in parsed_opts: if outfn: # encoding pass-through fmter.encoding = 'latin1' else: if sys.version_info < (3,): # use terminal encoding; Python 3's terminals already do that lexer.encoding = getattr(sys.stdin, 'encoding', None) or 'ascii' fmter.encoding = getattr(sys.stdout, 'encoding', None) or 'ascii' elif not outfn and sys.version_info > (3,): # output to terminal with encoding -> use .buffer outfile = sys.stdout.buffer # ... and do it! try: # process filters for fname, fopts in F_opts: lexer.add_filter(fname, **fopts) highlight(code, lexer, fmter, outfile) except Exception as err: import traceback info = traceback.format_exception(*sys.exc_info()) msg = info[-1].strip() if len(info) >= 3: # extract relevant file and position info msg += '\n (f%s)' % info[-2].split('\n')[0].strip()[1:] print(file=sys.stderr) print('*** Error while highlighting:', file=sys.stderr) print(msg, file=sys.stderr) return 1 return 0
def pygmentize_blob(value, path): try: lexer = guess_lexer_for_filename(path, value) except ClassNotFound: lexer = TextLexer() return mark_safe(highlight(value, lexer, HtmlFormatter()))
def show_text(text): return highlight(source(text), TextLexer(), HtmlFormatter(style='colorful'))
def format_text(text): result = highlight(text, TextLexer(), HtmlFormatter( noclasses=True, style='friendly')) return result
""" Like friendly, but a bit darker to enhance contrast on the green background. """ background_color = '#eeffcc' default_style = '' styles = FriendlyStyle.styles styles.update({ Generic.Output: 'italic #333', Comment: 'italic #408090', }) lexers = defaultdict( TextLexer, none=TextLexer(), python=PythonLexer(), pycon=PythonConsoleLexer(), rest=RstLexer(), c=CLexer(), ) for _lexer in lexers.values(): _lexer.add_filter('raiseonerror') fmter = HtmlFormatter(style=PythonDocStyle) def highlight_block(source, lang): if not pygments: return '<pre>' + cgi.escape(source) + '</pre>\n' if lang == 'python':
from sphinx.pygments_styles import SphinxStyle, NoneStyle from sphinx.util import logging from sphinx.util.pycompat import htmlescape from sphinx.util.texescape import tex_hl_escape_map_new if False: # For type annotation from typing import Any, Dict # NOQA from pygments.formatter import Formatter # NOQA from sphinx.util.typing import unicode # NOQA logger = logging.getLogger(__name__) lexers = { 'none': TextLexer(stripnl=False), 'python': PythonLexer(stripnl=False), 'python3': Python3Lexer(stripnl=False), 'pycon': PythonConsoleLexer(stripnl=False), 'pycon3': PythonConsoleLexer(python3=True, stripnl=False), 'rest': RstLexer(stripnl=False), 'c': CLexer(stripnl=False), } # type: Dict[unicode, Lexer] for _lexer in lexers.values(): _lexer.add_filter('raiseonerror') escape_hl_chars = {ord(u'\\'): u'\\PYGZbs{}', ord(u'{'): u'\\PYGZob{}', ord(u'}'): u'\\PYGZcb{}'}
def hilite(self): """ Pass code to the [Pygments](http://pygments.pocoo.org/) highliter with optional line numbers. The output should then be styled with css to your liking. No styles are applied by default - only styling hooks (i.e.: <span class="k">). returns : A string of html. """ self.src = self.src.strip('\n') self.colons = self.shebang = False if self.lang is None: self._getLang() use_linenos = True # preserve old Codehilite behavior for # backwards-compatibility if self.shebang: use_linenos = True elif self.colons: use_linenos = self.force_linenos # allow global linenos override if self.linenos is not None: use_linenos = self.linenos if pygments: try: lexer = get_lexer_by_name(self.lang) except ValueError: try: if self.guess_lang: lexer = guess_lexer(self.src) else: lexer = TextLexer() except ValueError: lexer = TextLexer() formatter = HtmlFormatter(linenos=use_linenos, cssclass=self.css_class, style=self.style, noclasses=self.noclasses) return highlight(self.src, lexer, formatter) else: # just escape and build markup usable by JS highlighting libs txt = self.src.replace('&', '&') txt = txt.replace('<', '<') txt = txt.replace('>', '>') txt = txt.replace('"', '"') classes = [] if self.lang: classes.append('language-%s' % self.lang) if self.linenos: classes.append('linenums') class_str = '' if classes: class_str = ' class="%s"' % ' '.join(classes) return '<pre class="%s"><code%s>%s</code></pre>\n' % ( self.css_class, class_str, txt)
def get_source_lexer(self, filename, data): return TextLexer()
def run(self): self.assert_has_content() try: lexer_name = self.arguments[0] lexer = get_lexer_by_name(lexer_name) except ValueError: # no lexer found - use the text one instead of an exception lexer_name = 'text' lexer = TextLexer() formatter = HtmlFormatter() # Construct cache filename cache_file = None content_text = u'\n'.join(self.content).encode('utf-8') cache_file_name = (u'%s-%s.html' % (lexer_name, hashlib.md5(content_text).hexdigest())) cached_path = self._get_cached_path(cache_file_name) # Look for cached version, otherwise parse if os.path.exists(cached_path): cache_file = open(cached_path, 'r') parsed = cache_file.read() else: parsed = highlight(content_text, lexer, formatter) # Strip pre tag and everything outside it pres = re.compile("<pre>(.+)<\/pre>", re.S) stripped = pres.search(parsed).group(1) lined = '' for idx, line in enumerate(stripped.splitlines(True)): lined += '<span class="line">%s</span>' % line # Add wrapper with optional caption and link code = '<figure class="code">' if self.options: caption = '' title = 'link' link = '' if 'caption' in self.options: caption = ('<span>%s</span>' % self.options['caption']) if 'title' in self.options: title = self.options['title'] if 'url' in self.options: link = ('<a href="%s">%s</a>' % (self.options['url'], title)) if caption or link: code += '<figcaption>%s %s</figcaption>' % (caption, link) code += ('<div class="highlight"><pre><code class="%s">%s</code>' '</pre></div>' % (lexer_name, lined)) code += '</figure>' # Write cache if cache_file is None: cache_file = open(cached_path, 'w') cache_file.write(parsed) cache_file.close() return [nodes.raw('', code, format='html')]
from sphinx.ext import doctest from sphinx.locale import __ from sphinx.pygments_styles import SphinxStyle, NoneStyle from sphinx.util import logging from sphinx.util.pycompat import htmlescape from sphinx.util.texescape import tex_hl_escape_map_new if False: # For type annotation from typing import Any, Dict # NOQA from pygments.formatter import Formatter # NOQA logger = logging.getLogger(__name__) lexers = dict( none=TextLexer(stripnl=False), python=PythonLexer(stripnl=False), python3=Python3Lexer(stripnl=False), pycon=PythonConsoleLexer(stripnl=False), pycon3=PythonConsoleLexer(python3=True, stripnl=False), rest=RstLexer(stripnl=False), c=CLexer(stripnl=False), ) # type: Dict[unicode, Lexer] for _lexer in lexers.values(): _lexer.add_filter('raiseonerror') escape_hl_chars = { ord(u'\\'): u'\\PYGZbs{}', ord(u'{'): u'\\PYGZob{}', ord(u'}'): u'\\PYGZcb{}' }
def highlight_text(text, lexer=TextLexer(), style=None): if style: formatter = TerminalTrueColorFormatter(style=style) else: formatter = TerminalTrueColorFormatter() return highlight(text, lexer, formatter)[:-1]
def highlight_text(no_color, text, style, lexer=TextLexer()): formatter = TerminalTrueColorFormatter(style=style) if no_color: formatter = TerminalTrueColorFormatter(style=NoColorStyle) return highlight(text, lexer, formatter)[:-1]
def render_listing(in_name, out_name, input_folder, output_folder, folders=[], files=[]): needs_ipython_css = False if in_name and in_name.endswith('.ipynb'): # Special handling: render ipynbs in listings (Issue #1900) ipynb_plugin = self.site.plugin_manager.getPluginByName("ipynb", "PageCompiler") if ipynb_plugin is None: msg = "To use .ipynb files as listings, you must set up the Jupyter compiler in COMPILERS and POSTS/PAGES." utils.LOGGER.error(msg) raise ValueError(msg) ipynb_compiler = ipynb_plugin.plugin_object with open(in_name, "r", encoding="utf8") as in_file: nb_json = ipynb_compiler._nbformat_read(in_file) code = ipynb_compiler._compile_string(nb_json) title = os.path.basename(in_name) needs_ipython_css = True elif in_name: with open(in_name, 'r', encoding='utf-8') as fd: try: lexer = get_lexer_for_filename(in_name) except Exception: try: lexer = guess_lexer(fd.read()) except Exception: lexer = TextLexer() fd.seek(0) code = highlight( fd.read(), lexer, utils.NikolaPygmentsHTML(in_name, linenos='table')) title = os.path.basename(in_name) else: code = '' title = os.path.split(os.path.dirname(out_name))[1] crumbs = utils.get_crumbs(os.path.relpath(out_name, self.kw['output_folder']), is_file=True) permalink = self.site.link( 'listing', os.path.join( input_folder, os.path.relpath( out_name[:-5], # remove '.html' os.path.join( self.kw['output_folder'], output_folder)))) if in_name: source_link = permalink[:-5] # remove '.html' else: source_link = None context = { 'code': code, 'title': title, 'crumbs': crumbs, 'permalink': permalink, 'lang': self.kw['default_lang'], 'folders': natsort.natsorted( folders, alg=natsort.ns.F | natsort.ns.IC), 'files': natsort.natsorted( files, alg=natsort.ns.F | natsort.ns.IC), 'description': title, 'source_link': source_link, 'pagekind': ['listing'], } if needs_ipython_css: # If someone does not have ipynb posts and only listings, we # need to enable ipynb CSS for ipynb listings. context['needs_ipython_css'] = True self.site.render_template('listing.tmpl', out_name, context)
from pygments import highlight from pygments.lexers import get_lexer_by_name, get_lexer_for_filename, TextLexer from pygments.formatters import HtmlFormatter from pygments.util import ClassNotFound # wrap lines in <span>s so that the Moin-generated line numbers work class MoinHtmlFormatter(HtmlFormatter): def wrap(self, source, outfile): for line in source: yield 1, '<span class="line">' + line[1] + '</span>' htmlformatter = MoinHtmlFormatter(noclasses=INLINESTYLES) textlexer = TextLexer() codeid = [0] class Parser: """ MoinMoin Pygments parser. """ if ATTACHMENTS: extensions = '*' else: extensions = [] Dependencies = [] def __init__(self, raw, request, **kw):
def _custom_guess(path): _, ext = os.path.splitext(path) if ext in _custom_lexers: return _custom_lexers[ext] return TextLexer()