def make_markedown(directory):
readme = os.path.join(root, "README2.md")
if not os.path.isfile(readme):
return
#path_to_root = os.path.relpath('.', directory)
# Open an output file
f = open(os.path.join(directory, "report.txt"), 'w+')
# Add the text from the README
readme = os.path.join(directory, "README2.md")
with open(readme, 'r') as readme_f:
# prev_markdown = "."
# for line in readme_f:
# markdown = str(mistune.markdown(line))
# # Get rid of paragraph markers
# markdown = markdown.replace('<p>','')
# markdown = markdown.replace('</p>','')
# f.write(markdown)
# if prev_markdown == "" and markdown == "":
# # Add a new line
# f.write("<br/><br/>")
# prev_markdown = markdown
renderer = mistune.Renderer(hard_wrap=False,escape=False)
markdown = mistune.Markdown(renderer=renderer)
data = readme_f.read()
f.write(markdown(data))
def wiki_main(username):
#try:
group = Group.query.get(int(current_user.get_id(
))) # because of this, might not be possible to redirect admin
if group.is_admin() or group.username == username:
p = Page.query.filter_by(group_id=group.id, is_main=True).first()
page = dict()
page['name'] = p.name
page['id'] = p.id
page['last_update'] = p.last_update.strftime('%m/%d/%Y')
f = open(POSTS_FOLDER + username + '/' + str(p.id) + '.txt')
renderer = mistune.Renderer(escape=False)
markdown = mistune.Markdown(renderer=renderer)
page['content'] = markdown(f.read())
f.close()
urls = []
other_pages = Page.query.filter_by(group_id=group.id, is_main=False)
for other_page in other_pages:
urls.append(other_page.name)
response = dict()
response['success'] = True
response['main_page'] = page
response['urls'] = urls
return render_template('wiki-page.html',
response=response,
username=username,
main_url=p.name)
def on_markdown_config(self, config, **extra):
# create inline and block lexers
inline_lexer = mistune.InlineLexer(mistune.Renderer())
block_lexer = mistune.BlockLexer()
# does an lexer already exist? if so, use that
if 'inline' in config.options:
inline_lexer = config.options['inline']
if 'block' in config.options:
block_lexer = config.options['inline']
# loop through all enabled plugins
for plugin in plugins:
# select the correct lexer
lexer = inline_lexer
if plugin.type == 'block':
lexer = block_lexer
# add the plugin in
setattr(lexer.rules, plugin.name, plugin.regex)
# if there is a position and renderer, add that in too
if hasattr(plugin, 'position') and hasattr(plugin, 'render'):
lexer.default_rules.insert(plugin.position, plugin.name)
setattr(lexer, 'output_%s' % plugin.name, plugin.render)
# set the config to use these custom lexers
config.options['inline'] = inline_lexer
config.options['block'] = block_lexer
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
renderer = mistune.Renderer(escape=True, hard_wrap=True)
# use this renderer instance
markdown = mistune.Markdown(renderer=renderer)
self.description_html = markdown(self.description)
super().save(*args, **kwargs)
def test_inline_lexer():
r = mistune.Renderer()
il = mistune.InlineLexer(r)
assert il.default_rules is not mistune.InlineLexer.default_rules
assert il.inline_html_rules is not mistune.InlineLexer.inline_html_rules
def transcribeStory(story: list):
"""
Takes a list of dicts that contain the story text and metadata and
transcribes it into the formatted book.
"""
flushBook()
#renderer = mistune.Renderer(escape=True, hard_wrap=True)
#markdown = mistune.Markdown(renderer = renderer)
for t in story:
text_translate_table[(t['type'])](t)
for c in story:
try:
addCitation([c['cite']])
except KeyError as err:
continue
result = readBook()
with open("output.markdown", mode='wt', encoding="utf-8") as file:
file.write(result)
renderer = mistune.Renderer(escape=True, hard_wrap=False)
markdown = mistune.Markdown(renderer=renderer)
htmltext = ftfy.fix_text(markdown(result))
with open("output.html", mode='wt', encoding="utf-8") as file:
file.write(htmltext)
return result
def __init__(self, md_book, site_kind, zip_path=None, out_dir=None):
self.book = md_book
if not(zip_path is not None or out_dir is not None):
raise ValueError('Either site_path or out_dir should be given')
if zip_path:
zip_path = zip_path.resolve()
self.out_zip_path = zip_path
self._out_zip = None
if out_dir:
out_dir = out_dir.resolve()
self.out_dir = out_dir
if site_kind not in SUPPORTED_SITE_KINDS:
msg = f'site_kind not supported'
raise NotImplementedError(msg)
self.site_kind = site_kind
self._sections_info = defaultdict(dict)
renderer = mistune.Renderer(use_xhtml=True)
self._render_markdown = mistune.Markdown(renderer)
self.citation_notes_should_be_endnotes = True
self.note_lis = defaultdict(list)
self.section_main_html = {}
self._special_sections = {}
self._references = {}
self._sections_added = []
def convert(text):
inline = HighlightInlineLexer(mistune.Renderer(),
hard_wrap=True,
parse_inline_html=True)
inline.enable_highlight()
block = SimpleTableBlockLexer(mistune.BlockGrammar())
block.enable_simple_table()
markdown = SimpleTableMarkdown(inline=inline, block=block)
return markdown(text)
class MarkdownRenderer(object):
"""
docstring
"""
__markdown_renderer = mistune.Markdown(
renderer=mistune.Renderer(escape=False, hard_wrap=True))
@classmethod
def render(cls, markdown):
return cls.__markdown_renderer(markdown)
class Cell(Selection):
renderer = mistune.Markdown(renderer=mistune.Renderer(escape=False))
def __init__(self,
data,
name=haikunator.haikunate(),
env=LiterateEnvironment()):
self.env = env
self.name = name
self.env.globals[self.name] = self
super().__init__(data)
def task_view(id):
id_clean = "".join([c.lower() for c in id if (c.isalnum() or c == '-')])
task_data = dao.tasks.load_one(id_clean)
if task_data is None:
flask.abort(404)
(title, text) = task_data
renderer = mistune.Renderer(escape=False)
markdown = mistune.Markdown(renderer=renderer)
test = load_test_stuff(id_clean)
data = {'title': title, 'text': markdown(text), 'test': test}
return flask.render_template('tasks/view.html', data=data)
def post(name):
db = sqlite3.connect('txti.db')
c = db.cursor()
c.execute("SELECT * FROM posts WHERE url=?", (name,))
data = c.fetchone()
c.close()
renderer = mistune.Renderer(escape=True)
markdown = mistune.Markdown(renderer=renderer)
content = markdown(data[4])
post = { 'title': data[3], 'date': data[1], 'url': data[2], 'content': content }
return flask.render_template('post.html',
post=post)
def save(self, *args, **kwargs):
self.modified_time = timezone.now()
if not self.excerpt:
renderer = mistune.Renderer(escape=True, hard_wrap=True)
markdown = mistune.Markdown(renderer=renderer)
# 先将 Markdown 文本渲染成 HTML 文本
# strip_tags 去掉 HTML 文本的全部 HTML 标签
# 从文本摘取前 54 个字符赋给 excerpt
self.excerpt = strip_tags(markdown.parse(self.body))[:54]
super().save(*args, **kwargs)
def __init__(self, config, *, prerenderer=None):
self.url_prefix = config.path_prefix
self.config = config
self.templates = {}
self.load_templates()
self.hard_links = False
self.navigation = None
self.prerenderer = prerenderer
renderer = mistune.Renderer(escape=False)
mistune_markdown = mistune.Markdown(renderer=renderer)
self._mistune_markdown = mistune_markdown
def parse(
body, *, renderer=None, rx=re.compile('\[[^\]]+?\]')
):
renderer = renderer or _Renderer(mistune.Renderer())
md = mistune.Markdown(renderer=renderer)
md.parse(body.strip())
level, text = next(iter(renderer.headers))
tags = []
title = None
for m in rx.finditer(text.strip()):
title = text[m.end():]
tags.append(m.group(0))
print("@", level, title or text, "@", tags)
def prepare_definition(text):
renderer = mistune.Renderer(escape=False, parse_block_html=True)
markdown = mistune.Markdown(renderer=renderer)
soup = BeautifulSoup(markdown(text), "html.parser")
img = soup.find("img")
if img is None:
return "<p>{}</p>".format(soup.text[0:200] + "...")
src = img.get("src")
try:
alt = img.get("alt")
except:
alt = ""
return "<img class='definition-img' src='{}' alt='{}'></img><p>{}</p>".format(
src, alt, soup.text[0:200] + "...")
def prepare_definition(
text
): # TODO: zaten alınan ilk 400 karakterde resim varsa ikinci bir resmi almaması gerek
renderer = mistune.Renderer(escape=False)
markdown = mistune.Markdown(renderer=renderer)
beautifultext = BeautifulSoup(markdown(text), "html.parser")
try:
src = beautifultext.find("img").get("src")
alt = beautifultext.find("img").get("alt")
image_markdown = "".format(alt, src)
return beautifultext.text[0:400 - len(image_markdown) -
4] + "..." + image_markdown
except:
return beautifultext.text[0:400 - 4] + "..."
def get_markdown_file():
# If you care about performance, it is better to re-use the Markdown instance
import os
file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'example.md')
# whether file exists or not.
if not os.path.isfile(file_path):
return "No markdown file for name {} yet.".format(file_path)
markdown = None
renderer = mistune.Renderer(escape=True, hard_wrap=True)
markdown = mistune.Markdown(renderer=renderer)
with open(file_path, 'rt') as f:
result = markdown(f.read())
return result
def clean_desc(self):
desc = self.cleaned_data['desc']
content = self.data['content']
renderer = mistune.Renderer(escape=True, hard_wrap=True)
# renderer = HighlightRenderer()
mk = mistune.Markdown(renderer=renderer)
output = mk(content)
soup = BeautifulSoup(output, 'html.parser')
content = soup.text[:150]
print(desc)
if desc:
return desc
else:
desc = content
return desc
def task_view(id):
id_clean = "".join([c.lower() for c in id if (c.isalnum() or c == '-')])
if '-' not in id_clean:
return task_category(id_clean)
task_data = dao.tasks.load_one(id_clean)
if task_data is None:
flask.abort(404)
(title, text) = task_data
renderer = mistune.Renderer(escape=False)
markdown = mistune.Markdown(renderer=renderer)
if 'username' in flask.session:
test = load_test_stuff(id_clean, flask.session['userid'])
else:
test = None
data = {'title': title, 'text': markdown(text)}
return flask.render_template('tasks/view.html', data=data, test=test)
def main():
"""
Main entry point
"""
args = parse_args(sys.argv[1:])
if args.style:
try:
style = import_module(f'{__name__}.styles.{args.style}').Style
except ModuleNotFoundError:
print(f"{sys.argv[0]}: style {args.style} is not found")
sys.exit(1)
else:
style = None
markdown = mistune.Markdown(renderer=mistune.Renderer(use_xhtml=1))
with open(args.input) as source:
html = markdown(source.read())
DocXWriter(args.output, style).parse(html)
def render_markdown_text(text_to_render, **kwargs):
"""Convert text_to_render to html
Renders the markdown as a template first so that any included Jinja template values
will be rendered to text before markdown conversion to html.
__kwargs__ can contain anything that you want to use in the template context.
The following kwargs may also be present:
escape: Default to True. If false any included html in the text will be left as-is
and not escaped for display
"""
text_to_render = render_template_string(text_to_render, **kwargs)
escape = kwargs.get('escape',
True) #Set to False to preserve included html
markdown = mistune.Markdown(renderer=mistune.Renderer(escape=escape))
return markdown(text_to_render)
def show_page(page_path):
"""Render custom pages like stats"""
renderer = mistune.Renderer(escape=False)
markdown = mistune.Markdown(renderer=renderer)
pages_folder = os.environ.get('PAGES_PATH', 'src/pages')
page_path = os.path.join(pages_folder, f"{page_path}.md")
if os.path.exists(page_path):
with open(page_path) as page:
content = page.read()
rendered_content = markdown(content)
return render_template('page.html', content=rendered_content)
else:
return render_template(
'error.html',
message='Page not found',
details='Did you try to check other pages?'), 404
def edit_article_handler(request, article_id):
"""
编辑文章 处理模块
"""
result = base_result()
user_id = request.META["user_info"].id
if article_id != "0":
result["data"] = BlogArticle.query_article_by_id(article_id)
renderer = mistune.Renderer(hard_wrap=True, parse_inline_html=True)
markdown = mistune.Markdown(renderer=renderer)
result["mark_down"] = markdown(result["data"]["content"])
else:
result["mark_down"] = None
del result["data"]
result["kind_list"] = BlogKind.query_user_kind(1)
result["user_info"] = UserInfo.query_format_info_by_user_id(user_id)
return render(request, "manage/edit.html", result)
def parse_article(text: str) -> Parsed:
capturing = _CaputringRenderer(mistune.Renderer())
m = mistune.Markdown(renderer=capturing)
m.render(text)
result = capturing.result
title = html.unescape(result["title"].title)
itr = iter(text.splitlines())
# lstrip title
buf = []
title_found = False
finding_limit = 5
for line in itertools.islice(itr, finding_limit):
if title in line:
title_found = True
break
buf.append(line)
# for section using === such as
# <section title>
# =============
#
# text body
headbuf = [next(itr)]
if not headbuf[0].strip("="):
headbuf.pop()
if title_found:
content = "\n".join(itertools.chain(headbuf, itr)).strip()
else:
content = "\n".join(itertools.chain(buf, headbuf, itr)).strip()
return Parsed(
title=title,
tags=result["title"].tags,
images=result["images"],
content=content,
)
def md_to_html(md_file, save_file=None):
"""
转换 markdown 为 html 文件
"""
with open(md_file, 'r', encoding='utf-8') as text:
renderer = mistune.Renderer(escape=True, hard_wrap=True)
# 使用渲染器
markdown = mistune.Markdown(renderer=renderer)
html = markdown(text.read())
html = TEMPLATES.replace('HTML_TEMPLATES', html)
# 如果没有指定保存文件名，那么让我们返回转换好的html内容
if save_file is None:
# save_file = md_file + ".html"
return html
with open(save_file, 'w', encoding='utf-8') as output_file:
output_file.write(html)
# print(save_file)
return save_file
def article_detail_handler(request, article_id):
account = request.META["user_info"]
result = dict()
renderer = mistune.Renderer(hard_wrap=True, parse_inline_html=True)
markdown = mistune.Markdown(renderer=renderer)
article = BlogArticle.query_article_by_id(article_id)
article["content"] = markdown(article["content"])
article["comment_list"] = BlogComment.query_comment_list(article_id, account.id if account else 0)
result["article"] = article
if account:
article["meta_info"]["liked"] = 1 if BlogLike.query_like_blog(account.id, article_id) else 0
result["user_info"] = UserInfo.query_format_info_by_user_id(request.META["user_info"].id)
# 添加访问记录 匿名访问、非本人访问，会添加一条访问记录
author_id = article["user_info"]["id"]
if not account or author_id != account.id:
BlogArticleMeta.change_meta_record(article_id, author_id, ["hit"])
# 更新缓存
BlogArticle.query_article_by_id(article_id, False)
return render(request, "article/detail.html", result)
def save(self, *args, **kwargs):
renderer = mistune.Renderer(escape=True, hard_wrap=True)
# use this renderer instance
markdown = mistune.Markdown(renderer=renderer)
self.message_html = markdown(self.message)
super().save(*args, **kwargs)
def markdown(value):
renderer = mistune.Renderer(escape=True)
markdown = mistune.Markdown(renderer=renderer)
return markdown(value)
class Captured:
def __init__(self, internal):
self.internal = internal
self.replacers = []
def __getattr__(self, name):
# print("@", name)
return getattr(self.internal, name)
def image(self, src, title, text):
self.replacers.append(
(re.compile(f"\( *{src} *\)"),
f"(http://example.com/images/{os.path.basename(src)})"))
print("!", src, title, text)
return self.internal.image(src, title, text)
caputured = Captured(mistune.Renderer())
m = mistune.Markdown(renderer=caputured)
with open("src/doc.md") as rf:
text = rf.read()
m.render(text)
print(caputured.replacers)
print("--")
for rx, rep in caputured.replacers:
text = rx.subn(rep, text)[0]
print(text)
