pyeasyphd 0.4.42__py3-none-any.whl

pyeasyphd/tools/search/search_keywords.py

@@ -0,0 +1,229 @@
+import copy
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from pyadvtools import generate_nested_dict, read_list, standard_path, write_list
+from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
+
+from ...main import PandocMdTo
+from ...utils.utils import html_head, html_style, html_tail
+from .data import obtain_search_keywords
+from .search_core import SearchResultsCore
+from .utils import extract_information, temp_html_style
+
+
+class Searchkeywords:
+    """Search keywords in bibliography data.
+
+    Args:
+        path_storage (str): Path to storage directory for journals or conferences.
+        path_output (str): Path to output directory for journals or conferences.
+        options (dict): Configuration options.
+
+    Attributes:
+        path_storage (str): Path to storage directory.
+        path_output (str): Path to output directory.
+        options (dict): Configuration options.
+        search_year_list (list[str]): list of years to search. Defaults to [].
+    """
+
+    def __init__(self, path_storage: str, path_output: str, options: dict[str, Any]) -> None:
+        """Initialize Searchkeywords with storage and output paths.
+
+        Args:
+            path_storage (str): Path to storage directory.
+            path_output (str): Path to output directory.
+            options (dict[str, Any]): Configuration options.
+        """
+        self.path_storage = standard_path(path_storage)
+        self.path_output = standard_path(path_output)
+
+        options_ = {}
+        options_["display_one_line_reference_note"] = True  # default is False
+        options_["is_standardize_bib"] = False  # default is True
+        options_["choose_abbr_zotero_save"] = "save"  # default is "save"
+        options_["function_common_again"] = True  # default is True
+        options_["function_common_again_for_abbr"] = False  # default is True
+        options_["function_common_again_for_zotero"] = False  # default is True
+        options_["function_common_again_for_save"] = False  # default is True
+        options_["is_sort_entry_fields"] = True  # default is True
+        options_["is_sort_blocks"] = True  # default is True
+        options_["sort_entries_by_field_keys_reverse"] = True  # default is True
+        options_["generate_entry_cite_keys"] = True  # default is True
+
+        options_["default_keywords_dict"] = obtain_search_keywords()
+        options_["default_search_field_list"] = ["title", "abstract"]
+        options_.update(options)
+        self.options = options_
+
+        self.search_year_list = options.get("search_year_list", [])
+        self._path_separate = self.path_output + "-Separate"
+
+        self._path_statistic = self.path_output + "-Statistics"
+        self._path_combine = self.path_output + "-Combine"
+
+    def run(self) -> None:
+        """Run the keyword search process."""
+        all_dict = {}
+        publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(self.path_storage, self.options)
+        for publisher in publisher_abbr_dict:
+            for abbr in publisher_abbr_dict[publisher]:
+                options = publisher_abbr_dict[publisher][abbr]
+
+                path_storage = os.path.join(self.path_storage, publisher, abbr)
+                path_output = os.path.join(self.path_output, publisher, abbr)
+                entry_type_keyword_type_keyword_field_number_dict = SearchResultsCore(
+                    path_storage, path_output, self._path_separate, abbr, options
+                ).optimize(copy.deepcopy(self.search_year_list))
+
+                all_dict.update({abbr: entry_type_keyword_type_keyword_field_number_dict})
+
+        if not self.options.get("print_on_screen", False):
+            extract_information(all_dict, self._path_statistic)
+
+            print()
+            self._generate_bib_html_for_publisher(publisher_abbr_dict, "bib")
+            print()
+            self._generate_bib_html_for_publisher(publisher_abbr_dict, "html")
+            self._generate_link_to_bib_html_for_combine()
+
+            print()
+            self._pandoc_md_to_html_in_path_separate()
+            self._generate_link_to_html_bib_for_separate()
+
+        return None
+
+    def _extract_files(
+        self, publisher_abbr_dict: dict, ext: str = "html"
+    ) -> dict[str, dict[str, dict[str, dict[str, list[str]]]]]:
+        data_dict = {}
+        for publisher in publisher_abbr_dict:
+            for abbr in publisher_abbr_dict[publisher]:
+                p = os.path.join(self.path_output, publisher, abbr)
+                if not os.path.exists(p):
+                    continue
+
+                for entry_type in [f for f in os.listdir(p) if os.path.isdir(os.path.join(p, f))]:
+                    if not (folders := [f for f in os.listdir(os.path.join(p, entry_type)) if "combine" in f.lower()]):
+                        continue
+
+                    for root, _, files in os.walk(os.path.join(p, entry_type, folders[0])):
+                        for file in [f for f in files if f.endswith(ext)]:
+                            (
+                                data_dict.setdefault(file, {})
+                                .setdefault(entry_type, {})
+                                .setdefault(publisher, {})
+                                .setdefault(abbr, [])
+                                .append(os.path.join(root, file))
+                            )
+        return data_dict
+
+    def _generate_bib_html_for_publisher(self, publisher_abbr_dict, ext: str = "html") -> None:
+        data_dict = self._extract_files(publisher_abbr_dict, ext)
+        for file in data_dict:
+            basename = file.split(".")[0]
+            for entry_type in data_dict[file]:
+                for publisher in data_dict[file][entry_type]:
+                    print(f"Generate {ext} for `{publisher}-{entry_type}-{basename}`")
+                    data_list = []
+                    for abbr in data_dict[file][entry_type][publisher]:
+                        for i in range(ll := len(data_dict[file][entry_type][publisher][abbr])):
+                            full_file = data_dict[file][entry_type][publisher][abbr][i]
+                            temp_data_list = read_list(full_file, "r", None)
+                            if ext == "html":
+                                if mch := re.search(r"(<h3.*)</body>", "".join(temp_data_list), re.DOTALL):
+                                    temp_data_list = mch.group(1).splitlines(keepends=True)
+
+                            data_list.extend(temp_data_list)
+                            if i < (ll - 1):
+                                data_list.append("\n")
+                        data_list.append("\n")
+
+                    p = os.path.join(self._path_combine, entry_type, publisher, ext)
+                    if ext == "html":
+                        data_list_ = [html_head.format(basename)]
+                        data_list_.extend(html_style)
+                        data_list_.append(f'<h2 id="{publisher.upper()}">{publisher.upper()}</h2>\n')
+                        data_list_.extend(data_list)
+                        data_list_.append(html_tail)
+                        write_list(data_list_, f"{basename}.{ext}", "w", p, False)
+
+                    else:
+                        write_list(data_list, f"{basename}.{ext}", "w", p, False)
+        return None
+
+    def _generate_link_to_bib_html_for_combine(self) -> None:
+        nested_dict = generate_nested_dict(self._path_combine)
+
+        for entry_type in nested_dict:
+            data_dict = {}
+            for publisher in nested_dict[entry_type]:
+                for ext in nested_dict[entry_type][publisher]:
+                    if ext == "html":
+                        for file in nested_dict[entry_type][publisher][ext]:
+                            data_dict.setdefault(publisher, []).append(file)
+
+                    if ext == "bib":
+                        for file in nested_dict[entry_type][publisher][ext]:
+                            if not re.search(r"\-zotero", file):
+                                continue
+
+                            data_dict.setdefault(publisher, []).append(file)
+
+            data_list = self._html_format(entry_type, data_dict, "Publishers", "combine")
+            write_list(data_list, f"{entry_type.lower()}_links.html", "w", self._path_combine, False)
+        return None
+
+    def _pandoc_md_to_html_in_path_separate(self) -> None:
+        mds = []
+        for root, _, files in os.walk(self._path_separate):
+            mds.extend([os.path.join(root, f) for f in files if f.endswith(".md")])
+
+        for full_md in mds:
+            print(f"pandoc md to html for `{full_md.split(self._path_separate)[-1]}`")
+            full_html = full_md.replace("-md", "-html").replace(".md", ".html")
+            PandocMdTo({}).pandoc_md_to_html(full_md, full_html, None, None, True)
+
+    def _generate_link_to_html_bib_for_separate(self) -> None:
+        for entry_type in (nested_dict := generate_nested_dict(self._path_separate)):
+            data_dict = {}
+            for keywords_type in nested_dict[entry_type]:
+                for ext in nested_dict[entry_type][keywords_type]:
+                    if not re.search(r"(\-html\-|\-bib\-zotero)", ext):
+                        continue
+
+                    for file in nested_dict[entry_type][keywords_type][ext]:
+                        data_dict.setdefault(os.path.basename(file).split(".")[0], []).append(file)
+
+            data_list = self._html_format(entry_type, data_dict, "Keywords", "separate")
+            write_list(data_list, f"{entry_type.lower()}_links.html", "w", self._path_separate, False)
+        return None
+
+    @staticmethod
+    def _html_format(entry_type, data_dict, name_flag, index):
+        data_list = [html_head.format(f"{entry_type.title()} Links"), temp_html_style]
+        data_list.append('\n<table border="1">\n')
+        data_list.append(f"<caption>{entry_type.title()} Links</caption>\n")
+
+        data_list.extend(["<thead>\n", "<tr>\n", f"<th>{name_flag}</th>\n", "</tr>\n", "</thead>\n"])
+
+        x = '<td><a href="{}" target="_blank">{}</a></td>\n'
+        data_list.append("<tbody>\n")
+        for name in data_dict:
+            data_list.append("<tr>\n")
+            data_list.append(f"<td>{name}</td>\n")
+
+            for f in data_dict[name]:
+                folders = Path(f).parts[1:]
+                if index == "combine":
+                    data_list.append(x.format(f, folders[-1].split("-")[0].title() + ":" + f.split(".")[-1]))
+                elif index == "separate":
+                    data_list.append(x.format(f, folders[-2].split("-")[0].title() + ":" + f.split(".")[-1]))
+            data_list.append("</tr>\n")
+        data_list.append("</tbody>\n")
+
+        data_list.append("</table>\n")
+        data_list.append(html_tail)
+        return data_list

pyeasyphd/tools/search/search_writers.py

@@ -0,0 +1,350 @@
+import copy
+import os
+
+from pyadvtools import combine_content_in_list, read_list, write_list
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonWriters
+
+from ...main import BasicInput, PandocMdTo
+from ...tools.search.utils import combine_keywords_for_file_name, combine_keywords_for_title, keywords_type_for_title
+
+
+class WriteInitialResult(BasicInput):
+    """Write initial results for single keyword.
+
+    Args:
+        options (dict): Configuration options.
+
+    Attributes:
+        options (dict): Configuration options.
+    """
+
+    def __init__(self, options: dict) -> None:
+        """Initialize WriteInitialResult with configuration options.
+
+        Args:
+            options (dict): Configuration options.
+        """
+        super().__init__(options)
+
+        self._level_title_md = "###"
+        self._level_title_tex = "subsection"
+        self._pandoc_md_to = PandocMdTo(options)
+
+    def main(
+        self,
+        path_initial: str,
+        output_prefix: str,
+        field: str,
+        keywords_type: str,
+        combine_keywords: str,
+        library_for_abbr: Library,
+        library_for_zotero: Library,
+        library_for_save: Library,
+    ) -> tuple[list[list[str]], list[str]]:
+        """Main method to write initial results.
+
+        Args:
+            path_initial (str): Path to initial directory.
+            output_prefix (str): Prefix for output files.
+            field (str): Field being searched.
+            keywords_type (str): Type of keywords.
+            combine_keywords (str): Combined keywords string.
+            library_for_abbr (Library): Abbreviated bibliography library.
+            library_for_zotero (Library): Zotero bibliography library.
+            library_for_save (Library): Save bibliography library.
+
+        Returns:
+            tuple[list[list[str]], list[str]]: Tuple containing data and error messages.
+        """
+        error_pandoc_md_md = []
+
+        # generate
+        cite_keys = [entry.key for entry in library_for_abbr.entries]
+
+        # update options
+        _options = copy.deepcopy(self.options)
+        _options["keep_entries_by_cite_keys"] = cite_keys
+        _python_writer = PythonWriters(_options)
+
+        # generate tex and md data
+        data_list_tex, data_list_md, header = self.generate_content_tex_md(
+            cite_keys, output_prefix, field, combine_keywords
+        )
+
+        # definition
+        file_prefix = combine_keywords_for_file_name(combine_keywords)  # the file name prefix
+
+        # write tex, md, and bib files
+        data_list = [data_list_tex, data_list_md, library_for_abbr, library_for_zotero, library_for_save]
+        mid_list = ["", "", "-abbr", "-zotero", "-save"]
+        post_list = ["tex", "md", "bib", "bib", "bib"]
+        path_write = os.path.join(path_initial, f"{field}-{keywords_type}")
+        for i in range(len(post_list)):
+            file_name = f"{file_prefix}{mid_list[i]}.{post_list[i]}"
+            _python_writer.write_to_file(data_list[i], file_name, "w", path_write)
+
+        # pandoc md to generate md file
+        path_bib = os.path.join(path_write, f"{file_prefix}{mid_list[2]}.bib")  # bib_for_abbr
+        data_list_pandoc_md = self._pandoc_md_to.pandoc_md_to_md(
+            path_bib, path_write, path_write, f"{file_prefix}.md", f"{file_prefix}-pandoc.md"
+        )
+
+        # mian part
+        # generate some md output data
+        data_basic_md: list[str] = []
+        data_beauty_md: list[str] = []
+        data_complex_md: list[str] = []
+        if data_list_pandoc_md:
+            data_basic_md, data_beauty_md, data_complex_md = self.generate_basic_beauty_complex_md(
+                header, cite_keys, data_list_pandoc_md, library_for_zotero
+            )
+        else:
+            error_pandoc_md_md.append(f"- pandoc full false: {file_prefix}_pandoc.md" + "\n")
+
+        # write basic beauty complex md files
+        basic_beauty_complex = ["-basic", "-beauty", "-complex"]
+        for d, name in zip([data_basic_md, data_beauty_md, data_complex_md], basic_beauty_complex, strict=True):
+            write_list(d, f"{file_prefix}{name}.md", "w", path_write)
+
+        # save all (tex, md, bib) files
+        x = [f"{i}.{j}" for i, j in zip(mid_list, post_list, strict=True)]
+        x.extend([f"{i}.md" for i in basic_beauty_complex])
+        data_temp = [[os.path.join(path_write, file_prefix + i)] for i in x]
+        return data_temp, error_pandoc_md_md
+
+    def generate_basic_beauty_complex_md(
+        self, header: str, cite_key_list: list[str], data_list_pandoc_md: list[str], library_for_zotero: Library
+    ) -> tuple[list[str], list[str], list[str]]:
+        """Generate basic, beauty, and complex markdown content.
+
+        Args:
+            header (str): Header string for the content.
+            cite_key_list (list[str]): list of citation keys.
+            data_list_pandoc_md (list[str]): list of pandoc markdown data.
+            library_for_zotero (Library): Zotero bibliography library.
+
+        Returns:
+            tuple[list[str], list[str], list[str]]: Tuple containing basic, beauty, and complex markdown content.
+        """
+        data_basic_md, data_beauty_md, data_complex_md = [], [], []
+
+        # library
+        _options = copy.deepcopy(self.options)
+        _python_writer = PythonWriters(_options)
+        key_url_http_bib_dict = _python_writer.output_key_url_http_bib_dict(library_for_zotero)
+
+        key_basic_dict, key_beauty_dict, key_complex_dict = self._pandoc_md_to.generate_key_data_dict(
+            data_list_pandoc_md, key_url_http_bib_dict
+        )
+
+        if key_basic_dict and key_beauty_dict and key_complex_dict:
+            data_basic_md, data_beauty_md, data_complex_md = [header + "\n"], [header + "\n"], [header + "\n"]
+            for i in range(length := len(cite_key_list)):
+                data_basic_md.extend(self._convert_to_special_list(key_basic_dict.get(cite_key_list[i], [])))
+                data_beauty_md.extend(self._convert_to_special_list(key_beauty_dict.get(cite_key_list[i], [])))
+                data_complex_md.extend(self._convert_to_special_list(key_complex_dict.get(cite_key_list[i], [])))
+                if i < (length - 1):
+                    data_basic_md.append("\n")
+                    data_beauty_md.append("\n")
+                    data_complex_md.append("\n")
+        return data_basic_md, data_beauty_md, data_complex_md
+
+    @staticmethod
+    def _convert_to_special_list(data_list: list[str]) -> list[str]:
+        """Convert data list to special formatted list.
+
+        Args:
+            data_list (list[str]): list of data strings.
+
+        Returns:
+            list[str]: Formatted list with proper indentation.
+        """
+        if len(data_list) > 0:
+            data_list[0] = "- " + data_list[0]
+        for j in range(len(data_list) - 1):
+            if data_list[j][-1] == "\n":
+                data_list[j + 1] = "  " + data_list[j + 1]
+        return data_list
+
+    def generate_content_tex_md(
+        self, cite_key_list: list[str], output_prefix: str, field: str, combine_keywords: str
+    ) -> tuple[list[str], list[str], str]:
+        """Generate LaTeX and markdown content.
+
+        Args:
+            cite_key_list (list[str]): list of citation keys.
+            output_prefix (str): Prefix for output files.
+            field (str): Field being searched.
+            combine_keywords (str): Combined keywords string.
+
+        Returns:
+            tuple[list[str], list[str], str]: Tuple containing LaTeX content, markdown content, and header.
+        """
+        c_k_f_t = combine_keywords_for_title(combine_keywords)
+
+        number_references = len(cite_key_list)
+        _title = f"{output_prefix} {field} contains {number_references} {c_k_f_t}"
+
+        tex_header = f"\\{self._level_title_tex}" + "{" + _title + "}\n"
+        tex_body = ["\\nocite{" + f"{c_k}" + "}\n" for c_k in cite_key_list]
+        tex_tail = "\\printbibliography\n\n\\ifx \\clearPage \\undefined \\else \\clearpage \\fi\n"
+        data_list_tex = combine_content_in_list([[tex_header], ["\n"], tex_body, ["\n"], [tex_tail]])
+
+        md_header = f"{self._level_title_md}" + " " + _title + "\n"
+        md_body = [r"- [@" + f"{c_k}" + "]\n" for c_k in cite_key_list]
+        data_list_md = combine_content_in_list([[md_header], ["\n"], md_body])
+        return data_list_tex, data_list_md, md_header
+
+
+class WriteSeparateResult:
+    """Write separate result for different keyword types."""
+
+    def __init__(self) -> None:
+        """Initialize WriteSeparateResult with title levels."""
+        self._level_title_md = "##"
+        self._level_title_tex = "section"
+
+    def main(
+        self, data_temp: list[list[str]], field: str, keywords_type: str, combine_keywords: str, path_separate: str
+    ) -> None:
+        """Main method to write separate results.
+
+        Args:
+            data_temp (list[list[str]]): list of data lists for different file types.
+            field (str): Field being processed.
+            keywords_type (str): Type of keywords.
+            combine_keywords (str): Combined keywords string.
+            path_separate (str): Path to separate directory.
+        """
+        k_t_f_t = keywords_type_for_title(keywords_type)
+        _title = f"{field.title()} contains {k_t_f_t}"
+
+        file_prefix = combine_keywords_for_file_name(combine_keywords)  # the file name prefix
+        mid_list = ["", "", "-abbr", "-zotero", "-save", "-basic", "-beauty", "-complex"]
+        post_list = ["tex", "md", "bib", "bib", "bib", "md", "md", "md"]
+
+        len_data_temp = len(data_temp)  # len(data_temp) = len(mid_list) = len(post_list) = 8
+        split_flag = mid_list.index("-abbr")
+
+        for i in range(split_flag, len_data_temp):
+            path_temp = os.path.join(path_separate, f"{keywords_type}", f"{field}-{post_list[i]}{mid_list[i]}")
+            full_file = os.path.join(path_temp, rf"{file_prefix}.{post_list[i]}")
+            temp_data_list = read_list(data_temp[i][0], "r", None)
+            if not os.path.isfile(full_file):
+                if post_list[i] == "md":
+                    temp_data_list.insert(0, f"{self._level_title_md}" + " " + _title + "\n\n")
+                elif post_list[i] == "tex":
+                    temp_data_list.insert(0, f"\\{self._level_title_tex}" + "{" + _title + "}\n\n")
+            else:
+                temp_data_list.insert(0, "\n")
+            write_list(temp_data_list, full_file, "a", None, False, False)  # Compulsory `a`
+        return None
+
+
+class WriteAbbrCombinedResults:
+    """Write combined results for abbreviations (such as `TEVC`, `PNAS`).
+
+    Args:
+        options (dict): Configuration options.
+
+    Attributes:
+        options (dict): Configuration options.
+        pandoc_md_basic_to_pdf (bool): Whether to convert basic markdown to PDF.
+        pandoc_md_beauty_to_pdf (bool): Whether to convert beauty markdown to PDF.
+        pandoc_md_complex_to_pdf (bool): Whether to convert complex markdown to PDF.
+        pandoc_md_basic_to_html (bool): Whether to convert basic markdown to HTML.
+        pandoc_md_beauty_to_html (bool): Whether to convert beauty markdown to HTML.
+        pandoc_md_complex_to_html (bool): Whether to convert complex markdown to HTML.
+    """
+
+    def __init__(self, options: dict) -> None:
+        """Initialize WriteAbbrCombinedResults with configuration options.
+
+        Args:
+            options (dict): Configuration options.
+        """
+        self.pandoc_md_basic_to_pdf: bool = options.get("pandoc_md_basic_to_pdf", False)
+        self.pandoc_md_beauty_to_pdf: bool = options.get("pandoc_md_beauty_to_pdf", False)
+        self.pandoc_md_complex_to_pdf: bool = options.get("pandoc_md_complex_to_pdf", False)
+        self.pandoc_md_basic_to_html: bool = options.get("pandoc_md_basic_to_html", False)
+        self.pandoc_md_beauty_to_html: bool = options.get("pandoc_md_beauty_to_html", False)
+        self.pandoc_md_complex_to_html: bool = options.get("pandoc_md_complex_to_html", True)
+
+        self._level_title_md = "##"
+        self._level_title_tex = "section"
+        self._pandoc_md_to = PandocMdTo(options)
+
+    def main(
+        self, search_field_list, keywords_type: str, field_data_dict: dict[str, list[list[str]]], path_combine: str
+    ) -> tuple[list[str], list[str]]:
+        """Main method to write combined results for abbreviations.
+
+        Args:
+            search_field_list: list of search fields.
+            keywords_type (str): Type of keywords.
+            field_data_dict (dict[str, list[list[str]]]): dictionary containing field data.
+            path_combine (str): Path to combine directory.
+
+        Returns:
+            tuple[list[str], list[str]]: Tuple containing error messages for PDF and HTML conversion.
+        """
+        path_subsection = os.path.join(path_combine, "tex-subsection")
+        path_md = os.path.join(path_combine, "md")
+        path_bib = os.path.join(path_combine, "bib")
+
+        mid_list = ["", "", "-abbr", "-zotero", "-save", "-basic", "-beauty", "-complex"]
+        post_list = ["tex", "md", "bib", "bib", "bib", "md", "md", "md"]
+        path_list = [path_subsection, path_md, path_bib, path_bib, path_bib]
+        for i in ["-basic", "-beauty", "-complex"]:
+            path_list.append(os.path.join(path_combine, f"md{i}"))
+        # len(mid_list) == len(post_list) == len(path_list) == 8
+
+        k_t_f_t = keywords_type_for_title(keywords_type)
+
+        error_pandoc_md_pdf, error_pandoc_md_html = [], []
+        for field in search_field_list:
+            if not field_data_dict.get(field):
+                continue
+
+            # write files
+            file_prefix = f"{field}-{keywords_type}"  # the file name prefix
+            _title = f"{field.title()} contains {k_t_f_t}"
+
+            for j in range(0, len(post_list)):
+                temp = combine_content_in_list([read_list(file, "r") for file in field_data_dict[field][j]], ["\n"])
+                if post_list[j] == "md":
+                    temp.insert(0, f"{self._level_title_md}" + " " + _title + "\n\n")
+                elif post_list[j] == "tex":
+                    temp.insert(0, f"\\{self._level_title_tex}" + "{" + _title + "}\n\n")
+                write_list(temp, f"{file_prefix}{mid_list[j]}.{post_list[j]}", "w", path_list[j])
+
+            # generate tex pdf html
+            # for tex
+            self._pandoc_md_to.generate_tex_content(file_prefix, path_subsection, path_bib, path_combine)
+
+            # for pdf
+            for i in ["basic", "beauty", "complex"]:
+                if eval(f"self.pandoc_md_{i}_to_pdf"):
+                    error_flag_pdf = self._pandoc_md_to.pandoc_md_to_pdf(
+                        os.path.join(path_combine, f"md-{i}"),
+                        f"{file_prefix}-{i}.md",
+                        os.path.join(path_combine, f"pdf-{i}"),
+                        f"{file_prefix}-{i}.pdf",
+                    )
+                    if error_flag_pdf:
+                        error_pandoc_md_pdf.append(error_flag_pdf)
+
+            # for html
+            for i in ["basic", "beauty", "complex"]:
+                if eval(f"self.pandoc_md_{i}_to_html"):
+                    error_flag_html = self._pandoc_md_to.pandoc_md_to_html(
+                        os.path.join(path_combine, f"md-{i}"),
+                        os.path.join(path_combine, f"html-{i}"),
+                        f"{file_prefix}-{i}.md",
+                        f"{file_prefix}-{i}.html",
+                        True,
+                    )
+                    if error_flag_html:
+                        error_pandoc_md_html.append(error_flag_html)
+        return error_pandoc_md_pdf, error_pandoc_md_html