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