def format_text( text, useMarkdown, markdownStyle, markdownLineNums, markdownTabLength, ): if useMarkdown: noclasses = markdownStyle != 'default' html_ish = markdown.markdown( text, output_format="xhtml1", extensions=[ SmartEmphasisExtension(), FencedCodeExtension(), FootnoteExtension(), AttrListExtension(), DefListExtension(), TableExtension(), AbbrExtension(), Nl2BrExtension(), CodeHiliteExtension(noclasses=noclasses, pygments_style=markdownStyle, linenums=markdownLineNums), SaneListExtension(), SmartyExtension() ], lazy_ol=False, tab_length=markdownTabLength, ) else: # Preserve whitespace. html_ish = text.replace('\n', '<br>').replace(' ', ' ') return html_ish
def parse(text): """ https://github.com/Python-Markdown/markdown/wiki/Third-Party-Extensions https://facelessuser.github.io/pymdown-extensions """ text = markdown.markdown(text, extensions=[ FootnoteExtension(), TableExtension(), FencedCodeExtension(), CodeHiliteExtension(), Nl2BrExtension(), TocExtension(slugify=slugs.uslugify, permalink=False), TrulySaneExt(), tilde.makeExtension(), caret.makeExtension(), ]) tags = 'a,h1,h2,h3,h4,h5,h6,p,div,pre,code,span,img,br,' \ 'ul,ol,li,table,tr,th,td,thead,tbody,blockquote,' \ 'del,em,strong,sub,sup' attrs = {'*': ['class'], 'a': ['href', 'rel'], 'img': ['alt']} attrs.update({f'h{n}': ['id'] for n in range(1, 7)}) # h1..h6 support TOC anchor text = bleach.clean( text, tags=tags.split(','), attributes=attrs, ) # HTML sanitizer return text
def convert_markdown_to_html(clean_md): """ Take a string `clean_md` and return a string where the Markdown syntax is converted to HTML. """ assert isinstance(clean_md, unicode), "Input `clean_md` is not Unicode" new_html = markdown.markdown(clean_md, output_format="xhtml1", extensions=[ SmartEmphasisExtension(), FencedCodeExtension(), FootnoteExtension(), AttrListExtension(), DefListExtension(), TableExtension(), AbbrExtension(), Nl2BrExtension(), CodeHiliteExtension( noclasses=True, pygments_style=preferences.PREFS.get( const.MARKDOWN_SYNTAX_STYLE), linenums=preferences.PREFS.get( const.MARKDOWN_LINE_NUMS)), SaneListExtension() ], lazy_ol=False) assert isinstance(new_html, unicode) return new_html
def extendMarkdown(self, md, md_globals): # Built-in extensions FencedCodeExtension().extendMarkdown(md, md_globals) SmartEmphasisExtension().extendMarkdown(md, md_globals) TableExtension().extendMarkdown(md, md_globals) #gfm.AutolinkExtension().extendMarkdown(md, md_globals) #gfm.AutomailExtension().extendMarkdown(md, md_globals) #gfm.HiddenHiliteExtension([ # ('guess_lang', 'False'), # ('css_class', 'highlight') #]).extendMarkdown(md, md_globals) #gfm.SemiSaneListExtension().extendMarkdown(md, md_globals) #gfm.SpacedLinkExtension().extendMarkdown(md, md_globals) #gfm.StrikethroughExtension().extendMarkdown(md, md_globals) # Custom extensions AutolinkExtension().extendMarkdown(md, md_globals) AutomailExtension().extendMarkdown(md, md_globals) HiddenHiliteExtension([ ('guess_lang', 'False'), ('css_class', 'highlight') ]).extendMarkdown(md, md_globals) SemiSaneListExtension().extendMarkdown(md, md_globals) SpacedLinkExtension().extendMarkdown(md, md_globals) StrikethroughExtension().extendMarkdown(md, md_globals)
def extendMarkdown(self, md, md_globals): # Built-in extensions gfmFencedCodeExtension().extendMarkdown(md) #FencedCodeExtension().extendMarkdown(md) #FencedCodeExtension().extendMarkdown(md, md_globals) #SmartEmphasisExtension().extendMarkdown(md, md_globals) #TableExtension().extendMarkdown(md, md_globals) TableExtension().extendMarkdown(md) # Custom extensions gfm.AutolinkExtension().extendMarkdown(md, md_globals) gfm.AutomailExtension().extendMarkdown(md, md_globals) # gfm.HiddenHiliteExtension([ # ('guess_lang', 'False'), # ('css_class', 'highlight') # ]).extendMarkdown(md, md_globals) # print(md_globals) # print(self.config) # print(dir(md)) # raise KeyboardInterrupt() #print(self.config) #gfm.HiddenHiliteExtension().extendMarkdown(md, md_globals) gfm.HiddenHiliteExtension().extendMarkdown(md, self.config) gfm.SemiSaneListExtension().extendMarkdown(md, md_globals) gfm.SpacedLinkExtension().extendMarkdown(md, md_globals) gfm.StrikethroughExtension().extendMarkdown(md, md_globals) gfm.TaskListExtension().extendMarkdown(md, md_globals)
def render_instructions(step): # TODO deduplicate markdown cleanup code instructions = step.instruction tags = markdown_tags + [ 'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead', 'img' ] parsed_md = md.markdown(instructions, extensions=[ 'markdown.extensions.fenced_code', TableExtension(), UrlizeExtension(), MarkdownFormatExtension() ]) markdown_attrs['*'] = markdown_attrs['*'] + ['class', 'width', 'height'] instructions = bleach.clean(parsed_md, tags, markdown_attrs) ingredients = [] for i in step.ingredients.all(): ingredients.append(IngredientObject(i)) try: template = Template(instructions) instructions = template.render(ingredients=ingredients) except TemplateSyntaxError: return _('Could not parse template code.' ) + ' Error: Template Syntax broken' except UndefinedError: return _('Could not parse template code.') + ' Error: Undefined Error' return instructions
def parse_markdown(text, noclasses, style, line_nums, tab_len, mathext): extensions = [] if mathext: extensions.append(MathExtension()) extensions.extend([ FencedCodeExtension(), FootnoteExtension(), AttrListExtension(), DefListExtension(), TableExtension(), AbbrExtension(), Nl2BrExtension(), CodeHiliteExtension( noclasses=noclasses, pygments_style=style, linenums=line_nums, ), SaneListExtension(), SmartyExtension() ]) return markdown.markdown( text, output_format="xhtml1", extensions=extensions, lazy_ol=False, tab_length=tab_len, )
def save(self, *args, **kwargs): self.html = markdown( self.data, extensions=[TableExtension(), GithubFlavoredMarkdownExtension()], safe_mode=True, enable_attributes=False) super(NoteMixin, self).save(*args, **kwargs)
def _render_documentation(self, path, detail): with open(path, "r") as f: content = markdown(f.read(), extensions=[ TableExtension(), FSMExtension(), BlockdiagExtension(format="svg") ]) return content
def save(self, *args, **kwargs): self.html = markdown(self.data, extensions=[TableExtension(), GithubFlavoredMarkdownExtension()], safe_mode=True, enable_attributes=False) # Define the new card with the greatest priority. if not self.pk and self.ancestor: self.set_priority() super(CardMixin, self).save(*args, **kwargs)
def mdToHtml(md, _extensions, configs): html = markdown.markdown(md, extensions=[ SaneListExtension(), TableExtension(), FencedCodeExtension(), DeleteSubExtension(**configs) ] + strToClassEXt(_extensions)) return html
def markdown(value, header_level=1): html = md(value, output_format='html5', safe_mode='escape', extensions=[ TocExtension(baselevel=header_level), CodeHiliteExtension(), FencedCodeExtension(), TableExtension(), ]) return mark_safe(html)
def render(self, gs, *, baselevel=2, hyphenate=False, paragraphs=None): md = Markdown(extensions=[ MetaExtension(), TableExtension(), WikiLinkExtension(), CMS7Extension(gs, path=self.source, baselevel=baselevel, hyphenate=hyphenate, paragraphs=paragraphs), TocExtension(anchorlink=True) ], output_format='html5') return Markup(md.convert(self.text))
def render(self, gs): md = Markdown(extensions=[ MetaExtension(), TableExtension(), WikiLinkExtension(), CMS7Extension(gs, baselevel=2), TocExtension() ], output_format='html5') return Markup(md.convert(self.text))
def extendMarkdown(self, md): # Built-in extensions TableExtension().extendMarkdown(md) # Custom extensions gfm.AutolinkExtension().extendMarkdown(md) gfm.AutomailExtension().extendMarkdown(md) gfm.SemiSaneListExtension().extendMarkdown(md) gfm.StandaloneFencedCodeExtension().extendMarkdown(md) gfm.StrikethroughExtension().extendMarkdown(md) gfm.TaskListExtension().extendMarkdown(md)
def help(): current_dir = os.path.join(os.path.dirname(__file__)) help_content = open(os.path.join(current_dir, "../templates/help.md"), "r").read() output_text = re.sub("<table>", '<table class="table">', markdown.markdown(help_content, extensions=[TocExtension(baselevel=1, title="Overview", toc_depth="2-3"), TableExtension()])) return render_template("help.html", markdown_text = Markup(output_text), loggedinuser=current_user )
def save(self, *args, **kwargs): self.html = markdown( self.data, extensions=[TableExtension(), GithubFlavoredMarkdownExtension()], safe_mode=True, enable_attributes=False) if not self.pk and self.ancestor: self.set_priority() super(PostMixin, self).save(*args, **kwargs)
def generateHtml(self): try: extensions = [ TableExtension(), WikiLinkExtension(html_class='internal', build_url=urlBuilder) ] source = self.blob.data.decode('utf-8') html = markdown.markdown(source, extensions=extensions) self.metadata['as'] = {'html': html} except Exception, e: print "markdown processing failed on", self.name, str(e)
def markdown(value): tags = markdown_tags + [ 'pre', 'table', 'td', 'tr', 'th', 'tbody', 'style', 'thead' ] parsed_md = md.markdown( value, extensions=[ 'markdown.extensions.fenced_code', TableExtension(), UrlizeExtension(), MarkdownFormatExtension() ] ) markdown_attrs['*'] = markdown_attrs['*'] + ['class'] return bleach.clean(parsed_md, tags, markdown_attrs)
def extendMarkdown(self, md, md_globals): # Built-in extensions FencedCodeExtension().extendMarkdown(md) TableExtension().extendMarkdown(md) # Custom extensions gfm.AutolinkExtension().extendMarkdown(md, md_globals) gfm.AutomailExtension().extendMarkdown(md, md_globals) gfm.HiddenHiliteExtension().extendMarkdown(md, self.config) gfm.SemiSaneListExtension().extendMarkdown(md, md_globals) gfm.SpacedLinkExtension().extendMarkdown(md, md_globals) gfm.StrikethroughExtension().extendMarkdown(md, md_globals) gfm.TaskListExtension().extendMarkdown(md, md_globals)
def renderContent(self) -> None: self.checkModified() if self.__renderedStr is not None: # Previous render is still valid. return if self.errors & DocErrors.CONTENT: # Loading failed; nothing to render. return if self.errors & DocErrors.RENDERING: # Rendering attempted and failed. return # Load content. contentPath = self.contentPath if contentPath is None: # If the init module fails to import, resources in the package # are inaccessible. Don't try to load them, to avoid error spam. return packageName = self.resource.packageName try: content = importlib_resources.read_text(packageName, contentPath.name) except Exception: logging.exception('Error loading documentation content "%s"', contentPath.name) self.errors |= DocErrors.CONTENT return # Create a private Markdown converter. # Rendering a the table of content will trigger Markdown conversion # of child pages, so we can't use a single shared instance. extractor = ExtractionExtension() md = Markdown(extensions=[ extractor, FixupExtension(), DefListExtension(), FencedCodeExtension(), CodeHiliteExtension(guess_lang=False), TableExtension() ]) # Do the actual rendering. try: self.__renderedStr = md.convert(content) except Exception: logging.exception('Error rendering Markdown for %s', packageName) self.errors |= DocErrors.RENDERING else: self.__extractedInfo = extractor.extracted
def documentation_formats(): """ Documentation formats page """ with open(os.path.join(app_folder, "md", "doc_formats.md"), "r", encoding='utf-8') as install_instr: content = install_instr.read() md = Markdown(extensions=[TocExtension(baselevel=1), TableExtension()]) content = Markup(md.convert(content)) toc = Markup(md.toc) return render_template("documentation.html", menu="documentation", content=content, toc=toc)
def md2html(md_text): css = ''' <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <style scoped="scoped"> div {float: left;margin-bottom: 2%} table { border-collapse: collapse; border-spacing: 0; empty-cells: show; border: 1px solid #cbcbcb; {#font-size: 3px;#} margin: 1% auto; table-layout: fixed; {#word-break: break-all;#} word-wrap: break-word; } table td, th { border-left: 1px solid #cbcbcb; border-width: 0 0 0 1px; margin: 0; padding: 0.3em 0.5em; width:100px } table td:first-child, table th:first-child { border-left-width: 0; } table thead, table tfoot { color: #000; text-align: left; vertical-align: bottom; } table thead { background: #e0e0e0; } table tfoot { background: #ededed; } table tr:nth-child(2n-1) td { background-color: #f2f2f2; } </style> ''' html = markdown.markdown( md_text, extensions=[FencedCodeExtension(), TableExtension()]) return css + html
def generateHTML(md_filename=None, source=None, css=None): if md_filename is None: if source is None: raise ValueError('You must supply md_filename or source') html_filename = tempfile.mktemp('html', 'md-edit') else: with open(md_filename, 'r') as f: source = f.read() html_filename = os.path.splitext(md_filename)[0] + '.html' extras = [ 'fenced-code-blocks', 'toc', 'footnotes', 'wiki-tables', 'code-friendly' ] extensions = [ TocExtension(baselevel=3), FencedCodeExtension(), TableExtension(), AdmonitionExtension(), CodeHiliteExtension() ] html = Markdown(extras=extras, extensions=extensions).convert(source) # custom postprocess # strike strike_pathern = re.compile(r'~{2}(.*?)~{2}') html = re.sub(strike_pathern, r'<del>\1</del>', html) # quoted quoted_pathern = re.compile(r'\:\"(.*?)\"\:') html = re.sub(quoted_pathern, r'“\1”', html) with open(html_filename, 'w') as f: f.write(html) if not css is None: html = '<style>' + css + '</style>' + html return html
def __init__(self, status: str): """ Initialize. Arguments: status: the content of the SECURITY.md file. """ self.headers = [] self.data = [] markdown_instance = markdown.Markdown(extensions=[TableExtension()]) elem = markdown_instance.parser.parseDocument( [s for s in status.split("\n") if s != "" and s[0] != "#" and s[0] != "["] ) self._pe(elem.getroot()) self.data = [r for r in self.data if len([c for c in r if c is not None]) > 0] for row in self.data: row.append("")
def test_align_columns_legacy(self): self.assertMarkdownRenders( self.dedent( """ | Item | Value | | :-------- | -----:| | Computer | $1600 | | Phone | $12 | | Pipe | $1 | """ ), self.dedent( """ <table> <thead> <tr> <th align="left">Item</th> <th align="right">Value</th> </tr> </thead> <tbody> <tr> <td align="left">Computer</td> <td align="right">$1600</td> </tr> <tr> <td align="left">Phone</td> <td align="right">$12</td> </tr> <tr> <td align="left">Pipe</td> <td align="right">$1</td> </tr> </tbody> </table> """ ), extensions=[TableExtension(use_align_attribute=True)] )
def extendMarkdown(self, md, md_globals): # Nl2BrExtension().extendMarkdown(md, md_globals) FencedCodeExtension().extendMarkdown(md, md_globals) SmartEmphasisExtension().extendMarkdown(md, md_globals) TableExtension().extendMarkdown(md, md_globals) AdmonitionExtension().extendMarkdown(md, md_globals) CodeHiliteExtension(use_pygments=True, css_class='roca_css').extendMarkdown( md, md_globals) TocExtension(anchorlink=False, permalink=True).extendMarkdown(md, md_globals) gfm.AutomailExtension().extendMarkdown(md, md_globals) gfm.SemiSaneListExtension().extendMarkdown(md, md_globals) gfm.SpacedLinkExtension().extendMarkdown(md, md_globals) gfm.StrikethroughExtension().extendMarkdown(md, md_globals) gfm.AutolinkExtension().extendMarkdown(md, md_globals) gfm.TaskListExtension().extendMarkdown(md, md_globals) SubstituteExtension().extendMarkdown(md, md_globals)
def help(request): path = os.path.join(os.path.dirname(__file__), "pages", "index.md") if request.path[:7] == "/about/": dir = request.path[7:] unsafe_path = os.path.join(os.path.dirname(__file__), "pages", dir) if unsafe_path.startswith( os.path.join(os.path.dirname(__file__), "pages")): safe_path = unsafe_path if os.path.isfile(safe_path): path = safe_path input_file = codecs.open(path, mode="r", encoding="utf-8") text = input_file.read() html = markdown.markdown(text, extensions=[TableExtension()]) return render(request, "about/help.html", context={"file": mark_safe(html)})
def test_align_three_legacy(self): self.assertMarkdownRenders( self.dedent( """ |foo|bar|baz| |:--|:-:|--:| | | Q | | |W | | W| """ ), self.dedent( """ <table> <thead> <tr> <th align="left">foo</th> <th align="center">bar</th> <th align="right">baz</th> </tr> </thead> <tbody> <tr> <td align="left"></td> <td align="center">Q</td> <td align="right"></td> </tr> <tr> <td align="left">W</td> <td align="center"></td> <td align="right">W</td> </tr> </tbody> </table> """ ), extensions=[TableExtension(use_align_attribute=True)] )
def compile(): """Process a markdown file according to command-line arguments""" parser = argparse.ArgumentParser( description='Create the documentation file') parser.add_argument('-l', help='Give language translations', default=False, action='store_true') parser.add_argument('-c', help='Check validity', default=False, action='store_true') parser.add_argument('-b', help='Add buttons for each example', default=False, action='store_true') parser.add_argument('--hide', help='Hide examples by default', default=False, action='store_true') parser.add_argument('--delete', help='Delete examples', default=False, action='store_true') parser.add_argument('--output', help='Output file name', default=None) parser.add_argument('infile') args = parser.parse_args() extensions = [TableExtension(), CodeHiliteExtension({}), EmbedExtension(args.delete, args.l) ] if args.l: from .translate import TranslateMlrExtension extensions.insert(0, TranslateMlrExtension()) if not args.c: from .embed_code import EmbedCodeExtension extensions.insert(0, EmbedCodeExtension(args.b, args.hide, args.delete)) if args.c: from .test_mlr import TestExtension extensions.insert(0, TestExtension(args.b, args.hide, args.delete)) output = args.output or ( os.path.basename(args.infile).rsplit('.', 1)[0] + '.html') markdown.markdownFromFile( input=args.infile, output=output, encoding='utf-8', extensions=extensions)