def set_lexer_from_filename(self, filename): """ Change the lexer based on the filename (actually only the extension is needed) :param filename: Filename or extension """ if filename.endswith("~"): filename = filename[0:len(filename) - 1] try: self._lexer = get_lexer_for_filename(filename) _logger().debug('lexer for filename (%s): %r', filename, self._lexer) except ClassNotFound: _logger().warning( 'failed to get lexer from filename: %s, using ' 'plain text instead...', filename) self._lexer = TextLexer() return False except ImportError: # import error while loading some pygments plugins, the editor # should not crash _logger().warning( 'failed to get lexer from filename: %s, using ' 'plain text instead...', filename) self._lexer = TextLexer() return False else: return True
def set_mime_type(self, mime_type): """ Update the highlighter lexer based on a mime type. :param mime_type: mime type of the new lexer to setup. """ if not mime_type: # Fall back to TextLexer self._lexer = TextLexer() return False try: self.set_lexer_from_mime_type(mime_type) except ClassNotFound: _logger().exception('failed to get lexer from mimetype') self._lexer = TextLexer() return False except ImportError: # import error while loading some pygments plugins, the editor # should not crash _logger().warning('failed to get lexer from mimetype (%s)' % mime_type) self._lexer = TextLexer() return False else: return True
def __init__(self, name, main_display, tabsize, multiline_window=1500, number_of_windows=1): self.name = name self.file = f = open(name) try: lexer = guess_lexer_for_filename(name, f.readline()) except TypeError: try: lexer = get_lexer_by_name(os.path.splitext(name)[1][1:]) except pygments.util.ClassNotFound: lexer = TextLexer() except pygments.util.ClassNotFound: lexer = TextLexer() lexer = Python3Lexer() if isinstance(lexer, PythonLexer) else lexer lexer.add_filter(NonEmptyFilter()) lexer.add_filter('tokenmerge') f.seek(0) self.lines = [] self.focus = 0 self.clipboard = None self.clipboard_pos = None self.lexer = lexer self.w_pos = {} self.all_tokens = None self._etext = lambda w: w.edit_text self.multiline_window = multiline_window self.number_of_windows = number_of_windows self.main_display = main_display self.line_kwargs = dict(caption="", allow_tab=True, lexer=lexer, wrap='clip', main_display=main_display, smart_home=True, tabsize=tabsize)
def render(file, size, browser=False, color=True, fontSize="10pt", margin="0.5in", relative=True, title=None): """Render file with filename as HTML page(s) of specified size.""" code = file.read().decode("utf-8", "ignore") if code.strip() and color: try: lexer = get_lexer_for_filename(file.filename) except: try: assert code.startswith("#!") # else, e.g., a .gitignore file with a dotfile is mistaken by GuessLexer lexer = guess_lexer(code.splitlines()[0]) except: lexer = TextLexer() string = highlight(code, lexer, HtmlFormatter(linenos="inline", nobackground=True)) else: string = highlight(code, TextLexer(), HtmlFormatter(linenos="inline", nobackground=True)) if not title: title = file.filename stylesheets = [ CSS(string="@page {{ border-top: 1px #808080 solid; margin: {}; padding-top: 1em; size: {}; }}".format(margin, size)), CSS(string="@page {{ @top-right {{ color: #808080; content: '{}'; padding-bottom: 1em; vertical-align: bottom; }} }}".format( title.replace("'", "\'"))), CSS(string="* {{ font-family: monospace; font-size: {}; margin: 0; overflow-wrap: break-word; white-space: pre-wrap; }}".format(fontSize)), CSS(string=HtmlFormatter().get_style_defs('.highlight')), CSS(string=".highlight { background: initial; }"), CSS(string=".lineno { color: #808080; }"), CSS(string=".lineno:after { content: ' '; }")] HTML(string=string).write_pdf('/tmp/output.pdf', stylesheets=stylesheets)
def getOutput(buildRetCode, buildLog, stdInputList, cmdArgsList, exitTypeList, stdoutStrList): s = '<pre>\n' if buildRetCode!=0: # build error s += buildLog else: assert(len(stdInputList)==len(cmdArgsList)) for i in range(len(stdInputList)): stdInput = stdInputList[i] cmdArgs = cmdArgsList[i] exitType = exitTypeList[i] stdoutStr = stdoutStrList[i] if exitType == 0: s += '(STD_INPUT: %s)\n'%stdInput s += '(CMD_ARGS: %s)\n'%cmdArgs # success, unistr = getUnicodeStr(stdoutStr) # s += highlight(unistr, TextLexer(), HtmlFormatter()) s += highlight(stdoutStr, TextLexer(), HtmlFormatter()) elif exitType == -1: s += highlight(stdoutStr, TextLexer(), HtmlFormatter()) elif exitType == 1: # time out s += '(STD_INPUT: %s)\n'%stdInput s += '(CMD_ARGS: %s)\n'%cmdArgs s += 'Timeout' s += '\n' return s
def languageLexerToPlain(self, event=None): print("Setting language to: Plain Text") self.lexer = TextLexer() self.currentLanguageName = "Plain Text" self.create_tags() self.recolorize() self.updateStatusBar()
def preview(): _csrf_protect() # Set lexer try: lexer = get_lexer_by_name(request.form['lexer']) except ClassNotFound: lexer = TextLexer() kwargs = {} # Set option values for pygments # font_size try: font_size = int(request.form['font_size']) if font_size > 0: kwargs['font_size'] = font_size except ValueError: pass if not 'font_size' in kwargs.keys(): kwargs['font_size'] = DEFAULT_FONT_SIZE # line_numbers if not 'is_display_linenum' in request.form: kwargs['line_numbers'] = False binary = _generate(request.form['text'], lexer, kwargs) return Response(binary.encode("base64"), mimetype='text/plain')
def set_lexer_from_filename(self, filename): """ Change the lexer based on the filename (actually only the extension is needed) :param filename: Filename or extension """ self._lexer = None if filename.endswith("~"): filename = filename[0:len(filename) - 1] try: self._lexer = get_lexer_for_filename(filename) except (ClassNotFound, ImportError): print(('class not found for url', filename)) try: m = mimetypes.guess_type(filename) print(m) self._lexer = get_lexer_for_mimetype(m[0]) except (ClassNotFound, IndexError, ImportError): self._lexer = get_lexer_for_mimetype('text/plain') if self._lexer is None: _logger().warning( 'failed to get lexer from filename: %s, using ' 'plain text instead...', filename) self._lexer = TextLexer()
def _get_pygments_lexer(language): if language == 'ipython2': try: from IPython.lib.lexers import IPythonLexer except ImportError: warn("IPython lexer unavailable, falling back on Python") language = 'python' else: return IPythonLexer() elif language == 'ipython3': try: from IPython.lib.lexers import IPython3Lexer except ImportError: warn("IPython3 lexer unavailable, falling back on Python 3") language = 'python3' else: return IPython3Lexer() try: return get_lexer_by_name(language, stripall=True) except ClassNotFound: warn("No lexer found for language %r. Treating as plain text." % language) from pygments.lexers.special import TextLexer return TextLexer()
def view_file(filename): """ Views file with syntax highlighting (if applicable) Args: filename (str): Full path to filename to render view response for. """ folder = filename.split(_AEON_TOPDIR).pop().strip('/') filename = os.path.join(_AEON_TOPDIR, filename) try: with open(filename, 'r') as f: data = f.read() # lexer = guess_lexer_for_filename(filename, data) formatter = HtmlFormatter(linenos=True) try: lexer = get_lexer_for_filename(filename) code = highlight(data, lexer, formatter) except ClassNotFound: lexer = TextLexer() code = highlight(data, lexer, formatter) stat = os.stat(filename) return render_template('view.html', content=code, folder=folder, stat=stat, filename=filename) except (OSError, IOError) as e: code = e[0] reason = e[1] flash( 'Error: Could not view file {filename}: {reason} ({code})'.format( filename=filename, reason=reason, code=code), 'danger') return render_template('view.html')
def get_text(self): quote = re.compile('^> (.*?)\n', re.MULTILINE|re.DOTALL) quote_results = quote.findall(self.text) #print self.text.encode('ascii', 'ignore') for quote_m in quote_results: #print quote_m.encode('ascii', 'ignore') self.text = self.text.replace("> " + quote_m + "\n", "<blockquote>" + quote_m + "</blockquote>" ) pre = re.compile('```(.*?)```', re.MULTILINE|re.DOTALL) pre_results = pre.findall(self.text) for pre_m in pre_results: from pygments import highlight from pygments.lexers import guess_lexer from pygments.lexers.special import TextLexer from pygments.formatters import HtmlFormatter from pygments.util import ClassNotFound try: lexer = guess_lexer(self.unescape_html(pre_m[:2048])) except (ClassNotFound, ValueError): lexer = TextLexer() formatted = highlight(self.unescape_html(pre_m), lexer, HtmlFormatter()) self.text = self.text.replace("```" + pre_m + "```", formatted ) code = re.compile('`(.*?)`', re.MULTILINE|re.DOTALL) code_results = code.findall(self.text) for code_m in code_results: self.text = self.text.replace("`" + code_m + "`", "<code>" + code_m + "</code>" ) p = re.compile('<(.*?)>') results = p.findall(self.text) for m in results: if m.startswith('@U'): slack_id = m.replace("@",'').split("|")[0] try: user = User.objects.get(slack_id = slack_id) except: user = None if user: self.text = self.text.replace("<" + m + ">", user.slack_username ) if m.startswith('http'): link = m.split("|")[0] try: title = m.split("|")[1] except IndexError: title = '' if False: #link.endswith(('png', 'jpg', 'jpeg', 'gif',)): self.text = self.text.replace("<" + m + ">", "<a href='"+link + "' title='"+title+"'>" + "<img width=300px src='"+link+"'>" + "</a>" ) else: self.text = self.text.replace("<" + m + ">", "<a href='"+link + "' title='"+title+"'>" + link + "</a>" ) return self.text
def format_html(filename, source): """Format the source text given as HTML with Pygments.""" try: lexer = guess_lexer_for_filename(filename, source, stripnl=False) except ClassNotFound: lexer = TextLexer(stripnl=False) formatter = HtmlFormatter(nowrap=True) return highlight(source, lexer, formatter)
def format_rtf(t): tokensource = list(TextLexer().get_tokens(t)) fmt = RtfFormatter() buf = StringIO() fmt.format(tokensource, buf) result = buf.getvalue() buf.close() return result
def detect_from_name(): _csrf_protect() # Detect lexer try: lexer = get_lexer_for_filename(request.form['name']) except ClassNotFound: lexer = TextLexer() return Response(lexer.aliases[0], mimetype='text/plain')
def _get_lexer(filename: Optional[PurePath], text: str) -> Lexer: if filename: with suppress(ClassNotFound): return get_lexer_for_filename(normcase(filename.name)) with suppress(ClassNotFound): return guess_lexer(text) return TextLexer()
def _pygments_highlight(source, output_formatter, language="ipython", metadata=None): """ Return a syntax-highlighted version of the input source Parameters ---------- source : str source of the cell to highlight output_formatter : Pygments formatter language : str language to highlight the syntax of metadata : NotebookNode cell metadata metadata of the cell to highlight """ from pygments import highlight from pygments.lexers import get_lexer_by_name from pygments.util import ClassNotFound # If the cell uses a magic extension language, # use the magic language instead. if language.startswith( "ipython") and metadata and "magics_language" in metadata: language = metadata["magics_language"] lexer = None if language == "ipython2": try: from IPython.lib.lexers import IPythonLexer except ImportError: warn("IPython lexer unavailable, falling back on Python") language = "python" else: lexer = IPythonLexer() elif language == "ipython3": try: from IPython.lib.lexers import IPython3Lexer except ImportError: warn("IPython3 lexer unavailable, falling back on Python 3") language = "python3" else: lexer = IPython3Lexer() if lexer is None: try: lexer = get_lexer_by_name(language, stripall=True) except ClassNotFound: warn("No lexer found for language %r. Treating as plain text." % language) from pygments.lexers.special import TextLexer lexer = TextLexer() return highlight(source, lexer, output_formatter)
def guess_lexer_for_filename(filename): from pygments.lexers import get_lexer_for_filename from pygments.util import ClassNotFound try: lexer = get_lexer_for_filename(filename) except ClassNotFound: from pygments.lexers.special import TextLexer lexer = TextLexer() return lexer
def get_lexer(self): # this function gets the lexer depending on the files name try: lexer = get_lexer_for_filename(self.short_name) except pygments.util.ClassNotFound: lexer = TextLexer() lexer.add_filter('tokenmerge') return lexer
def jinja_pygments_formatter(data): formatter = HtmlFormatter(cssclass='codehilite') if isinstance(data, dict) or isinstance(data, list): data = jsonutils.dumps(data, indent=4, sort_keys=True) lexer = JsonLexer() elif six.string_types or six.text_type: try: data = jsonutils.dumps(jsonutils.loads(data), indent=4, sort_keys=True) lexer = JsonLexer() except (ValueError, TypeError): lexer = TextLexer() else: lexer = TextLexer() lexer.stripall = True return highlight(Markup(data).unescape(), lexer, formatter)
def _ensure_lexer(self): if self.lexer is not None: return try: lexer = pygments_cache.get_lexer_for_filename(self.name) except pygments.util.ClassNotFound: lexer = TextLexer() lexer = Python3Lexer() if isinstance(lexer, PythonLexer) else lexer lexer.add_filter(NonEmptyFilter()) lexer.add_filter('tokenmerge') self.lexer = self.line_kwargs['lexer'] = lexer
def format_data(data): formatter = HtmlFormatter(cssclass="codehilite") if isinstance(data, bool) or isinstance(data, int) or isinstance( data, float): return highlight(str(data), TextLexer(), formatter) elif isinstance(data, str): try: data = json.dumps(json.loads(data), indent=4, sort_keys=True) lexer = JsonLexer() except (ValueError, TypeError): lexer = TextLexer() elif isinstance(data, dict) or isinstance(data, list): data = json.dumps(data, indent=4, sort_keys=True) lexer = JsonLexer() else: lexer = TextLexer() lexer.stripall = True return highlight(data, lexer, formatter)
def run(self): self.assert_has_content() try: lexer = get_lexer_by_name(self.arguments[0]) except ValueError: # no lexer found - use the text one instead of an exception lexer = TextLexer() # take an arbitrary option if more than one is given formatter = self.options and VARIANTS[self.options.keys()[0]] or DEFAULT parsed = highlight(u'\n'.join(self.content), lexer, formatter) return [nodes.raw('', parsed, format='html')]
def get_context(self, value, parent_context=None): context = super().get_context(value, parent_context=parent_context) try: lexer = get_lexer_by_name(value['language'], stripall=True) except ClassNotFound: lexer = TextLexer(stripall=True) formatter = HtmlFormatter(linenos=None, cssclass='codehilite', noclasses=False) context['html_code'] = highlight(value['code'], lexer, formatter) context['html_code'] = mark_safe(context['html_code']) return context
def getOutput(buildRetCode, buildLog, userInputList, exitTypeList, stdoutStrList): s = '<pre>\n' if buildRetCode!=0: # build error s += buildLog else: for i in range(len(userInputList)): userInput = userInputList[i] exitType = exitTypeList[i] stdoutStr = stdoutStrList[i] if exitType == 0: s += '(user input: %s)\n'%userInput # success, unistr = getUnicodeStr(stdoutStr) # s += highlight(unistr, TextLexer(), HtmlFormatter()) s += highlight(stdoutStr, TextLexer(), HtmlFormatter()) elif exitType == -1: s += highlight(stdoutStr, TextLexer(), HtmlFormatter()) elif exitType == 1: # time out s += '(user input: %s)\n'%userInput s += 'Timeout' s += '\n' return s
def get(self, request, *args, **kwargs): context = self.get_context_data(**kwargs) code_directory = os.path.realpath( settings.CODE_DIRECTORY) + os.path.sep absolute_path = self.request.GET.get('path') if not absolute_path: return redirect(reverse('web:browse') + '?path=/') if not absolute_path.startswith('/'): raise Http404 absolute_path = '.' + absolute_path absolute_path = os.path.join(settings.CODE_DIRECTORY, absolute_path) absolute_path = os.path.realpath(absolute_path) if not absolute_path.startswith(code_directory): raise Http404 if not os.path.exists(absolute_path): raise Http404 if not os.path.isfile(absolute_path): raise Http404 relative_path = '/' + absolute_path[len(code_directory):] breadcrumbs = self.get_breadcrumbs(relative_path) annotations = {} for annotation in CodeAnnotation.objects.filter(path=relative_path): annotations[annotation.line_number] = { 'user': annotation.user, 'annotation': annotation.annotation } with open(absolute_path) as f: code = f.read() try: lexer = get_lexer_for_filename(absolute_path) except ClassNotFound: lexer = TextLexer() code = highlight( code, lexer, Formatter(annotations=annotations, linenos='inline', linespans='line')) context.update({ 'code': code, 'css': HtmlFormatter().get_style_defs('.highlight'), 'relative_path': relative_path, 'breadcrumbs': breadcrumbs, }) return self.render_to_response(context)
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 _pygments_highlight(source, output_formatter, language='ipython', metadata=None): """ Return a syntax-highlighted version of the input source Parameters ---------- source : str source of the cell to highlight output_formatter : Pygments formatter language : str language to highlight the syntax of metadata : NotebookNode cell metadata metadata of the cell to highlight """ from pygments import highlight from pygments.lexers import get_lexer_by_name from pygments.util import ClassNotFound # If the cell uses a magic extension language, # use the magic language instead. if language.startswith('ipython') \ and metadata \ and 'magics_language' in metadata: language = metadata['magics_language'] if language == 'ipython2': from IPython.lib.lexers import IPythonLexer lexer = IPythonLexer() elif language == 'ipython3': from IPython.lib.lexers import IPython3Lexer lexer = IPython3Lexer() else: try: lexer = get_lexer_by_name(language, stripall=True) except ClassNotFound: warn("No lexer found for language %r. Treating as plain text." % language) from pygments.lexers.special import TextLexer lexer = TextLexer() return highlight(source, lexer, output_formatter)
def _highlight(data, is_json=True): """ Render an HTML page with a highlighted JSON string or plain text. :param data: Data to highlight, should be a string or JSON-able object :param is_json: If the data is a JSON string or can be converted into such :return: Response object with rendered template with highlighted data """ if is_json and not isinstance(data, (str, bytes)): data = json.dumps(data, indent=2) # Pygments highlighting lexer = JsonLexer() if is_json else TextLexer() formatter = HtmlFormatter() highlight = pygments.highlight(data, lexer, formatter) return f.render_template("results.html", highlight=highlight, extra_css=formatter.get_style_defs())
def fetch_lexer(source: str, language: str = None, filename: str = None, mime_type: str = None) -> Lexer: """ :param source: :param language: :param filename: :param mime_type: :return: """ environ.abort_thread() try: if language: return get_lexer_by_name(language, stripall=True) except ClassNotFound: pass if filename: try: return get_lexer_for_filename(filename, stripall=True) except ClassNotFound: pass try: return guess_lexer_for_filename(filename, source, stripall=True) except ClassNotFound: pass try: if mime_type: return get_lexer_for_mimetype(mime_type, stripall=True) except ClassNotFound: pass try: return guess_lexer(source, stripall=True) except ClassNotFound: return TextLexer()
def _parse_src(cls, src_contents, src_filename): """ Return a stream of `(token_type, value)` tuples parsed from `src_contents` (str) Uses `src_filename` to guess the type of file so it can highlight syntax correctly. """ # Parse the source into tokens try: lexer = guess_lexer_for_filename(src_filename, src_contents) except ClassNotFound: lexer = TextLexer() # Ensure that we don't strip newlines from # the source file when lexing. lexer.stripnl = False return pygments.lex(src_contents, lexer)