python类markdown()的实例源码

def get_queryset(self):
        query_set = super(BlogListView, self).get_queryset().order_by("-ctime")
        if self.request.GET.get("search"):
            query_set = query_set.filter(title__contains=self.request.GET.get("search"))
        for each in query_set:
            each.digest = markdown2.markdown(each.digest)
        return query_set

def get_object(self, queryset=None):
        obj = get_object_or_404(Blog, id=self.kwargs.get("blog_id"))
        # obj.article = markdown2.markdown(obj.article)
        return obj

def block_code(self, code, lang):
        lang = CODE_LANG
        if not lang:
            return '\n<pre><code>%s</code></pre>\n' % \
                mistune.escape(code)
        lexer = get_lexer_by_name(lang, stripall=True)
        formatter = html.HtmlFormatter()
        return highlight(code, lexer, formatter)

# renderer = HighlightRenderer()
# markdown = mistune.Markdown(renderer=renderer)
# print(markdown('```python\nassert 1 == 1\n```'))

def md2html_by_markdown2(md_text):
    import markdown2
    extras = ['code-friendly', 'fenced-code-blocks', 'footnotes']
    html_text = markdown2.markdown(md_text, extras=extras)
    return html_text

def convert_md_file(argv):
    is_convert_html = True
    if len(sys.argv) >= 3:
        is_convert_html = False

    md_filename = argv[0]
    css_filename = os.path.join(getthispath(), 'default.css')   # ??CSS????http://richleland.github.io/pygments-css/
    html_filename = '%s.html' % (md_filename[:-3])
    pdf_filename = '.'.join([md_filename.rsplit('.')[0], 'pdf'])
    css_text = None
    md_text = None

    with codecs.open(css_filename, mode='r', encoding='utf-8') as f:
        css_text = '<style type = "text/css">\n' + f.read() + "\n</style>\n"

    with codecs.open(md_filename, mode='r', encoding='utf-8') as f:
        md_text = f.read()

    # ?????????mistune
    if False:
        html_text = md2html_by_markdown2(md_text)
    else:
        global CODE_LANG
        CODE_LANG = 'java'
        markdown = mistune.Markdown(renderer=HighlightRenderer())
        html_text = markdown(md_text)

    if is_convert_html:
        # save to html file
        #?windows?encoding?????gbk??????utf-8???????
        with codecs.open(html_filename, 'w', encoding='gbk', errors='xmlcharrefreplace') as f:
            f.write(css_text + html_text)
        if os.path.exists(html_filename):
            os.popen(html_filename)
    else:
        # save to pdf file
        HTML(string=html_text).write_pdf(pdf_filename, stylesheets=[css_filename])
        if os.path.exists(pdf_filename):
            os.popen(pdf_filename)

def send(self, event, users, instance, paths):
        from_address = settings.ASYNC_EMAIL_FROM
        reply_to = {}
        if hasattr(settings, 'ASYNC_EMAIL_REPLY_TO'):
            reply_to = {'Reply-To': settings.ASYNC_EMAIL_REPLY_TO, 'Return-Path': settings.ASYNC_EMAIL_REPLY_TO}
        messages = []
        for user, templates in users.items():
            if not self.enabled(event, user, paths) or not user.email:
                continue
            template = self._get_template(templates)
            if template is None:
                continue
            params = self.prepare(template, instance)
            e = mail.EmailMultiAlternatives(
                subject=params['subject'],
                body=params['description'],
                from_email=from_address,
                to=[user.email, ],
                headers=reply_to
            )
            e.attach_alternative(markdown2.markdown(params['description'], extras=["link-patterns"],
                                                    link_patterns=link_registry.link_patterns(request), safe_mode=True),
                                 'text/html')
            messages.append(e)
        if len(messages):
            connection = mail.get_connection()
            connection.send_messages(messages)

def get_blog(id):
    blog = yield from Blog.find(id)
    if not blog:
        raise APIValueError('id', 'can not find blog id is :{}'.format(id))
    comments = yield from Comment.find_all('blog_id=?', [id], order_by='created_at desc')
    for c in comments:
        c.html_content = text2html(c.content)
    blog.html_content = markdown2.markdown(blog.content)
    return {
        '__template__': 'blog.html',
        'blog': blog,
        'comments': comments
    }

def render(content):
    result = markdown(content, extras=["code-color"], safe_mode=False)
    return result

def parse(self, content):
        """Parse content to raw text.

        :param content: content to parse
        :type content: str
        :return: raw/plain content representation
        :rtype: str
        """
        return BeautifulSoup(markdown2.markdown(content), 'lxml').get_text()

def blog(blog_id):
    blog = Blog.get(blog_id)
    if blog is None:
        raise notfound()
    blog.html_content = markdown2.markdown(blog.content)
    comments = Comment.find_by(
        'where blog_id=? order by created_at desc limit 1000', blog_id)
    return dict(blog=blog, comments=comments, user=ctx.request.user)

def api_get_blogs():
    format = ctx.request.get('format', '')
    blogs, page = _get_blogs_by_page()
    if format == 'html':
        for blog in blogs:
            blog.content = markdown2.markdown(blog.content)
    return dict(blogs=blogs, page=page)

def save_model(self, request, obj, form, change):
        """
        ?????????
        """
        if settings.MARKDOWN:
            obj.body = markdown2.markdown(obj.text, extras=['fenced-code-blocks'], )  # ??markdown??
        else:
            obj.body = obj.text
        obj.description = obj.description or markdown2.markdown(obj.text[:140], extras=['fenced-code-blocks'], )  # ??
        obj.author = request.user  # ???????
        obj.save()

def get_readme(self):
        readme = self.get_file('README.md')

        if readme:
            with open(readme, 'r') as f:
                readme = markdown(f.read(), extras=["code-friendly"])

        return readme

def desc_html(self):
        if self.description_is_markdown:
            fmt = markdown2.markdown(self.description, extras=["footnotes", "fenced-code-blocks"])
            return mark_safe(fmt)
        else:
            return self.description

def get_context_data(self, **kwargs):
        document = kwargs.pop('legal')
        with open('/home/lex/projects/osedev/osedev/legal/{}.md'.format(document), 'r') as md:
            return super().get_context_data(
                legal=markdown(md.read(), extras=[
                    'tables', 'cuddled-lists', 'break-on-newline', 'header-ids'
                ]),
                **kwargs
            )

def custom_markdown(value):
    return mark_safe(markdown2.markdown(force_text(value),
        extras=["fenced-code-blocks", "cuddled-lists", "metadata", "tables", "spoiler"]))

def markdown_to_html(self, content):
        return markdown2.markdown(content).encode("utf-8").decode()

def get_releases(self):
        res = requests.get(
            'https://api.github.com/repos/OGKevin/combunqwebapp/releases') \
            .json()

        try:
            data = res[:7]
        except TypeError as e:
            logging.error(e)
            return None
        else:
            for x in data:
                x['created_at'] = arrow.get(x['created_at']).format('Do MMM')
                x['body'] = markdown2.markdown(x['body'])
            return data

def about(self):
        """About page, content of it is configurable in settings"""
        about_page = markdown2.markdown(self.core.config.get("about_page"))
        return self.render('about.html', about_page=about_page)

def save(self, *args, **kwargs):
        self.slug = slugify(unidecode(self.title))
        if not self.body and self.md_file:
            self.body = self.md_file.read()
        html = markdown2.markdown(self.body,extras=["fenced-code-blocks", "tables"])
        self.html_file.save(self.title + '.html',ContentFile(html.encode('utf-8')), save=False)
        self.html_file.close()
        super().save(*args, **kwargs)

def save(self, commit=True):
        author = self.cleaned_data['author']
        title = self.cleaned_data['title']
        content = self.cleaned_data['content']
        markdown = Markdown()
        html = markdown.convert(content)
        post = Post(author=author, title=title, content=content, html=html)
        post.save()

        tags_text = self.cleaned_data['tags']
        tag_names = split_tags(tags_text)
        for tag_name in tag_names:
            tag_name.strip()
            if 0 < len(tag_name) < 16:
                tag = self.create_and_get(tag_name)
                post.tags.add(tag)

        return self.instance

def getMessage(self):
        msgAsMarkdown = ""
        subject = ""
        # for each line in file
        # set the first line to message 
        # put the rest into a long string
        f = open(self.templatePath,"r")
        lines = f.readlines()

        firstLineOfMessage = 0


        for line in lines:
            firstLineOfMessage = firstLineOfMessage + 1
            if line == '\n':
                break

        for i in range(firstLineOfMessage,len(lines)):
            msgAsMarkdown = msgAsMarkdown + lines[i]

        markdowner = Markdown()
        message = markdowner.convert(msgAsMarkdown)
        f.close()
        return message

def convert_markdown(request):
    markdown = Markdown()
    converted_string = markdown.convert(request.POST['text'])
    return HttpResponse(converted_string)

def get_markdown():
    """
    Find and set a valid markdown parser
    Checks for one of these parsers:
        - pandoc
        - markdown2
    """
    markdown = None
    if shutil.which('pandoc'):
        markdown = lambda x: subprocess.run(
            ["pandoc", "-f", "markdown", "-t", "html"],
            input=x.encode("utf-8"),
            stdout=subprocess.PIPE).stdout.decode("utf-8")
    else:
        try:
            import markdown2
            _md_extras = [
                "code-friendly",
                "fenced-code-blocks",
                "footnotes",
                "header-ids",
            ]
            markdown = markdown2.Markdown(extras=_md_extras).convert
        except ImportError:
            pass

    if markdown is None:
        print("No markdown parser found. Will serve as plain text.")
    return markdown