pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/main/pandoc_md_to.py

@@ -0,0 +1,361 @@
+import copy
+import os
+import re
+import time
+from typing import Dict, List, Optional, Tuple
+
+from pyadvtools import (
+    combine_content_in_list,
+    delete_empty_lines_last_occur_add_new_line,
+    insert_list_in_list,
+    read_list,
+    substitute_in_list,
+    write_list,
+)
+
+from ..utils.utils import operate_on_generate_html
+from .basic_input import BasicInput
+
+
+class PandocMdTo(BasicInput):
+    """Pandoc md to md, tex, html, pdf and so on.
+
+    Args:
+        options (dict): Options.
+
+    Attributes:
+        markdown_name (str = "multi-markdown"): Markdown name.
+        markdown_citation (str = "markdown_mmd"): Markdown citation.
+        columns_in_md (int = 120): Columns in md.
+        google_connected_paper_scite (bool = True): Google connected paper scite.
+        display_one_line_reference_note (bool = False): Display one line reference note.
+        cite_flag_in_tex (str = "cite"): Cite flag in tex.
+    """
+
+    def __init__(self, options: dict) -> None:
+        super().__init__(options)
+
+        self.markdown_name: str = "multi-markdown"
+        self.markdown_citation: str = "markdown_mmd"
+        if self.markdown_name == "pandoc-markdown":
+            self.markdown_citation = "markdown-citations"
+
+        self.columns_in_md: int = options.get("columns_in_md", 120)
+        self.google_connected_paper_scite: bool = options.get("google_connected_paper_scite", True)
+        self.display_one_line_reference_note: bool = options.get("display_one_line_reference_note", False)
+        # tex
+        self.cite_flag_in_tex: str = options.get("cite_flag_in_tex", "cite")
+
+    # for pandoc markdown files to markdown files
+    def pandoc_md_to_md(
+        self,
+        path_bib: str,
+        path_md_one: str,
+        path_md_two: str,
+        name_md_one: Optional[str],
+        name_md_two: Optional[str],
+    ) -> List[str]:
+        full_one = path_md_one if name_md_one is None else os.path.join(path_md_one, name_md_one)
+        full_two = path_md_two if name_md_two is None else os.path.join(path_md_two, name_md_two)
+        return self._pandoc_md_to_md(full_one, full_two, path_bib)
+
+    def _pandoc_md_to_md(self, full_md_one: str, full_md_two: str, path_bib: str) -> List[str]:
+        """Pandoc."""
+        if not os.path.exists(path_two := os.path.dirname(full_md_two)):
+            os.makedirs(path_two)
+
+        if os.path.exists(self.full_csl_style_pandoc):
+            cmd = (
+                f"pandoc {full_md_one} -t {self.markdown_citation} "
+                f'-o {full_md_two} -M reference-section-title="References" '
+                f"-C --bibliography={path_bib} --csl={self.full_csl_style_pandoc} --columns {self.columns_in_md}"
+            )
+        else:
+            cmd = (
+                f"pandoc {full_md_one} -t {self.markdown_citation} "
+                f'-o {full_md_two} -M reference-section-title="References" '
+                f"-C --bibliography={path_bib} --columns {self.columns_in_md}"
+            )
+
+        try:
+            os.system(cmd)
+        except Exception as e:
+            print("pandoc md to md:", e)
+
+        if not os.path.exists(full_md_two):
+            print(f"- pandoc false from md to md: {os.path.basename(full_md_two)}\n")
+            return []
+
+        return self._standardize_markdown_content(full_md_two)
+
+    @staticmethod
+    def _standardize_markdown_content(full_md: str) -> List[str]:
+        regex = re.compile(r"(\s*>*\s*[-+*]+)\s\s\s(.*)")
+        for i in range(len(data_list := read_list(full_md, "r"))):
+            if mch := regex.match(data_list[i]):
+                data_list[i] = data_list[i].replace(mch.group(), mch.group(1) + " " + mch.group(2))
+        return data_list
+
+    # for pandoc markdown files to tex files
+    def pandoc_md_to_tex(
+        self,
+        template_name: str,
+        path_md: str,
+        path_tex: str,
+        name_md: Optional[str],
+        name_tex: Optional[str],
+    ) -> List[str]:
+        full_one = path_md if name_md is None else os.path.join(path_md, name_md)
+        full_two = path_tex if name_tex is None else os.path.join(path_tex, name_tex)
+        return self._pandoc_md_to_tex(full_one, full_two, template_name)
+
+    def _pandoc_md_to_tex(self, full_md: str, full_tex: str, template_name: str) -> List[str]:
+        """Pandoc."""
+        if not os.path.exists(path_tex := os.path.dirname(full_tex)):
+            os.makedirs(path_tex)
+
+        try:
+            if template_name.lower() == "beamer":
+                os.system(f"pandoc {full_md} -t beamer -o {full_tex} --from markdown ")
+            else:
+                os.system(f"pandoc {full_md} -o {full_tex} --from markdown ")
+        except Exception as e:
+            print("pandoc md to tex:", e)
+
+        if not os.path.exists(full_tex):
+            print(f"- pandoc false from md to tex: {os.path.basename(full_md)}\n")
+            return []
+
+        return self._substitute_in_tex_from_md(read_list(full_tex, "r", None))
+
+    def _substitute_in_tex_from_md(self, data_list: List[str]) -> List[str]:
+        old_str_list = [r"{\[}@", r"{\[}-@", r"{\[}", r"{\]}", r"\\_"]
+        new_str_list = [rf"\\{self.cite_flag_in_tex}" + "{", rf"\\{self.cite_flag_in_tex}" + "{", "{", "}", "_"]
+        old_str_list.extend([r"\\footnote<.->{", r";", r"@"])
+        new_str_list.extend([r"\\footnote{", ",", ""])
+        return substitute_in_list(old_str_list, new_str_list, data_list)
+
+    # for pandoc markdown files to html files
+    def pandoc_md_to_html(
+        self, path_md: str, path_html: str, name_md: Optional[str], name_html: Optional[str], operate: bool = False
+    ) -> str:
+        full_one = path_md if name_md is None else os.path.join(path_md, name_md)
+        full_two = path_html if name_html is None else os.path.join(path_html, name_html)
+        return self._pandoc_md_to_html(full_one, full_two, operate)
+
+    @staticmethod
+    def _pandoc_md_to_html(full_md: str, full_html: str, operate: bool = False) -> str:
+        """Pandoc."""
+        if not os.path.exists(path_html := os.path.dirname(full_html)):
+            os.makedirs(path_html)
+
+        cmd = f"pandoc {full_md} -o {full_html} --from markdown "
+
+        try:
+            os.system(cmd)
+        except Exception as e:
+            print("pandoc md to html:", e)
+
+        if not os.path.exists(full_html):
+            return f"- pandoc false from md to html: {os.path.basename(full_md)}\n"
+
+        if operate:
+            operate_on_generate_html(full_html)
+        return ""
+
+    # for pandoc markdown files to pdf files
+    def pandoc_md_to_pdf(
+        self,
+        path_md: str,
+        path_pdf: str,
+        name_md: Optional[str],
+        name_pdf: Optional[str],
+    ) -> str:
+        full_one = path_md if name_md is None else os.path.join(path_md, name_md)
+        full_two = path_pdf if name_pdf is None else os.path.join(path_pdf, name_pdf)
+        return self._pandoc_md_to_pdf(full_one, full_two)
+
+    def _pandoc_md_to_pdf(self, full_md: str, full_pdf: str) -> str:
+        """Pandoc."""
+        if not os.path.exists(path_pdf := os.path.dirname(full_pdf)):
+            os.makedirs(path_pdf)
+
+        if os.path.exists(self.full_tex_article_template_pandoc):
+            cmd = (
+                f"pandoc {full_md} -o {full_pdf} --from markdown "
+                f"--template {self.full_tex_article_template_pandoc} --listings --pdf-engine=xelatex"
+            )
+        else:
+            cmd = f"pandoc {full_md} -o {full_pdf} --from markdown  --listings --pdf-engine=xelatex"
+
+        try:
+            os.system(cmd)
+        except Exception as e:
+            print("pandoc md to pdf:", e)
+
+        if not os.path.exists(full_pdf):
+            return f"- pandoc false from md to pdf: {os.path.basename(full_md)}\n"
+        return ""
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    # md
+    def generate_key_data_dict(
+        self,
+        pandoc_md_data_list: List[str],
+        key_url_http_bib_dict: Dict[str, List[List[str]]],
+    ) -> Tuple[Dict[str, List[str]], Dict[str, List[str]], Dict[str, List[str]]]:
+        """Generate."""
+        key_reference_dict = self._generate_citation_key_reference_dict_from_pandoc_md(pandoc_md_data_list)
+        (
+            key_basic_dict,
+            key_beauty_dict,
+            key_complex_dict,
+        ) = self._generate_basic_beauty_complex_dict(key_url_http_bib_dict, key_reference_dict)
+        return key_basic_dict, key_beauty_dict, key_complex_dict
+
+    def _generate_citation_key_reference_dict_from_pandoc_md(
+        self, pandoc_md_data_list: List[str]
+    ) -> Dict[str, List[str]]:
+        """Generate."""
+        pandoc_md_data_list = self.__append_pandoc_md_reference_part(pandoc_md_data_list)
+
+        line_index, len_data = 0, len(pandoc_md_data_list)
+        if self.markdown_name == "pandoc-markdown":
+            a_flag, b_flag = r"^:::\s{#ref-(.*)\s\.csl-entry}", r"^:::"
+        else:  # multi-markdown
+            a_flag, b_flag = r'^<div\sid="ref-(.*?)"', r"^</div>"
+
+        regex_one, regex_two = re.compile(a_flag), re.compile(b_flag)
+        key_reference_dict = {}
+        while line_index < len_data:
+            match_one = regex_one.search(pandoc_md_data_list[line_index])
+            line_index += 1
+            if not match_one:
+                continue
+            citation_key = match_one.group(1).strip()
+
+            content = []
+            while line_index < len_data:
+                line = pandoc_md_data_list[line_index]
+                if regex_two.search(line):
+                    break
+
+                line_index += 1
+                if mch := re.search(r"([<\[]https?://)", line):
+                    content.append(line.split(mch.group(1))[0][:-1])
+                    break
+                else:
+                    if line.strip():
+                        content.append(line)
+
+            key_reference_dict.update({citation_key: delete_empty_lines_last_occur_add_new_line(content)})
+        return key_reference_dict
+
+    def __append_pandoc_md_reference_part(self, pandoc_md_data_list: List[str]) -> List[str]:
+        """Append the line which starts with '::: {#'."""
+        line_index, len_data = 0, len(pandoc_md_data_list)
+        if self.markdown_name == "pandoc-markdown":
+            a_flag, b_flag = r":::\s{#", r"}"
+        else:  # multi-markdown
+            a_flag, b_flag = r'<div\sid="ref', r">"
+        regex = re.compile(a_flag)
+        new_list = []
+        while line_index < len_data:
+            line = pandoc_md_data_list[line_index]
+            line_index += 1
+            if regex.search(line):
+                while line_index < len_data:
+                    if b_flag != line.rstrip()[-1]:
+                        line = line.rstrip() + " " + pandoc_md_data_list[line_index].lstrip()
+                        line_index += 1
+                    else:
+                        new_list.append(line)
+                        break
+                if line_index == len_data:
+                    new_list.append(line)
+            else:
+                new_list.append(line)
+        return delete_empty_lines_last_occur_add_new_line(new_list)
+
+    def _generate_basic_beauty_complex_dict(
+        self,
+        key_url_http_bib_dict: Dict[str, List[List[str]]],
+        key_reference_dict: Dict[str, list],
+    ) -> Tuple[Dict[str, List[str]], Dict[str, List[str]], Dict[str, List[str]]]:
+        """Generate."""
+        header_list = ["<details>\n", "```\n"]
+        tail_list = ["```\n", "</details>\n"]
+
+        key_basic_dict: Dict[str, List[str]] = {}
+        key_beauty_dict: Dict[str, List[str]] = {}
+        key_complex_dict: Dict[str, List[str]] = {}
+
+        key_list_http = list(key_url_http_bib_dict.keys())
+        key_list_md = list(key_reference_dict.keys())
+        if set(key_list_http) != set(key_list_md):
+            print(f"`key_list_md`: set({key_list_md}) should be the same with `key_list_http`: set({key_list_http}).")
+            return key_basic_dict, key_beauty_dict, key_complex_dict
+
+        for k in key_list_http:
+            a: List[str] = copy.deepcopy(key_reference_dict[k])
+            b: List[str] = copy.deepcopy(key_reference_dict[k])
+            aa: List[str] = key_url_http_bib_dict[k][0]
+            bb: List[str] = key_url_http_bib_dict[k][1]
+
+            if (not self.google_connected_paper_scite) and aa:
+                bb = [f"([www]({aa[0].strip()}))\n"]
+
+            a.extend(aa)
+            b.extend(bb)
+
+            if self.display_one_line_reference_note:
+                a = ["".join(a).replace("\n", " ").strip() + "\n"]
+                b = ["".join(b).replace("\n", " ").strip() + "\n"]
+
+            c = combine_content_in_list([b, header_list, key_url_http_bib_dict[k][2], tail_list])
+            key_basic_dict.update({k: a})
+            key_beauty_dict.update({k: b})
+            key_complex_dict.update({k: c})
+        return key_basic_dict, key_beauty_dict, key_complex_dict
+
+    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
+    # tex
+    def generate_tex_content(self, file_prefix: str, path_subsection: str, path_bib: str, path_combine: str) -> None:
+        # for latex
+        # add template for tex file
+        add_bib_name = "{}/{}-abbr.bib".format(os.path.basename(path_bib), file_prefix)
+        add_tex_name = "{}/{}.tex".format(os.path.basename(path_subsection), file_prefix)
+        insert_part_one, insert_part_two = self._generate_tex_content(file_prefix, add_tex_name, add_bib_name)
+
+        # write tex
+        data_temp = insert_list_in_list(
+            self.article_template_tex, insert_part_one, r"\\begin{document}", "before"
+        )
+        data_temp = insert_list_in_list(data_temp, insert_part_two, r"\\begin{document}", "after")
+        write_list(data_temp, f"{file_prefix}.tex", "w", os.path.join(path_combine, "tex"))
+        return None
+
+    @staticmethod
+    def _generate_tex_content(file_prefix: str, add_tex_name: str, add_bib_name: str) -> Tuple[List[str], List[str]]:
+        if len(file_prefix) == 0:
+            file_prefix = "file_prefix"
+
+        part_one = [
+            "\\date{" + "{}".format(time.strftime("%B %d, %Y")) + "}\n\n",
+            "\\ifx \\fullpath \\undefined\n",
+            "    \\addbibresource{" + "../{}".format(add_bib_name) + "}\n",
+            "\\else\n",
+            "    \\addbibresource{" + "\\fullpath/{}".format(add_bib_name) + "}\n",
+            "\\fi\n\n",
+        ]
+        part_two = [
+            "\n",
+            "% \\maketitle\n",
+            "\\tableofcontents\n\n",
+            "\\ifx \\fullpath \\undefined\n",
+            "    \\input{" + "../{}".format(add_tex_name) + "}\n",
+            "\\else\n",
+            "    \\input{" + "\\fullpath/{}".format(add_tex_name) + "}\n",
+            "\\fi\n",
+        ]
+        return part_one, part_two

pyeasyphd/main/python_run_bib.py

@@ -0,0 +1,73 @@
+from typing import Any, Dict, List, Tuple, Union
+
+from pyadvtools import (
+    transform_to_data_list,
+)
+
+from ..bib.bibtexparser import Entry, Library
+from ..bib.core import ConvertLibrayToLibrary, ConvertStrToLibrary
+from .basic_input import BasicInput
+
+
+class PythonRunBib(BasicInput):
+    """Python bib.
+
+    Args:
+        options (Dict[str, Any]): Options.
+    """
+
+    def __init__(self, options: Dict[str, Any]) -> None:
+        super().__init__(options)
+
+    def parse_to_single_standard_library(
+        self,
+        original_data: Union[List[str], str, Library],
+        given_cite_keys: List[str] = [],
+        **kwargs,
+    ) -> Library:
+        # update
+        self.options["keep_entries_by_cite_keys"] = given_cite_keys
+
+        if not isinstance(original_data, Library):
+            original_data = transform_to_data_list(original_data, extension=".bib", **kwargs)
+            original_data = ConvertStrToLibrary(self.options).generate_library(original_data)
+
+        library = ConvertLibrayToLibrary(self.options).generate_single_library(original_data)
+        return library
+
+    def parse_to_multi_standard_library(
+        self,
+        original_data: Union[List[str], str, Library],
+        given_cite_keys: List[str] = [],
+        **kwargs,
+    ) -> Tuple[Library, Library, Library]:
+        # update
+        self.options["keep_entries_by_cite_keys"] = given_cite_keys
+
+        if not isinstance(original_data, Library):
+            original_data = transform_to_data_list(original_data, extension=".bib", **kwargs)
+            original_data = ConvertStrToLibrary(self.options).generate_library(original_data)
+
+        libraries = ConvertLibrayToLibrary(self.options).generate_multi_libraries(original_data)
+        abbr_library, zotero_library, save_library = libraries
+        return abbr_library, zotero_library, save_library
+
+    def parse_to_nested_entries_dict(
+        self,
+        original_data: Union[List[str], str, Library],
+        given_cite_keys: List[str] = [],
+        **kwargs,
+    ) -> Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, List[Entry]]]]]]:
+        library = self.parse_to_single_standard_library(original_data, given_cite_keys, **kwargs)
+
+        entry_type_year_volume_number_month_entry_dict = {}
+        for entry in library.entries:
+            entry_type = entry.entry_type
+            year = entry["year"] if "year" in entry else "year"
+            volume = entry["volume"] if "volume" in entry else "volume"
+            number = entry["number"] if "number" in entry else "number"
+            month = entry["month"] if "month" in entry else "month"
+            entry_type_year_volume_number_month_entry_dict.setdefault(entry_type, {}).setdefault(year, {}).setdefault(
+                volume, {}
+            ).setdefault(number, {}).setdefault(month, []).append(entry)
+        return entry_type_year_volume_number_month_entry_dict

pyeasyphd/main/python_run_md.py

@@ -0,0 +1,235 @@
+import copy
+import os
+import re
+import shutil
+import time
+from typing import Any, Dict, List, Tuple
+
+from pyadvtools import (
+    combine_content_in_list,
+    delete_empty_lines_last_occur_add_new_line,
+    read_list,
+    write_list,
+)
+
+from ..bib.core import ConvertStrToLibrary
+from .basic_input import BasicInput
+from .pandoc_md_to import PandocMdTo
+from .python_writers import PythonWriters
+
+
+class PythonRunMd(BasicInput):
+    """Python markdown.
+
+    Args:
+        options (Dict[str, Any]): Options.
+
+    Attributes:
+        delete_temp_generate_md (bool = True): Whether to delete temp generate md.
+        add_reference_in_md (bool = True): Whether to add reference in md.
+        add_bib_in_md (bool = False): Whether to add bib in md.
+        replace_cite_to_fullcite_in_md (bool = False): Whether to replace cite to fullcite in md.
+        replace_by_basic_beauty_complex_in_md (str = "beauty"): Replace by basic, beauty, or complex.
+        display_basic_beauty_complex_references_in_md (str = "beauty"): Display basic, beauty, or complex references.
+    """
+
+    def __init__(self, options: Dict[str, Any]) -> None:
+        super().__init__(options)
+
+        # for md
+        self.final_output_main_md_name: str = options.get("final_output_main_md_name", "")
+        self.delete_temp_generate_md: bool = options.get("delete_temp_generate_md", True)
+        self.add_reference_in_md: bool = options.get("add_reference_in_md", True)
+        self.add_bib_in_md: bool = options.get("add_bib_in_md", False)
+        self.replace_cite_to_fullcite_in_md: bool = options.get("replace_cite_to_fullcite_in_md", False)
+        self.replace_by_basic_beauty_complex_in_md: str = options.get("replace_by_basic_beauty_complex_in_md", "beauty")
+        self.display_basic_beauty_complex_references_in_md: str = options.get(
+            "display_basic_beauty_complex_references_in_md", "beauty"
+        )
+
+        # for md
+        self._pandoc_md_to = PandocMdTo(self.options)
+
+        _options = {}
+        _options["is_standardize_bib"] = False
+        _options["is_display_implicit_comments"] = False
+        _options.update(options)
+        self._generate_library = ConvertStrToLibrary(_options)
+
+    # for markdown files
+    def special_operate_for_md(
+        self,
+        path_output: str,
+        data_list_md: List[str],
+        output_md_name: str,
+        full_bib_for_abbr: str,
+        full_bib_for_zotero: str,
+        template_name: str = "article",
+        generate_html: bool = False,
+        generate_tex: bool = True
+    ) -> Tuple[List[str], List[str]]:
+        """Markdown."""
+        path_temp = os.path.join(path_output, "{}".format(time.strftime("%Y_%m_%d_%H_%M_%S")))
+        if not os.path.exists(path_temp):
+            os.makedirs(path_temp)
+
+        # write original md content to temp file
+        full_temp_md = os.path.join(path_temp, output_md_name)
+        write_list(data_list_md, full_temp_md, "w", None, False)
+
+        # pandoc md to md to update md content
+        if read_list(full_bib_for_abbr, "r") and read_list(full_bib_for_zotero, "r"):
+            data_list_md = self._special_operate_for_md(
+                output_md_name, path_temp, full_bib_for_abbr, full_bib_for_zotero
+            )
+        elif os.path.exists(full_bib_for_abbr) and os.path.exists(full_bib_for_zotero):
+            print(f"The content of bib: {full_bib_for_abbr} or {full_bib_for_zotero} is empty.")
+        else:
+            pass
+
+        # main name
+        main_name = self.final_output_main_md_name
+        if len(main_name) == 0:
+            main_name = output_md_name.split(".md")[0] + "_" + self.replace_by_basic_beauty_complex_in_md
+            main_name = main_name + "_" + self.display_basic_beauty_complex_references_in_md + ".md"
+        if main_name.lower() == output_md_name.lower():
+            main_name = main_name.split(".md")[0] + "_.md"
+        if main_name[-3:] != ".md":
+            main_name = main_name + ".md"
+
+        # write new generated md content to given file
+        write_list(data_list_md, main_name, "w", path_output, False)
+
+        # for generating html file from md file
+        if data_list_md and generate_html:
+            self._pandoc_md_to.pandoc_md_to_html(
+                path_output, path_output, main_name, f'{main_name.split(".md")[0]}.html', True
+            )
+
+        # pandoc md to latex
+        data_list_tex = []
+        if generate_tex:
+            n5 = "5_pandoc" + ".tex"
+            data_list_tex = self._pandoc_md_to.pandoc_md_to_tex(template_name, path_temp, path_temp, output_md_name, n5)
+
+        # delete temp path
+        if self.delete_temp_generate_md:
+            shutil.rmtree(path_temp)
+        return data_list_md, data_list_tex
+
+    def _special_operate_for_md(
+        self,
+        output_md_name: str,
+        path_temp: str,
+        full_bib_for_abbr: str,
+        full_bib_for_zotero: str,
+    ) -> List[str]:
+        # pandoc markdown to markdown
+        n1 = "1_pandoc" + ".md"
+        data_list_md = self._pandoc_md_to.pandoc_md_to_md(full_bib_for_abbr, path_temp, path_temp, output_md_name, n1)
+
+        # use zotero bib to generate library
+        bib_for_zotero = read_list(full_bib_for_zotero, "r")
+        library = self._generate_library.generate_library(bib_for_zotero)
+
+        _options = {}
+        _options.update(self.options)
+        _options["add_index_to_enties"] = False
+        _python_writers = PythonWriters(_options)
+        key_url_http_bib_dict = _python_writers.output_key_url_http_bib_dict(library)
+
+        content_md = []
+        if data_list_md and key_url_http_bib_dict:
+            key_basic_dict, key_beauty_dict, key_complex_dict = self._pandoc_md_to.generate_key_data_dict(
+                data_list_md, key_url_http_bib_dict
+            )
+
+            key_in_md = list(key_url_http_bib_dict.keys())
+
+            # generate by replacing `- [@citation_key]` to `- [citation_key]`
+            content = read_list(output_md_name, "r", path_temp)
+            if self.replace_cite_to_fullcite_in_md:
+                regex = re.compile(r"(\s*[-\+\*]\s*)\[@({})\]".format("|".join(key_in_md)))
+                for i in range(len(content)):
+                    if not (mch := regex.match(content[i])):
+                        continue
+
+                    content[i] = content[i].replace(mch.group(), mch.group(1) + "[" + mch.group(2) + "]")
+            n2 = "2_generate" + ".md"
+            write_list(content, n2, "w", path_temp)
+
+            # pandoc markdown to markdown
+            n3 = "3_pandoc" + ".md"
+            data_list_md = self._pandoc_md_to.pandoc_md_to_md(full_bib_for_abbr, path_temp, path_temp, n2, n3)
+
+            # generate by replacing `- [citation_key]` to `- reference`
+            if self.replace_cite_to_fullcite_in_md:
+                regex = re.compile(r"(\s*)([-\+\*])(\s*)[\\]*\[({})[\\]*\]".format("|".join(key_in_md)))
+                for i in range(len(data_list_md)):
+                    if not (mch := regex.search(data_list_md[i])):
+                        continue
+
+                    space_one, b, space_two, cite_key = mch.groups()
+                    if self.replace_by_basic_beauty_complex_in_md.lower() == "basic":
+                        temp_list = copy.deepcopy(key_basic_dict[cite_key])
+                    elif self.replace_by_basic_beauty_complex_in_md.lower() == "complex":
+                        temp_list = copy.deepcopy(key_complex_dict[cite_key])
+                    else:
+                        temp_list = copy.deepcopy(key_beauty_dict[cite_key])
+
+                    temp = "".join(self._special_format(temp_list, space_one, space_two))
+                    data_list_md[i] = data_list_md[i].replace(mch.group(), space_one + b + space_two + temp.strip())
+            n4 = "4_generate" + ".md"
+            write_list(data_list_md, os.path.join(path_temp, n4), "w")
+
+            # obtain footnote part (in the last part of the contents)
+            main_part, last_part = [], []
+            main_part_flag, last_part_flag = True, True
+            for line_index in range(len(data_list_md)):
+                if main_part_flag and re.match(r"#+ References\s[\[{]", data_list_md[line_index]):
+                    main_part_flag = False
+                    main_part = delete_empty_lines_last_occur_add_new_line(data_list_md[:line_index])
+                if last_part_flag and re.match(r"^\[\^1]: ", data_list_md[line_index]):
+                    last_part_flag = False
+                    last_part = delete_empty_lines_last_occur_add_new_line(data_list_md[line_index:])
+
+            if main_part_flag:
+                main_part = delete_empty_lines_last_occur_add_new_line(data_list_md)
+            if self.add_reference_in_md:
+                main_part.append("\n## References\n")
+            if len(last_part) > 0:
+                last_part.insert(0, "[//]: (Footnotes)\n\n")
+                last_part.append("\n")
+
+            # for bib
+            bib_in_md = []
+            if self.add_bib_in_md:
+                temp_c = combine_content_in_list([key_url_http_bib_dict[k][2] for k in key_in_md])
+                bib_in_md = combine_content_in_list([["<details>\n```\n"], temp_c, ["```\n</details>\n"]])
+
+            # Generate basic/beauty/complex markdown content
+            if dct := eval(f"key_{self.display_basic_beauty_complex_references_in_md}_dict"):
+                content_md = self._generate_content_md(dct, key_in_md, main_part, last_part, bib_in_md)
+        return content_md
+
+    @staticmethod
+    def _special_format(temp_list: List[str], space_one: str, space_two: str) -> List[str]:
+        # special format for alignment
+        for j in range(len(temp_list) - 1):
+            if temp_list[j][-1] == "\n":
+                temp_list[j + 1] = (space_one + " " + space_two) + temp_list[j + 1]
+        return temp_list
+
+    def _generate_content_md(
+        self,
+        key_basic_beauty_complex_dict: Dict[str, List[str]],
+        key_in_md_tex: List[str],
+        main_part: List[str],
+        last_part: List[str],
+        bib_in_md: List[str],
+    ) -> List[str]:
+        temp_b = []
+        if self.add_reference_in_md:
+            temp_b = combine_content_in_list([key_basic_beauty_complex_dict[k] for k in key_in_md_tex], ["\n"])
+        content_md = combine_content_in_list([main_part, ["\n"], temp_b, last_part, bib_in_md])
+        return content_md