def __highlight__(content, dom_element="pre", linenos=True, noclasses=True):
"""
Performs syntax highlighting on text inside of dom_element
Uses BeautifulSoup for processing and pygments for highlighting
@param content The HTML (or XML) content to parse
@param dom_element The dom tag to search and replace with highlighted
@return The content with highlighted code withing dom_element
"""
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter
from BeautifulSoup import BeautifulSoup, BeautifulStoneSoup
decodedString = unicode(BeautifulStoneSoup(content, convertEntities=BeautifulStoneSoup.HTML_ENTITIES))
# decodedString=html_entity_decode(content.encode('utf-8'))
soup = BeautifulSoup(content)
formatter = HtmlFormatter(linenos=linenos, noclasses=noclasses)
for tag in soup.findAll(dom_element):
language = tag.get("lang") or "text"
try:
lexer = get_lexer_by_name(language, encoding="UTF-8")
except:
lexer = get_lexer_by_name("text", encoding="UTF-8")
tag.replaceWith(highlight(tag.renderContents(), lexer, formatter))
pass
return unicode(str(soup), "utf-8", errors="ignore")
def _pygmentize(paste, lang):
"""
Guess (or force if lang is given) highlight on a given paste via pygments
"""
if lang:
try:
lexer = lexers.get_lexer_by_name(lang)
except lexers.ClassNotFound:
lexer = lexers.get_lexer_by_name('text')
else:
lexer = lexers.get_lexer_for_mimetype(paste.mimetype)
a = '<small><a href="/edit/%s">edit</a></small>' % (paste.id,)
if paste.ip:
ip = IPy.IP(long(paste.ip, 2))
util.log.debug('Originally pasted from %s' % (ip,))
if paste.filename:
title = u'%s, created on %s' % (paste.filename, paste.created, )
else:
title = u'created on %s' % (paste.created, )
title = '%s %s (%s)' % (paste.mimetype, title, a,)
util.log.debug(lexer)
return pygments.highlight(
paste.content, lexer, formatters.HtmlFormatter(
full=True, linenos='table',
encoding='utf-8', lineanchors='ln', title=title)
)
def hl(code,lang,p):
try:
lexer = get_lexer_by_name(lang,encoding='utf8')
except ClassNotFound:
lexer = get_lexer_by_name('text',encoding='utf8')
formatter = HtmlLineFormatter(pasteid=p,linenos=True,encoding='utf8')
return highlight(code,lexer,formatter)
def highlight(value, arg=None, autoescape=None):
"""
Filter syntax-highlights code.
Optional argument: lexer.
"""
if autoescape:
from django.utils.html import conditional_escape
escaper = conditional_escape
else:
escaper = lambda x: x
from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter
from pygments.lexers import get_lexer_by_name, guess_lexer
try:
lexer = get_lexer_by_name(arg, stripnl=False, encoding=u'UTF-8')
except ValueError:
try:
# Guess a lexer by the contents of the block.
lexer = guess_lexer(value)
except ValueError:
# Just make it plain text.
lexer = get_lexer_by_name(u'text', stripnl=False,
encoding=u'UTF-8')
# TODO: Translation. uggettext?
code = highlight(value, lexer, HtmlFormatter())
return mark_safe(code)
def syntax_hl(src, lang=None, guess_lang=False, inline=False, code_wrap=False):
"""Highlight."""
css_class = 'highlight'
src = src.strip('\n')
try:
lexer = get_lexer_by_name(lang)
except ValueError:
try:
if guess_lang:
lexer = guess_lexer(src)
else:
lexer = get_lexer_by_name('text')
except ValueError:
lexer = get_lexer_by_name('text')
if inline:
formatter = SublimeInlineHtmlFormatter(
cssclass=css_class
)
elif code_wrap:
formatter = SublimeWrapBlockFormatter(
cssclass=css_class
)
else:
formatter = SublimeBlockFormatter(
cssclass=css_class
)
return highlight(src, lexer, formatter)
def paste_lexer(pastename,lexmode=None):
global data, formatter
memory = Client(memcached)
database = Client(memcachedb)
bottle.response.content_type = "text/html;charset=UTF-8"
if bottle.request.environ['HTTP_X_FORWARDED_SSL'] == 'on':
proto = 'https'
else:
proto = 'http'
paste = msgpack.loads(get_data(memory,database,"paste:"+pastename) or "")
if paste:
if lexmode:
url="%s://%s/p%s/%s"%(proto,domain,pastename,lexmode)
else:
url="%s://%s/p%s"%(proto,domain,pastename)
rurl="%s://%s/rp%s"%(proto,domain,pastename)
if not paste[4]:
lexer_name = (lexmode or paste[2]).lower()
try:
lexer = get_lexer_by_name(lexer_name, stripall=True)
except:
lexer = get_lexer_by_name('text', stripall=True)
hlpaste = memory.get("hlcache:%s:%s" % (pastename, lexer_name))
if hlpaste == None:
hlpaste = highlight(paste[0].decode("utf-8"), lexer, formatter)
memory.set("hlcache:%s:%s" % (pastename, lexer_name),
hlpaste.encode("utf-8"))
else:
hlpaste = hlpaste.decode("utf-8")
return bottle.template('paste', paste=hlpaste, title=paste[1],
url=url, rurl=rurl, passwd=None, lexmode=lexer.name)
else:
if 'p' in bottle.request.params:
if sha256(bottle.request.params['p']).digest() == paste[4]:
lexer_name = (lexmode or paste[2]).lower()
try:
lexer = get_lexer_by_name(lexer_name, stripall=True)
except:
lexer = get_lexer_by_name('text', stripall=True)
hlpaste = memory.get("hlcache:%s:%s" % (pastename,
lexer_name))
if hlpaste == None:
hlpaste = highlight(paste[0].decode("utf-8"), lexer,
formatter)
memory.set("hlcache:%s:%s" % (pastename, lexer_name),
hlpaste.encode("utf-8"))
else:
hlpaste = hlpaste.decode("utf-8")
return bottle.template('paste', paste=hlpaste,
title=paste[1], url=url, rurl=rurl,
passwd=bottle.request.params['p'],
lexmode=lexer.name)
else:
return bottle.template("pasteauth", url=url, rurl=rurl,
passwd=None, incorrect=True)
else:
return bottle.template("pasteauth", url=url, rurl=rurl,
passwd=None, incorrect=False)
else:
raise HTTPError(404, "Paste not in database")
def generate_pygments_tex_file( input_file_path, output_file_path ):
if output_file_path is None:
inputf_no_ext = input_file_path.split(".")[0]
output_file_path = inputf_no_ext + ".tex"
print "Reading Notation 3 file: " + input_file_path
with open (input_file_path, "r") as input_file:
code = input_file.read()
# LatexFormatter( full = True ) may be useful to see the packages, color definitions, etc. required by the LaTeX document importing it
# linenos = True to show line numbers
linenos = not inputf_no_ext.endswith("nolinenos")
ext = input_file_path.split(".")[1]
lexer = None
if ext=="n3":
lexer = get_lexer_by_name("n3")
elif ext=="sparql":
lexer = get_lexer_by_name("sparql")
highlighted_code = highlight( code, lexer, LatexFormatter( linenos = linenos ) )
# super-ugly fix to hidde syntax errors.
# It would be better to simply fix the lesser
# I really hate setting the font here, but I wasn't able to do it in the main document :-S
highlighted_code = r"\expandafter\def\csname PY@tok@err\endcsname{}" + "\n{\small\n" + highlighted_code
highlighted_code += "\n}"
print "Generating pygmented file: " + output_file_path
with open (output_file_path, "w") as output_file:
output_file.write( highlighted_code )
def highlight_code(self, html):
BeautifulSoup.QUOTE_TAGS['code'] = None
soup = BeautifulSoup(html)
preblocks = soup.findAll('code')
for pre in preblocks:
if pre.has_key('class'):
try:
code = ''.join([unicode(item) for item in pre.contents])
if 'inline' in pre['class']:
lexer = lexers.get_lexer_by_name(pre['class'].split(' ')[0])
formatter = InlineHtmlFormatter()
code_hl = highlight(code, lexer, formatter)
pre.contents = [BeautifulSoup(code_hl)]
pre.name = 'span'
print "here"
print pre
else:
lexer = lexers.get_lexer_by_name(pre['class'])
formatter = formatters.HtmlFormatter(linenos='table')
code_hl = highlight(code, lexer, formatter)
pre.contents = [BeautifulSoup(code_hl)]
pre.name = 'div'
except:
#logging.debug(sys.exc_info())
#logging.debug(pre['class'])
break
return unicode(soup)
def run(self):
socket = self.context.socket(zmq.REP)
socket.connect('inproc://backend')
while True:
lang, code = socket.recv_multipart()
lang = lang.decode(encoding="UTF-8")
code = code.decode(encoding="UTF-8")
rv = ""
try:
try:
if lang == "gdb":
lex = GDBLexer(encoding="utf-8")
elif lang == "toml":
lex = TOMLLexer(encoding="utf-8")
else:
lex = get_lexer_by_name(lang, encoding="utf-8")
except ClassNotFound as err:
lex = get_lexer_by_name("text", encoding="utf-8")
rv = highlight(code, lex, self.formatter)
except ValueError as err:
rv = "Pygments Error: {}".format(err)
socket.send(rv)
socket.close()
def view_paste(paste):
r = get_paste(paste)
lang = request.args.get('l') if 'l' in request.args else r.language
paste = r.code
lexer = None
if lang == None:
try:
lexer = guess_lexer(paste)
except ClassNotFound:
pass
if lexer is None:
try:
lexer = get_lexer_by_name(lang)
except:
abort(500, 'Invalid lexer: %s' % lang)
if lexer is None:
try:
lexer = get_lexer_by_name('text')
except:
abort(500, 'Invalid lexer: %s' % lang)
formatter = HtmlFormatter(linenos=True)#, cssclass='syntax')#, style='friendly')
h = pygments.highlight(paste, lexer, formatter)
pasteid = r.private_id if r.private_id else r.paste_id
return render_template('viewpaste.html', data=h, theme=get_theme(),
langs=LANGS, pasteid=pasteid, currlang=lexer.aliases[0])
def __init__(self, document):
self.document = document
self.tokens = []
self.offsets = []
self.end = 0 # up to where we lexed last
if document.location:
filename = document.location
try:
# HACK! overrides should come from settings...
if os.path.splitext(filename)[1] == '.html':
# assume django template
self.lexer = get_lexer_by_name('html+django',
stripnl=False,
encoding='utf8')
elif os.path.splitext(filename)[1] == '.py':
# otherwise we end up with the annoying NumPy lexer..
self.lexer = get_lexer_by_name('python',
stripnl=False,
encoding='utf8')
else:
self.lexer = get_lexer_for_filename(filename,
stripnl=False,
encoding='utf8')
except ClassNotFound:
self.lexer = None
else:
self.lexer = None
def main(fn, lexer=None):
if lexer is not None:
lx = get_lexer_by_name(lexer)
else:
try:
lx = get_lexer_for_filename(os.path.basename(fn))
except ValueError:
try:
name, rest = fn.split('_', 1)
lx = get_lexer_by_name(name)
except ValueError:
raise AssertionError('no lexer found for file %r' % fn)
debug_lexer = False
# does not work for e.g. ExtendedRegexLexers
if lx.__class__.__bases__ == (RegexLexer,):
lx.__class__.__bases__ = (DebuggingRegexLexer,)
debug_lexer = True
lno = 1
text = file(fn, 'U').read()
text = text.strip('\n') + '\n'
text = text.decode('latin1')
tokens = []
states = []
def show_token(tok, state):
reprs = map(repr, tok)
print ' ' + reprs[1] + ' ' + ' ' * (29-len(reprs[1])) + reprs[0],
if debug_lexer:
print ' ' + ' ' * (29-len(reprs[0])) + repr(state),
print
for type, val in lx.get_tokens(text):
lno += val.count('\n')
if type == Error:
print 'Error parsing', fn, 'on line', lno
print 'Previous tokens' + (debug_lexer and ' and states' or '') + ':'
if showall:
for tok, state in zip(tokens, states):
show_token(tok, state)
else:
for i in range(len(tokens) - num, len(tokens)):
show_token(tokens[i], states[i])
print 'Error token:'
l = len(repr(val))
print ' ' + repr(val),
if debug_lexer and hasattr(lx, 'statestack'):
print ' ' * (60-l) + repr(lx.statestack),
print
print
return 1
tokens.append((type,val))
if debug_lexer:
if hasattr(lx, 'statestack'):
states.append(lx.statestack[:])
else:
states.append(None)
if showall:
for tok, state in zip(tokens, states):
show_token(tok, state)
return 0
def has_custom_pygments_lexer(name):
from pygments.lexers import get_lexer_by_name
if name == 'ipy':
try:
get_lexer_by_name('ipy')
except Exception as e:
print '*** warning: !bc ipy used for IPython sessions, but'
print ' ipython is not supported for syntax highlighting!'
print ' install:'
print ' git clone https://[email protected]/hplbit/pygments-ipython-console.git; cd pygments-ipython-console; sudo python setup.py install'
print e
return False
if name == 'doconce':
try:
get_lexer_by_name(name)
except Exception as e:
print '*** warning: !bc do used for DocOnce code, but'
print ' not supported for syntax highlighting!'
print ' install:'
print ' sudo pip install -e git+https://github.com/hplgit/pygments-doconce#egg=pygments-doconce'
print '\n or manually:'
print ' git clone https://github.com/hplgit/pygments-doconce.git; cd pygments-doconce; sudo python setup.py install'
print e
return False
return True
def colorize(paste_key):
" Color the paste in a deferred task. "
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter
from pygments.lexers import guess_lexer
paste = db.get(paste_key)
if paste.syntax == 'auto':
lexer = guess_lexer(paste.text)
else:
lexer = get_lexer_by_name(paste.syntax, stripall=True)
if lexer is None:
lexer = guess_lexer(paste.text)
if lexer is None:
lexer = get_lexer_by_name('text')
formatter = HtmlFormatter(linenos=True, cssclass="highlight")
paste.syntax = lexer.name
paste.highlighted = highlight(paste.text, lexer, formatter)
paste.colorized=True
paste.put()
def _style(raw_code, language, cssclass):
"""Returns a string of formatted and styled HTML, where
raw_code is a string, language is a string that Pygments has a lexer for,
and cssclass is a class style available for Pygments."""
# Note: eventually, cssclass would be obtained from a user's preferences
# and would not need to be passed as an argument to style()
global _pygment_lexer_names, _sharp
raw_code = replace_entity_pattern(raw_code)
requested_language = language
try:
lexer = lexers[language]
except:
if language in _pygment_lexer_names:
language = _pygment_lexer_names[requested_language]
lexers[requested_language] = get_lexer_by_name(language)
else:
lexers[language] = get_lexer_by_name(language)
lexer = lexers[requested_language]
formatter = PreHtmlFormatter()
formatter.cssclass = cssclass
formatter.style = get_style_by_name(cssclass)
# the removal of "\n" below prevents an extra space to be introduced
# with the background color of the selected cssclass
styled_code = highlight(raw_code, lexer, formatter).replace("\n</pre>", "</pre>")
return recover_entity_pattern(styled_code)
def _lang_by_name(self, lang_name):
try:
get_lexer_by_name(lang_name, encoding='utf-8')
return lang_name
except (ClassNotFound, ImportError) as e:
self.log(self.logger.WARNING, '%s: %s' % (lang_name, e))
return ''
def colorize (self, sheet_content):
""" Colorizes cheatsheet content if so configured """
# only colorize if so configured
if 'CHEATCOLORS' not in os.environ:
return sheet_content
try:
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import TerminalFormatter
# if pygments can't load, just return the uncolorized text
except ImportError:
return sheet_content
first_line = sheet_content.splitlines()[0]
lexer = get_lexer_by_name('bash')
if first_line.startswith('```'):
sheet_content = '\n'.join(sheet_content.split('\n')[1:-2])
try:
lexer = get_lexer_by_name(first_line[3:])
except Exception:
pass
return highlight(sheet_content, lexer, TerminalFormatter())
def get_file_lexer(filename, content):
""" Try to get a lexer by file extension, guess by content if that fails.
"""
try:
# Pygments sometimes returns a weird lexer for .txt files.
if filename.lower().endswith('.txt'):
lexer = lexers.get_lexer_by_name('text')
debug('Lexer forced by extension: {:>20} -> {}'.format(
lexer.name,
filename,
))
else:
lexer = lexers.get_lexer_for_filename(filename)
debug('Lexer chosen by file name: {:>20} -> {}'.format(
lexer.name,
filename,
))
except ClassNotFound:
try:
# Guess by content.
lexer = lexers.guess_lexer(content)
debug('Lexer guessed by content: {:>20} -> {}'.format(
lexer.name,
filename,
))
except ClassNotFound:
# Fall back to default lexer.
lexer = lexers.get_lexer_by_name(DEFAULT_LEXER)
debug('Lexer set to default: {:>20} -> {}'.format(
lexer.name,
filename,
))
return lexer
def __init__(self, config):
super().__init__(config)
log.debug("Text Backend Init.")
if hasattr(self.bot_config, 'BOT_IDENTITY') and 'username' in self.bot_config.BOT_IDENTITY:
self.bot_identifier = self.build_identifier(self.bot_config.BOT_IDENTITY['username'])
else:
# Just a default identity for the bot if nothing has been specified.
self.bot_identifier = self.build_identifier('@errbot')
log.debug('Bot username set at %s.', self.bot_identifier)
self._inroom = False
self._rooms = []
self._multiline = False
self.demo_mode = self.bot_config.TEXT_DEMO_MODE if hasattr(self.bot_config, 'TEXT_DEMO_MODE') else False
if not self.demo_mode:
self.md_html = xhtml() # for more debug feedback on md
self.md_text = text() # for more debug feedback on md
self.md_borderless_ansi = borderless_ansi()
self.md_im = imtext()
self.md_lexer = get_lexer_by_name("md", stripall=True)
self.md_ansi = ansi()
self.html_lexer = get_lexer_by_name("html", stripall=True)
self.terminal_formatter = Terminal256Formatter(style='paraiso-dark')
self.user = self.build_identifier(self.bot_config.BOT_ADMINS[0])
self._register_identifiers_pickling()
def highlight_code(code, language, formatter):
try:
lexer = get_lexer_by_name(language)
except ClassNotFound:
lexer = get_lexer_by_name("text")
highlighted = "\n\n{0}\n\n".format(highlight(code, lexer, formatter))
return highlighted
def block_code(self, text, lang):
try:
lexer = get_lexer_by_name(lang, stripall=True)
except:
lexer = get_lexer_by_name('text')
formatter = HtmlFormatter(cssclass='highlight {0}'.format(lexer.name.lower()))
return highlight(text, lexer, formatter)
def block_code(self,
code,
lang,
code_tag=True,
inlinestyles=False,
linenos=False):
"""Render code block.
:param code_tag: If True html will contain <code>-tag.
:param inlinestyles: If True html contains inline styles.
:param linenos: If True html contains line numbers
:return:
"""
try:
lexer = get_lexer_by_name(lang, stripnl=False)
except pygments.util.ClassNotFound:
lexer = get_lexer_by_name('text', stripnl=False)
if code_tag:
formatter = CodeHtmlFormatter(lang,
noclasses=inlinestyles,
linenos=linenos)
else:
formatter = HtmlFormatter(noclasses=inlinestyles, linenos=linenos)
return highlight(code, lexer=lexer, formatter=formatter)
def test_get_lexers():
# test that the lexers functions work
def verify(func, args):
x = func(opt='val', *args)
assert isinstance(x, lexers.PythonLexer)
assert x.options["opt"] == "val"
for func, args in [(lexers.get_lexer_by_name, ("python",)),
(lexers.get_lexer_for_filename, ("test.py",)),
(lexers.get_lexer_for_mimetype, ("text/x-python",)),
(lexers.guess_lexer, ("#!/usr/bin/python -O\nprint",)),
(lexers.guess_lexer_for_filename, ("a.py", "<%= @foo %>"))
]:
yield verify, func, args
for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.items():
assert cls == lexers.find_lexer_class(lname).__name__
for alias in aliases:
assert cls == lexers.get_lexer_by_name(alias).__class__.__name__
for mimetype in mimetypes:
assert cls == lexers.get_lexer_for_mimetype(mimetype).__class__.__name__
try:
lexers.get_lexer_by_name(None)
except ClassNotFound:
pass
else:
raise Exception
def style_ansi(raw_code, lang=None):
""" actual code hilite """
lexer = 0
if lang:
try:
lexer = get_lexer_by_name(lang)
except ValueError:
print col(R, 'Lexer for %s not found' % lang)
lexer = None
if not lexer:
try:
if guess_lexer:
lexer = pyg_guess_lexer(raw_code)
except:
pass
if not lexer:
lexer = get_lexer_by_name(def_lexer)
tokens = lex(raw_code, lexer)
cod = []
for t, v in tokens:
if not v:
continue
_col = code_hl_tokens.get(t)
if _col:
cod.append(col(v, _col))
else:
cod.append(v)
return ''.join(cod)
def process(self, attributes, content, reason):
lexer_name = attributes.get('syntax', 'text')
try:
lexer = get_lexer_by_name(lexer_name)
except ValueError:
lexer = get_lexer_by_name('text')
return HTMLElement(highlight(content, lexer, get_formatter()))
def __init__(self, config):
super().__init__(config)
log.debug("Text Backend Init.")
try:
# Load readline for better editing/history behaviour
import readline
except ImportError:
# Readline is Unix-only
log.debug("Python readline module is not available")
pass
self.bot_identifier = self.build_identifier('Err')
self.demo_mode = self.bot_config.TEXT_DEMO_MODE if hasattr(self.bot_config, 'TEXT_DEMO_MODE') else False
self._rooms = set()
if not self.demo_mode:
self.md_html = xhtml() # for more debug feedback on md
self.md_text = text() # for more debug feedback on md
self.md_borderless_ansi = borderless_ansi()
self.md_im = imtext()
self.md_lexer = get_lexer_by_name("md", stripall=True)
self.md_ansi = ansi()
self.html_lexer = get_lexer_by_name("html", stripall=True)
self.terminal_formatter = Terminal256Formatter(style='paraiso-dark')
self.user = self.build_identifier(self.bot_config.BOT_ADMINS[0])
def colorize(language, title, text):
"""Colorize the text syntax.
Guess the language of the text and colorize it.
Returns a tuple containing the colorized text and the language name.
"""
formatter = HtmlFormatter(
linenos=True, style=PygmentsStyle, noclasses=True, nobackground=True)
#Try to get the lexer by name
try:
lexer = get_lexer_by_name(language.lower())
return highlight(text, lexer, formatter), lexer.name
except LexerNotFound:
pass
#Try to get the lexer by filename
try:
lexer = get_lexer_for_filename(title.lower())
return highlight(text, lexer, formatter), lexer.name
except LexerNotFound:
pass
#Try to guess the lexer from the text
try:
lexer = guess_lexer(text)
if lexer.analyse_text(text) > .3:
return highlight(text, lexer, formatter), lexer.name
except LexerNotFound:
pass
#Fallback to the plain/text lexer
lexer = get_lexer_by_name('text')
return highlight(text, lexer, formatter), lexer.name
def setup(app):
app.add_domain(HTTPDomain)
try:
get_lexer_by_name('http')
except ClassNotFound:
app.add_lexer('http', HTTPLexer())
app.add_config_value('http_index_ignore_prefixes', [], None)
def add_code_style(self, content):
"""
добавялем подсветку кода
"""
code_start = u"<pre><code>"
code_end = u"</code></pre>"
code_start_len = len(code_start)
is_code = False
_lexer = "text"
code = []
result = []
for line in content.splitlines():
if line.startswith(code_start):
is_code = True
_lexer = line[code_start_len:].strip()
elif line.endswith(code_end):
is_code = False
try:
lexer = get_lexer_by_name(_lexer, stripall=True)
except ValueError:
lexer = get_lexer_by_name("text", stripall=True)
formatter = HtmlFormatter()
result.append(
highlight(u"\n".join(i.replace("<", "<").replace(">", ">") for i in code), lexer, formatter)
)
code = []
elif is_code:
code.append(line)
else:
result.append(line)
return u"\n".join(result)
def syntax(dic, text):
"""
highlight code using pygments
USAGE:
[rk:syntax lang="LANG_NAME"]CODE[/rk:syntax]
"""
pygments_formatter = HtmlFormatter()
langs = {}
for i in dic:
try:
lexer = get_lexer_by_name(i['attributes']['lang'])
except ValueError:
lexer = get_lexer_by_name('text')
if i['attributes']['lang'] == 'php' and i['code'].find('<?php') < 1:
i['code'] = '<?php\n\r%s' % i['code']
parsed = highlight(i['code'], lexer, pygments_formatter)
text = text.replace(i['tag'], '<div class="box" style="overflow:hidden;font-size:11px;">%s</div>' % parsed)
langs['<style>%s</style>' % pygments_formatter.get_style_defs()] = True
styles = ''
for style in langs.keys():
styles = styles + style
text = text + styles
return text
return 1
try:
outfile = open(outfn, 'wb')
except Exception, err:
print >> sys.stderr, 'Error: cannot open outfile:', err
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), err:
print >> sys.stderr, 'Error:', err
return 1
if args:
if len(args) > 1:
print >> sys.stderr, usage
return 2
infn = args[0]
try:
code = open(infn, 'rb').read()
except Exception, err:
print >> sys.stderr, 'Error: cannot read infile:', err
return 1
import collections
import os
import os.path
import re
import subprocess
import sys
from urllib.parse import urlparse
from typing import List, Optional, Dict, Tuple
from pygments import highlight
from pygments.formatters.html import HtmlFormatter
from pygments.lexers import get_lexer_by_name
from h2o_wave import main, app, Q, ui
py_lexer = get_lexer_by_name('python')
html_formatter = HtmlFormatter(full=True, style='xcode')
example_dir = os.path.dirname(os.path.realpath(__file__))
_app_address = urlparse(
os.environ.get(f'H2O_WAVE_APP_ADDRESS', 'http://127.0.0.1:8000'))
_app_host, _app_port = _app_address.hostname, '10102'
class Example:
def __init__(self, filename: str, title: str, description: str,
source: str):
self.name = os.path.splitext(filename)[0]
self.filename = filename
self.title = title
self.description = description
def source(self, code):
"""Source code highlighting for any language"""
lexer = get_lexer_by_name(self.language.replace(' ', ''))
formatter = HtmlFormatter(noclasses=True, linenos='table')
return highlight(code, lexer, formatter)
# Build out the appropriate matchers and delimiters for each language.
for ext, l in languages.items():
# Does the line begin with a comment?
l["comment_matcher"] = re.compile(r"^\s*" + l["symbol"] + "\s?")
# The dividing token we feed into Pygments, to delimit the boundaries between
# sections.
l["divider_text"] = "\n" + l["symbol"] + "DIVIDER\n"
# The mirror of `divider_text` that we expect Pygments to return. We can split
# on this to recover the original sections.
l["divider_html"] = re.compile(r'\n*<span class="c[1]?">' + l["symbol"] +
'DIVIDER</span>\n*')
# Get the Pygments Lexer for this language.
l["lexer"] = lexers.get_lexer_by_name(l["name"])
def get_language(source, code, language=None):
"""Get the current language we're documenting, based on the extension."""
if language is not None:
for l in languages.values():
if l["name"] == language:
return l
else:
raise ValueError("Unknown forced language: " + language)
m = re.match(r'.*(\..+)', os.path.basename(source)) if source else None
if m and m.group(1) in languages:
return languages[m.group(1)]
def get_lexer(self): return lexers.get_lexer_by_name(self.language_code)
def _get_lexer(self):
if self.syntax:
return get_lexer_by_name(self.syntax)
else:
return guess_lexer(self.code)
def highlight_code(code, lang):
return highlight(code, get_lexer_by_name(lang), HtmlFormatter())
def syntax_highlight(data):
if not data:
return ''
lexer = lexers.get_lexer_by_name('sql')
formatter = formatters.HtmlFormatter(linenos=False)
return highlight(data, lexer, formatter)
def get(self, request, *args, **kwargs):
"""Handle GET requests for this view.
This will create the renderer for the diff fragment, render it, and
return it.
If there's an error when rendering the diff fragment, an error page
will be rendered and returned instead.
Args:
request (django.http.HttpRequest):
The HTTP request.
*args (tuple):
Additional positional arguments for the view.
**kwargs (dict):
Additional keyword arguments for the view.
Returns:
django.http.HttpResponse:
A response containing the rendered fragment.
"""
filediff_id = kwargs.get('filediff_id')
interfilediff_id = kwargs.get('interfilediff_id')
chunk_index = kwargs.get('chunk_index')
base_filediff_id = request.GET.get('base-filediff-id')
try:
renderer_settings = self._get_renderer_settings(**kwargs)
etag = self.make_etag(renderer_settings, **kwargs)
if etag_if_none_match(request, etag):
return HttpResponseNotModified()
diff_info_or_response = self.process_diffset_info(
base_filediff_id=base_filediff_id,
**kwargs)
if isinstance(diff_info_or_response, HttpResponse):
return diff_info_or_response
except Http404:
raise
except Exception as e:
logging.exception('%s.get: Error when processing diffset info '
'for filediff ID=%s, interfilediff ID=%s, '
'chunk_index=%s: %s',
self.__class__.__name__,
filediff_id,
interfilediff_id,
chunk_index,
e,
request=request)
return exception_traceback(self.request, e,
self.error_template_name)
kwargs.update(diff_info_or_response)
try:
context = self.get_context_data(**kwargs)
renderer = self.create_renderer(
context=context,
renderer_settings=renderer_settings,
*args, **kwargs)
response = renderer.render_to_response(request)
except PatchError as e:
logging.warning(
'%s.get: PatchError when rendering diffset for filediff '
'ID=%s, interfilediff ID=%s, chunk_index=%s: %s',
self.__class__.__name__,
filediff_id,
interfilediff_id,
chunk_index,
e,
request=request)
try:
url_kwargs = {
key: kwargs[key]
for key in ('chunk_index', 'interfilediff_id',
'review_request_id', 'filediff_id',
'revision', 'interdiff_revision')
if key in kwargs and kwargs[key] is not None
}
bundle_url = local_site_reverse('patch-error-bundle',
kwargs=url_kwargs,
request=request)
except NoReverseMatch:
# We'll sometimes see errors about this failing to resolve when
# web crawlers start accessing fragment URLs without the proper
# attributes. Ignore them.
bundle_url = ''
if e.rejects:
lexer = get_lexer_by_name('diff')
formatter = HtmlFormatter()
rejects = highlight(e.rejects, lexer, formatter)
else:
rejects = None
return HttpResponseServerError(render_to_string(
self.patch_error_template_name,
RequestContext(request, {
'bundle_url': bundle_url,
'file': diff_info_or_response['diff_file'],
'filename': os.path.basename(e.filename),
'patch_output': e.error_output,
'rejects': mark_safe(rejects),
})))
except FileNotFoundError as e:
return HttpResponseServerError(render_to_string(
self.error_template_name,
RequestContext(request, {
'error': e,
'file': diff_info_or_response['diff_file'],
})))
except Exception as e:
logging.exception('%s.get: Error when rendering diffset for '
'filediff ID=%s, interfilediff ID=%s, '
'chunkindex=%s: %s',
self.__class__.__name__,
filediff_id,
interfilediff_id,
chunk_index,
e,
request=request)
return exception_traceback(
self.request, e, self.error_template_name,
extra_context={
'file': diff_info_or_response['diff_file'],
})
if response.status_code == 200:
set_etag(response, etag)
return response
def render_snippet(txt, lexer):
lexer = get_lexer_by_name(find_lexer(lexer))
return highlight(txt,lexer,HtmlFormatter())
def __init__(self, style='tango'):
self.lexer = get_lexer_by_name("python")
self.style = style
self.set_style(style)
def pygments_highlight(text, lang, style):
lexer = get_lexer_by_name(lang, stripall=False)
formatter = HtmlFormatter(nowrap=True, style=style)
return pygments.highlight(text, lexer, formatter)
def __init__(self, **kwargs):
super(LuaCodeInput, self).__init__(**kwargs)
self.lexer = lexers.get_lexer_by_name('lua')
def source_by_run_id(request, run_id):
try:
solution = Solution.objects.get(solution_id=run_id)
except Solution.DoesNotExist:
return HttpResponse('not found such solution', status=404)
if solution.user_id != request.user.username and not request.user.is_superuser:
return HttpResponse('do not have permissions', status=304)
height_style = request.GET.get('style', 'monokai')
try:
source_code = OjSourceCode.objects.get(solution_id=run_id)
except ObjectDoesNotExist:
return HttpResponse('no this problem', status=404)
if 'file' in request.GET:
if request.GET.get('file') == 'as_txt_file':
file_name = 'oj-' + run_id + '.txt'
else:
file_name = 'oj-' + run_id
return render_source_file(request, source_code.source, file_name)
_url = request.get_host() + reverse('only_source_by_run_id',
args=[
run_id,
])
if request.is_secure():
_url = 'https://' + _url
else:
_url = 'http://' + _url
if 'qrcode' in request.GET:
return render_qrcode(request, _url)
poster = solution.user_id
if solution.judge_type == 0:
lang = language_name[solution.language]
if 13 <= solution.language <= 14:
standard_lang = 'C++'
elif solution.language == 6:
standard_lang = 'Python'
elif solution.language == 3:
standard_lang = 'Java'
elif solution.language == 16:
standard_lang = 'JavaScript'
elif solution.language == 17:
standard_lang = 'Python3'
else:
standard_lang = lang
else:
lang = solution.language_name
if solution.language_name == 'G++':
standard_lang = 'C++'
elif solution.language_name == 'GCC':
standard_lang = 'C'
else:
standard_lang = solution.language_name
lexer = get_lexer_by_name(standard_lang)
source = source_code.source
start_time = time.time()
style_sheet = HtmlFormatter(
linenos=True, style=height_style).get_style_defs('.highlight')
source = highlight(source, lexer,
HtmlFormatter(linenos=True, style=height_style))
use_time = round((time.time() - start_time) * 1000, 2)
return render_source_page(request, poster, run_id, height_style,
style_sheet, source, lang, solution.in_date,
use_time, _url)
def highlight_block(self,
source,
lang,
opts=None,
warn=None,
force=False,
**kwargs):
if not isinstance(source, text_type):
source = source.decode()
# find out which lexer to use
if lang in ('py', 'python'):
if source.startswith('>>>'):
# interactive session
lexer = lexers['pycon']
elif not force:
# maybe Python -- try parsing it
if self.try_parse(source):
lexer = lexers['python']
else:
lexer = lexers['none']
else:
lexer = lexers['python']
elif lang in ('python3', 'py3') and source.startswith('>>>'):
# for py3, recognize interactive sessions, but do not try parsing...
lexer = lexers['pycon3']
elif lang == 'guess':
try:
lexer = guess_lexer(source)
except Exception:
lexer = lexers['none']
else:
if lang in lexers:
lexer = lexers[lang]
else:
if lang.startswith("force_"):
lang = lang.split("force_", 1)[1]
raiseonerror = False
else:
raiseonerror = True
try:
lexer = lexers[lang] = get_lexer_by_name(
lang, **(opts or {}))
except ClassNotFound:
if warn:
warn('Pygments lexer name %r is not known' % lang)
lexer = lexers['none']
else:
raise
else:
if raiseonerror:
lexer.add_filter('raiseonerror')
# trim doctest options if wanted
if isinstance(lexer, PythonConsoleLexer) and self.trim_doctest_flags:
source = doctest.blankline_re.sub('', source)
source = doctest.doctestopt_re.sub('', source)
# highlight via Pygments
formatter = self.get_formatter(**kwargs)
try:
hlsource = highlight(source, lexer, formatter)
except ErrorToken as exc:
# this is most probably not the selected language,
# so let it pass unhighlighted
if warn:
warn(
'Could not parse literal_block as "%s". highlighting skipped.'
% lang)
else:
raise exc
hlsource = highlight(source, lexers['none'], formatter)
if self.dest == 'html':
return hlsource
else:
if not isinstance(hlsource, text_type): # Py2 / Pygments < 1.6
hlsource = hlsource.decode()
return hlsource.translate(tex_hl_escape_map_new)
def run(self):
"""Run code block directive."""
self.assert_has_content()
if 'linenos' in self.options:
self.options['number-lines'] = self.options['linenos']
if 'tab-width' in self.options:
self.content = [
x.replace('\t', ' ' * self.options['tab-width'])
for x in self.content
]
if self.arguments:
language = self.arguments[0]
else:
language = 'text'
set_classes(self.options)
classes = ['code']
if language:
classes.append(language)
if 'classes' in self.options:
classes.extend(self.options['classes'])
code = '\n'.join(self.content)
try:
lexer = get_lexer_by_name(language)
except pygments.util.ClassNotFound:
raise self.error(
'Cannot find pygments lexer for language "{0}"'.format(
language))
if 'number-lines' in self.options:
linenos = 'table'
# optional argument `startline`, defaults to 1
try:
linenostart = int(self.options['number-lines'] or 1)
except ValueError:
raise self.error(':number-lines: with non-integer start value')
else:
linenos = False
linenostart = 1 # actually unused
if self.site.invariant: # for testing purposes
anchor_ref = 'rest_code_' + 'fixedvaluethatisnotauuid'
else:
anchor_ref = 'rest_code_' + uuid.uuid4().hex
formatter = utils.NikolaPygmentsHTML(anchor_ref=anchor_ref,
classes=classes,
linenos=linenos,
linenostart=linenostart)
out = pygments.highlight(code, lexer, formatter)
node = nodes.raw('', out, format='html')
self.add_name(node)
# if called from "include", set the source
if 'source' in self.options:
node.attributes['source'] = self.options['source']
return [node]
def lexer_name(self):
if self.lexer == 'markdown':
return 'Markdown'
else:
return get_lexer_by_name(self.lexer).name
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify_uniquely(self.title, Snipt)
if not self.key:
self.key = md5.new(self.slug + str(datetime.datetime.now()) +
str(random.random())).hexdigest()
if self.lexer == 'markdown':
self.stylized = markdown(self.code, 'default')
# Snipt embeds
for match in re.findall('\[\[(\w{32})\]\]', self.stylized):
self.stylized = self.stylized.replace(
'[[' + str(match) + ']]',
'<script type="text/javascript" src="https://snipt.net/embed/{}/?snipt"></script><div id="snipt-embed-{}"></div>'
.format(match, match))
# YouTube embeds
for match in re.findall('\[\[youtube-(\w{11})\-(\d+)x(\d+)\]\]',
self.stylized):
self.stylized = self.stylized.replace(
'[[youtube-{}-{}x{}]]'.format(str(match[0]), str(match[1]),
str(match[2])),
'<iframe width="{}" height="{}" src="https://www.youtube.com/embed/{}" frameborder="0" allowfullscreen></iframe>'
.format(match[1], match[2], match[0]))
# Vimeo embeds
for match in re.findall('\[\[vimeo-(\d+)\-(\d+)x(\d+)\]\]',
self.stylized):
self.stylized = self.stylized.replace(
'[[vimeo-{}-{}x{}]]'.format(str(match[0]), str(match[1]),
str(match[2])),
'<iframe src="https://player.vimeo.com/video/{}" width="{}" height="{}" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'
.format(match[0], match[1], match[2]))
# Tweet embeds
for match in re.findall('\[\[tweet-(\d+)\]\]', self.stylized):
self.stylized = self.stylized.replace(
'[[tweet-{}]]'.format(str(match)),
'<div class="embedded-tweet" data-tweet-id="{}"></div>'.
format(str(match)))
# Parse Snipt usernames
for match in re.findall('@(\w+) ', self.stylized):
# Try and get the Snipt user by username.
user = get_object_or_None(User, username=match)
if user:
url = user.profile.get_user_profile_url()
self.stylized = self.stylized.replace(
'@{} '.format(str(match)),
'<a href="{}">@{}</a> '.format(url, match))
else:
self.stylized = highlight(
self.code, get_lexer_by_name(self.lexer, encoding='UTF-8'),
HtmlFormatter(
linenos='table',
anchorlinenos=True,
lineanchors='L',
linespans='L',
))
self.line_count = len(self.code.split('\n'))
if self.lexer == 'markdown':
lexer_for_embedded = 'text'
else:
lexer_for_embedded = self.lexer
embedded = highlight(
self.code, get_lexer_by_name(lexer_for_embedded, encoding='UTF-8'),
HtmlFormatter(style='native',
noclasses=True,
prestyles="""
background-color: #1C1C1C;
border-radius: 5px;
color: #D0D0D0;
display: block;
font: 11px Monaco, monospace;
margin: 0;
overflow: auto;
padding: 15px;
-webkit-border-radius: 5px;
-moz-border-radius: 5px;
"""))
embedded = (embedded.replace("\\\"", "\\\\\"").replace(
'\'', '\\\'').replace("\\",
"\\\\").replace('background: #202020', ''))
self.embedded = embedded
return super(Snipt, self).save(*args, **kwargs)
def tokenize(input_file, file_format, text_style):
lexer = get_lexer_by_name(file_format, stripall=True)
formatter = HtmlFormatter(noclasses=True,
nobackground=True,
style=text_style)
return (highlight(input_file, lexer, formatter))
def render_non_journal(file: Path):
is_secret = re.search(r"\b(secret|credential)s?\b$", file.stem)
journal_date: Optional[str]
if file.is_relative_to(ASSET_ROOT):
journal_date = "-".join(get_asset_date(file))
else:
journal_date = None
if is_secret and not is_localhost():
return render_template(
"non-journal.html.j2",
breadcrumbs=make_breadcrumbs(file),
content="",
theme_mode=get_theme_from_cookie(),
is_secret=True,
is_localhost=False,
journal_date=journal_date,
)
name, ext = os.path.splitext(file)
mime_type = mimetypes.guess_type(file)[0]
if not ext:
with open(file, "r") as f:
return f.read()
elif ext == ".md":
return format_markdown(
file,
title=file.stem,
template="non-journal",
breadcrumbs=make_breadcrumbs(file),
is_secret=is_secret,
is_localhost=is_localhost(),
highlight_article=is_secret,
journal_date=journal_date,
)
elif ext == ".drawio":
mt = "application/vnd.jgraph.mxfile"
with open(file, "r") as f:
img = f.read()
resp = Response(img, mimetype=mt)
return resp
elif mime_type:
if mime_type.startswith("image"):
with open(file, "rb") as f:
img = f.read()
resp = Response(img, mimetype=mime_type)
return resp
with open(file, "r") as f:
text = f.read()
m = re.search(r"(?:vim: ft=)(\S+?)([\s.])", text)
if m:
lexer_name = m.group(1)
lexer = get_lexer_by_name(LEXER_MAP.get(lexer_name, lexer_name))
else:
try:
lexer = get_lexer_for_filename(file)
except ClassNotFound:
lexer = None
if lexer:
content = highlight(
text, lexer, HtmlFormatter(style="solarized-light", cssclass="highlight")
)
else:
content = "\n".join(text.split("\n"))
return render_template(
"non-journal.html.j2",
breadcrumbs=make_breadcrumbs(file),
content=content,
theme_mode=get_theme_from_cookie(),
is_localhost=is_localhost(),
is_secret=is_secret,
highlight_article=is_secret,
journal_date=journal_date,
)
def colorize_traceback(traceback: str) -> str:
lexer = get_lexer_by_name("pytb", stripall=True)
formatter = TerminalFormatter()
return highlight(traceback, lexer, formatter)
def _run(args, default_font):
"""Run pyxstitch."""
content = None
file_name = None
file_ext = os.path.splitext(args.file)
is_raw = False
for item in file_ext:
if item == "." + _RAW:
is_raw = True
break
default_lexer = get_lexer_by_name("text")
use_lexer = args.lexer
use_style = args.style
is_bw = False
# Shortcut to black and white is to just use a Text lexer
if args.theme == _B_AND_W:
if use_lexer is not None:
log.Log.write("black & white overrides lexer input")
if use_style != _DEF_STYLE:
log.Log.write("black & white overrides style")
use_lexer = "Text"
use_style = _B_AND_W
is_bw = True
is_auto = use_lexer == _AUTODETECT
if is_auto:
use_lexer = None
if not is_raw:
if use_lexer or args.is_text:
if use_lexer:
lexer = get_lexer_by_name(use_lexer)
else:
lexer = default_lexer
else:
try:
lexer = get_lexer_for_filename(args.file)
except Exception as e:
log.Log.write(e)
exit(1)
if os.path.exists(args.file):
file_name = file_ext[0]
with open(args.file, 'r') as f:
content = f.read()
else:
if file_ext[1] is not None and len(file_ext[1]) > 1:
log.Log.write("file not found, pass extension for stdin or a file")
exit(1)
file_name = "output"
content = "".join(sys.stdin.readlines())
if is_raw:
_replay(args, file_name, content)
return
if is_auto:
log.Log.write(content)
try:
lexer = guess_lexer(content)
log.Log.write('using {} lexer'.format(lexer.name))
except Exception as e: # noqa: F841
log.Log.write('unable to guess a lexer...defaulting to text')
lexer = default_lexer
output_name = args.output
is_raw = args.is_raw
if output_name is None:
output_name = _create_file_name(file_name, args)
else:
if args.output.endswith(_RAW) and not is_raw:
log.Log.write('specify output as {}?'.format(_RAW))
exit(1)
preproc = fnt.preprocess(content)
text = preproc[0]
rows = preproc[1]
cols = preproc[2]
config_file = args.config
if config_file is None:
conf = os.path.join(str(Path.home()), ".pyxstitch.config")
if os.path.exists(conf):
config_file = conf
if config_file is not None and not os.path.exists(config_file):
log.Log.write("unable to find config file: {}".format(config_file))
formatting = fmt.new_formatter(use_style,
output_name,
args.multipage,
colorize=args.is_dmc,
dark=args.is_dark,
is_raw=is_raw,
is_bw=is_bw,
map_colors=args.map,
font_name=args.font,
rows=rows,
columns=cols,
symbols=args.symbols,
config=args.kv,
config_file=config_file,
horizontal=args.hzoom,
vertical=args.vzoom)
if args.font == default_font:
log.Log.write("font: {}".format(formatting.font_factory.display_name))
log.Log.write("Using lexer: {}".format(lexer.name))
highlight(text, lexer, formatting)
def post(db):
"""
Main upload interface. Users can password-protect an entry if they so
desire. You can send an already SHA1 cyphered text to this endpoint so
your intended password does not fly insecure through the internet
"""
form = bottle.request.forms
upload = form.get('upload')
filename = form.get('filename') if form.get('filename') != '-' else None
syntax = form.get('syntax') if form.get('syntax') != '-' else None
password = form.get('password')
try:
parent = int(form.get('parent')) if form.get('parent') else None
except Exception as e:
util.log.warn('Parent value does not seem like an int: %s' % (e, ))
is_encrypted = bool(form.get('is_encrypted'))
redirect = bool(form.get('redirect'))
util.log.debug('Filename: {0}, Syntax: {1}'.format(
filename,
syntax,
))
default_lexer = lexers.get_lexer_for_mimetype('text/plain')
if upload:
if syntax:
util.log.debug('Guessing lexer for explicit syntax {0}'.format(
syntax, ))
try:
lexer = lexers.get_lexer_by_name(syntax)
except lexers.ClassNotFound:
lexer = default_lexer
else:
if filename:
util.log.debug('Guessing lexer for filename {0}'.format(
filename, ))
try:
lexer = lexers.guess_lexer_for_filename(filename, upload)
except lexers.ClassNotFound:
lexer = lexers.guess_lexer(upload)
else:
util.log.debug('Use default lexer')
lexer = default_lexer
util.log.debug(lexer.mimetypes)
lx = None
if lexer.name:
lx = lexer.name
else:
if lexer.aliases:
lx = lexer.aliases[0]
mime = lexer.mimetypes[0]
ip = bottle.request.remote_addr
if ip:
# Try not to store crap in the database if it's not a valid IP
try:
ip = bin(IPy.IP(ip).int())
except Exception as ex:
util.log.warn(
'Impossible to store the source IP address: {0}'.format(
ex))
ip = None
paste = model.Paste(content=upload,
mimetype=mime,
is_encrypted=is_encrypted,
password=password,
ip=ip,
filename=filename,
lexer=lx,
parent=parent)
util.log.debug(paste)
db.add(paste)
db.commit()
if redirect:
bottle.redirect('{0}/{1}'.format(
get_url(),
paste.id,
))
else:
return bottle.HTTPResponse('{0}/{1}'.format(
get_url(),
paste.id,
))
else:
return bottle.HTTPError(400, 'No paste provided')
def _highlight_code(code: str):
lexer = lexers.get_lexer_by_name('python')
style = get_style_by_name('xcode')
formatter = HtmlFormatter(full=True, style=style)
return HTML(highlight(code, lexer, formatter))
def block_code(self, code, lang=None):
if not lang:
return '\n<pre><code>%s</code></pre>\n' % mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = HtmlFormatter(classprefix='highlight ')
return highlight(code, lexer, formatter)
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 pythonprettyprint(val):
s = pprint.pformat(val)
lexer = lexers.get_lexer_by_name('python')
formatter = HtmlFormatter()
return mark_safe(highlight(s, lexer, formatter))
def get_tokens_unprocessed(self, data):
sql = PsqlRegexLexer(**self.options)
lines = lookahead(line_re.findall(data))
# prompt-output cycle
while 1:
# consume the lines of the command: start with an optional prompt
# and continue until the end of command is detected
curcode = ''
insertions = []
while 1:
try:
line = lines.next()
except StopIteration:
# allow the emission of partially collected items
# the repl loop will be broken below
break
# Identify a shell prompt in case of psql commandline example
if line.startswith('$') and not curcode:
lexer = get_lexer_by_name('console', **self.options)
for x in lexer.get_tokens_unprocessed(line):
yield x
break
# Identify a psql prompt
mprompt = re_prompt.match(line)
if mprompt is not None:
insertions.append((len(curcode),
[(0, Generic.Prompt, mprompt.group())]))
curcode += line[len(mprompt.group()):]
else:
curcode += line
# Check if this is the end of the command
# TODO: better handle multiline comments at the end with
# a lexer with an external state?
if re_psql_command.match(curcode) \
or re_end_command.search(curcode):
break
# Emit the combined stream of command and prompt(s)
for item in do_insertions(insertions,
sql.get_tokens_unprocessed(curcode)):
yield item
# Emit the output lines
out_token = Generic.Output
while 1:
line = lines.next()
mprompt = re_prompt.match(line)
if mprompt is not None:
# push the line back to have it processed by the prompt
lines.send(line)
break
mmsg = re_message.match(line)
if mmsg is not None:
if mmsg.group(1).startswith("ERROR") \
or mmsg.group(1).startswith("FATAL"):
out_token = Generic.Error
yield (mmsg.start(1), Generic.Strong, mmsg.group(1))
yield (mmsg.start(2), out_token, mmsg.group(2))
else:
yield (0, out_token, line)
def block_code(self, code, lang=None):
if not lang:
return "\n<pre><code>%s</code></pre>\n" % mistune.escape(code)
lexer = get_lexer_by_name(lang, stripall=True)
formatter = html.HtmlFormatter()
return highlight(code, lexer, formatter)
def add_attribute(string, name, value, attributes):
if not value:
return string
elif name == "bold":
return "{bold_on}{text}{bold_off}".format(
bold_on=W.color("bold"),
text=string,
bold_off=W.color("-bold"),
)
elif name == "italic":
return "{italic_on}{text}{italic_off}".format(
italic_on=W.color("italic"),
text=string,
italic_off=W.color("-italic"),
)
elif name == "underline":
return "{underline_on}{text}{underline_off}".format(
underline_on=W.color("underline"),
text=string,
underline_off=W.color("-underline"),
)
elif name == "strikethrough":
return string_strikethrough(string)
elif name == "quote":
return self.textwrapper.fill(
W.string_remove_color(string.replace("\n", ""), "")
)
elif name == "code":
code_color_pair = color_pair(
G.CONFIG.color.untagged_code_fg,
G.CONFIG.color.untagged_code_bg
)
margin = G.CONFIG.look.code_block_margin
if attributes["preformatted"]:
# code block
try:
lexer = get_lexer_by_name(value)
except ClassNotFound:
if G.CONFIG.look.code_blocks:
return colored_text_block(
string,
margin=margin,
color_pair=code_color_pair)
else:
return string_color_and_reset(string,
code_color_pair)
try:
style = get_style_by_name(G.CONFIG.look.pygments_style)
except ClassNotFound:
style = "native"
if G.CONFIG.look.code_blocks:
code_block = text_block(string, margin=margin)
else:
code_block = string
# highlight adds a newline to the end of the string, remove
# it from the output
highlighted_code = highlight(
code_block,
lexer,
WeechatFormatter(style=style)
).rstrip()
return highlighted_code
else:
return string_color_and_reset(string, code_color_pair)
elif name == "fgcolor":
return "{color_on}{text}{color_off}".format(
color_on=W.color(value),
text=string,
color_off=W.color("resetcolor"),
)
elif name == "bgcolor":
return "{color_on}{text}{color_off}".format(
color_on=W.color("," + value),
text=string,
color_off=W.color("resetcolor"),
)
else:
return string
