def __init__(self, nesting_level=4, md_ext=_ext): # self.rndr = HtmlRenderer(nesting_level=nesting_level) self.rndr = CustomRenderer(nesting_level=nesting_level) self.tocrndr = HtmlTocRenderer(nesting_level=nesting_level) self.md = Markdown(self.rndr, extensions=md_ext) self.toc = Markdown(self.tocrndr, extensions=('fenced-code', 'autolink', 'underline'))
def setup(self): self.r = Markdown(HtmlRenderer()).render tests_dir = path.dirname(__file__) for text_path in glob(path.join(tests_dir, self.suite, '*.text')): html_path = '%s.html' % path.splitext(text_path)[0] self._create_test(text_path, html_path)
def parse(text): chg = Renderer() chg.reset() md = Markdown(renderer=chg) md(text) return chg
def description(job_id): # SELECT JOB FROM DATABASE job = select_job(job_id) # render descripton markdown to html render = HtmlRenderer() md = Markdown(render) job["description"] = Markup(md(job.get("description"))) return render_template("description.html", job=job)
def inspect(cls, raw): renderer = cls() markdown = renderer.preprocess(raw) extensions = EXT_FENCED_CODE | EXT_NO_INTRA_EMPHASIS md = Markdown(renderer, extensions=extensions) full = md(markdown) renderer.postprocess(full) return renderer
def preview(): from misaka import Markdown, HtmlRenderer if request.method == "POST": content = request.args.get('content') html = HtmlRenderer() markdown = Markdown(html) return Markup(markdown(content)) else: abort(404)
def __init__(self, markdown, renderer=None, url_prefix=None): self.raw = markdown self.renderer = renderer or MarkmentRenderer() self.renderer.url_prefix = url_prefix self.markdown = Markdown( self.renderer, extensions=self.extensions, ) self.rendered = self.compile() self.url_references = self.renderer.url_references
def read(request, slug): articles = get_list_or_404(Article, slug=slug, publie=True) article = articles[0] categories = [cat.nom for cat in article.categorie.all()] tiret = "-" categories = tiret.join(categories) # for some special posts, we use js code, so we use specific template retour = jump_special_view(request, locals()) if retour: return retour url_article = '{}'.format(getattr(article, 'urlGitHub')) response = get_article_from_local(url_article) extension = url_article.split('.')[1] if response != 'Error': if extension == 'md': rndr = HtmlRenderer() md = Markdown(rndr, extensions=('fenced-code', 'math')) article_markdown = md(response) return render( request, 'markdown.html', { 'article': article, 'categories': categories, 'article_markdown': article_markdown, 'url_github': url_article }) elif extension == 'ipynb': notebook = format_read(response, as_version=4) html_explorer = HTMLExporter() html_explorer.template_file = 'basic' (body, _) = html_explorer.from_notebook_node(notebook) return render( request, 'lire_ipynb.html', { 'article': article, 'ipynb': body, 'categories': categories, 'url_github': url_article }) else: article_markdown = ('Error reading this article!') return render( request, 'markdown.html', { 'article': article, 'categories': categories, 'article_markdown': article_markdown, 'url_github': url_article })
def preview(): if request.method == "POST": from misaka import Markdown, HtmlRenderer choice = request.values.get('choice') content = request.values.get('content') if choice == 'Default': return safe_clean(content) else: html = HtmlRenderer() markdown = Markdown(html) return Markup(markdown(content)) else: abort(404)
def story(content_uri): """Return the text referenced by content_uri. If uri can not be resolved it is returned as is. Current allowed scheme is 'git'. The netloc 'yaj-dir' resolves to the local source tree. The buffer get processed by mako and rendered as markdown. """ fullpath = uri.resolve_to_path(content_uri) buf0 = fetch.read(fullpath) # markdown rndr = HtmlRenderer() md = Markdown(rndr) return md(buf0)
def safe_markdown(text): class HighlighterRenderer(HtmlRenderer): def blockcode(self, text, lang): lang = 'python' if not lang: return '\n<pre><code>{}</code></pre>\n'.format(text.strip()) lexer = get_lexer_by_name(lang, stripall=True) formatter = HtmlFormatter() return highlight(text, lexer, formatter) renderer = HighlighterRenderer() md = Markdown(renderer, extensions=('fenced-code', )) return Markup(md(safe_clean(text)))
def main(): md = Markdown( # skip-html - 跳过原文中的 HTML 代码 # hard-wrap - 每个 \n 都渲染为 <br> renderer=_Renderer(flags=('hard-wrap', 'skip-html')), # space-headers - 只将 # Title 转为 <header> # #Title 会保持原样 extensions=('disable-indented-code', 'autolink', 'space-headers')) print md(u'''some text next line next para''') # 空行中央有一个全角空格
def index(): """Present readme.md""" # Open readme.md file with open(os.path.dirname(app.root_path) + '/app/readme.md', 'r') as markdown_file: print('os.path.dirname(app.root_path)', os.path.dirname(app.root_path)) # Read the content of the file content = markdown_file.read() rndr = HtmlRenderer() md = Markdown(rndr) # Convert it to HTML return md(content)
def test_list_custom_start(self): class ListCustomStartRenderer(HtmlRenderer): def list(self, text, is_ordered, is_block, prefix): if prefix: return '<ol start="{start}">\n{text}</ol>\n'.format( start=prefix, text=text) return super(ListCustomStartRenderer, self).list(text, is_ordered, is_block, prefix) text = ' 5. five\n 6. six\n 7. seven' rendered = Markdown(ListCustomStartRenderer())(text) ok(rendered).diff( '<ol start="5">\n<li>five</li>\n<li>six</li>\n<li>seven</li>\n</ol>\n' )
def safe_markdown(text): class HighlighterRenderer(HtmlRenderer): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) def blockcode(self, text, lang): if not lang: return '\n<pre><code>{}</code></pre>\n'.format(text.strip()) lexer = get_lexer_by_name(lang, stripall=True) formatter = HtmlFormatter(linenos=True) return highlight(text, lexer, formatter) renderer = HighlighterRenderer() md = Markdown(renderer, extensions=('fenced-code', )) return Markup(md(safe_clean(text)))
def get_text_from_markdown(markdown_text): renderer = HtmlRenderer() markdown = Markdown(renderer, extensions=('tables', 'autolink', 'strikethrough', 'quote', 'superscript', 'fenced-code')) html = markdown(markdown_text) parsed_html = fromstring(html) # remove quoted text [x.getparent().remove(x) for x in parsed_html.xpath('//blockquote')] # remove automatically added links for link in parsed_html.xpath('//a'): if link.text_content() == link.get('href'): link.getparent().remove(link) text = ''.join(parsed_html.text_content()).strip() return text
def create(): md = Markdown(HtmlRenderer()) form = PostForm() post = Post() if form.validate_on_submit(): post.title = form.title.data post.body = form.body.data post.body_html = md(post.body) post.outline = form.outline.data post.created = datetime.now() db.session.add(post) return redirect(url_for('main.admin')) try: db.session.commit() except ImportError: db.session.rollback return render_template('create_post.html', form=form)
def __init__(self): Gtk.Window.__init__(self, type=Gtk.WindowType.TOPLEVEL, title="MDLive Markdown Editor") self.version = "0.1.0" default_width = 1280 default_height = 720 self.set_default_size(default_width, default_height) self.set_position(Gtk.WindowPosition.MOUSE) self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.add(self.box) self.menu_bar = MenuBar(self) self.split_box = Gtk.HPaned() self.split_box.set_position(default_width / 2) self.editor = Gtk.TextView() self.editor.set_wrap_mode(Gtk.WrapMode.WORD_CHAR) self.editor_buffer = self.editor.get_buffer() self.editor_scroller = Gtk.ScrolledWindow() self.editor_scroller.add(self.editor) self.preview = WebKit.WebView() self.preview.open("file://" + self.installed_path() + "/assets/index.html") self.preview_scroller = Gtk.ScrolledWindow() self.preview_scroller.add(self.preview) self.split_box.add1(self.editor_scroller) self.split_box.add2(self.preview_scroller) self.box.pack_start(self.menu_bar, False, False, 0) self.box.pack_start(self.split_box, True, True, 0) self.renderer = Renderer() self.markdown = Markdown(self.renderer, extensions=misaka.EXT_FENCED_CODE | misaka.EXT_AUTOLINK | misaka.EXT_SPACE_HEADERS) self.editor_buffer.connect("end-user-action", self.on_buffer_end_user_action)
def post_content(slug): login = session.get("logged_in") post = db.session.query(Posts).filter(Posts.slug == slug).first() if not post: return abort(404) render = HtmlRenderer() md = Markdown(render) session['post_id'] = post.id user_id = session.get("user_id") username = session.get("username") post.content = Markup(md(post.content)) return render_template("post/post-content.html", login=login, post=post, user=username)
def setText(self, text): htmlrd = HighlighterRenderer() mdToHtml = Markdown(htmlrd, extensions=('fenced-code', 'tables', 'footnotes', 'autolink', 'highlight','strikethrough', 'underline', 'quote', 'superscript', 'math', 'no-intra-emphasis', 'space-headers', 'math-explicit')) html = mdToHtml(text) html = html.replace('<table>', '<table border="1">') #css head cssStyle = '<style type = "text/css">\n' #css body with open('./resource/typora.style', 'r') as file: typoraStyle = file.read() cssStyle = cssStyle + typoraStyle cssStyle = cssStyle + HtmlFormatter().get_style_defs('.highlight') #css end cssStyle = cssStyle + '</style>\n' self.setHtml(cssStyle + html)
def convert_to_html(filename, input_encoding='UTF-8'): """ Convert a file with Markdown or reStructuredText markup to HTML. :param filename: The filename of the text file to convert (a string). :param encoding: The encoding of the text file (a string). :returns: A tuple of two strings: 1. The HTML to embed in the ``<head>``. 2. The HTML to embed in the ``<body>``. """ # Determine the filename extension. basename, extension = os.path.splitext(filename) extension = extension.lower() # Read the input file into a Unicode string. with codecs.open(filename, encoding=input_encoding) as handle: text = handle.read() # Convert the input file. timer = Timer() if extension in MARKDOWN_EXTENSIONS: logger.debug( "Filename extension of input file (%s) indicates Markdown.", extension) converter = Markdown(HtmlRenderer()) head = '' body = converter.render(text) elif extension in RESTRUCTUREDTEXT_EXTENSIONS: logger.debug( "Filename extension of input file (%s) indicates reStructuredText.", extension) parts = publish_parts(source=text, writer_name='html', settings_overrides=dict(doctitle_xform=False)) head = parts['stylesheet'] body = parts['html_body'] else: msg = "Input file not supported! (filename extension %s not recognized)" raise ValueError(msg % extension) logger.debug("Converted %s input text to %s HTML in %s.", format_size(len(text)), format_size(len(head) + len(body)), timer) return head, body
def __init__(self, config: Config, som: dict, build_cache: dict = None): self.config = config self.som = som self.build_cache = build_cache md_renderer = HarrierHtmlRenderer() self.md = Markdown(md_renderer, extensions=MD_EXTENSIONS) template_dirs = [ str(self.config.get_tmp_dir()), str(self.config.theme_dir / 'templates') ] logger.debug('template directories: %s', ', '.join(template_dirs)) extensions = 'jinja2.ext.loopcontrols', MarkdownExtension self.env = Environment(loader=FileSystemLoader(template_dirs), extensions=extensions) self.env.filters.update( glob=page_glob, slugify=slugify, format=format_filter, tojson=json_filter, debug=debug_filter, markdown=self.md, paginate=paginate_filter, ) self.env.filters.update(self.config.extensions.template_filters) self.env.globals.update( url=resolve_url, resolve_url=resolve_url, inline_css=inline_css, shape=shape, width=width, height=height, ) self.env.globals.update(self.config.extensions.template_functions) self.env.tests.update(self.config.extensions.template_tests) self.checked_dirs = set() self.to_gen = [] self.to_copy = []
def render_with(self, flag, text): return Markdown(self.r[flag]).render(text)
def setup(self): self.r = Markdown(HtmlRenderer()).render
def render_with(self, text, flags=0, extensions=0): return Markdown(HtmlRenderer(), extensions).render(text)
def md1(value): rndr = HtmlRenderer() md = Markdown(rndr) return md.render(value)
def image(self, link, title, alt_text): """Don't allow images (they could be big). Use simple links intead. """ # Don't forget about escaping return '<a href="{0}">{0}</a>'.format(xhtml_escape(link)) def block_code(self, code, language): # Don't forget about escaping code = ignore_trailing_newlines(xhtml_escape(code)) if language: language = xhtml_escape(language) klass = ' class="language-{0}"'.format(language) else: klass = '' return '<pre><code{0}>{1}</code></pre>\n'.format(klass, code) # Don't touch HTML_ESCAPE flag! renderer = BnwRenderer(m.HTML_ESCAPE | m.HTML_SAFELINK) markdown_parser = Markdown( renderer, m.EXT_NO_INTRA_EMPHASIS | m.EXT_AUTOLINK | m.EXT_FENCED_CODE) class MarkdownFormat(object): def format(self, raw, secure=False): raw = _unicode(raw) formatted_text = ignore_trailing_newlines(markdown_parser.render(raw)) thumbs = get_thumbs(raw, secure) return formatted_text, thumbs
class VimwikiHtmlRenderer(HtmlRenderer, LinkPreprocessor): def __call__(self, text, *args, **kwargs): text = self.preprocess(text) return super(VimwikiHtmlRenderer, self).__call__(text) def block_code(self, text, lang): if not lang: return u'\n<pre><code>%s</code></pre>\n' % \ mistune.escape(text.strip()) lexer = get_lexer_by_name(lang, stripall=True) formatter = CodeHtmlFormatter() return highlight(text, lexer, formatter) renderer = VimwikiHtmlRenderer() to_html = Markdown(renderer, extensions=EXT_NO_INTRA_EMPHASIS | EXT_TABLES | EXT_FENCED_CODE | EXT_AUTOLINK | EXT_STRIKETHROUGH | EXT_SUPERSCRIPT) input_file = renderer.preprocess(input_file) main_content = to_html(input_file) if renderer.percent_codes['no_html']: print(output_file_path + " not converted due to presence of " "'%nohtml' in the file.") else: if renderer.percent_codes['toc']: toc_renderer = VimwikiTocRenderer() to_toc = Markdown(toc_renderer, extensions=EXT_NO_INTRA_EMPHASIS | EXT_AUTOLINK) toc_content = to_toc(input_file) else: toc_content = None
if not link.startswith(('http', 'https', '//')): link = try_md2html(link) return u'<a href="{0}">{0}</a>'.format(link) def link(self, link, title, content): if not link.startswith(('http', 'https', '//')): link = try_md2html(link) if title: return u'<a href="{0}">{1}</a>'.format(link, content) return u'<a href="{0}" title="{2}">{1}</a>'.format( link, content, title) render = GmlsHtmlRenderer() markdown = Markdown(render, extensions=(EXT_TABLES | EXT_FENCED_CODE | EXT_NO_INTRA_EMPHASIS | EXT_AUTOLINK)) @app.route('/', defaults={'path': './'}) # noqa @app.route('/<path:path>') def handle(path): if os.path.isdir(path): # 'directory' => 'directory/' if not path.endswith('/'): return redirect(url_for('handle', path=path + '/')) # collect entries in this directory lilist = [] readme = None for entry in os.listdir(path):
import logging import re import secrets from base64 import urlsafe_b64encode from typing import Dict, NamedTuple import chevron import sass from chevron import ChevronError from misaka import HtmlRenderer, Markdown markdown = Markdown(HtmlRenderer(flags=['hard-wrap']), extensions=['no-intra-emphasis']) logger = logging.getLogger('morpheus.render') class MessageDef(NamedTuple): first_name: str last_name: str main_template: str mustache_partials: Dict[str, dict] macros: Dict[str, dict] subject_template: str context: dict headers: dict class EmailInfo(NamedTuple): full_name: str subject: str html_body: str