def _highlight_lines(self, tokensource):
"""
Highlighted the lines specified in the `hl_lines` option by
post-processing the token stream coming from `_format_lines`.
"""
if not isinstance(self.hl_lines, dict):
HtmlFormatter._highlight_lines(tokensource)
else:
hl_lines = {}
for css, lines in self.hl_lines.items():
hl_lines.update(dict([(line, css) for line in lines]))
hls = hl_lines.keys()
for i, (t, value) in enumerate(tokensource):
if t != 1:
yield t, value
if i + 1 in hls: # i + 1 because Python indexes start at 0
css = hl_lines[i + 1]
if css:
yield 1, '<span class="%s">%s</span>' % (css, value)
elif self.noclasses:
style = ''
if self.style.highlight_color is not None:
style = (' style="background-color: %s"' %
(self.style.highlight_color,))
yield 1, '<span%s>%s</span>' % (style, value)
else:
yield 1, '<span class="hll">%s</span>' % value
else:
yield 1, value
def process_request(self, req):
style = req.args['style']
try:
style_cls = get_style_by_name(style)
except ValueError as e:
raise HTTPNotFound(e)
parts = style_cls.__module__.split('.')
filename = resource_filename('.'.join(parts[:-1]), parts[-1] + '.py')
mtime = datetime.fromtimestamp(os.path.getmtime(filename), localtz)
last_modified = http_date(mtime)
if last_modified == req.get_header('If-Modified-Since'):
req.send_response(304)
req.end_headers()
return
formatter = HtmlFormatter(style=style_cls)
content = u'\n\n'.join([
formatter.get_style_defs('div.code pre'),
formatter.get_style_defs('table.code td')
]).encode('utf-8')
req.send_response(200)
req.send_header('Content-Type', 'text/css; charset=utf-8')
req.send_header('Last-Modified', last_modified)
req.send_header('Content-Length', len(content))
req.write(content)
def _bbcodeAsHtml(self):
style = get_style_by_name('igor')
formatter = HtmlFormatter(style=style)
lexer = get_lexer_by_name("bbcode", stripall=True)
css = formatter.get_style_defs()
txt = highlight(self._bbcode, lexer, HtmlFormatter())
return "<style>%s</style>\n%s" % (css, txt)
def render_code(self):
formatter = HtmlFormatter(style='default', nowrap=True, classprefix='code%s-' % self.pk)
html = highlight(self.code, get_lexer_by_name(self.syntax), formatter)
css = formatter.get_style_defs()
# Included in a DIV, so the next item will be displayed below.
return _('<div class="code"><style type="text/css">%(css)s</style>\n<pre>%(html)s</pre></div>\n') % {'css':css, 'html':html}
def prev_view_code(self, code, laugange):
htmlFormatter = HtmlFormatter()
lexer = CppLexer()
if laugange == "Cpp":
lexer = CppLexer()
elif laugange == "CSharp":
lexer = CSharpLexer()
codeDiv = highlight(code, lexer, htmlFormatter)
codeCss = htmlFormatter.get_style_defs(".highlight")
#
html = """
<html>
<head>
<style type="text/css">
%s
</style>
</head>
<body>
%s
</body>
</html>
""" % (codeCss, codeDiv)
self.webView.setHtml(html)
self.setStyleSheet(codeCss)
# 输出文件测试验证
# ff = open('test.html', 'w')
# ff.write(html)
# ff.close()
pass
def highlight_paste(paste, hl_lines):
'''Use pygments to syntax highlight a paste, returns by the way the CSS'''
lexer = get_lexer_by_name(paste.hl_alias)
formatter = HtmlFormatter(linenos=True, cssclass='source', hl_lines=hl_lines)
return (
highlight(paste.content, lexer, formatter),
formatter.get_style_defs('.source')
)
def style_defs(cls):
"""
Return the CSS style definitions required
by the formatted snippet.
"""
formatter = HtmlFormatter()
formatter.style.highlight_color = cls.VIOLATION_COLOR
return formatter.get_style_defs()
def __init__(self, **options):
HtmlFormatter.__init__(self, **options)
self.hl_lines = {None: self.hl_lines}
if isinstance(options.get('css_lines'), dict):
for k, lines in options['css_lines'].items():
self.hl_lines[k] = set()
for lineno in lines:
try:
self.hl_lines[k].add(int(lineno))
except ValueError:
pass
def get(self, paste_id):
try:
aid = b64.num_decode(paste_id)
paste = Paste.get_by_id(aid)
content, lang = paste.content, paste.type
formatter = HtmlFormatter()
self.response.out.write(template.render("paste.html", {'css': formatter.get_style_defs('.highlight'),
'paste': highlight(content, get_lexer_by_name(lang), formatter)}))
except Exception:
self.response.set_status(404)
self.response.out.write(template.render("404.html", {}))
def getOutput(self):
"""
Returns the output
:rtype: str
"""
if not self.formatted:
lex = JavaLexer()
formatter = HtmlFormatter(full=True)
formatter.noclasses = True
self._output = highlight(self._output, lex, formatter)
self.formatted = True
return self._output
def render_code(instance, style_name='default'):
# Some interesting options in the HtmlFormatter:
# - nowrap -> no wrap inside <pre>
# - classprefix -> prefix for the classnames
# - noclasses -> all inline styles.
#
# To get_style_defs(), you can pass a selector prefix.
#
style = styles.get_style_by_name(style_name)
formatter = HtmlFormatter(linenos=instance.linenumbers, style=style, nowrap=True, classprefix='code%s-' % instance.pk)
html = highlight(instance.code, get_lexer_by_name(instance.language), formatter)
css = formatter.get_style_defs()
# Included in a DIV, so the next item will be displayed below.
return '<div class="code"><style type="text/css">' + css + '</style>\n<pre>' + html + '</pre></div>\n'
def __init__(self, parent, lexer=None):
super(PygmentsHighlighter, self).__init__(parent)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.set_style('default')
def __init__(self, document, lexer=None):
super(PygmentsSyntaxHighlighter, self).__init__(document)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.__previousFilename = ""
self.style = "default"
def __init__(self, parent, lexer=None):
super(QPygmentsHighlighter, self).__init__(parent)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.style = styles.getStyle("Default").pygmentsStyle
self.enabled = True
def process_request(self, req):
# settings panel
if not 'style' in req.args:
req._no_pygments_stylesheet = True
styles = list(get_all_styles())
styles.sort(lambda a, b: cmp(a.lower(), b.lower()))
if req.method == 'POST':
style = req.args.get('new_style')
if style and style in styles:
req.session['pygments_style'] = style
output = self._highlight('html', self.EXAMPLE, False)
req.hdf['output'] = Markup(output)
req.hdf['current'] = req.session.get('pygments_style',
self.default_style)
req.hdf['styles'] = styles
req.hdf['pygments_path'] = self.env.href.pygments()
return 'pygments_settings.cs', None
# provide stylesheet
else:
style = req.args['style']
parts = style.__module__.split('.')
filename = resource_filename('.'.join(parts[:-1]), parts[-1] + '.py')
mtime = datetime.utcfromtimestamp(os.path.getmtime(filename))
last_modified = http_date(time.mktime(mtime.timetuple()))
if last_modified == req.get_header('If-Modified-Since'):
req.send_response(304)
req.end_headers()
return
formatter = HtmlFormatter(style=style)
content = u'\n\n'.join([
formatter.get_style_defs('div.code pre'),
formatter.get_style_defs('table.code td')
]).encode('utf-8')
req.send_response(200)
req.send_header('Content-Type', 'text/css; charset=utf-8')
req.send_header('Last-Modified', last_modified)
req.send_header('Content-Length', len(content))
req.write(content)
def export():
if not os.path.exists(PYGMENTS_PATH):
os.makedirs(PYGMENTS_PATH)
styles = list(get_all_styles())
for style in styles:
print("Generating CSS for %s" % style)
opts = {"style": style}
path = os.path.join(PYGMENTS_PATH, "%s.css" % style)
formatter = HtmlFormatter(**opts)
css_content = formatter.get_style_defs()
# little fix because pelican doesn't append background color.
css_content = css_content.replace(".hll", ".highlight")
with open(path, "w") as f:
f.write(css_content)
def export():
if not os.path.exists(PYGMENTS_PATH):
os.makedirs(PYGMENTS_PATH)
styles = list(get_all_styles())
for style in styles:
print('Generating CSS for %s' % style)
opts = {
'style': style,
'noclasses': False,
'nobackground': False,
}
path = os.path.join(PYGMENTS_PATH, '%s.css' % style)
formatter = HtmlFormatter(**opts)
css_content = formatter.get_style_defs('.highlight')
with open(path, 'w') as f:
f.write(css_content)
def __init__(self, parent, lexer=None):
super(PygmentsHighlighter, self).__init__(parent)
self._document = self.document()
self._formatter = HtmlFormatter(nowrap=True)
self.set_style('default')
if lexer is not None:
self._lexer = lexer
else:
if PY3:
self._lexer = Python3Lexer()
else:
self._lexer = PythonLexer()
def trans(content, type, style, suffix):
print(type, style, suffix)
if not suffix:
lexer = get_lexer_by_name(type)
else:
try:
lexer = get_lexer_for_filename(suffix)
except:
lexer = get_lexer_by_name(type)
# 指定风格
formatter = HtmlFormatter(style=style)
# 获取html
html = highlight(content, lexer, formatter)
return html
def save(self, *args, **kwargs):
"""
利用pygments，创建高亮的html文本呈现code块,然后再保存
"""
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Snippet, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
lexer = get_lexer_by_name(self.language)
# linenos = self.linenos and 'table' or False
linenos = 'table' if self.linenos else False
# options = self.title and {'title': self.title} or {}
options = {'title': self.title} if self.title else {}
formatter = HtmlFormatter(
style=self.style,
linenos=linenos,
full=True,
**options,
)
self.highlighted = highlight(self.code, lexer, formatter)
super().save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
Use the `pygments` library to create a highlighted HTML
representation of the code snippet.
"""
lexer = get_lexer_by_name(self.language)
linenos = 'table' if self.linenos else False
options = {'title': self.title} if self.title else {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Snippet, self).save(*args, **kwargs)
def create_highlighted_text(text,
lexer_name='text',
style='friendly',
title=None):
lexer = get_lexer_by_name(lexer_name)
# linenos = 'table' if self.linenos else False
linenos = False
options = {'title': title} if title else {}
formatter = HtmlFormatter(style=style,
linenos=linenos,
full=True,
**options)
highlighted = highlight(text, lexer, formatter)
return highlighted
def save(self, *args, **kwargs):
"""
code snippet의 하이라이팅을 생성하기 위해
pygments 라이브러리를 사용한다
"""
lexer = get_lexer_by_name(self.language)
linenos = 'table' if self.linenos else False
options = {'title': self.title} if self.title else {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Snippet, self).save(*args, **kwargs)
def diff_prettified(self):
"""Function to display pretty version of our data"""
# Convert the data to sorted, indented JSON
response = json.loads(self.difference)
response = json.dumps(response, sort_keys=True, indent=1, ensure_ascii=False).replace('ó', "ó")
# response = codecs.encode(str(response)).decode('utf-8')
# Truncate the data. Alter as needed
response = response[:10000]
# Get the Pygments formatter
formatter = HtmlFormatter(style='colorful', lineseparator="<br>")
# Highlight the data
response = highlight(response, JsonLexer(), formatter)
# Get the stylesheet
style = "<style>" + formatter.get_style_defs() + "</style>"
# Safe the output
return mark_safe(style + response)
def save(self, *args, **kwargs):
"""
Use the 'pygments' library to create a highlighted HTML
representation of the code snippet
"""
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Blog, self).save(*args, **kwargs)
def html(self):
"""
Return an HTML representation of the snippet.
"""
formatter = HtmlFormatter(
cssclass=self.DIV_CSS_CLASS,
linenos=True,
linenostart=self._start_line,
hl_lines=self._shift_lines(self._violation_lines,
self._start_line),
lineanchors=self._src_filename,
)
return pygments.format(self.src_tokens(), formatter)
def save(self, *args, **kwargs):
"""
Use the `pygments` library to create a highlighted HTML
representation of the code snippet.
"""
lexer = get_lexer_by_name(self.name)
boardingid = 'table' if self.boardingid else False
options = {'title': self.name} if self.name else {}
formatter = HtmlFormatter(style=self.name,
boardingid=boardingid,
full=True,
**options)
self.highlighted = highlight(self.contact, lexer, formatter)
super(passengers, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
使用‘pygments’库去创建一个高亮的html表示的代码片段
:return:
"""
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and "table" or False
options = self.title and {"title": self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Snippet, self).save(*args, **kwargs)
def blockcode(self, text, lang):
if not lang:
return '\n<pre><code>{}</code></pre>\n'.format(text.strip())
try:
lexer = get_lexer_by_name(lang, stripall=True)
except ClassNotFound:
lexer = None
if lexer:
formatter = HtmlFormatter(linenos='inline')
return highlight(text, lexer, formatter)
# default
return '\n<pre><code>{}</code></pre>\n'.format(text.strip())
def prepare_style():
""" read and process style/ directory """
config = Config()
# copy static files
if not os.path.exists(os.path.join(config.outputdir, 'style')):
os.makedirs(os.path.join(config.outputdir, 'style'))
# copy supplementary files to ouput dir
for filename in os.listdir(config.styledir):
if os.path.splitext(filename)[1].lower() != '.css':
shutil.copy(
os.path.join(config.styledir, filename),
os.path.join(config.outputdir, 'style')
)
# generate syntax highlight css and append all other CSS files
allcss = HtmlFormatter().get_style_defs('.codehilite')
for cssfile in glob.iglob(os.path.join(config.styledir, '*.css')):
allcss = allcss + codecs.open(cssfile, 'r', 'utf-8').read()
allcss = allcss.replace('{{styleurl}}', "{}style/".format(config.blogurl))
# minimise css
return cssmin(allcss, wrap=1000)
def upload_file_remote(dest_file: Path, ext: str, file_path: Path, zip_flag,
plain, in_file, ppb_path_on_host, ppb_target_host,
metadata: dict) -> None:
"""
dest_file: destination filename + extension (example: 77a80349869f.png)
ext: file extension, like dest_file.suffix
file_path: path to input file.
"""
with tempfile.TemporaryDirectory() as tmpdirname:
send_metadata(dest_file, metadata, ppb_path_on_host, ppb_target_host,
tmpdirname)
tempfile_path = os.path.join(tmpdirname, in_file)
if zip_flag:
zip_command = f'zip -r {tempfile_path} {file_path}'
log.info(zip_command)
os.system(zip_command)
file_path = tempfile_path
elif not plain and not check_extension(
ext, {
*IMAGE_EXTENSIONS, *VIDEO_EXTENSIONS,
*COMPRESSION_EXTENSIONS, '', 'pdf'
}):
with open(file_path, mode='r') as c:
code = c.read()
with open(tempfile_path, mode='w') as f:
if ext == '.log':
lexer = BashLexer()
else:
try:
lexer = guess_lexer_for_filename(file_path, c)
except Exception as e:
print(e)
try:
highlight(code,
lexer,
HtmlFormatter(linenos=True, full=True),
outfile=f)
except:
# if pygments fails to find a lexer, continue without highlighting
tempfile_path = file_path
lexer = None
file_path = tempfile_path
log.info(f'Highlighted {file_path} with lexer {lexer}.')
rsync_command = f'rsync -avP {file_path} {ppb_target_host}:{ppb_path_on_host}/{dest_file}'
log.info(rsync_command)
os.system(rsync_command)
def html(self):
# TODO: section tags for each section and subsection
out = HTML()
out.start_tag("article")
for block in self.blocks:
if block.content_type is None:
out.element("p", html=Text(" ".join(block.lines)).html)
elif block.content_type in (Heading, HorizontalRule):
for line in block.lines:
out.write_html(line.html)
elif block.content_type is Literal:
source = "".join(line.line for line in block.lines)
lang, _, metadata = block.metadata.partition(" ")
try:
lexer = get_lexer_by_name(lang)
except ClassNotFound:
lexer = None
if lexer is None:
out.start_tag("pre")
out.write_text(source)
out.end_tag("pre")
else:
out.write_raw(highlight(source, lexer, HtmlFormatter()))
elif block.content_type is Quote:
out.start_tag("blockquote")
for line in block.lines:
out.write_html(line.html)
out.end_tag("blockquote")
elif block.content_type is ListItem:
level = 0
for line in block.lines:
while level > line.level:
out.end_tag()
level -= 1
while level < line.level:
out.start_tag(line.list_tag(level))
level += 1
out.write_html(line.html)
while level:
out.end_tag()
level -= 1
elif block.content_type is TableRow:
out.start_tag("table")
for line in block.lines:
out.write_html(line.html)
out.end_tag("table")
out.element("footer")
out.end_tag("article")
return out.html
def export():
if not os.path.exists(PYGMENTS_PATH):
os.makedirs(PYGMENTS_PATH)
styles = list(get_all_styles())
for style in styles:
print("Generating CSS for %s" % style)
opts = {
"style": style,
"noclasses": False,
"nobackground": False,
}
path = os.path.join(PYGMENTS_PATH, "%s.css" % style)
formatter = HtmlFormatter(**opts)
md_css = formatter.get_style_defs(".highlight")
rst_css = formatter.get_style_defs(".literal-block")
with open(path, "w+") as f:
f.write(md_css)
f.write("\n")
f.write(rst_css)
def pygmentize(code, linenos=False, tofile=False, outputfile=''):
style = 'colorful'
defstyles = 'overflow:auto;width:auto;'
formatter = HtmlFormatter(style=style,
linenos=False,
noclasses=True,
cssclass='',
cssstyles=defstyles + get_default_style(),
prestyles='margin: 0')
html = highlight(code, JavaLexer(), formatter)
if linenos:
html = insert_line_numbers(html)
html = "<!-- Rapport généré avec TPGen -->" + html
return html
def get_classes_by_start(code):
"""Returns a dictionary mapping positions in the code to html equivalent to what Pygments would
insert prior to that position."""
lexer = Python3Lexer()
formatter = HtmlFormatter()
# pygments seems to ignore initial newlines (etc.?), so to line up with all our other stuff,
# we need to shift the starting position by that much
start_position = len(code) - len(code.lstrip())
parser = MyHTMLParser(start_position=start_position)
tokens = lexer.get_tokens(code.lstrip())
pygments_html = io.StringIO()
formatter.format(tokens, pygments_html)
pygments_html.seek(0)
html = pygments_html.read()
parser.feed(html)
# not really sure why these are different by 1, but let's make sure we find out about it if
# that changes
assert parser.current_position == len(
code) + 1, 'code is length {}, parser ended up at {}'.format(
len(code), parser.current_position)
return parser.start_classes
def handle_output(self, process: QProcess):
output: QByteArray = process.readAllStandardOutput()
message = output.data().decode('utf-8').strip()
if message.startswith('{') or message.startswith('['):
formatter = HtmlFormatter()
formatter.noclasses = True
formatter.linenos = False
formatter.nobackground = True
message = highlight(message, JsonLexer(), formatter)
self.output.insertHtml(message)
else:
self.output.append(message)
# This is just for generating the command lists in constants
# commands = None
# if '== Blockchain ==' in message:
# commands = self.parse_litecoin_cli_commands(message)
# elif 'lncli [global options] command [command options]' in message:
# commands = self.parse_lncli_commands(message)
# if commands is not None:
# log.debug('commands', commands=commands)
max_scroll = self.output.verticalScrollBar().maximum()
self.output.verticalScrollBar().setValue(max_scroll)
def format_code_for_display(concept_key, lang):
"""
Returns the formatted HTML formatted syntax-highlighted text for a concept key (from a meta language file) and a language
:param concept_key: name of the key to format
:param lang: language to format it (in meta language/syntax highlighter format)
:return: string with code with applied HTML formatting
"""
if lang.concept_unknown(
concept_key) or lang.concept_code(concept_key) is None:
return "Unknown"
if lang.concept_implemented(concept_key):
return highlight(lang.concept_code(concept_key),
get_lexer_by_name(lang.key, startinline=True),
HtmlFormatter())
return None
def __init__(self, query, highlightFormat: str = "html"):
'''
construct me for the given query and highlightFormat
Args:
query(Query): the query to do the syntax highlighting for
highlightFormat(str): the highlight format to be used
'''
self.query = query
self.highlightFormat = highlightFormat
self.lexer = get_lexer_by_name(self.query.lang)
if self.highlightFormat == "html":
self.formatter = HtmlFormatter()
elif self.highlightFormat == "latex":
self.formatter = LatexFormatter()
def export():
if not os.path.exists(PYGMENTS_PATH):
os.makedirs(PYGMENTS_PATH)
styles = list(get_all_styles())
for style in styles:
print('Generating CSS for %s' % style)
opts = {
'style': style,
'noclasses': False,
'nobackground': False,
}
path = os.path.join(PYGMENTS_PATH, '%s.css' % style)
formatter = HtmlFormatter(**opts)
md_css = formatter.get_style_defs('.highlight')
rst_css = formatter.get_style_defs('.literal-block')
with open(path, 'w+') as f:
f.write(md_css)
f.write('\n')
f.write(rst_css)
def save(self, *args, **kwargs):
"""使用`pygments`库创建一个高亮显示的HTML表示代码段。"""
lexer = get_lexer_by_name(self.language)
"""
linenos = (True and 'table') or False => or 前的语句为True,所以不执行 or 后的语句 => linenos = 'table'
linenos = (False and 'table') or False => or 前的语句为False,所以执行 or 后的语句 => linenos = False
"""
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super().save(*args, **kwargs)
def syntax_highlight(file):
code = file.path.read_text()
try:
lexer = get_lexer_for_mimetype(file.client_mimetype)
except ClassNotFound:
try:
lexer = guess_lexer(code)
except ClassNotFound:
lexer = TextLexer()
return highlight(
code,
lexer,
HtmlFormatter(linenos="table", anchorlinenos=True, lineanchors="line"),
)
def save(self, *args, **kwargs):
"""
`pygments` 라이브러리를 사용하여 하이라이트된 코드를 만든다.
"""
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(
style=self.style,
linenos=linenos,
full=True,
**options,
)
self.highlighted = highlight(self.code, lexer, formatter)
super().save(*args, **kwargs)
def highlightCode(self, code, language):
#converting the html to platin
td = QTextDocument()
td.setHtml(code)
print("the plain text is here : " + td.toPlainText())
codeLexer = get_lexer_by_name(language)
f = open("highlightTest.html", 'wb')
#fi = open("highlightTest.png",'wb')
#style = get_style_by_name("native")
formatter = HtmlFormatter(full=True, noclasses=True, encoding="UTF-8")
#imgFormater = ImageFormatter()
result = highlight(td.toPlainText(), codeLexer, formatter)
td.setHtml(result.decode("UTF-8"))
print(td.toHtml())
return td.toHtml()
def format(self, extension=None):
"""Write pretty HTML logs."""
M = self.M
# pygments lexing setup:
# (pygments HTML-formatter handles HTML-escaping)
import pygments
from pygments.lexers.text import IrcLogsLexer
from pygments.formatters.html import HtmlFormatter
import pygments.token as token
from pygments.lexer import bygroups
# Don't do any encoding in this function with pygments.
# That's only right before the i/o functions in the Config
# object.
formatter = HtmlFormatter(lineanchors='l',
full=True, style=M.config.pygmentizeStyle,
outencoding=self.M.config.output_codec)
Lexer = IrcLogsLexer
Lexer.tokens['msg'][1:1] = [
# match: #topic commands
(r"(\#topic[ \t\f\v]*)(.*\n)",
bygroups(token.Keyword, token.Generic.Heading), '#pop'),
# match: #command (others)
(r"(\#[^\s]+[ \t\f\v]*)(.*\n)",
bygroups(token.Keyword, token.Generic.Strong), '#pop'),
]
lexer = Lexer()
out = pygments.highlight("\n".join(M.lines), lexer, formatter)
# Hack it to add "pre { white-space: pre-wrap; }", which make
# it wrap the pygments html logs. I think that in a newer
# version of pygmetns, the "prestyles" HTMLFormatter option
# would do this, but I want to maintain compatibility with
# lenny. Thus, I do these substitution hacks to add the
# format in. Thanks to a comment on the blog of Francis
# Giannaros (http://francis.giannaros.org) for the suggestion
# and instructions for how.
out, n = re.subn(
r"(\n\s*pre\s*\{[^}]+;\s*)(\})",
r"\1\n white-space: pre-wrap;\2",
out, count=1
)
if n == 0:
out = re.sub(
r"(\n\s*</style>)",
r"\npre { white-space: pre-wrap; }\1",
out, count=1
)
return out
def save(self, *args, **kwargs):
lexer = get_lexer_by_name(self.language)
linenos = 'table' if self.linenos else False
options = {'title': self.title} if self.title else {}
formatter = HtmlFormatter(
style=self.style,
linenos=linenos,
full=True,
**options, # 그냥 딕셔너리 이름.
)
self.highlighted = highlight(self.code, lexer, formatter)
super().save(*args, **kwargs)
# admin에서 저장할 때도 이 메서드가 호출이 됨.
# admin 페이지에서 'Save and continue editing'하면 아래 Highlighted
# 에 저장됨.
def save(self, *args, **kwargs):
lexer = get_lexer_by_name(self.language)
display_linenos = self.display_linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=display_linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
if not self.code.endswith('\r\n'):
self.code += u'\r\n'
self.linenos = self.code.count('\r\n')
super(Snippet, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
使用 pygments 来创建高亮的 HTML 代码。
:param args:
:param kwargs:
:return:
"""
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
super(Snippet, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
'''
使用 pygments 創建高亮的HTML文本
'''
lexer = get_lexer_by_name(self.language)
linenos = self.linenos and 'table' or False
options = self.title and {'title': self.title} or {}
formatter = HtmlFormatter(style=self.style,
linenos=linenos,
full=True,
**options)
self.highlighted = highlight(self.code, lexer, formatter)
'''
呼叫父類別內的 save() 存檔
'''
super().save(*args, **kwargs)
def __init__(self, parent, lexer=None):
super(Highlighter, self).__init__(parent)
self._document = self.document()
self._formatter = HtmlFormatter()
self._lexer = lexer if lexer else PythonLexer()
self.set_style('default')
class PygmentsHighlighter(QtGui.QSyntaxHighlighter):
""" Syntax highlighter that uses Pygments for parsing. """
#---------------------------------------------------------------------------
# 'QSyntaxHighlighter' interface
#---------------------------------------------------------------------------
def __init__(self, parent, lexer=None):
super(PygmentsHighlighter, self).__init__(parent)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.set_style('default')
def highlightBlock(self, string):
""" Highlight a block of text.
"""
prev_data = self.currentBlock().previous().userData()
if prev_data is not None:
self._lexer._saved_state_stack = prev_data.syntax_stack
elif hasattr(self._lexer, '_saved_state_stack'):
del self._lexer._saved_state_stack
# Lex the text using Pygments
index = 0
for token, text in self._lexer.get_tokens(string):
length = len(text)
self.setFormat(index, length, self._get_format(token))
index += length
if hasattr(self._lexer, '_saved_state_stack'):
data = PygmentsBlockUserData(
syntax_stack=self._lexer._saved_state_stack)
self.currentBlock().setUserData(data)
# Clean up for the next go-round.
del self._lexer._saved_state_stack
#---------------------------------------------------------------------------
# 'PygmentsHighlighter' interface
#---------------------------------------------------------------------------
def set_style(self, style):
""" Sets the style to the specified Pygments style.
"""
if isinstance(style, str):
style = get_style_by_name(style)
self._style = style
self._clear_caches()
def set_style_sheet(self, stylesheet):
""" Sets a CSS stylesheet. The classes in the stylesheet should
correspond to those generated by:
pygmentize -S <style> -f html
Note that 'set_style' and 'set_style_sheet' completely override each
other, i.e. they cannot be used in conjunction.
"""
self._document.setDefaultStyleSheet(stylesheet)
self._style = None
self._clear_caches()
#---------------------------------------------------------------------------
# Protected interface
#---------------------------------------------------------------------------
def _clear_caches(self):
""" Clear caches for brushes and formats.
"""
self._brushes = {}
self._formats = {}
def _get_format(self, token):
""" Returns a QTextCharFormat for token or None.
"""
if token in self._formats:
return self._formats[token]
if self._style is None:
result = self._get_format_from_document(token, self._document)
else:
result = self._get_format_from_style(token, self._style)
self._formats[token] = result
return result
def _get_format_from_document(self, token, document):
""" Returns a QTextCharFormat for token by
"""
code, html = next(self._formatter._format_lines([(token, 'dummy')]))
self._document.setHtml(html)
return QtGui.QTextCursor(self._document).charFormat()
def _get_format_from_style(self, token, style):
""" Returns a QTextCharFormat for token by reading a Pygments style.
"""
result = QtGui.QTextCharFormat()
for key, value in list(style.style_for_token(token).items()):
if value:
if key == 'color':
result.setForeground(self._get_brush(value))
elif key == 'bgcolor':
result.setBackground(self._get_brush(value))
elif key == 'bold':
result.setFontWeight(QtGui.QFont.Bold)
elif key == 'italic':
result.setFontItalic(True)
elif key == 'underline':
result.setUnderlineStyle(
QtGui.QTextCharFormat.SingleUnderline)
elif key == 'sans':
result.setFontStyleHint(QtGui.QFont.SansSerif)
elif key == 'roman':
result.setFontStyleHint(QtGui.QFont.Times)
elif key == 'mono':
result.setFontStyleHint(QtGui.QFont.TypeWriter)
return result
def _get_brush(self, color):
""" Returns a brush for the color.
"""
result = self._brushes.get(color)
if result is None:
qcolor = self._get_color(color)
result = QtGui.QBrush(qcolor)
self._brushes[color] = result
return result
def _get_color(self, color):
""" Returns a QColor built from a Pygments color string.
"""
qcolor = QtGui.QColor()
qcolor.setRgb(int(color[:2], base=16),
int(color[2:4], base=16),
int(color[4:6], base=16))
return qcolor
class QPygmentsHighlighter(QSyntaxHighlighter):
""" Syntax highlighter that uses Pygments for parsing. """
hilighlightingBlock = Signal(unicode, QSyntaxHighlighter)
#---------------------------------------------------------------------------
# 'QSyntaxHighlighter' interface
#---------------------------------------------------------------------------
def __init__(self, parent, lexer=None):
super(QPygmentsHighlighter, self).__init__(parent)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.style = styles.getStyle("Default").pygmentsStyle
self.enabled = True
def setLexerFromFilename(self, filename):
"""
Change the lexer based on the filename (actually only the extension is needed)
:param filename: Filename or extension
"""
try:
self._lexer = get_lexer_for_filename(filename)
except ClassNotFound:
self._lexer = PythonLexer()
def highlightBlock(self, text):
""" Highlight a block of text """
if self.enabled is False:
return
text = unicode(text)
original_text = text
prev_data = self.currentBlock().previous().userData()
if prev_data is not None:
self._lexer._saved_state_stack = prev_data.syntax_stack
elif hasattr(self._lexer, '_saved_state_stack'):
del self._lexer._saved_state_stack
# Lex the text using Pygments
index = 0
for token, text in self._lexer.get_tokens(text):
length = len(text)
self.setFormat(index, length, self._get_format(token))
index += length
if hasattr(self._lexer, '_saved_state_stack'):
data = PygmentsBlockUserData(
syntax_stack=self._lexer._saved_state_stack)
self.currentBlock().setUserData(data)
# Clean up for the next go-round.
del self._lexer._saved_state_stack
#Spaces
expression = QRegExp('\s+')
index = expression.indexIn(original_text, 0)
while index >= 0:
index = expression.pos(0)
length = len(expression.cap(0))
self.setFormat(index, length, self._get_format(Whitespace))
index = expression.indexIn(original_text, index + length)
self.hilighlightingBlock.emit(original_text, self)
# expression = QRegExp('\s+')
# index = expression.indexIn(original_text, 0)
# while index >= 0:
# index = expression.pos(0)
# length = len(expression.cap(0))
# self.setFormat(index, length, self._get_format(Whitespace))
# index = expression.indexIn(original_text, index + length)
#---------------------------------------------------------------------------
# 'PygmentsHighlighter' interface
#---------------------------------------------------------------------------
def __set_style(self, style):
""" Sets the style to the specified Pygments style.
"""
if (isinstance(style, str) or
isinstance(style, unicode)):
style = get_style_by_name(style)
self._style = style
self._clear_caches()
def set_style_sheet(self, stylesheet):
""" Sets a CSS stylesheet. The classes in the stylesheet should
correspond to those generated by:
pygmentize -S <style> -f html
Note that 'set_style' and 'set_style_sheet' completely override each
other, i.e. they cannot be used in conjunction.
"""
self._document.setDefaultStyleSheet(stylesheet)
self._style = None
self._clear_caches()
def __get_style(self):
return self._style
#: gets/sets the **pygments** style.
style = property(__get_style, __set_style)
#---------------------------------------------------------------------------
# Protected interface
#---------------------------------------------------------------------------
def _clear_caches(self):
""" Clear caches for brushes and formats.
"""
self._brushes = {}
self._formats = {}
def _get_format(self, token):
""" Returns a QTextCharFormat for token or None.
"""
if token in self._formats:
return self._formats[token]
if self._style is None:
result = self._get_format_from_document(token, self._document)
else:
result = self._get_format_from_style(token, self._style)
self._formats[token] = result
return result
def _get_format_from_document(self, token, document):
""" Returns a QTextCharFormat for token by
"""
code, html = next(self._formatter._format_lines([(token, 'dummy')]))
self._document.setHtml(html)
return QtGui.QTextCursor(self._document).charFormat()
def _get_format_from_style(self, token, style):
""" Returns a QTextCharFormat for token by reading a Pygments style.
"""
result = QtGui.QTextCharFormat()
for key, value in list(style.style_for_token(token).items()):
if value:
if key == 'color':
result.setForeground(self._get_brush(value))
elif key == 'bgcolor':
result.setBackground(self._get_brush(value))
elif key == 'bold':
result.setFontWeight(QtGui.QFont.Bold)
elif key == 'italic':
result.setFontItalic(True)
elif key == 'underline':
result.setUnderlineStyle(
QtGui.QTextCharFormat.SingleUnderline)
elif key == 'sans':
result.setFontStyleHint(QtGui.QFont.SansSerif)
elif key == 'roman':
result.setFontStyleHint(QtGui.QFont.Times)
elif key == 'mono':
result.setFontStyleHint(QtGui.QFont.TypeWriter)
return result
def _get_brush(self, color):
""" Returns a brush for the color.
"""
result = self._brushes.get(color)
if result is None:
qcolor = self._get_color(color)
result = QtGui.QBrush(qcolor)
self._brushes[color] = result
return result
def _get_color(self, color):
""" Returns a QColor built from a Pygments color string.
"""
color = unicode(color).replace("#", "")
qcolor = QtGui.QColor()
qcolor.setRgb(int(color[:2], base=16),
int(color[2:4], base=16),
int(color[4:6], base=16))
return qcolor
def __init__(self, **options):
HtmlFormatter.__init__(self, **options)
class PygmentsSyntaxHighlighter(SyntaxHighlighter):
"""
This mode enable syntax highlighting using the pygments library
Here the properties added by the mode to
:attr:`pyqode.core.QCodeEdit.style`:
====================== ====================== ======= ====================== =====================
Key Section Type Default value Description
====================== ====================== ======= ====================== =====================
pygmentsStyle General QColor Computed. Background color for matching symbols
====================== ====================== ======= ====================== =====================
.. warning:: There are some issues with multi-line comments, they are not
properly highlighted until a full re-highlight is triggered.
The text is automatically re-highlighted on save.
"""
#: Mode description
DESCRIPTION = "Apply syntax highlighting to the editor using pygments"
#: Associates a fold detector to a specific pygments lexer.
try:
LEXERS_FOLD_DETECTORS = {
# indent based
PythonLexer: IndentBasedFoldDetector(),
CythonLexer: IndentBasedFoldDetector(),
BashLexer: IndentBasedFoldDetector(),
BatchLexer: IndentBasedFoldDetector(),
XmlLexer: IndentBasedFoldDetector(),
HtmlLexer: IndentBasedFoldDetector(),
JsonLexer: IndentBasedFoldDetector(),
BooLexer: IndentBasedFoldDetector(),
MakefileLexer: IndentBasedFoldDetector(),
CMakeLexer: IndentBasedFoldDetector(),
RstLexer: IndentBasedFoldDetector(),
# c family
CLexer: CharBasedFoldDetector(),
CppLexer: CharBasedFoldDetector(),
CSharpLexer: CharBasedFoldDetector(),
ActionScriptLexer: CharBasedFoldDetector(),
CoffeeScriptLexer: CharBasedFoldDetector(),
CssLexer: CharBasedFoldDetector(),
JavascriptLexer: CharBasedFoldDetector(),
JavaLexer: CharBasedFoldDetector(),
QmlLexer: CharBasedFoldDetector(),
PhpLexer: CharBasedFoldDetector(),
AdaLexer: CharBasedFoldDetector(),
CudaLexer: CharBasedFoldDetector(),
DLexer: CharBasedFoldDetector(),
GLShaderLexer: CharBasedFoldDetector(),
GoLexer: CharBasedFoldDetector(),
ObjectiveCLexer: CharBasedFoldDetector(),
ObjectiveCppLexer: CharBasedFoldDetector(),
ValaLexer: CharBasedFoldDetector(),
}
except NameError:
logger.warning("PygmentsSyntaxHighlighter: Failed to setup fold "
"detectors associations. Please upgrade your pygments "
"installation.")
LEXERS_FOLD_DETECTORS = {}
@property
def pygmentsStyle(self):
return self.editor.style.value("pygmentsStyle")
@pygmentsStyle.setter
def pygmentsStyle(self, value):
return self.editor.style.setValue("pygmentsStyle", value)
def __init__(self, document, lexer=None):
super(PygmentsSyntaxHighlighter, self).__init__(document)
self._document = QtGui.QTextDocument()
self._formatter = HtmlFormatter(nowrap=True)
self._lexer = lexer if lexer else PythonLexer()
self.__previousFilename = ""
self.style = "default"
def _onInstall(self, editor):
"""
:type editor: pyqode.code.QCodeEdit
"""
SyntaxHighlighter._onInstall(self, editor)
self.triggers = ["*", '**', '"', "'", "/"]
self._clear_caches()
self.prev_txt = ""
style = editor.style.addProperty("pygmentsStyle", "default")
self.style = style
self.editor.style.setValue(
"background",
QtGui.QColor(self.style.background_color))
c = self.style.style_for_token(Text)['color']
if c is None:
c = '000000'
self.editor.style.setValue(
"foreground", QtGui.QColor("#{0}".format(c)))
def _onStateChanged(self, state):
self.enabled = state
if state is True:
self.editor.textSaved.connect(self.rehighlight)
else:
self.editor.textSaved.disconnect(self.rehighlight)
self.rehighlight()
def __updateLexer(self):
self.setLexerFromFilename(self.editor.fileName)
if hasattr(self.editor, "foldingPanel"):
if type(self._lexer) in self.LEXERS_FOLD_DETECTORS:
self.setFoldDetector(
self.LEXERS_FOLD_DETECTORS[type(self._lexer)])
self.editor.foldingPanel.enabled = True
else:
self.editor.foldingPanel.enabled = False
def __onTextSaved(self):
self.rehighlight()
def _onStyleChanged(self, section, key):
""" Updates the pygments style """
if key == "pygmentsStyle" or not key:
self.style = self.editor.style.value(
"pygmentsStyle")
self.rehighlight()
self.editor.style.setValue(
"background",
QtGui.QColor(self.style.background_color))
c = self.style.style_for_token(Text)['color']
if c is None:
c = '000000'
self.editor.style.setValue(
"foreground", QtGui.QColor("#{0}".format(c)))
def setLexerFromFilename(self, filename):
"""
Change the lexer based on the filename (actually only the extension is
needed)
:param filename: Filename or extension
"""
try:
if filename.endswith("~"):
filename = filename[0:len(filename) - 1]
self._lexer = get_lexer_for_filename(filename)
except ClassNotFound:
logger.warning("Failed to find lexer from filename %s" % filename)
self._lexer = None
def setLexerFromMimeType(self, mime, **options):
try:
self._lexer = get_lexer_for_mimetype(mime, **options)
except ClassNotFound:
logger.warning("Failed to find lexer from mime type %s" % mime)
self._lexer = None
def doHighlightBlock(self, text):
fn = self.editor.fileName
if fn != self.__previousFilename:
self.__previousFilename = fn
self.__updateLexer()
if self._lexer is None:
return
#Spaces
expression = QRegExp('\s+')
index = expression.indexIn(text, 0)
while index >= 0:
index = expression.pos(0)
length = len(expression.cap(0))
self.setFormat(index, length, self._get_format(Whitespace))
index = expression.indexIn(text, index + length)
if self.enabled is False:
return
prev_data = self.currentBlock().previous().userData()
if hasattr(prev_data, "syntax_stack"):
self._lexer._saved_state_stack = prev_data.syntax_stack
elif hasattr(self._lexer, '_saved_state_stack'):
del self._lexer._saved_state_stack
# Lex the text using Pygments
index = 0
usd = self.currentBlock().userData()
usd.cc_disabled_zones[:] = []
for token, text in self._lexer.get_tokens(text):
length = len(text)
if "comment" in str(token).lower():
# to the end
usd.cc_disabled_zones.append((index, pow(2, 32)))
elif "string" in str(token).lower():
usd.cc_disabled_zones.append((index, index + length))
self.setFormat(index, length, self._get_format(token))
index += length
if hasattr(self._lexer, '_saved_state_stack'):
data = self.currentBlock().userData()
setattr(data, "syntax_stack", self._lexer._saved_state_stack)
self.currentBlock().setUserData(data)
# Clean up for the next go-round.
del self._lexer._saved_state_stack
def __set_style(self, style):
""" Sets the style to the specified Pygments style.
"""
if (isinstance(style, str) or
isinstance(style, unicode)):
style = get_style_by_name(style)
self._style = style
self._clear_caches()
def __get_style(self):
return self._style
#: gets/sets the **pygments** style.
style = property(__get_style, __set_style)
def _clear_caches(self):
""" Clear caches for brushes and formats.
"""
self._brushes = {}
self._formats = {}
def _get_format(self, token):
""" Returns a QTextCharFormat for token or None.
"""
if token in self._formats:
return self._formats[token]
if self._style is None:
result = self._get_format_from_document(token, self._document)
else:
result = self._get_format_from_style(token, self._style)
self._formats[token] = result
return result
def _get_format_from_document(self, token, document):
""" Returns a QTextCharFormat for token by
"""
code, html = next(self._formatter._format_lines([(token, 'dummy')]))
self._document.setHtml(html)
return QtGui.QTextCursor(self._document).charFormat()
def _get_format_from_style(self, token, style):
""" Returns a QTextCharFormat for token by reading a Pygments style.
"""
result = QtGui.QTextCharFormat()
for key, value in list(style.style_for_token(token).items()):
if value:
if key == 'color':
result.setForeground(self._get_brush(value))
elif key == 'bgcolor':
result.setBackground(self._get_brush(value))
elif key == 'bold':
result.setFontWeight(QtGui.QFont.Bold)
elif key == 'italic':
result.setFontItalic(True)
elif key == 'underline':
result.setUnderlineStyle(
QtGui.QTextCharFormat.SingleUnderline)
elif key == 'sans':
result.setFontStyleHint(QtGui.QFont.SansSerif)
elif key == 'roman':
result.setFontStyleHint(QtGui.QFont.Times)
elif key == 'mono':
result.setFontStyleHint(QtGui.QFont.TypeWriter)
return result
def _get_brush(self, color):
""" Returns a brush for the color.
"""
result = self._brushes.get(color)
if result is None:
qcolor = self._get_color(color)
result = QtGui.QBrush(qcolor)
self._brushes[color] = result
return result
@staticmethod
def _get_color(color):
""" Returns a QColor built from a Pygments color string.
"""
color = str(color).replace("#", "")
qcolor = QtGui.QColor()
qcolor.setRgb(int(color[:2], base=16),
int(color[2:4], base=16),
int(color[4:6], base=16))
return qcolor