Python pypandoc.convert函数代码示例

    def test_unicode_input(self):
        # make sure that pandoc always returns unicode and does not mishandle it
        expected = u'üäöîôû{0}======{0}{0}'.format(os.linesep)
        written = pypandoc.convert(u'<h1>üäöîôû</h1>', 'md', format='html')
        self.assertTrue(isinstance(written, pypandoc.unicode_type))
        self.assertEqualExceptForNewlineEnd(expected, written)
        bytes = u'<h1>üäöîôû</h1>'.encode("utf-8")
        written = pypandoc.convert(bytes, 'md', format='html')
        self.assertEqualExceptForNewlineEnd(expected, written)
        self.assertTrue(isinstance(written, pypandoc.unicode_type))

        # Only use german umlauts in th next test, as iso-8859-15 covers that
        expected = u'üäö€{0}===={0}{0}'.format(os.linesep)
        bytes = u'<h1>üäö€</h1>'.encode("iso-8859-15")
        # Without encoding, this fails as we expect utf-8 per default

        def f():
            pypandoc.convert(bytes, 'md', format='html')
        self.assertRaises(RuntimeError, f)

        def f():
            # we have to use something which interprets '\xa4', so latin and -1 does not work :-/
            pypandoc.convert(bytes, 'md', format='html', encoding="utf-16")
        self.assertRaises(RuntimeError, f)
        # with the right encoding it should work...
        written = pypandoc.convert(bytes, 'md', format='html', encoding="iso-8859-15")
        self.assertEqualExceptForNewlineEnd(expected, written)
        self.assertTrue(isinstance(written, pypandoc.unicode_type))

 def format_comment(self, comment):
     if comment.body == "[deleted]":
         return pypandoc.convert("[deleted]", "tex", format="md")
     text = ""
     text += self.format_comment_header(comment)
     text += pypandoc.convert(comment.body, "tex", format="md")
     return text

def save_to_media(request, rst_template, context, format, filename=None):
    DOCUTILS_FOR = getattr(settings, 'GRIFFIN_DOCUTILS_FOR', [])
    
    if (not PANDOC_AVAILABLE) or (format in DOCUTILS_FOR):
        return save_to_media_docutils(request, rst_template, context, format, filename=None)
    
    if not filename:
        filename = _get_default_filename()
        
    final_filename = '%s.%s'%(filename, format)
    destination = os.path.join(settings.MEDIA_ROOT, 'resume_download')
    destination_final = os.path.join(destination, final_filename)
        
    destination_rst = write_rst(request, rst_template, context, filename)
    
    # Finally, convert to the desired format.
    if format == 'rst':
        destination_final = destination_rst
    else:
        logger.debug("Converting %s to %s (with pandoc)"%(
            destination_rst, destination_final))
        try:
            pypandoc.convert(destination_rst, format, outputfile=destination_final)
        except ImportError as ie:
            logger.error(ie)
            return None
        
    media_link = settings.MEDIA_URL + 'resume_download/' + final_filename
        
    logger.debug("Media link for resume is %s"%media_link)
    
    return media_link

    def test_conversion_with_citeproc_filter(self):
        if os.environ.get('CI', None):
            print("Skipping: there is a bug with citeproc on travis.")
            return

        # we just want to get a temp file name, where we can write to
        filters = ['pandoc-citeproc']
        written = pypandoc.convert('./filter_test.md', to='html', format='md',
                                   outputfile=None, filters=filters)
        import re as re
        # only properly converted file will have this in it
        found = re.search(r'Fenner', written)
        self.assertTrue(found.group() == 'Fenner')
        # only properly converted file will have this in it
        found = re.search(r'10.1038', written)
        self.assertTrue(found.group() == '10.1038')

        # make sure that it splits the filter line
        for filters in ['pandoc-citeproc', u'pandoc-citeproc']:
            written = pypandoc.convert('./filter_test.md', to='html', format='md',
                                       outputfile=None, filters=filters)
            # only properly converted file will have this in it
            found = re.search(r'Fenner', written)
            self.assertTrue(found.group() == 'Fenner')
            # only properly converted file will have this in it
            found = re.search(r'10.1038', written)
            self.assertTrue(found.group() == '10.1038')

def end_novel(css=None):
    out_file.close()
    if css is None:
        pypandoc.convert(md_file_path, 'html', outputfile=html_file_path, extra_args=['-s'])
    else:
        pypandoc.convert(md_file_path, 'html', outputfile=html_file_path, extra_args=['-s', '-c', css])
    print('Total words: ' + str(word_count))

def ex_edit(request, pk):
    exercice = get_object_or_404(Exercice, pk=pk)
    if request.method == "POST":
        form = ExoForm(request.POST, instance=exercice)
        if form.is_valid():
            exercice = form.save(commit=False)
            exercice.pub_date = timezone.now()
            if exercice.enonce_latex:
                exercice.enonce_html = pypandoc.convert(exercice.enonce_latex,'html5',format='latex',extra_args=['--mathjax','--smart'])
            if exercice.indication_latex:
                exercice.indication_html = pypandoc.convert(exercice.indication_latex,'html5',format='latex',extra_args=['--mathjax','--smart'])  
            exercice.save()
            form.save_m2m()
            group_name = 'PUBLIC'
            group =  Group.objects.get(name=group_name)
            perm_codename = 'see_exercice_{0}'.format(pk)
            perm =  get_object_or_404(Permission,codename=perm_codename)
            if exercice.get_visibility_display() == 'Public':
                group.permissions.add(perm)
            elif perm in group.permissions.all():
                group.permissions.remove(perm)
                
            return redirect('detail', exercice_id=pk)
    else:
        form = ExoForm(instance=exercice)
    return render(request, 'exobase/exercice_edit.html', {'form': form, 'exercice': exercice})   

def common_setup(src_dir):
    readme_file = 'README.md'
    changelog_file = 'CHANGES.md'
    version_file = 'VERSION'

    # Convert Markdown to RST for PyPI
    try:
        import pypandoc
        long_description = pypandoc.convert(readme_file, 'rst')
        changelog = pypandoc.convert(changelog_file, 'rst')
    except (IOError, ImportError, OSError):
        long_description = open(readme_file).read()
        changelog = open(changelog_file).read()

    # Gather trailing arguments for pytest, this can't be done using setuptools' api
    if 'test' in sys.argv:
        PyTest.pytest_args = sys.argv[sys.argv.index('test') + 1:]
        if PyTest.pytest_args:
            sys.argv = sys.argv[:-len(PyTest.pytest_args)]
    PyTest.src_dir = src_dir

    return dict(
            # Version is shared between all the projects in this repo
            version=open(version_file).read().strip(),
            long_description='\n'.join((long_description, changelog)),
            url='https://github.com/manahl/pytest-plugins',
            license='MIT license',
            platforms=['unix', 'linux'],
            cmdclass={'test': PyTest},
            setup_requires=['setuptools-git'],
            include_package_data=True
            )

 def test_conversion_from_markdown_with_extensions(self):
     input = u'~~strike~~'
     expected_with_extension = u'<p><del>strike</del></p>'
     expected_without_extension = u'<p><sub><sub>strike</sub></sub></p>'
     received_with_extension = pypandoc.convert(input, 'html', format=u'markdown+strikeout')
     received_without_extension = pypandoc.convert(input, 'html', format=u'markdown-strikeout')
     self.assertEqualExceptForNewlineEnd(expected_with_extension, received_with_extension)
     self.assertEqualExceptForNewlineEnd(expected_without_extension, received_without_extension)

def render_doc_(notebook, output_format, output_file, template, extra_args):
    """"""
    pypandoc.convert(
        source=template.render(notebook), to="pdf" if output_format == "pdf" else output_format,
        format="markdown-blank_before_header",
        outputfile=output_file,
        extra_args=extra_args
    )

def do_one_round():
    # get all posts from starting point to now
    now = pytz.utc.localize(datetime.now())
    start = get_start(feed_file)

    print "Collecting posts since %s" % start
    sys.stdout.flush()

    posts = get_posts_list(load_feeds(), start)
    posts.sort()

    print "Downloaded %s posts" % len(posts)

    if posts:
        print "Compiling newspaper"
        sys.stdout.flush()

        result = html_head + u"\n".join([html_perpost.format(**nicepost(post)) for post in posts]) + html_tail

        # with codecs.open('dailynews.html', 'w', 'utf-8') as f:
        #     f.write(result)

        print "Creating epub"
        sys.stdout.flush()

        os.environ["PYPANDOC_PANDOC"] = PANDOC
        ofile = "dailynews.epub"
        oofile = "dailynews.mobi"
        pypandoc.convert(
            result,
            to="epub3",
            format="html",
            outputfile=ofile,
            extra_args=["--standalone", "--epub-cover-image=cover.png"],
        )

        print "Converting to kindle"
        sys.stdout.flush()
        os.system("%s %s -o %s >/dev/null 2>&1" % (KINDLE_GEN, ofile, oofile))

        print "Sending to kindle email"
        sys.stdout.flush()

        send_mail(
            send_from=EMAIL_FROM,
            send_to=[KINDLE_EMAIL],
            subject="Daily News",
            text="This is your daily news.\n\n--\n\n",
            files=[oofile],
        )
        print "Cleaning up."
        sys.stdout.flush()
        os.remove(ofile)
        os.remove(oofile)

    print "Finished."
    sys.stdout.flush()
    update_start(now)

def end_novel():
    out_file.close()
    pypandoc.convert(
        md_file_path,
        "html",
        outputfile=html_file_path,
        extra_args=["-s", "-c", "https://mattfister.github.io/nanogenmo2015/samples/base.css"],
    )
    print "Total words: " + str(word_count)

    def _create(self):
        args, kwargs = self.get_pandoc_params()
        try:
            pypandoc.convert(*args, **kwargs)
        except:
            self.errors.append(str("PANDOC-ERROR: " + str(sys.exc_info())))
            return

        self.upload()

def get_description():
    if (not os.path.exists("README.txt") or
        (os.path.exists("README.md") and os.stat("README.txt").st_mtime < os.stat("README.md").st_mtime)):
        try:
            import pypandoc
            pypandoc.convert("README.md", "rst", outputfile="README.txt")
        except (ImportError, OSError, IOError) as exc:
            warnings.warn("Markdown to RST conversion failed (%s), using plain markdown for description" % exc)
            return open("README.md", "rt").read()
    return open("README.txt", "rt").read()

 def test_conversion_with_markdown_extensions(self):
     input = '<s>strike</s>'
     expected_with_extension = u'~~strike~~'
     expected_without_extension = u'<s>strike</s>'
     received_with_extension = pypandoc.convert(input, 'markdown+strikeout',
                                                format='html')
     received_without_extension = pypandoc.convert(input,
                                                   'markdown-strikeout',
                                                   format='html')
     self.assertEqualExceptForNewlineEnd(expected_with_extension, received_with_extension)
     self.assertEqualExceptForNewlineEnd(expected_without_extension, received_without_extension)

    def test_pdf_conversion(self):
        tf = tempfile.NamedTemporaryFile(suffix='.pdf', delete=False)
        name = tf.name
        tf.close()

        try:
            pypandoc.convert('#some title\n', to='pdf', format='md', outputfile=name)
        except:
            raise
        finally:
            os.remove(name)