def _get_pygments_lexers(add_empty=True):
r = []
if add_empty:
r.append(('', ''),)
for lexer in get_all_lexers():
r.append((lexer[1][0], _(lexer[0])),)
return r
def _get_pygments_lexers(add_empty=True):
r = {}
if add_empty:
r[""] = ""
for lexer in get_all_lexers():
r[lexer[1][0]] = lexer[0]
return r
def __init__(self, lexers):
"""
Constructor
@param lexers reference to the lexers dictionary
"""
super(EditorHighlightersPage, self).__init__()
self.setupUi(self)
self.setObjectName("EditorHighlightersPage")
self.editorLexerList.headerItem().setText(self.editorLexerList.columnCount(), "")
header = self.editorLexerList.header()
if qVersion() >= "5.0.0":
header.setSectionResizeMode(QHeaderView.ResizeToContents)
else:
header.setResizeMode(QHeaderView.ResizeToContents)
header.setSortIndicator(0, Qt.AscendingOrder)
try:
self.extsep = os.extsep
except AttributeError:
self.extsep = "."
self.extras = ["-----------", self.tr("Alternative")]
languages = [""] + sorted(lexers.keys()) + self.extras
self.editorLexerCombo.addItems(languages)
pygmentsLexers = [""] + sorted([l[0] for l in get_all_lexers()])
self.pygmentsLexerCombo.addItems(pygmentsLexers)
# set initial values
lexerAssocs = Preferences.getEditorLexerAssocs()
for ext in lexerAssocs:
QTreeWidgetItem(self.editorLexerList, [ext, lexerAssocs[ext]])
self.editorLexerList.sortByColumn(0, Qt.AscendingOrder)
def load_lexers():
global lexers
# load available pygments lexers
lexers = []
try:
global get_lexer_by_name
from pygments.lexers import get_lexer_by_name
global highlight
from pygments import highlight
global Terminal256Formatter
from pygments.formatters import Terminal256Formatter
global TerminalFormatter
from pygments.formatters import TerminalFormatter
from pygments.lexers import get_all_lexers
except ImportError:
logging.warning("the pygments module has not been found, syntax coloring is not available")
pass
else:
for lexer in get_all_lexers():
try:
lexers.append(lexer[1][0])
except IndexError:
logging.warning("cannot load lexer: %s" % lexer[0])
pass
else:
logging.debug("loaded lexer %s" % lexer[1][0])
lexers.sort()
def lexers():
"""
Return the list of the pigments lexers.
"""
result = [(lexer[0], lexer[1][0]) for lexer in get_all_lexers()]
result.sort()
return result
def index():
from flask import render_template
contenttypes = []
for lexer_info in get_all_lexers():
contenttypes.extend(lexer_info[3])
return render_template('index.html',
contenttypes=contenttypes)
def index():
code = request.form.get('code', "print 'hello world!'")
lexer = (
request.form.get('lexer', '') or
unquote(request.cookies.get('lexer', 'python')))
lexers = [(l[1][0], l[0]) for l in get_all_lexers()]
lexers = sorted(lexers, lambda a, b: cmp(a[1].lower(), b[1].lower()))
style = (
request.form.get('style', '') or
unquote(request.cookies.get('style', 'colorful')))
styles = sorted(get_all_styles(), key=str.lower)
linenos = (
request.form.get('linenos', '') or
request.method == 'GET' and
unquote(request.cookies.get('linenos', ''))) or ''
divstyles = request.form.get(
'divstyles', unquote(request.cookies.get('divstyles', '')))
divstyles = divstyles or get_default_style()
html = hilite_me(code, lexer, {}, style, linenos, divstyles)
response = make_response(render_template('index.html', **locals()))
next_year = datetime.datetime.now() + datetime.timedelta(days=365)
response.set_cookie('lexer', quote(lexer), expires=next_year)
response.set_cookie('style', quote(style), expires=next_year)
response.set_cookie('linenos', quote(linenos), expires=next_year)
response.set_cookie('divstyles', quote(divstyles), expires=next_year)
return response
def lexerlist(with_fnames=False):
lst = list(lexers.get_all_lexers()) + [("ANSI", ["ansi"], [], None)]
for name, aliases, fnames, _ in sorted(lst):
if with_fnames:
yield aliases, fnames
else:
yield aliases[0], name
def get_legal_pygments_lexers():
from pygments.lexers import get_all_lexers
lexers = []
for classname, names, dummy, dymmy in list(get_all_lexers()):
for name in names:
lexers.append(name)
return lexers
def load_lexers():
global context
# load available pygments lexers
lexers = []
try:
global get_lexer_by_name
from pygments.lexers import get_lexer_by_name
global highlight
from pygments import highlight
global Terminal256Formatter
from pygments.formatters import Terminal256Formatter
global TerminalFormatter
from pygments.formatters import TerminalFormatter
from pygments.lexers import get_all_lexers
except ImportError:
logging.warning("the pygments module has not been found, syntax coloring is not available")
else:
try:
for lexer in get_all_lexers():
try:
lexers.append(lexer[1][0])
except IndexError:
logging.warning("cannot load lexer: %s" % lexer[1][0])
pass
except:
logging.warning("error while executing the pygment module, syntax coloring is not available")
lexers.sort()
logging.debug("loaded %i lexers: %s" % (len(lexers), ", ".join(lexers)))
context["lexers"] = lexers
def PreparePygmentsFileList(dirname):
'''
Use the lexer list and file extensions from the Pygments and prepare the list of files for which
lexers are available.
'''
from pygments.lexers import get_all_lexers
import fnmatch
#Prepare a list of fnmatch patterns from lexers
fnmatchpatlist = []
for lexer in get_all_lexers():
fnmatchpatlist = fnmatchpatlist+[pat for pat in lexer[2]]
rawfilelist = GetDirFileList(dirname)
#since one fnmatch pattern can exist in multiple lexers. We need remove duplicates from the fnmatch pattern list
fnmatchpatlist=set(fnmatchpatlist)
filelist = []
for fname in rawfilelist:
for pattern in fnmatchpatlist:
if(fnmatch.fnmatch(fname,pattern)):
filelist.append(fname)
#match is found.now break out of pattern matching loop
#but continue the outer loop
break
return(filelist)
def index():
contenttypes = [
'text/x-bepasty-redirect', # redirect / link shortener service
]
for lexer_info in get_all_lexers():
contenttypes.extend(lexer_info[3])
return render_template('index.html', contenttypes=contenttypes)
def _lexer_alias_name_map(self):
lexer_alias_name_map = {}
for lexer_name, aliases, _, _ in get_all_lexers():
name = aliases[0] if aliases else lexer_name
for alias in aliases:
lexer_alias_name_map[alias] = name
return lexer_alias_name_map
def __init__(self, project, parent=None):
"""
Constructor
@param project reference to the project object
@param parent reference to the parent widget (QWidget)
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self.editorLexerList.headerItem().setText(self.editorLexerList.columnCount(), "")
header = self.editorLexerList.header()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setSortIndicator(0, Qt.AscendingOrder)
try:
self.extsep = os.extsep
except AttributeError:
self.extsep = "."
self.extras = ["-----------", self.trUtf8("Alternative")]
languages = [""] + sorted(QScintilla.Lexers.getSupportedLanguages().keys()) + self.extras
for lang in languages:
self.editorLexerCombo.addItem(lang)
pygmentsLexers = [""] + sorted([l[0] for l in get_all_lexers()])
for pygmentsLexer in pygmentsLexers:
self.pygmentsLexerCombo.addItem(pygmentsLexer)
# set initial values
self.project = project
for ext, lexer in self.project.pdata["LEXERASSOCS"].items():
QTreeWidgetItem(self.editorLexerList, QStringList() << ext << lexer)
self.editorLexerList.sortByColumn(0, Qt.AscendingOrder)
def get_context_data(self, **kwargs):
context = super(SyntaxView, self).get_context_data(**kwargs)
context['syntax_list'] = sorted(
[(i[1][0], i[0]) for i in get_all_lexers()] +
[('rrst', 'Restructured Text (Rendered)'),
('md', 'Markdown (Rendered)')])
return context
def __init__(self, parent):
Gtk.Dialog.__init__(self, "Insert code", parent, 0, use_header_bar=True,
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
self.set_modal(True)
self.set_default_size(500, 350)
cancel_button = self.get_header_bar().get_children()[0]
self.set_focus(cancel_button)
ok_button = self.get_header_bar().get_children()[1]
ok_button.set_name("Insert")
ok_button.get_style_context().add_class("suggested-action")
box = self.get_content_area()
combobox = Gtk.ComboBoxText.new_with_entry()
combobox_entry = combobox.get_child()
completion = Gtk.EntryCompletion()
completion.set_model(combobox.get_model())
completion.set_text_column(0)
combobox_entry.set_completion(completion)
combobox_entry.set_placeholder_text("Select language")
# Fill combobox with languages
for item in get_all_lexers():
combobox.append(item[1][0], item[0])
box.add(combobox)
textview = Gtk.TextView()
textview.props.expand = True
box.add(textview)
self.show_all()
def __init__(self, lexers):
"""
Constructor
@param lexers reference to the lexers dictionary
"""
ConfigurationPageBase.__init__(self)
self.setupUi(self)
self.setObjectName("EditorHighlightersPage")
self.editorLexerList.headerItem().setText(self.editorLexerList.columnCount(), "")
header = self.editorLexerList.header()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setSortIndicator(0, Qt.AscendingOrder)
try:
self.extsep = os.extsep
except AttributeError:
self.extsep = "."
self.extras = ["-----------", self.trUtf8("Alternative")]
languages = [''] + sorted(lexers.keys()) + self.extras
for lang in languages:
self.editorLexerCombo.addItem(lang)
pygmentsLexers = [''] + sorted([l[0] for l in get_all_lexers()])
for pygmentsLexer in pygmentsLexers:
self.pygmentsLexerCombo.addItem(pygmentsLexer)
# set initial values
lexerAssocs = Preferences.getEditorLexerAssocs()
for ext in lexerAssocs.keys():
QTreeWidgetItem(self.editorLexerList,
QStringList() << ext << lexerAssocs[ext])
self.editorLexerList.sortByColumn(0, Qt.AscendingOrder)
def __init__(self, *args, **kwargs):
kwargs['initial'] = dict(kwargs.get('initial', {}), language='cpp')
super(HighlighterForm, self).__init__(*args, **kwargs)
choices = []
for name, aliases, filetypes, mimetypes in get_all_lexers():
choices.append((aliases[0], name))
self.fields['language'].choices = choices
def get_all_languages():
all_languages = ['none']
for lexers in get_all_lexers():
all_languages.extend(lexers[1])
return all_languages
def language_list(selfcls):
'''
get the support languages short name list from the pygments.
'''
langlist = ['%s (Names : %s)' % (lexer[0], ','.join(lexer[1]))
for lexer in get_all_lexers()]
langlist = sorted(langlist)
return langlist
def get_lexers(sorted_list=False):
lexers = {}
for name, aliases, _, _ in get_all_lexers():
if isinstance(aliases, (list, tuple)):
aliases = aliases[0]
lexers[aliases] = name
#lexers.sort(key=operator.itemgetter(0))
return lexers
def is_lang_supported(selfcls, lang):
'''
check 'lang' is there in the short name of supported lexers
'''
for lexer in get_all_lexers():
if lang in lexer[1]:
return True
return False
def get_lexers():
"""Get the supported language list.
Yield tuples containing the language Displayable name and the language
lexer name: ('Display Name', 'Lexer Name')
"""
for lexer in get_all_lexers():
yield lexer[0], lexer[1][0]
def get_lexer_list():
lexers = []
for lexer in get_all_lexers():
name, aliases, filetypes, mimetypes = lexer
lexers.extend([alias for alias in aliases])
return lexers
def _get_pygments_lexers(add_empty=True):
r = []
if add_empty:
r.append((u'', u''),)
for lexer in get_all_lexers():
r.append((lexer[1][0], _(lexer[0])),)
r.sort(key=itemgetter(1))
return r
def __init__(self, initial=None, *args, **kwargs):
super(PasteForm, self).__init__(initial=initial, *args, **kwargs)
# Load all the choices for the languages pygments currently supports
languages = dict(((lexer[0], lexer[1][0]) for lexer in lexers.get_all_lexers()))
sorted_languages = languages.keys()
sorted_languages.sort()
self.fields['language'].choices += ((languages[name], name) for name in sorted_languages)
self.fields['content'].widget.attrs.update({'placeholder': '<code> ... </code>'})
def _languages():
rv = OrderedDict()
lexers = list(get_all_lexers())
lexers.sort(key=lambda x: x[0])
for lexer in lexers:
for alias in lexer[1]:
rv[alias] = lexer[0]
return rv
def handle_all_languages(self):
all_lexers = list(lexers.get_all_lexers())
ret = []
for l in all_lexers:
if l[1][0] != "text":
ret.append((l[1][0],l[0],))
ret.sort()
return [('text', 'Plain text',)] + ret
def receive_paste():
paste = Paste(request.form['paste'], request.form['lang'])
from pygments.lexers import get_all_lexers
languages = set(map(lambda l:l[1][0], list(get_all_lexers())))
if paste.lang not in languages or len(paste.src) > 10**5:
abort(403)
db_session.add(paste)
db_session.commit()
return redirect(url_for('show_paste', pasteid = paste.id))
def piu():
lexdict = {}
lexlist = []
for _, names, fnames, _ in lexers.get_all_lexers():
lexlist.extend(names)
for fn in fnames:
lexdict[fn] = names[0]
response.content_type = 'text/plain'
return template('piu.py', extmap=lexdict, lexers=lexlist)
)
REPORT_CATEGORIES = getattr(
settings,
"NPB_REPORT_CATEGORIES",
(
("illicit", _("illicit content")),
("explicit", _("explicit content")),
("copyright", _("copyright infrigment")),
("private", _("private information exposure")),
("other", _("other")),
),
)
LEXERS = [("", _("auto detect"))]
LEXERS += [(l[1][0], l[0]) for l in get_all_lexers()]
class Paste(models.Model):
uuid = models.UUIDField(
primary_key=True,
default=uuid.uuid4,
editable=False,
verbose_name=_("identifier"),
)
is_suspended = models.BooleanField(
default=False, blank=True, verbose_name=_("suspended paste")
)
suspension_reason = models.CharField(
max_length=512, default="", blank=True, verbose_name=_("suspension reason")
)
from typing import List, Tuple
from django.contrib.auth import get_user_model
from django.db import models
from django.utils.translation import gettext_lazy as _
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
from paste import constants
_lexers = (item for item in get_all_lexers() if item[1])
def _max_len(choices: List[Tuple[str, str]]) -> int:
"""Return the maximum length of the first subitems of each item."""
return max(len(item[0]) for item in choices)
class Snippet(models.Model):
"""A source code snippet with its highlighting and privacy options. May be
owned by a user.
"""
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in _lexers])
STYLE_CHOICES = sorted([(item, item) for item in get_all_styles()])
title = models.CharField(_('title'),
max_length=constants.TITLE_MAX_LENGTH,
blank=True)
content = models.TextField(_('content'))
# pylint: disable=W0221
"""
https://github.com/PyCQA/pylint-django/issues/94 <- pylint: disable=W0221
Snippet
"""
from django.db import models
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
from pygments.lexers import get_lexer_by_name
from pygments.formatters.html import HtmlFormatter
from pygments import highlight
LEXERS = [i for i in get_all_lexers() if i[1]]
LANGUAGE_CHOICES = sorted([(i[1][0], i[0]) for i in LEXERS])
STYLE_CHOICES = sorted((i, i) for i in get_all_styles())
class Snippet(models.Model):
"""
Snippet
"""
created = models.DateTimeField(auto_now_add=True)
title = models.CharField(max_length=100, blank=True, default='')
code = models.TextField()
linenos = models.BooleanField(default=False)
language = models.CharField(choices=LANGUAGE_CHOICES,
default='python',
max_length=100)
style = models.CharField(choices=STYLE_CHOICES,
default='friendly',
max_length=100)
def get_languages() -> List[str]:
if not languages:
languages.extend(sorted([x[0] for x in get_all_lexers()]))
return languages
#!/usr/bin/python
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter
all_lexers = []
for i in get_all_lexers():
i = i[0]
if (" " not in i) and ("+" not in i) and ("(" not in i) and (
"-" not in i) and ("/" not in i):
all_lexers.append(i)
all_lexers.sort()
all_formats = [i for i in get_all_styles()]
all_formats.sort()
def cool(code):
tmp = '<div style="border-radius: 4px;border: solid #4286f4;background-color: whitesmoke;"> {} <div style="background-color: lawngreen;"><object align="right">♥Dcode♥ </object></div></div>'
return tmp.format(code)
def codes(codes, lexer='html', style='colorful'):
beauti_looks = "overflow:auto; width:auto; background-color:#f6f8fa; border-radius: 3px;font-family: Courier,monospace;"
#beauti_looks+= 'border:solid;border-width:.1em .1em .1em .1em;padding:.2em .6em;'
formatter = HtmlFormatter(
style=style,
noclasses=True,
linenos='table',
def newpaste():
if request.method == 'POST':
paste_opt = {}
for param in config.defaults: #init form parameters with defaults
paste_opt[param] = config.defaults[param]
for param in request.form:
if param in paste_opt:
paste_opt[param] = request.form[param]
if paste_opt['paste'] == '':
return config.msg_empty_paste, 400
try:
if not config.paste_limits['ttl_min'] < \
float(paste_opt['ttl']) < \
config.paste_limits['ttl_max']:
return config.msg_invalid_ttl, 400
except ValueError:
return config.msg_invalid_ttl, 400
try:
if paste_opt['lexer'] == 'auto':
paste_opt['lexer'] = guess_lexer(paste_opt['paste']).aliases[0]
except pygments.util.ClassNotFound:
paste_opt['lexer'] = 'text'
try:
if paste_opt['burn'] == '' or paste_opt['burn'] == 0 or paste_opt[
'burn'] == config.defaults['burn']:
paste_opt['burn'] = config.defaults['burn']
elif not config.paste_limits['burn_min'] <= int(
paste_opt['burn']) <= config.paste_limits['burn_max']:
return config.msg_invalid_burn, 400
except ValueError:
return config.msg_invalid_burn, 400
with psycopg2.connect(config.dsn) as db:
url_len = config.url_len
paste_opt['pasteid'] = ''
while url_collision(db, paste_opt['pasteid']):
for _ in range(url_len):
paste_opt['pasteid'] += choice(config.url_alph)
url_len += 1
paste_opt['token'] = \
urlsafe_b64encode((getrandbits(config.token_len * 8)) \
.to_bytes(config.token_len, 'little')).decode('utf-8')
stats = paste_stats(paste_opt['paste']) #generate text stats
db_newpaste(db, paste_opt, stats)
pastecount(db) #increment total pastes
if request.path != '/newpaste': #plaintext reply
if paste_opt['raw'] == 'true':
reptype = 'viewraw'
else:
reptype = 'viewpaste'
return config.domain + url_for(reptype, pasteid=paste_opt['pasteid']) + \
" | " + paste_opt['token'] + "\n"
flash(paste_opt['token'])
return redirect(paste_opt['pasteid'])
elif request.method == 'GET':
lexers_all = sorted(get_all_lexers())
return render_template('newpaste.html', \
lexers_all=lexers_all, lexers_common=config.lexers_common, \
ttl=config.ttl_options, paste_limits=config.paste_limits)
else:
abort(405)
def get_short_lexers() -> Iterator[str]:
for lex in get_all_lexers():
if len(lex[1]) > 0:
yield lex[1][0]
def _create_popup(self, instance):
# create the popup
content = BoxLayout(orientation='vertical', spacing='5dp')
popup_width = min(0.95 * Window.width, dp(700))
self.popup = Popup(content=content,
title=self.title,
size_hint=(None, None),
size=(popup_width, '400dp'))
self.popup.height = 0.95 * Window.height
# add all the options
#content.add_widget(Widget(size_hint_y=None, height=1))
scrolls_box = BoxLayout(orientation='horizontal', spacing='5dp')
layout_all = GridLayout(cols=1,
padding=5,
spacing=5,
size_hint=(None, None))
layout_all.bind(minimum_height=layout_all.setter('height'))
scroll_all = ScrollView(size_hint=(None, None),
size=(300, 320),
pos_hint={
'center_x': .5,
'center_y': .5
},
do_scroll_x=False)
lex_gen = (lex[0] for lex in lexers.get_all_lexers())
for lex in lex_gen:
btn = Button(text=str(lex), size=(300, 30), size_hint=(None, None))
btn.bind(on_release=self._add_lang)
layout_all.add_widget(btn)
scroll_all.add_widget(layout_all)
scrolls_box.add_widget(scroll_all)
layout_use = GridLayout(cols=1,
padding=5,
spacing=5,
size_hint=(None, None))
layout_use.bind(minimum_height=layout_use.setter('height'))
scroll_use = ScrollView(size_hint=(None, None),
size=(300, 320),
pos_hint={
'center_x': .5,
'center_y': .5
},
do_scroll_x=False)
for opt in self.options:
btn = Button(text=str(opt), size=(300, 30), size_hint=(None, None))
btn.bind(on_release=self._rm_lang)
layout_use.add_widget(btn)
scroll_use.add_widget(layout_use)
scrolls_box.add_widget(scroll_use)
content.add_widget(scrolls_box)
btn_ok = Button(text='OK', size_hint_y=None, height=dp(50))
btn_ok.bind(on_release=self._set_option)
btn_cl = Button(text='Cancel', size_hint_y=None, height=dp(50))
btn_cl.bind(on_release=self.popup.dismiss)
content.add_widget(btn_ok)
content.add_widget(btn_cl)
# and open the popup !
self.popup.open()
from pkg_resources import resource_filename
from pygments.lexers import get_all_lexers
from sphinx.util.osutil import copyfile
from sphinx.util import logging
FILES = [
'tabs.js',
'tabs.css',
'semantic-ui-2.2.10/segment.min.css',
'semantic-ui-2.2.10/menu.min.css',
'semantic-ui-2.2.10/tab.min.css',
'semantic-ui-2.2.10/tab.min.js',
]
LEXER_MAP = {}
for lexer in get_all_lexers():
for short_name in lexer[1]:
LEXER_MAP[short_name] = lexer[0]
def get_compatible_builders(app):
builders = [
'html', 'singlehtml', 'dirhtml', 'readthedocs', 'readthedocsdirhtml',
'readthedocssinglehtml', 'readthedocssinglehtmllocalmedia', 'spelling'
]
builders.extend(app.config['sphinx_tabs_valid_builders'])
return builders
class TabsDirective(Directive):
""" Top-level tabs directive """
from rest_framework import serializers
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
#--initialize variables
# get all lexers in list format
LEXERS = [lexer for lexer in get_all_lexers()]
# organize all lexers in tuples with two values ('lexer', 'LEXER')
LANGUAGES = sorted([(lexer[0].lower(), lexer[1][0]) for lexer in LEXERS])
# get and organize all styles available for highlighting the code snippet.
STYLES = sorted([(style, style) for style in get_all_styles()])
# available formatters as @ version 0.1.1 (not released).
# hardcoded.
FORMATTERS = sorted((
('bbcode', 'bbcode'),
('html', 'html'),
('irc', 'irc'),
('rtf', 'rtf'),
('svg', 'svg'),
('text', 'text'),
('terminal', 'terminal'),
('terminal256', 'terminal256'),
))
# a tuple of the line number formats available.
LINENUMBER = (
('none', 'none'),
('table', 'table'),
('inline', 'inline'),
)
# HTML: the css styling formats available. inline or class.
CSS = (('inline', 'inline'), ('class', 'class'))
def top():
return render_template('live_convert.html', lexers=get_all_lexers())
from django.db import models
from pygments import lexers
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
LEXERS = [lexer for lexer in get_all_lexers() if lexer[1]]
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in LEXERS])
STYLE_CHOICES = sorted([(item, item) for item in get_all_styles()])
class Snippet(models.Model):
created = models.DateTimeField(auto_now_add=True)
title = models.CharField(max_length=100, blank=True, default='')
code = models.TextField()
linenos = models.BooleanField(default=False)
language = models.CharField(choices=LANGUAGE_CHOICES,
default='python',
max_length=100)
style = models.CharField(choices=STYLE_CHOICES,
default='friendly',
max_length=100)
class Meta:
ordering = ['created']
def get_extra_mimetypes(self):
for lexname, aliases, _, mimetypes in get_all_lexers():
name = aliases[0] if aliases else lexname
for mimetype in mimetypes:
yield mimetype, aliases
def list_languages():
"""List all languages."""
languages = list(get_all_lexers())
languages.sort(key=lambda x: x[0].lstrip(" _-.").lower())
return languages
'VB.net': ( 1, None, None),
## ;
'REBOL': ( 1, None, None),
'LLVM': ( 1, None, None),
## --
'Ada': ( 2, None, None),
'Eiffel': ( 2, None, None),
'Vhdl': ( 2, None, None),
# ``*>`` as an inline comment is not supported.
## * or /
'COBOL': ( 1, None, None),
## ;
'INI': ( 1, None, None),
## #
'YAML': ( 1, None, None),
}
#
# Supported extensions
# ====================
# Compute a list of supported filename globs: supported by the lexer and
# by CodeChat (inline / block comment info in COMMENT_DELIMITER_INFO).
SUPPORTED_GLOBS = set()
# Per `get_all_lexers
# <http://pygments.org/docs/api/#pygments.lexers.get_all_lexers>`_, we get a
# tuple. Pick out only the filename and examine it.
for longname, aliases, filename_patterns, mimetypes in get_all_lexers():
# Pick only filenames we have comment info for.
if longname in COMMENT_DELIMITER_INFO:
# Apply normcase to each glob, so it will match on this OS.
SUPPORTED_GLOBS |= set(filename_patterns)
def get_lexers(): return get_all_lexers()
from django.db import models
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
from pygments.lexers import get_lexer_by_name
from pygments.formatters.html import HtmlFormatter
from pygments import highlight
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in get_all_lexers()])
STYLE_CHOICES = sorted([(item, item) for item in get_all_styles()])
class Snippet(models.Model):
created = models.DateTimeField(auto_now_add=True)
title = models.CharField(max_length=100, blank=True, default='')
code = models.TextField()
linenos = models.BooleanField(default=False)
language = models.CharField(choices=LANGUAGE_CHOICES,
default='python',
max_length=100)
style = models.CharField(choices=STYLE_CHOICES,
default='friendly',
max_length=100)
owner = models.ForeignKey('auth.User',
related_name='snippets',
on_delete=models.CASCADE)
highlighted = models.TextField()
class Meta:
ordering = ('created', )
def save(self, *args, **kwargs):
def showAllLexer(self):
""" will show all available lexers """
for lexer in lexers.get_all_lexers():
print(lexer)
def list_lexers():
lexers = [i for _, i, _, _ in get_all_lexers()]
return DictResponse(lexers)
def __init__(self):
self.all_langs = {lexer[0]: lexer[1][0] for lexer in lexers.get_all_lexers()}
self.all_styles = [style for style in styles.get_all_styles()]
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.utils.html import escape
from pygments import highlight
from pygments.formatters.html import HtmlFormatter
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.lexers.python import PythonLexer
LEXER_LIST_ALL = sorted([(lexer[1][0], lexer[0]) for lexer in get_all_lexers()
if lexer[1]])
LEXER_LIST = (
('nasm', 'Assembler'),
('bash', 'Bash'),
('c', 'C'),
('cpp', 'C++'),
('css', 'CSS'),
('diff', 'Diff'),
('django', 'Django/Jinja'),
('po', 'Gettext/Po'),
('html', 'HTML'),
('ini', 'INI config file'),
('irc', 'IRC logs'),
('java', 'Java'),
('js', 'JavaScript'),
from flask import Flask, render_template, flash, redirect, url_for, session, logging, request
from flask_mysqldb import MySQL
from wtforms import Form, StringField, TextAreaField, PasswordField, validators, SelectField
from passlib.hash import sha256_crypt
from functools import wraps
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.formatters import HtmlFormatter
from pygments import highlight
LEXERS = sorted(get_all_lexers(), key=lambda l: l[0].lower())
app = Flask(__name__)
# Config MYSQL
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = '******'
app.config['MYSQL_PASSWORD'] = ''
app.config['MYSQL_DB'] = 'spqr'
app.config['MYSQL_CURSORCLASS'] = 'DictCursor'
# init MYSQL
mysql = MySQL(app)
@app.route("/")
def index():
return render_template('index.html')
# Trending
@app.route('/public_paste')
from pyramid.view import view_config
from repoze.monty import marshal
from cluegun.models import PasteEntry
from cluegun.models import PasteBin
from cluegun.models import IPasteBin
app_version = '0.0'
COOKIE_LANGUAGE = 'cluegun.last_lang'
COOKIE_AUTHOR = 'cluegun.last_author'
formatter = formatters.HtmlFormatter(linenos=True, cssclass="source")
style_defs = formatter.get_style_defs()
all_lexers = list(lexers.get_all_lexers())
all_lexers.sort()
lexer_info = []
for name, aliases, filetypes, mimetypes_ in all_lexers:
lexer_info.append({'alias': aliases[0], 'name': name})
# utility functions
def get_pastes(context, request, max):
pastebin = find_interface(context, IPasteBin)
pastes = []
app_url = request.application_url
keys = list(pastebin.keys())
def byint(a, b):
if anki21:
string = str
else:
import string
HOTKEY = local_conf["hotkey"]
STYLE = local_conf["style"]
LIMITED_LANGS = local_conf["limitToLangs"]
# This code sets a correspondence between:
# The "language names": long, descriptive names we want
# to show the user AND
# The "language aliases": short, cryptic names for internal
# use by HtmlFormatter
LANGUAGES_MAP = {lex[0]: lex[1][0] for lex in get_all_lexers()}
ERR_LEXER = ("<b>Error</b>: Selected language not found.<br>"
"If you set a custom lang selection please make sure<br>"
"you typed all list entries correctly.")
ERR_STYLE = ("<b>Error</b>: Selected style not found.<br>"
"If you set a custom style please make sure<br>"
"you typed it correctly.")
# Misc
def showError(msg, parent):
showWarning(msg, title="Syntax Highlighting Error", parent=parent)
#!/usr/bin/env python2
# -*- encoding: utf-8 -*-
from __future__ import unicode_literals
import sys
from pygments import highlight
from pygments.lexers import SqlLexer
from pygments.formatters import TerminalFormatter
#in_ = sys.stdin.read()
#print highlight(in_, SqlLexer(), TerminalFormatter())
from pygments.lexers import get_all_lexers
i = get_all_lexers()
while True:
try:
o = i.next()
extensions = ','.join(o[2])
if not extensions:
continue
print("fileviewer {0} pygmentize -l {1}".format(extensions, o[1][0]))
except StopIteration:
break
except Exception as e:
print(e)
from django.db import models
# Create your models here.
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles
LEXERS = [item for item in get_all_lexers() if item[1]]
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in LEXERS])
STYLE_CHOICES = sorted([(item, item) for item in get_all_styles()])
class Snippet(models.Model):
created = models.DateTimeField(auto_now_add=True)
title = models.CharField(max_length=100, blank=True, default='')
code = models.TextField()
linenos = models.BooleanField(default=False)
language = models.CharField(choices=LANGUAGE_CHOICES, default='python', max_length=100)
style = models.CharField(choices=STYLE_CHOICES, default='friendly', max_length=100)
class Meta:
ordering = ['created']
"""
Using pygments to render the code.
"""
from pygments import highlight, styles
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.formatters.html import HtmlFormatter
from pygments.styles import get_all_styles
from django.utils.translation import ugettext as _
from fluent_contents.plugins.code import appsettings
STYLE_CHOICES = map(lambda x: (x, x), get_all_styles())
STYLE_CHOICES.sort(lambda x, y: cmp(x[1].lower(), y[1].lower()))
_languageChoices = map(lambda x: (x[1][0], x[0]), get_all_lexers())
_languageChoices.sort(lambda x, y: cmp(x[1].lower(), y[1].lower()))
LANGUAGE_CHOICES = tuple(
[t for t in _languageChoices if t[0] in appsettings.FLUENT_CODE_SHORTLIST])
if not appsettings.FLUENT_CODE_SHORTLIST_ONLY:
LANGUAGE_CHOICES += (_('Combinations'),
[t for t in _languageChoices if '+' in t[0]]),
LANGUAGE_CHOICES += (_('Advanced'), [
t for t in _languageChoices
if '+' not in t[0] and t[0] not in appsettings.FLUENT_CODE_SHORTLIST
]),
def render_code(instance, style_name='default'):
# Some interesting options in the HtmlFormatter:
# - nowrap -> no wrap inside <pre>
# - classprefix -> prefix for the classnames
# -*- coding: utf-8 -*-
from docutils.parsers import rst
from pygments import highlight
from pygments.lexers import get_lexer_by_name, get_all_lexers
from pygments.formatters import HtmlFormatter
from pylonshq.lib.pygmentsupport import code_block
__all__ = ['code_highlight']
langdict = {}
for lang in get_all_lexers():
if lang[1]:
langdict[lang[1][0]] = lang[0]
formatter = HtmlFormatter(linenos=True, cssclass="syntax", encoding='utf-8')
def code_highlight(code, truncate_lines=None):
# Ensure that code-block is regged properly
rst.directives.register_directive('code-block', code_block)
source = code.code
if truncate_lines:
split_source = source.split('\n')
if len(split_source) > truncate_lines:
source = split_source[:truncate_lines - 1]
source.append('...')
source = ''.join(source)
lexer = get_lexer_by_name(code.language, stripall=True)
return highlight(source, lexer, formatter).decode('utf-8')
from django.db import models
from django.utils import timezone
from pygments.lexers import get_all_lexers #for api
from pygments.styles import get_all_styles #for api
from pygments.lexers import get_lexer_by_name #for api
from pygments.formatters.html import HtmlFormatter #for api
from pygments import highlight #for api
LEXERS = [item for item in get_all_lexers() if item[1]] #indentify options for certain columns in Post
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in LEXERS])
STYLE_CHOICES = sorted((item, item) for item in get_all_styles())
class Post(models.Model): #Post model which stores all the data for the todo's
author = models.ForeignKey('auth.User', related_name='snippets', on_delete=models.CASCADE, default=False)
title = models.CharField(default=" ", max_length=200)
text = models.TextField(default=" ")
#number = models.IntegerField()
created_date = models.DateTimeField(
default=timezone.now)
published_date = models.DateTimeField(
default=timezone.now)
linenos = models.BooleanField(default=False)
language = models.CharField(choices=LANGUAGE_CHOICES, default='python', max_length=100)
style = models.CharField(choices=STYLE_CHOICES, default='friendly', max_length=100)
highlighted = models.TextField(default=False)
def publish(self):
self.published_date = timezone.now()
self.save()
def __str__(self):
def get_extra_mimetypes(self):
for _, aliases, _, mimetypes in get_all_lexers():
for mimetype in mimetypes:
yield mimetype, aliases
