blob: 498f7e892dfce75e09e7e8bafa982f50259e5e9b [file] [log] [blame]
Python Markdown
A Python implementation of John Gruber's Markdown.
Started by Manfred Stienstra (
Maintained for a few years by Yuri Takhteyev (
Currently maintained by Waylan Limberg (,
Dmitry Shachnev ( and Isaac Muse (
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see for details).
Markdown also allows post-processors, which are similar to preprocessors in
that they need to implement a "run" method. However, they are run after core
from collections import OrderedDict
from . import util
import re
def build_postprocessors(md, **kwargs):
""" Build the default postprocessors for Markdown. """
postprocessors = util.Registry()
postprocessors.register(RawHtmlPostprocessor(md), 'raw_html', 30)
postprocessors.register(AndSubstitutePostprocessor(), 'amp_substitute', 20)
return postprocessors
class Postprocessor(util.Processor):
Postprocessors are run after the ElementTree it converted back into text.
Each Postprocessor implements a "run" method that takes a pointer to a
text string, modifies it as necessary and returns a text string.
Postprocessors must extend markdown.Postprocessor.
def run(self, text):
Subclasses of Postprocessor should implement a `run` method, which
takes the html document as a single text string and returns a
(possibly modified) string.
pass # pragma: no cover
class RawHtmlPostprocessor(Postprocessor):
""" Restore raw html to the document. """
BLOCK_LEVEL_REGEX = re.compile(r'^\<\/?([^ >]+)')
def run(self, text):
""" Iterate over html stash and restore html. """
replacements = OrderedDict()
for i in range(
html = self.stash_to_string([i])
if self.isblocklevel(html):
replacements["<p>{}</p>".format(] = html
replacements[] = html
def substitute_match(m):
key =
if key not in replacements:
if key[3:-4] in replacements:
return f'<p>{ replacements[key[3:-4]] }</p>'
return key
return replacements[key]
if replacements:
base_placeholder = util.HTML_PLACEHOLDER % r'([0-9]+)'
pattern = re.compile(f'<p>{ base_placeholder }</p>|{ base_placeholder }')
processed_text = pattern.sub(substitute_match, text)
return text
if processed_text == text:
return processed_text
def isblocklevel(self, html):
m = self.BLOCK_LEVEL_REGEX.match(html)
if m:
if[0] in ('!', '?', '@', '%'):
# Comment, php etc...
return True
return False
def stash_to_string(self, text):
""" Convert a stashed object to a string. """
return str(text)
class AndSubstitutePostprocessor(Postprocessor):
""" Restore valid entities """
def run(self, text):
text = text.replace(util.AMP_SUBSTITUTE, "&")
return text
"This class will be removed in the future; "
"use 'treeprocessors.UnescapeTreeprocessor' instead."
class UnescapePostprocessor(Postprocessor):
""" Restore escaped chars """
RE = re.compile(r'{}(\d+){}'.format(util.STX, util.ETX))
def unescape(self, m):
return chr(int(
def run(self, text):
return self.RE.sub(self.unescape, text)