Python pypandoc 模块，convert_text() 实例源码

def save_part(lines):
    """save last part on rst file"""
    # has content ?
    if len(lines) > 2:
        # get path
        title = lines[0].replace(' ', '_')
        path = os.path.join(README_DOC_PATH, '%s.rst' % title)

        # get content
        content = '\n'.join(lines[:-2])
        content = content.replace('docs/img/', ' ../img/')
        print(content)

        # save
        pypandoc.convert_text(content, 'rst', format='md', outputfile=path)

    # flush last part
    return lines[-2:]


# create directory

def get_long_description():
    current_dir = path.abspath(path.dirname(__file__))
    readme_path = path.join(current_dir, 'README.md')
    with open(readme_path, encoding='utf-8') as f:
        try:
            import pypandoc
            long_description = pypandoc.convert_text(f.read(), 'rst', 'markdown_github').replace('\r', '')
        except(OSError, ImportError):
            print('\n\n!!! pandoc not found. long_description is not correct. Do not upload this to PyPI. !!!\n\n')
            long_description = f.read()
    return long_description

def __init__(self, source_data):
        try:
            import pypandoc
        except ImportError as e:
            raise PypandocImportError(e)

        super(MediaWikiTableFormatter, self).__init__(
            pypandoc.convert_text(source_data, "html", format="mediawiki"))

def md2rst(text):
    return pypandoc.convert_text(text, 'rst', format='markdown_github')

def convert(file, stdin, instanceid):
    if stdin:
        text = ""
        with open(file, 'r') as filehandle:
            text = filehandle.read()
        # this fails
        pypandoc.convert_text(text, "asciidoc",
                              format="html",
                              outputfile="%s.asciidoc" % instanceid)
    else:  # this works
        output = pypandoc.convert_file(file, "asciidoc",
                                       format="html")

def main(input_file, output='', to='', extra_args=None):
    """
    the main process
    :param input_file: the path of input mdac file
    :param output: the output file full path
    :param to: the output format of the file
    :param extra_args: a list of extra arguments provided to pandoc
    """
    if to:
        logging.warning('it is recommend to include command line arguments in'
                        'your mdac file meta')

        # get the file name if no file name is specified
        if not output:
            output = __get_output_filename__(input_file=input_file,
                                             config={},
                                             output_format=to)

        compile_function = __get_compile_function__(to)

        with open(input_file, 'r', encoding='utf-8') as f:
            input_content = f.read()

        pre_compile_res = pre_compile(input_content)

        compile_res = compile_function(pre_compile_res)

        pypandoc.convert_text(source=compile_res,
                              outputfile=output,
                              format='md',
                              to=to,
                              extra_args=extra_args)

    else:
        __compile_with_reg_data__(input_file)

def read_description(filename):
    with codecs.open(filename, encoding='utf-8') as f:
        try:
            import pypandoc
            return pypandoc.convert_text(f.read(), format='md', to='rst')
        except ImportError:
            return f.read()

def get_long_description():
    """Pypi doesn't like .md - I don't like .rst - let's compromise."""
    here = Path(__file__).parent
    readme = (here / 'README.md').read_text()
    changelog = (here / 'CHANGELOG.md').read_text()
    if 'upload' in sys.argv:
        import pypandoc
        readme = pypandoc.convert_text(readme, to='rst', format='md')
        changelog = pypandoc.convert_text(changelog, to='rst', format='md')
        changelog = linkify(changelog)
    return "%s\n\n%s" % (readme, changelog)

def md2html(content, to_file):
    import pypandoc
    if os.path.isfile(content):
        content = open(content).read()
    if not os.path.splitext(to_file)[1] == '.html':
        to_file += '.html'
    output = pypandoc.convert_text(content, 'html', format = 'md')
    with open(to_file, 'w') as f:
        f.write(output)

def get_long_description():
    descr = _read(README_PATH)
    try:
        import pypandoc
        descr = pypandoc.convert_text(descr, to='rst', format='md')
    except (IOError, ImportError):
        pass
    return descr

def to_pdf_file(self, filename):
        results = self.sorted_results
        tally = lambda c, s: sum(1 for res in results if res['issue_confidence'] == c and res['issue_severity'] == s)
        summary_table = [[s] + [tally(c, s) for c in reversed(bandit.RANKING)] for s in reversed(bandit.RANKING)]
        summary_table = tabulate.tabulate(
            summary_table,
            headers=[''] + list(reversed(bandit.RANKING)),
            tablefmt='markdown'
        )
        ctr = collections.Counter()
        ctr.update(((res['test_id'], res['test_name'], res['issue_severity']) for res in results))
        findings_table = [(k[0], k[1], k[2], v) for k, v in ctr.items()]
        findings_table = sorted(findings_table, key=lambda k: k[3])
        findings_table = sorted(findings_table, key=lambda k: bandit.RANKING_VALUES[k[2]])
        findings_table = reversed(findings_table)
        findings_table = tabulate.tabulate(
            findings_table,
            headers=('ID', 'Finding Name', 'Severity', 'Occurrences'),
            tablefmt='markdown'
        )
        text = PDF_TEMPLATE.render(
            extra=self.data.get('_jj'),
            findings_table=findings_table,
            results=results,
            python_version=self.data.get('python_version'),
            summary_table=summary_table,
            timestamp=self.generated_at
        )
        pypandoc.convert_text(text, 'pdf', extra_args=['--latex-engine=xelatex'], format='markdown', outputfile=filename)

def markdown_to_reveal(text: str, config: Config) -> str:
    """
    Transform a Markdown input file to an HTML (reveal.js) output string.

    Parameters
    ----------
    markdown_text
        Markdown text to convert to HTML.
    config
        Markdownreveal configuration.

    Returns
    -------
        The converted string.
    """
    extra_args = [
        '-s',
        '--slide-level=2',
        '-V', 'revealjs-url=revealjs',
    ]
    if config['katex']:
        extra_args.extend([
            '--katex=katex/katex.min.js',
            '--katex-stylesheet=katex/katex.min.css',
        ])
    extra_args.extend(pandoc_extra_to_args(config))
    extra_args.extend(reveal_extra_to_args(config))
    input_format = 'markdown'
    if config['emoji_codes']:
        input_format += '+emoji'
    output = convert_text(
        source=text,
        format=input_format,
        to='revealjs',
        extra_args=extra_args,
    )

    # HTML substitution
    output = tweak_html(output, config)

    return output

def read_long_description():
    try:
        import pypandoc
        with open("README.md") as f:
            text = f.read()

        # Remove screenshots as they get rendered poorly on PyPi
        stripped_text = text[:text.index("# Screenshots")].rstrip()
        return pypandoc.convert_text(stripped_text, 'rst', format='md')
    except:
        return ""

def _process_value(self, config_section, config_key, value_type):
        """
        Process the value
        :param config_section:  The section in the config
        :param config_key:      The key in the config
        :param value_type:      The type of the value
        :return:                The processed value
        """

        if config_section not in self.config:
            return None
        if config_key not in self.config[config_section]:
            return None

        value = self.config[config_section][config_key]

        if value_type == bool:
            value = value.strip().lower() == 'true'
        elif value_type == str:
            if value.startswith('file://'):
                value_path = os.path.join(self.base_path, value[len('file://'):])
                with open(value_path, 'r') as value_file:
                    value = value_file.read()
                if value_path.lower().endswith('.md'):
                    try:
                        import pypandoc
                        value = pypandoc.convert_text(value, 'rst', format='md')
                        value = value.replace("\r", "")
                    except ImportError:
                        print("Pandoc not found. Markdown to reStructuredText conversion failed.")
        elif value_type == list:
            if value.startswith('file://'):
                value_path = os.path.join(self.base_path, value[len('file://'):])
                with open(value_path, 'r') as value_file:
                    value = value_file.readlines()
                    value = filter(lambda k: bool(k), value)
                    value = list(map(lambda k: k.strip().replace('\n', ''), value))
            else:
                value = value.split(',')

        return value

def as_json(document):
    "JSON representation of the markdown document"
    return json.loads(pypandoc.convert_text(document, 'json',
                                            format='markdown'))

def convert(source: str, to: str, extra_args=(),
            output_file: str=None) -> None:
    """
    Convert a source document to an output file.

    Parameters
    ----------
    source : str
    to : str
    extra_args : iterable
    output_file : str

    Notes
    -----
    Either writes to ``output_file`` or prints to stdout.
    """
    output_name = (
        os.path.splitext(os.path.basename(output_file))[0]
        if output_file is not None
        else 'std_out'
    )

    standalone = '--standalone' in extra_args
    self_contained = '--self-contained' in extra_args
    stitcher = Stitch(name=output_name, to=to, standalone=standalone,
                      self_contained=self_contained)
    result = stitcher.stitch(source)
    result = json.dumps(result)
    newdoc = pypandoc.convert_text(result, to, format='json',
                                   extra_args=extra_args,
                                   outputfile=output_file)

    if output_file is None:
        print(newdoc)

def tokenize(source: str) -> dict:
    """
    Convert a document to pandoc's JSON AST.
    """
    return json.loads(pypandoc.convert_text(source, 'json', 'markdown'))

def convert_figure(self):
        r""" This uses pandoc to convert the explicit table text only. """

        pandoc_args = ["--mathjax"]

        try:
            converted_table = pypandoc.convert_text(
                self.table_text,
                to='markdown',
                format='latex',
                extra_args = pandoc_args)

        except AttributeError:
            # for pypandoc version before 1.2
            converted_table = pypandoc.convert(
                self.table_text,
                to='markdown',
                format='latex',
                extra_args=pandoc_args) 

        if self.label_text:
            this_label = self.label_text
        else:
            this_label = "tbl:" + self.uid

        converted_caption = ": {} {{#{}}}".format(self.caption_text.replace("\n", " "), this_label)

        self.output_content = "{}{}".format(converted_table, converted_caption)

def run_pandoc(content, extra=[]):
    """ Creates a temporary file, runs pandoc TeX->MD on it (with content)
    and then reopens and returns the string. """
    print("Running Pandoc (LT -> MD)")
    output = pypandoc.convert_text(content, "md", format="latex", extra_args=extra)

    return output

def __invoke_pandoc__(input_content: str, output_format: str,
                      extra_args: dict, output_file: str, default: dict):
    """
    invoke pandoc via pypandoc.
    :param output_file: the file name of the output file
    :param default: the default argument dict.
                    the key is long name of the para, the
    :param input_content: the markdown content ready to be compiled
    :param output_format: a string indicate the output format of the file
                            like 'beamer', 'pdf', 'html')
    :param extra_args: all the other argument that pandoc accepts
    """

    def __convert_arg(arg: Tuple[str, Union[str, bool, list]]):
        """
        a helper that converts the a arg tuple into regular command line arg
        :param arg: a tuple, where the first is the long name of the argument
                    the second is the value of the argument
        :return: if the second one is a bool,
        """
        # extract info from arg
        arg_name = arg[0]
        val = arg[1]

        # if the value is true
        # if the second element is false it should be filtered out by
        # the parent function
        if val is True:
            return '--{arg}'.format(arg=arg_name)

        # if the value is a list
        # gives the
        elif isinstance(val, list):
            return ' '.join("--{arg}={val}".format(arg=arg_name, val=element)
                            for element in val)

        # if the val is a string
        else:
            return "--{arg}={val}".format(arg=arg_name, val=val)

    # merge the two dict
    arg_dict = default.copy()
    arg_dict.update(extra_args)  # default will be overloaded via extra_args

    # convert extra args to list
    # exclude where the second one is false
    converted_args = [__convert_arg(arg) for arg in arg_dict.items()
                      if arg[1] is not False]

    # invoke pandoc
    pypandoc.convert_text(source=input_content, format='md',
                          to=output_format, outputfile=output_file,
                          extra_args=converted_args)