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)