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 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 block_code(self, text, lang):
if lang == 'figure':
#process figure block
print("Found a figure!")
return
# pass through
return HtmlRenderer.block_code(self, text, lang)
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 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 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 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 setup(self):
pants = SmartyPants()
self.r = {
HTML_SKIP_HTML: HtmlRenderer(HTML_SKIP_HTML),
HTML_SKIP_IMAGES: HtmlRenderer(HTML_SKIP_IMAGES),
HTML_SKIP_LINKS: HtmlRenderer(HTML_SKIP_LINKS),
HTML_SAFELINK: HtmlRenderer(HTML_SAFELINK),
HTML_ESCAPE: HtmlRenderer(HTML_ESCAPE),
HTML_HARD_WRAP: HtmlRenderer(HTML_HARD_WRAP)
}
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 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 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
{payload_hash}"""
_AUTH_ALGORITHM = 'AWS4-HMAC-SHA256'
_CREDENTIAL_SCOPE = '{date_stamp}/{region}/{service}/{auth_request}'
_STRING_TO_SIGN = """\
{algorithm}
{x_amz_date}
{credential_scope}
{canonical_request_hash}"""
_AUTH_HEADER = (
'{algorithm} Credential={access_key}/{credential_scope},SignedHeaders={signed_headers},Signature={signature}'
)
flags = ('hard-wrap', )
extensions = ('no-intra-emphasis', )
safe_markdown = Markdown(
HtmlRenderer(flags=flags), # maybe should use SaferHtmlRenderer
extensions=extensions)
DEBUG_PRINT_REGEX = re.compile(r'{{ ?__debug_context__ ?}}')
class UserEmail(NamedTuple):
id: int
ctx: Dict[str, Any] = {}
ticket_id: int = None
class BaseEmailActor(BaseActor):
def __init__(self, *, http_client=None, **kwargs):
super().__init__(**kwargs)
self.client = http_client or ClientSession(
timeout=ClientTimeout(total=10), loop=self.loop)
#!/usr/bin/env python3
import os
import sys
from datetime import datetime
from misaka import HtmlRenderer, Markdown
from multiprocessing import Pool
from utils import ABS, has_extension, MarkdownHeader, NULL_MARKDOWN_HEADER, parse_header, parse_post, READ, WRITE
# https://misaka.readthedocs.io/en/latest/ or https://docs.rs/hoedown/6.0.0/hoedown/
POST_RENDERER_FLAGS = []
POST_RENDERER = HtmlRenderer(POST_RENDERER_FLAGS)
POST_PARSER_EXTENSIONS = [
'autolink', 'fenced-code', 'footnotes', 'highlight', 'no-intra-emphasis',
'quote', 'space-headers', 'strikethrough', 'superscript', 'tables'
]
POST_PARSER = Markdown(POST_RENDERER, POST_PARSER_EXTENSIONS)
PLACEHOLDERS = {
'TITLE': 'TITLE',
'CONTENT': 'PLACEHOLDER',
'LIST_ITEM': 'LIST_ITEM',
'POST_ID': 'SLUG',
'POST_TITLE': 'TITLE',
'POST_DYNAMIC_LINK': 'DYNAMIC_LINK',
'POST_STATIC_LINK': 'STATIC_LINK',
'POST_CONTENT': 'PLACEHOLDER',
'POST_DATE': 'PUBLISH_DATE',
'POST_EDIT_DATE': 'EDIT_DATE',
from elements import link, article, social, Post
from flask import Flask, render_template, jsonify, send_from_directory, abort
import random
from misaka import Markdown, HtmlRenderer
import os
renderer = HtmlRenderer()
md = Markdown(renderer, extensions=("fenced-code", ))
blogpath = "blog"
app = Flask(__name__)
@app.errorhandler(404)
def resource_not_found(e):
return jsonify(error=str(e)), 404
socials_left = [
social(
"https://twitter.com/malpractitioner",
"twitter",
"Me on Twitter",
"I'm probably the most active here",
),
social(
"https://instagram.com/malpractitioner_",
"instagram",
"Me on Instagram",
"Primarily for food, music and keyboard stories",
),
def main():
rndr = HtmlRenderer()
md = Markdown(rndr)
print md('some text')
print m.html('some other text')
def markdown(text, clean=True):
renderer = HtmlRenderer()
md = Markdown(renderer, extensions=('fenced-code', ))
if clean:
return Markup(safe_clean(md(text)))
return Markup(md(text))
def __init__(self, markdownDoc):
self.document = "markdown/" + markdownDoc
self.tocRen = HtmlTocRenderer(3)
self.docRen = HtmlRenderer(0, 3)
# coding: utf-8
from warnings import warn
from misaka import Markdown, HtmlRenderer
from BeautifulSoup import BeautifulSoup
rndr = HtmlRenderer()
md = Markdown(rndr)
VALID_TAGS = [
'div',
'h2',
'h3',
'span',
'a',
'p',
'br',
'img',
'center',
'b',
'strong',
'em',
'i',
'ol',
'ul',
'li',
'dl',
'dt',
'dd',
'table',
def safe_markdown(text):
from flask import Markup
from misaka import Markdown, HtmlRenderer
html = HtmlRenderer()
markdown = Markdown(html)
return Markup(markdown(text))
# encoding: utf-8
from __future__ import unicode_literals
from misaka import Markdown, HtmlRenderer # , SmartyPants
from misaka import HTML_ESCAPE, HTML_HARD_WRAP
from misaka import EXT_FENCED_CODE, EXT_NO_INTRA_EMPHASIS, EXT_AUTOLINK, EXT_SPACE_HEADERS, EXT_STRIKETHROUGH, EXT_SUPERSCRIPT
from .string import String
from ....schema.compat import unicode, py3
md = Markdown(
HtmlRenderer(flags=HTML_ESCAPE | HTML_HARD_WRAP),
extensions = EXT_FENCED_CODE | \
EXT_NO_INTRA_EMPHASIS | \
EXT_AUTOLINK | \
EXT_SPACE_HEADERS | \
EXT_STRIKETHROUGH | \
EXT_SUPERSCRIPT
)
class MarkdownString(unicode):
def __html__(self):
return md(self)
class Markdown(String):
def to_foreign(self, obj, name, value): # pylint:disable=unused-argument
if hasattr(value, '__markdown__'):
from __future__ import unicode_literals
from django.db import models
from django.template import loader, Template
from misaka import Markdown, HtmlRenderer
markdown = Markdown(HtmlRenderer(), extensions=('fenced-code', ))
# Create your models here.
class Content(models.Model):
content_name = models.CharField('Content Name', max_length=256)
is_draft = models.BooleanField('Draft')
last_updated = models.DateTimeField('Last Updated', auto_now=True)
content_value = ''
template = loader.get_template('basilica/text.html')
def get_content(self):
return self.content_value
def render(self):
return self.template.render({'content': self.get_content()})
class Meta:
abstract = True
class Text(Content):
content_value = models.CharField('Content Value', max_length=256)
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
def markdown(text):
renderer = HtmlRenderer()
md = Markdown(renderer, extensions=('fenced-code', ))
return Markup(md(text))
def md1(value):
rndr = HtmlRenderer()
md = Markdown(rndr)
return md.render(value)
def __new__(cls, flags=0, **kwargs):
return HtmlRenderer.__new__(cls, flags)
def render_with(self, text, flags=0, extensions=0):
return Markdown(HtmlRenderer(), extensions).render(text)
{payload_hash}"""
_AUTH_ALGORITHM = 'AWS4-HMAC-SHA256'
_CREDENTIAL_SCOPE = '{date_stamp}/{region}/{service}/{auth_request}'
_STRING_TO_SIGN = """\
{algorithm}
{x_amz_date}
{credential_scope}
{canonical_request_hash}"""
_AUTH_HEADER = (
'{algorithm} Credential={access_key}/{credential_scope},SignedHeaders={signed_headers},Signature={signature}'
)
flags = ('hard-wrap', )
extensions = ('no-intra-emphasis', )
safe_markdown = Markdown(
HtmlRenderer(flags=flags),
extensions=extensions) # maybe should use SaferHtmlRenderer
DEBUG_PRINT_REGEX = re.compile(r'{{ ?__debug_context__ ?}}')
class UserEmail(NamedTuple):
id: int
ctx: Dict[str, Any] = {}
ticket_id: int = None
class BaseEmailActor(BaseActor):
def __init__(self, *, http_client=None, **kwargs):
super().__init__(**kwargs)
self.client = http_client or ClientSession(
timeout=ClientTimeout(total=10), loop=self.loop)
def setup(self):
self.r = Markdown(HtmlRenderer()).render
def safe_markdown(text):
html = HtmlRenderer()
markdown = Markdown(html)
return Markup(markdown(text))
# _bergi's custom tags
import misaka
from misaka import HtmlRenderer
import datetime
from django import template
from django.utils.dateformat import format
register = template.Library()
renderer = HtmlRenderer(misaka.HTML_ESCAPE)
md = misaka.Markdown(renderer,
extensions=misaka.EXT_FENCED_CODE
| misaka.EXT_NO_INTRA_EMPHASIS | misaka.EXT_TABLES
| misaka.EXT_AUTOLINK | misaka.EXT_SPACE_HEADERS
| misaka.EXT_STRIKETHROUGH | misaka.EXT_SUPERSCRIPT)
@register.filter
def markdown(text):
return md(text)
# only show past years
@register.filter
def datefmt(date):
now = datetime.datetime.now()
if date.year == now.year:
return format(date, "j F")
def __init__(self, flags):
HtmlRenderer.__init__(self, flags)
self.doc_info = {}
