pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/main/python_run_tex.py

@@ -0,0 +1,149 @@
+import os
+import re
+from typing import Any, Dict, List, Optional
+
+from pyadvtools import (
+    delete_files,
+    insert_list_in_list,
+    read_list,
+    write_list,
+)
+
+from .basic_input import BasicInput
+
+
+class PythonRunTex(BasicInput):
+    """Python tex.
+
+    Args:
+        options (Dict[str, Any]): Options.
+
+    Attributes:
+        run_latex (bool = False): Whether to run latex.
+        pdflatex_xelatex (str = "pdflatex"): pdflatex or xelatex.
+        delete_run_latex_cache (bool = True): Whether to delete run latex cache.
+    """
+
+    def __init__(self, options: Dict[str, Any]) -> None:
+        super().__init__(options)
+
+        # for tex
+        self.final_output_main_tex_name: str = options.get("final_output_main_tex_name", "")
+        self.run_latex: bool = options.get("run_latex", False)
+        self.pdflatex_xelatex: str = options.get("pdflatex_xelatex", "pdflatex")  # pdflatex, xelatex
+        self.delete_run_latex_cache: bool = options.get("delete_run_latex_cache", True)
+        self.latex_clean_file_types: Optional[List[str]] = options.get("latex_clean_file_types", None)
+
+    def generate_standard_tex_data_list(
+        self,
+        data_list_body: List[str],
+        output_tex_name: str,
+        path_output: str,
+        figure_folder_name: str = "figs",
+        tex_folder_name: str = "tex",
+        bib_folder_name: str = "bib",
+        bib_name: str = "abbr.bib",
+        template_name: str = "article",
+    ) -> List[str]:
+        # for figures
+        for i in range(len(data_list_body)):
+            if re.search(r"\\includegraphics", data_list_body[i]):
+                data_list_body[i] = data_list_body[i].replace("./Figures/", f"./{figure_folder_name}/")
+                data_list_body[i] = data_list_body[i].replace("Figures/", f"{figure_folder_name}/")
+        write_list(data_list_body, output_tex_name, "w", os.path.join(path_output, tex_folder_name), False)
+
+        self._special_operate_tex(
+            data_list_body, template_name, output_tex_name, path_output, tex_folder_name, bib_folder_name, bib_name
+        )
+        return data_list_body
+
+    # for tex files
+    def _special_operate_tex(
+        self,
+        data_list_body: List[str],
+        template_name: str,
+        output_tex_name: str,
+        path_output: str,
+        tex_folder_name: str,
+        bib_folder_name: str,
+        bib_name: str,
+    ) -> None:
+        # read template data
+        template_h, template_t = [], []
+        if template_name.lower() == "paper":
+            template_h, template_t = self.article_template_header_tex, self.article_template_tail_tex
+        elif template_name.lower() == "beamer":
+            template_h, template_t = self.beamer_template_header_tex, self.beamer_template_tail_tex
+
+        # style
+        if usepackages := self.usepackages_tex:
+            usepackages.insert(0, "\n")
+
+        # command
+        if math_commands := self.math_commands_tex:
+            math_commands.insert(0, "\n")
+
+        # main name
+        main_name = self.final_output_main_tex_name
+        if len(main_name) == 0:
+            main_name = output_tex_name.split(".text")[0] + "_main.tex"
+        if main_name.lower() == output_tex_name.lower():
+            main_name = main_name.split(".tex")[0] + "_.tex"
+        if main_name[-4:] != ".tex":
+            main_name = main_name + ".tex"
+
+        data_list = []
+        if (len(template_h) != 0) and (len(template_t) != 0):
+            # header
+            data_list = insert_list_in_list(template_h, usepackages, r"\\documentclass", "after")
+            data_list = insert_list_in_list(data_list, math_commands, r"\\documentclass", "after")
+
+            if template_name.lower() == "beamer":
+                data_list = insert_list_in_list(data_list, ["\n\\def\\allfiles{}\n"], r"\\documentclass", "after")
+
+            if self.pdflatex_xelatex == "xelatex":
+                data_list = insert_list_in_list(data_list, ["\n\\def\\cn{}\n"], r"\\documentclass", "after")
+
+            # for bib
+            regex = re.compile(r"\\addbibresource{\./References/References\.bib}")
+            for i in range(len(data_list)):
+                mch = regex.search(data_list[i])
+                if not mch:
+                    continue
+                if bib_folder_name:
+                    data_list[i] = "\\addbibresource{" + f"./{bib_folder_name}/{bib_name}" + "}\n"
+                else:
+                    data_list[i] = "\\addbibresource{" + f"./{bib_name}" + "}\n"
+
+            # body
+            if len(data_list_body) != 0:
+                data_list.append("\n")
+                data_list.extend(data_list_body)
+                data_list.append("\n")
+
+            # tail
+            data_list.extend(template_t)
+
+            # save file
+            write_list(data_list, main_name, "w", path_output, False)
+        else:
+            data_list = read_list(output_tex_name, "r", os.path.join(path_output, tex_folder_name))
+            write_list(data_list, main_name, "w", path_output, False)
+
+        # run latex
+        if self.run_latex:
+            os.chdir(path_output)
+            try:
+                os.system("latexmk -{} {}".format(self.pdflatex_xelatex, main_name))
+            except Exception as e:
+                print(e)
+
+        # delete cache
+        if self.delete_run_latex_cache:
+            if self.latex_clean_file_types is not None:
+                postfix = self.latex_clean_file_types
+            else:
+                postfix = ['.aux', '.bbl', '.bcf', '.blg', '.fdb_latexmk', '.fls', '.log', '.out', '.run.xml']
+                postfix.extend(['.synctex.gz', '.gz', '.nav', '.snm', '.toc', '.xdv'])
+            delete_files(path_output, postfix)
+        return None

pyeasyphd/main/python_writers.py

@@ -0,0 +1,212 @@
+import os
+import re
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from pyadvtools import (
+    write_list,
+)
+
+from ..bib.bibtexparser import BibtexFormat, Block, Library
+from ..bib.core import ConvertLibrayToStr
+from .basic_input import BasicInput
+from .python_run_bib import PythonRunBib
+
+
+class PythonWriters(BasicInput):
+    """Python writers.
+
+    Args:
+        options (Dict[str, Any]): Options.
+
+    Attributes:
+        bib_for_abbr_name (str = "abbr.bib"): Bib for abbr name.
+        bib_for_zotero_name (str = "zotero.bib"): Bib for zotero name.
+        bib_for_save_name (str = "save.bib"): Bib for save name.
+        choose_abbr_zotero_save (str = "save"): Choose "abbr", "zotero", or "save".
+        display_google_connected_scite (List[str] = ["google", "connected", "scite"]): Choose multiple items.
+    """
+
+    def __init__(self, options: Dict[str, Any]) -> None:
+        options["is_sort_entry_fields"] = options.get("is_sort_entry_fields", True)
+        options["is_sort_blocks"] = options.get("is_sort_blocks", True)
+        options["sort_entries_by_field_keys_reverse"] = options.get("sort_entries_by_field_keys_reverse", True)
+        super().__init__(options)
+
+        self.bib_for_abbr_name = options.get("bib_for_abbr_name", "abbr.bib")
+        self.bib_for_zotero_name = options.get("bib_for_zotero_name", "zotero.bib")
+        self.bib_for_save_name = options.get("bib_for_save_name", "save.bib")
+        self.choose_abbr_zotero_save = options.get("choose_abbr_zotero_save", "save")
+
+        self.display_google_connected_scite = options.get(
+            "display_google_connected_scite", ["google", "connected", "scite"]
+        )
+
+        self.bibtex_format_indent = options.get("bibtex_format_indent", "  ")
+        self.bibtex_format_trailing_comma = options.get("bibtex_format_trailing_comma", True)
+        self.bibtex_format_block_separator = options.get("bibtex_format_block_separator", "")
+
+        bibtex_format = BibtexFormat()
+        bibtex_format.indent = self.bibtex_format_indent
+        bibtex_format.block_separator = self.bibtex_format_block_separator
+        bibtex_format.trailing_comma = self.bibtex_format_trailing_comma
+        self.bibtex_format: Optional[BibtexFormat] = bibtex_format
+
+        self._python_bib = PythonRunBib(self.options)
+
+    def write_to_str(self, library: Union[Library, List[Block]]) -> List[str]:
+        """Serialize a BibTeX database to a string.
+
+        Args:
+            library (Library | List[Block]): BibTeX database to serialize.
+            bibtex_format (Optional[BibtexFormat] = None):
+
+        """
+        return ConvertLibrayToStr(self.options).generate_str(library, self.bibtex_format)
+
+    def write_to_file(
+        self,
+        original_data: Union[Library, List[Block], List[str]],
+        file_name: str,
+        write_flag: str = "w",
+        path_storage: Optional[str] = None,
+        check: bool = True,
+        delete_first_empty: bool = True,
+        delete_last_empty: bool = True,
+        compulsory: bool = False,
+        delete_original_file: bool = False,
+    ) -> None:
+        """Write.
+
+        Args:
+            original_data (Union[Library, List[Block], List[str]]): data
+            file_name (str): file name
+            write_flag (str = "w"): write flag
+            path_storage (Optional[str] = None): path storage
+            check (bool = True): check
+            delete_first_empty (bool = True): delete first empty
+            delete_last_empty (bool = True): delete last empty
+            compulsory (bool = False): compulsory
+            delete_original_file (bool = False): delete original file
+            bibtex_format (Optional[BibtexFormat] = None):
+
+        """
+        _options = {}
+        _options.update(self.options)
+        _library_str = ConvertLibrayToStr(_options)
+
+        if isinstance(original_data, Library):
+            data_list = _library_str.generate_str(original_data, self.bibtex_format)
+        elif isinstance(original_data, list):
+            if all([isinstance(line, str) for line in original_data]):
+                data_list = [line for line in original_data if isinstance(line, str)]
+            else:
+                data_list = [line for line in original_data if isinstance(line, Block)]
+                data_list = _library_str.generate_str(data_list, self.bibtex_format)
+
+        write_list(
+            data_list,
+            file_name,
+            write_flag,
+            path_storage,
+            check,
+            delete_first_empty,
+            delete_last_empty,
+            compulsory,
+            delete_original_file,
+        )
+        return None
+
+    def write_multi_library_to_file(
+        self,
+        path_output: str,
+        bib_for_abbr: Union[Library, List[Block]],
+        bib_for_zotero: Union[Library, List[Block]],
+        bib_for_save: Union[Library, List[Block]],
+        given_cite_keys: List[str] = [],
+        **kwargs,
+    ) -> Tuple[str, str, str]:
+        _options = {}
+        _options.update(self.options)
+        _options["keep_entries_by_cite_keys"] = given_cite_keys
+        _options["sort_entries_by_cite_keys"] = given_cite_keys
+
+        bib_abbr = ConvertLibrayToStr(_options).generate_str(bib_for_abbr, **kwargs)
+        write_list(bib_abbr, self.bib_for_abbr_name, "w", path_output, False, **kwargs)
+
+        bib_zotero = ConvertLibrayToStr(_options).generate_str(bib_for_zotero, **kwargs)
+        write_list(bib_zotero, self.bib_for_zotero_name, "w", path_output, False, **kwargs)
+
+        bib_save = ConvertLibrayToStr(_options).generate_str(bib_for_save, **kwargs)
+        write_list(bib_save, self.bib_for_save_name, "w", path_output, False, **kwargs)
+
+        full_bib_for_abbr = os.path.join(path_output, self.bib_for_abbr_name)
+        full_bib_for_zotero = os.path.join(path_output, self.bib_for_zotero_name)
+        full_bib_for_save = os.path.join(path_output, self.bib_for_save_name)
+        return full_bib_for_abbr, full_bib_for_zotero, full_bib_for_save
+
+    def output_key_url_http_bib_dict(self, library: Library) -> Dict[str, List[List[str]]]:
+        _options = {}
+        _options.update(self.options)
+        _options["empty_entry_cite_keys"] = True
+
+        key_url_http_bib_dict: Dict[str, List[List[str]]] = {}
+
+        for key, entry in library.entries_dict.items():
+
+            url = entry["url"] if "url" in entry else ""
+            if len(url) == 0:
+                url = entry["doi"] if "doi" in entry else ""
+                if (len(url) != 0) and (not re.match(r"https*://", url)):
+                    url = f"https://doi.org/{url}"
+
+            link_list = self._generate_link_list(entry)
+            patch_bib = ConvertLibrayToStr(_options).generate_str([entry])
+
+            v: List[List[str]] = [[], [], patch_bib]
+
+            if len(url) != 0:
+                v[0] = [url + "\n"]
+                link_list.insert(0, rf"[www]({url})")
+
+            join_link = []
+            if link_list:
+                for i in range(len(link_list) - 1):
+                    join_link.append(link_list[i].strip() + " |\n")
+                join_link.append(link_list[-1].strip() + "\n")
+
+                join_link[0] = "(" + join_link[0]
+                join_link[-1] = join_link[-1].strip() + ")\n"
+
+                v[1] = join_link
+
+            key_url_http_bib_dict.update({key: v})
+        return key_url_http_bib_dict
+
+    def _generate_link_list(self, entry) -> List[str]:
+        title = entry["title"] if "title" in entry else ""
+        if not title:
+            return []
+
+        title = re.sub(r"\s+", "+", title)
+        url_google = f"https://scholar.google.com/scholar?q={title}"
+        url_connected = f"https://www.connectedpapers.com/search?q={title}"
+        url_scite = f"https://scite.ai/search?q={title}"
+
+        # Search cited number
+        cited_number = entry["annotation"] if "annotation" in entry else ""
+        if cited_number:
+            cited_number = re.sub(r"[^0-9]+", "", cited_number)
+            cited_number = int(cited_number) if cited_number.isdigit() else ""
+            google = f"[Google Scholar: {cited_number}]({url_google})"
+        else:
+            google = f"[Google Scholar]({url_google})"
+
+        connected = f"[Connected Papers]({url_connected})"
+        scite = f"[Scite]({url_scite})"
+
+        link_list = []
+        for i, j in zip(["google", "connected", "scite"], [google, connected, scite]):
+            if i in self.display_google_connected_scite:
+                link_list.append(j)
+
+        return link_list

pyeasyphd/pyeasyphd.py

@@ -0,0 +1,72 @@
+import os
+
+import sublime
+import sublime_plugin
+from pyadvtools import IterateUpdateDict
+
+from pyeasyphd.tools.py_run_bib_md_tex import PyRunBibMdTex
+
+
+def delete_files(path_storage: str, extensions) -> None:
+    """Delete."""
+    for name in os.listdir(path_storage):
+        for ext in extensions:
+            if name.endswith(ext) and os.path.isfile(os.path.join(path_storage, name)):
+                os.remove(os.path.join(path_storage, name))
+
+
+class PypapersCommand(sublime_plugin.WindowCommand):
+    def run(self, template="Paper", output_level="next", delete_cache=False):
+        vars_dict = self.window.extract_variables()
+
+        packages_path = vars_dict["packages"]
+
+        # settings
+        options, default_settings, user_settings, project_settings = {}, {}, {}, {}
+        file_default_settings = os.path.join(packages_path, "pypapers", "pypapers.sublime-settings")
+        if os.path.exists(file_default_settings):
+            default_settings = sublime.decode_value(open(file_default_settings).read())
+
+        file_user_settings = os.path.join(packages_path, "User", "PyPapers.sublime-settings")
+        if os.path.exists(file_user_settings):
+            user_settings = sublime.decode_value(open(file_user_settings).read())
+
+        project_settings = self.window.project_data().get("settings", {})
+
+        iter_update_dict = IterateUpdateDict()
+        options = iter_update_dict.dict_update(options, default_settings)
+        options = iter_update_dict.dict_update(options, user_settings)
+        options = iter_update_dict.dict_update(options, project_settings)
+
+        # update
+        for key in vars_dict:
+            if isinstance(vars_dict[key], str):
+                os.environ[key] = vars_dict[key]
+
+        for key in options:
+            if isinstance(options[key], str):
+                options[key] = os.path.expandvars(os.path.expanduser(options[key]))
+
+        if delete_cache:
+            file_path = vars_dict['file_path']
+
+            if latex_clean_file_types := options.get('latex_clean_file_types', []):
+                postfix = latex_clean_file_types
+            else:
+                postfix = ['.aux', '.bbl', '.bcf', '.blg', '.fdb_latexmk', '.fls', '.log', '.out', '.run.xml']
+                postfix.extend(['.synctex.gz', '.gz', '.nav', '.snm', '.toc', '.xdv'])
+
+            delete_files(file_path, postfix)
+            delete_files(os.path.dirname(file_path), postfix)
+
+        else:
+            # main
+            path_output = options.get("path_output", "")
+            if len(path_output.strip()) == 0:
+                path_output = vars_dict["file_path"]
+
+            p_r_l_m = PyRunBibMdTex(path_output, vars_dict["file_extension"], template, options)
+            p_r_l_m.run_files([vars_dict["file"]], vars_dict["file_base_name"], output_level)
+
+        # display
+        self.window.status_message('Successful.')

pyeasyphd/pyeasyphd.sublime-settings

@@ -0,0 +1,235 @@
+{
+    // config
+    // config path
+    "path_config": "",
+
+    // figures, templates, bibs
+    "path_bibs": "",
+    "path_figures": "",
+    "path_templates": "",
+
+    // pypapers/bib/core/convert_str_to_str.py
+    "default_additional_field_list": [],
+
+    // pypapers/bib/bibtexparser/middlewares_str_to_str.py
+    "substitute_in_bib": true,
+    "substitute_old_list": [],
+    "substitute_new_list": [],
+
+
+    // pypapers/bib/core/convert_str_to_library.py
+    "is_standardize_bib": true,
+
+    // pypapers/bib/bibtexparser/middlewares_str_to_library.py
+    "is_display_implicit_comments": true,
+
+
+    // pypapers/bib/core/convert_library_to_library.py
+    // "abbr", "zotero", or "save"
+    "choose_abbr_zotero_save": "save",
+
+    // pypapers/bib/bibtexparser/middlewares_library_to_library.py
+    "function_common_again": true,
+    "function_common_again_abbr": true,
+    "function_common_again_zotero": true,
+    "function_common_again_save": true,
+    // "is_sort_entry_fields": false,
+    // "is_sort_blocks": false,
+    // "sort_entries_by_cite_keys": [],
+    // "sort_entries_by_field_keys": ["year", "volume", "number", "month", "pages"],
+    // "sort_entries_by_field_keys_reverse": false,
+
+    // for common
+    "lower_entry_type": true,
+    "lower_entry_field_key": true,
+    "keep_entries_by_cite_keys": [],
+    "update_month_year": true,
+    "update_number_volume": true,
+    "update_pages": true,
+    "update_title": true,
+    "sentence_title_case": true,
+    "generate_entry_cite_keys": false,
+    "full_abbr_article_dict": {},
+    "full_abbr_inproceedings_dict": {},
+    "full_names_in_json": "names_full",
+    "abbr_names_in_json": "names_abbr",
+
+    // special for abbr
+    // abbreviate
+    "full_to_abbr_for_abbr": true,
+    // 0, 1, 2
+    "abbr_index_article_for_abbr": 1,
+    "abbr_index_inproceedings_for_abbr": 2,
+
+    // format doi and url
+    // keep only doi or url
+    "doi_or_url_for_abbr": true,
+    // change doi to url format (https://doi.org/xxx)
+    "doi_to_url_for_abbr": true,
+    // add link to fields
+    "add_link_to_fields_for_abbr": null,
+
+    // keep some fields for abbr
+    // true, false
+    "keep_fields_for_abbr": true,
+    "keep_entry_list_for_abbr": ["article", "inproceedings", "incollection", "misc", "book", "phdthesis", "mastersthesis", "techreport"],
+    "keep_field_list_list_for_abbr": [
+        ["author", "title", "year", "month", "journal", "pages", "volume", "number", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "booktitle", "pages", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "booktitle", "pages", "publisher", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "publisher", "howpublished", "pages", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "publisher", "edition", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "type", "school", "address", "pages", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "type", "school", "address", "pages", "doi", "url", "annotation"],
+        ["author", "title", "year", "month", "type", "institution", "address", "pages", "doi", "url", "annotation"],
+    ],
+
+    // delete fields list for abbr
+    "delete_fields_list_for_abbr": [],
+
+    // replace some fields for abbr
+    "replace_fields_for_abbr": true,
+    "replace_old_field_list_for_abbr": [["publisher"]],
+    "replace_new_field_list_for_abbr": [["howpublished"]],
+    "replace_entry_list_for_abbr": ["misc"],
+    // constrain the number of authors for abbr
+    "maximum_authors_for_abbr": 0,
+
+    // special for zotero
+    // format doi and url
+    "doi_or_url_for_zotero": true,
+
+    // keep some fields for zotero
+    // true, false
+    "keep_fields_for_zotero": true,
+    "keep_entry_list_for_zotero": ["article", "inproceedings", "incollection", "misc", "book", "phdthesis", "mastersthesis", "techreport"],
+    "keep_field_list_list_for_zotero": [
+        ["abstract", "author", "title", "year", "month", "journal", "pages", "volume", "number", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "booktitle", "pages", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "booktitle", "pages", "publisher", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "publisher", "pages", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "publisher", "edition", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "type", "school", "address", "pages", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "type", "school", "address", "pages", "doi", "url", "annotation"],
+        ["abstract", "author", "title", "year", "month", "type", "institution", "address", "pages", "doi", "url", "annotation"],
+    ],
+
+    // delete fields list for zotero
+    "delete_fields_list_for_zotero": [],
+
+    // delete redundant in `journal` or `booktitle`
+    "delete_redundant_in_journal_booktitle": true,
+
+    // title (lower, upper) journal and booktitle
+    "title_journal_booktitle_for_zotero": true,
+
+    // add field 'archive'.
+    "add_archive_for_zotero": true,
+
+    // add field 'journal abbreviation'.
+    "add_journal_abbr_for_zotero": true,
+
+    // special for save
+    // delete fields list for save
+    "delete_fields_list_for_save": [],
+
+
+    // pypapers/bib/core/convert_library_to_str.py
+    "is_standardize_library": false,
+    "empty_entry_cite_keys": false,
+    "add_index_to_entries": false,
+    "entries_necessary": true,
+
+    // pypapers/bib/bibtexparser/middlewares_library_to_str.py
+    "is_sort_entry_fields": true,
+    "is_sort_blocks": true,
+    "sort_entries_by_cite_keys": [],
+    "sort_entries_by_field_keys": ["year", "volume", "number", "month", "pages"],
+    "sort_entries_by_field_keys_reverse": true,
+
+
+    // pypapers/main/pandoc_md_to.py
+    // for pandoc
+    "csl_name": "apa-no-ampersand",
+    // the number of columns in md files
+    "columns_in_md": 120,
+    // display one line reference note
+    "google_connected_paper_scite": true,
+    "display_one_line_reference_note": false,
+    // "fullcite", "cite"
+    "cite_flag_in_tex": "cite",
+
+    // for bib file
+    // pypapers/main/python_writers.py
+    // "abbr.bib", "zotero.bib", "save.bib"
+    "bib_for_abbr_name": "abbr.bib",
+    "bib_for_zotero_name": "zotero.bib",
+    "bib_for_save_name": "save.bib",
+    // "choose_abbr_zotero_save": "save",
+    // choose multiple items ["google", "connected", "scite"]
+    "display_google_connected_scite": ["google", "connected", "scite"],
+    // bib format
+    "bibtex_format_indent": "  ",
+    "bibtex_format_trailing_comma": true,
+    "bibtex_format_block_separator": "",
+
+    // for md file
+    // pypapers/main/python_run_md.py
+    // default is ""
+    "final_output_main_md_name": "",
+    // true, false
+    "delete_temp_generate_md": true,
+    // add reference to markdown files
+    "add_reference_in_md": true,
+    // add bib to markdown files
+    "add_bib_in_md": false,
+    // true, false
+    "replace_cite_to_fullcite_in_md": false,
+    // basic, beauty, complex
+    "replace_by_basic_beauty_complex_in_md": "beauty",
+    // basic, beauty, complex
+    "display_basic_beauty_complex_references_in_md": "beauty",
+
+    // for tex file
+    // pypapers/main/python_run_tex.py
+    // handly preamble
+    "handly_preamble": false,
+
+    // default is ""
+    "final_output_main_tex_name": "",
+    // true, false
+    "run_latex": false,
+    // "pdflatex", "xelatex"
+    "pdflatex_xelatex": "pdflatex",
+    // true, false
+    "delete_run_latex_cache": true,
+    "latex_clean_file_types": [
+        ".aux", ".bbl", ".bcf", ".blg", ".fdb_latexmk", ".fls", ".log", ".out", ".run.xml", ".synctex.gz", ".gz",
+        ".nav", ".snm", ".toc", ".xdv"
+    ],
+
+    // pypapers/tools/python_run_latex_md.py
+    // true, false
+    "generate_html": false,
+
+    // true, false
+    "generate_tex": true,
+
+    // ture, false
+    "shutil_figures": true,
+
+    // for figure, bib, tex, and md
+    "figure_folder_name": "fig", // "" or "figs" or "main"
+    "bib_folder_name": "bib", // "" or "bibs" or "main"
+    "md_folder_name": "md", // "" or "mds" or "main"
+    "tex_folder_name": "tex", // "" or "texes" or "main"
+
+    // for delete original md, tex, and bib files in output folder
+    "delete_original_md_in_output_folder": false,
+    "delete_original_tex_in_output_folder": false,
+    "delete_original_bib_in_output_folder": false,
+
+    // pypapers/pypapers.py
+    // default is the same with the active file
+    "path_output": "",
+}

pyeasyphd/pyeasyphd.sublime-syntax

@@ -0,0 +1,5 @@
+%YAML 1.2
+---
+name: pyeasyphd
+file_extensions: [py]
+scope: source.python