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
