pyeasyphd 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

pyeasyphd/main/__init__.py

@@ -1,11 +1,10 @@
-"""Initialization."""
+"""Main module for PyEasyPhD core functionality.
 
-__all__ = [
-    "BasicInput",
-    "PandocMdTo",
-    "PythonRunMd",
-    "PythonRunTex",
-]
+This module contains the core classes for processing academic papers,
+managing bibliographies, and converting between different formats.
+"""
+
+__all__ = ["BasicInput", "PandocMdTo", "PythonRunMd", "PythonRunTex"]
 
 from .basic_input import BasicInput
 from .pandoc_md_to import PandocMdTo

pyeasyphd/main/basic_input.py

@@ -1,71 +1,43 @@
 import os
 from typing import Any, Dict
 
-from pyadvtools import read_list, standard_path
+from pyadvtools import read_list
 from pybibtexer.main import BasicInput as BasicInputInPyBibtexer
 
 
 class BasicInput(BasicInputInPyBibtexer):
-    """Basic input.
+    """Basic input class for handling bibliography and template configurations.
 
     Args:
-        options (Dict[str, Any]): Options.
+        options (Dict[str, Any]): Configuration options.
 
     Attributes:
-        path_bibs (str): Path bibs.
-        path_figures (str): Path figures.
-        path_templates (str): Path templates.
-
-        full_csl_style_pandoc (str): Full path to csl style for pandoc.
+        full_json_c (str): Full path to conferences JSON file.
+        full_json_j (str): Full path to journals JSON file.
+        full_csl_style_pandoc (str): Full path to CSL style for pandoc.
         full_tex_article_template_pandoc (str): Full path to tex article template for pandoc.
-        article_template_tex (List[str]): Article template for LaTex.
-
-        article_template_header_tex (List[str]): Article template header for LaTex.
-        article_template_tail_tex (List[str]): Article template tail for LaTex.
-        beamer_template_header_tex (List[str]): Beamer template header for LaTex.
-        beamer_template_tail_tex (List[str]): Beamer template tail for LaTex.
-        math_commands_tex (List[str]): Tex math commands for LaTex.
-        usepackages_tex (List[str]): Tex usepackages for LaTex.
-        handly_preamble (bool): Handly preamble.
-
-        options (Dict[str, Any]): Options.
+        full_tex_beamer_template_pandoc (str): Full path to tex beamer template for pandoc.
+        article_template_tex (List[str]): Article template for LaTeX.
+        article_template_header_tex (List[str]): Article template header for LaTeX.
+        article_template_tail_tex (List[str]): Article template tail for LaTeX.
+        beamer_template_header_tex (List[str]): Beamer template header for LaTeX.
+        beamer_template_tail_tex (List[str]): Beamer template tail for LaTeX.
+        math_commands_tex (List[str]): LaTeX math commands.
+        usepackages_tex (List[str]): LaTeX usepackages.
+        handly_preamble (bool): Whether to handle preamble manually.
+        options (Dict[str, Any]): Configuration options.
     """
 
     def __init__(self, options: Dict[str, Any]) -> None:
-        # The paths of Figures, Bibs, and Templates
-        self.path_bibs: str = standard_path(options.get("path_bibs", ""))
-        self.path_figures: str = standard_path(options.get("path_figures", ""))
-        self.path_templates: str = standard_path(options.get("path_templates", ""))
-
-        # Update
-        path_config = standard_path(options.get("path_config", ""))
-        if len(self.path_bibs) == 0:
-            for folder in [
-                "bib", "bibs", "Bib", "Bibs", "BIB", "BIBS",
-                "reference", "references", "Reference", "References", "REFERENCE", "REFERENCES"
-            ]:
-                if os.path.exists(p := os.path.join(path_config, folder)):
-                    self.path_bibs = p
-                    break
-
-        if len(self.path_figures) == 0:
-            for folder in [
-                "figure", "figures", "Figure", "Figures", "FIGURE", "FIGURES",
-                "fig", "figs", "Fig", "Figs", "FIG", "FIGS",
-            ]:
-                if os.path.exists(p := os.path.join(path_config, folder)):
-                    self.path_figures = p
-                    break
-
-        if len(self.path_templates) == 0:
-            for folder in ["template", "templates", "Template", "Templates", "TEMPLATE", "TEMPLATES"]:
-                if os.path.exists(p := os.path.join(path_config, folder)):
-                    self.path_templates = p
-                    break
-
-        full_json_c = os.path.join(self.path_templates, "AbbrFull", "conferences.json")
-        full_json_j = os.path.join(self.path_templates, "AbbrFull", "journals.json")
-        super().__init__(full_json_c, full_json_j, options)
+        """Initialize BasicInput with configuration options.
+
+        Args:
+            options (Dict[str, Any]): Configuration options dictionary.
+        """
+        super().__init__(options)
+
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        self._path_templates = os.path.join(os.path.dirname(current_dir), "data", "Templates")
 
         # main
         self._initialize_pandoc_md_to(options)
@@ -73,31 +45,36 @@ class BasicInput(BasicInputInPyBibtexer):
 
         self.options = options
 
-    # main
     def _initialize_pandoc_md_to(self, options: Dict[str, Any]) -> None:
+        """Initialize pandoc markdown to other formats configuration.
+
+        Args:
+            options (Dict[str, Any]): Configuration options.
+        """
         csl_name = options.get("csl_name", "apa-no-ampersand")
-        if len(csl_name) == 0:
+        if not isinstance(csl_name, str):
             csl_name = "apa-no-ampersand"
+        self.full_csl_style_pandoc = os.path.join(self._path_templates, "CSL", f"{csl_name}.csl")
+        if not os.path.exists(self.full_csl_style_pandoc):
+            self.full_csl_style_pandoc = os.path.join(self._path_templates, "CSL", "apa-no-ampersand.csl")
 
-        full_csl_style_pandoc = os.path.join(self.path_templates, "CSL", f"{csl_name}.csl")
-        if (p := options.get("full_csl")) is not None:
-            full_csl_style_pandoc = p
-        self.full_csl_style_pandoc = full_csl_style_pandoc
-
-        full_tex_article_template_pandoc = os.path.join(self.path_templates, "TEX", "eisvogel.tex")
-        if (p := options.get("full_eisvogel")) is not None:
-            full_tex_article_template_pandoc = p
-        self.full_tex_article_template_pandoc = full_tex_article_template_pandoc
+        self.full_tex_article_template_pandoc = os.path.join(self._path_templates, "TEX", "eisvogel.latex")
+        self.full_tex_beamer_template_pandoc = os.path.join(self._path_templates, "TEX", "eisvogel.beamer")
 
-        self.article_template_tex = self._try_read_list(options, "TEX", "Article.tex", "full_article")
+        self.article_template_tex = self._try_read_list("TEX", "Article.tex")
 
     def _initialize_python_run_tex(self, options: Dict[str, Any]) -> None:
-        self.article_template_header_tex = self._try_read_list(options, "TEX", "Article_Header.tex", "full_article_header")
-        self.article_template_tail_tex = self._try_read_list(options, "TEX", "Article_Tail.tex", "full_article_tail")
-        self.beamer_template_header_tex = self._try_read_list(options, "TEX", "Beamer_Header.tex", "full_beamer_header")
-        self.beamer_template_tail_tex = self._try_read_list(options, "TEX", "Beamer_Tail.tex", "full_beamer_tail")
-        self.math_commands_tex = self._try_read_list(options, "TEX", "math_commands.tex", "full_math_commands")
-        self.usepackages_tex = self._try_read_list(options, "TEX", "Style.tex", "full_usepackages_tex")
+        """Initialize Python LaTeX processing configuration.
+
+        Args:
+            options (Dict[str, Any]): Configuration options.
+        """
+        self.article_template_header_tex = self._try_read_list("TEX", "Article_Header.tex")
+        self.article_template_tail_tex = self._try_read_list("TEX", "Article_Tail.tex")
+        self.beamer_template_header_tex = self._try_read_list("TEX", "Beamer_Header.tex")
+        self.beamer_template_tail_tex = self._try_read_list("TEX", "Beamer_Tail.tex")
+        self.math_commands_tex = self._try_read_list("TEX", "math_commands.tex")
+        self.usepackages_tex = self._try_read_list("TEX", "Style.tex")
 
         # handly preamble
         self.handly_preamble = options.get("handly_preamble", False)
@@ -106,12 +83,17 @@ class BasicInput(BasicInputInPyBibtexer):
             self.beamer_template_header_tex, self.beamer_template_tail_tex = [], []
             self.math_commands_tex, self.usepackages_tex = [], []
 
-    def _try_read_list(self, options: Dict[str, Any], folder_name: str, file_name: str, key: str):
-        path_file = os.path.join(self.path_templates, folder_name, file_name)
-        if (p := options.get(key)) is None:
-            return []
-        else:
-            path_file = p
+    def _try_read_list(self, folder_name: str, file_name: str):
+        """Try to read a list from a file in the templates directory.
+
+        Args:
+            folder_name (str): Name of the folder in templates directory.
+            file_name (str): Name of the file to read.
+
+        Returns:
+            List[str]: List of lines from the file, or empty list if file cannot be read.
+        """
+        path_file = os.path.join(self._path_templates, folder_name, file_name)
 
         try:
             data_list = read_list(path_file)

pyeasyphd/main/pandoc_md_to.py

@@ -19,21 +19,26 @@ from .basic_input import BasicInput
 
 
 class PandocMdTo(BasicInput):
-    """Pandoc md to md, tex, html, pdf and so on.
+    """Pandoc markdown to various formats (md, tex, html, pdf).
 
     Args:
-        options (dict): Options.
+        options (dict): Configuration 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.
+        markdown_name (str): Markdown name. Defaults to "multi-markdown".
+        markdown_citation (str): Markdown citation format. Defaults to "markdown_mmd".
+        columns_in_md (int): Number of columns in markdown. Defaults to 120.
+        google_connected_paper_scite (bool): Whether to use Google connected paper scite. Defaults to True.
+        display_one_line_reference_note (bool): Whether to display one line reference note. Defaults to False.
+        cite_flag_in_tex (str): Citation flag in LaTeX. Defaults to "cite".
     """
 
     def __init__(self, options: dict) -> None:
+        """Initialize PandocMdTo with configuration options.
+
+        Args:
+            options (dict): Configuration options.
+        """
         super().__init__(options)
 
         self.markdown_name: str = "multi-markdown"
@@ -47,21 +52,36 @@ class PandocMdTo(BasicInput):
         # 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],
+        self, path_bib: str, path_md_one: str, path_md_two: str, name_md_one: Optional[str], name_md_two: Optional[str]
     ) -> List[str]:
+        """Convert markdown to markdown using pandoc.
+
+        Args:
+            path_bib (str): Path to bibliography file.
+            path_md_one (str): Path to source markdown directory.
+            path_md_two (str): Path to destination markdown directory.
+            name_md_one (Optional[str]): Name of source markdown file.
+            name_md_two (Optional[str]): Name of destination markdown file.
+
+        Returns:
+            List[str]: List of processed markdown content lines.
+        """
         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."""
+        """Internal method to convert markdown to markdown using pandoc.
+
+        Args:
+            full_md_one (str): Full path to source markdown file.
+            full_md_two (str): Full path to destination markdown file.
+            path_bib (str): Path to bibliography file.
+
+        Returns:
+            List[str]: List of processed markdown content lines.
+        """
         if not os.path.exists(path_two := os.path.dirname(full_md_two)):
             os.makedirs(path_two)
 
@@ -79,7 +99,7 @@ class PandocMdTo(BasicInput):
             )
 
         try:
-            subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+            subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             print("Pandoc error in pandoc md to md:", e.stderr)
 
@@ -99,12 +119,7 @@ class PandocMdTo(BasicInput):
 
     # 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],
+        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)
@@ -121,7 +136,7 @@ class PandocMdTo(BasicInput):
             cmd = f"pandoc {full_md} -o {full_tex} --from markdown "
 
         try:
-            subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+            subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             print("Pandoc error in pandoc md to tex:", e.stderr)
 
@@ -155,7 +170,7 @@ class PandocMdTo(BasicInput):
         cmd = f"pandoc {full_md} -o {full_html} --from markdown "
 
         try:
-            subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+            subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             print("Pandoc error in pandoc md to html:", e.stderr)
 
@@ -167,13 +182,7 @@ class PandocMdTo(BasicInput):
         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:
+    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)
@@ -192,7 +201,7 @@ class PandocMdTo(BasicInput):
             cmd = f"pandoc {full_md} -o {full_pdf} --from markdown  --listings --pdf-engine=xelatex"
 
         try:
-            subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+            subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
         except subprocess.CalledProcessError as e:
             print("Pandoc error in pandoc md to pdf:", e.stderr)
 
@@ -203,17 +212,13 @@ class PandocMdTo(BasicInput):
     # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
     # md
     def generate_key_data_dict(
-        self,
-        pandoc_md_data_list: List[str],
-        key_url_http_bib_dict: Dict[str, List[List[str]]],
+        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)
+        (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(
@@ -281,9 +286,7 @@ class PandocMdTo(BasicInput):
         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],
+        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"]
@@ -331,9 +334,7 @@ class PandocMdTo(BasicInput):
         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(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

pyeasyphd/main/python_run_md.py

@@ -5,12 +5,7 @@ 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 pyadvtools import combine_content_in_list, delete_empty_lines_last_occur_add_new_line, read_list, write_list
 from pybibtexer.bib.core import ConvertStrToLibrary
 from pybibtexer.main.python_writers import PythonWriters
 
@@ -19,21 +14,26 @@ from .pandoc_md_to import PandocMdTo
 
 
 class PythonRunMd(BasicInput):
-    """Python markdown.
+    """Python markdown processing class.
 
     Args:
-        options (Dict[str, Any]): Options.
+        options (Dict[str, Any]): Configuration 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.
+        delete_temp_generate_md (bool): Whether to delete temporary generated markdown files. Defaults to True.
+        add_reference_in_md (bool): Whether to add references in markdown. Defaults to True.
+        add_bib_in_md (bool): Whether to add bibliography in markdown. Defaults to False.
+        replace_cite_to_fullcite_in_md (bool): Whether to replace citations with full citations in markdown. Defaults to False.
+        replace_by_basic_beauty_complex_in_md (str): Replace by basic, beauty, or complex format. Defaults to "beauty".
+        display_basic_beauty_complex_references_in_md (str): Display basic, beauty, or complex references. Defaults to "beauty".
     """
 
     def __init__(self, options: Dict[str, Any]) -> None:
+        """Initialize PythonRunMd with configuration options.
+
+        Args:
+            options (Dict[str, Any]): Configuration options.
+        """
         super().__init__(options)
 
         # for md
@@ -56,7 +56,6 @@ class PythonRunMd(BasicInput):
         _options.update(options)
         self._generate_library = ConvertStrToLibrary(_options)
 
-    # for markdown files
     def special_operate_for_md(
         self,
         path_output: str,
@@ -66,9 +65,23 @@ class PythonRunMd(BasicInput):
         full_bib_for_zotero: str,
         template_name: str = "article",
         generate_html: bool = False,
-        generate_tex: bool = True
+        generate_tex: bool = True,
     ) -> Tuple[List[str], List[str]]:
-        """Markdown."""
+        """Perform special operations on markdown files.
+
+        Args:
+            path_output (str): Path to output directory.
+            data_list_md (List[str]): List of markdown content lines.
+            output_md_name (str): Name of output markdown file.
+            full_bib_for_abbr (str): Path to abbreviated bibliography file.
+            full_bib_for_zotero (str): Path to Zotero bibliography file.
+            template_name (str, optional): Name of template to use. Defaults to "article".
+            generate_html (bool, optional): Whether to generate HTML. Defaults to False.
+            generate_tex (bool, optional): Whether to generate LaTeX. Defaults to True.
+
+        Returns:
+            Tuple[List[str], List[str]]: Tuple containing processed markdown and LaTeX content.
+        """
         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)
@@ -118,12 +131,19 @@ class PythonRunMd(BasicInput):
         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,
+        self, output_md_name: str, path_temp: str, full_bib_for_abbr: str, full_bib_for_zotero: str
     ) -> List[str]:
+        """Perform special operations for markdown processing.
+
+        Args:
+            output_md_name (str): Name of output markdown file.
+            path_temp (str): Path to temporary directory.
+            full_bib_for_abbr (str): Path to abbreviated bibliography file.
+            full_bib_for_zotero (str): Path to Zotero bibliography file.
+
+        Returns:
+            List[str]: List of processed markdown content lines.
+        """
         # 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)
@@ -135,7 +155,7 @@ class PythonRunMd(BasicInput):
         _options = {}
         _options.update(self.options)
         _options["add_index_to_enties"] = False
-        _python_writers = PythonWriters(self.full_json_c, self.full_json_j, _options)
+        _python_writers = PythonWriters(_options)
         key_url_http_bib_dict = _python_writers.output_key_url_http_bib_dict(library)
 
         content_md = []
@@ -214,7 +234,16 @@ class PythonRunMd(BasicInput):
 
     @staticmethod
     def _special_format(temp_list: List[str], space_one: str, space_two: str) -> List[str]:
-        # special format for alignment
+        """Apply special formatting for alignment.
+
+        Args:
+            temp_list (List[str]): List of strings to format.
+            space_one (str): First space string.
+            space_two (str): Second space string.
+
+        Returns:
+            List[str]: Formatted list of strings.
+        """
         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]
@@ -228,6 +257,18 @@ class PythonRunMd(BasicInput):
         last_part: List[str],
         bib_in_md: List[str],
     ) -> List[str]:
+        """Generate markdown content from various components.
+
+        Args:
+            key_basic_beauty_complex_dict (Dict[str, List[str]]): Dictionary of formatted references.
+            key_in_md_tex (List[str]): List of citation keys in markdown/LaTeX.
+            main_part (List[str]): Main content part.
+            last_part (List[str]): Last content part.
+            bib_in_md (List[str]): Bibliography content for markdown.
+
+        Returns:
+            List[str]: Generated markdown content.
+        """
         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"])

pyeasyphd/main/python_run_tex.py

@@ -1,31 +1,32 @@
 import os
 import re
+import shutil
 import subprocess
 from typing import Any, Dict, List, Optional
 
-from pyadvtools import (
-    delete_files,
-    insert_list_in_list,
-    read_list,
-    write_list,
-)
+from pyadvtools import delete_files, insert_list_in_list, read_list, write_list
 
 from .basic_input import BasicInput
 
 
 class PythonRunTex(BasicInput):
-    """Python tex.
+    """Python LaTeX processing class.
 
     Args:
-        options (Dict[str, Any]): Options.
+        options (Dict[str, Any]): Configuration 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.
+        run_latex (bool): Whether to run LaTeX compilation. Defaults to False.
+        pdflatex_xelatex (str): LaTeX engine to use ('pdflatex' or 'xelatex'). Defaults to "pdflatex".
+        delete_run_latex_cache (bool): Whether to delete LaTeX cache files. Defaults to True.
     """
 
     def __init__(self, options: Dict[str, Any]) -> None:
+        """Initialize PythonRunTex with configuration options.
+
+        Args:
+            options (Dict[str, Any]): Configuration options.
+        """
         super().__init__(options)
 
         # for tex
@@ -46,10 +47,27 @@ class PythonRunTex(BasicInput):
         bib_name: str = "abbr.bib",
         template_name: str = "article",
     ) -> List[str]:
+        """Generate standard LaTeX data list with proper formatting.
+
+        Args:
+            data_list_body (List[str]): List of body content strings.
+            output_tex_name (str): Name of output LaTeX file.
+            path_output (str): Path to output directory.
+            figure_folder_name (str, optional): Name of figures folder. Defaults to "figs".
+            tex_folder_name (str, optional): Name of LaTeX folder. Defaults to "tex".
+            bib_folder_name (str, optional): Name of bibliography folder. Defaults to "bib".
+            bib_name (str, optional): Name of bibliography file. Defaults to "abbr.bib".
+            template_name (str, optional): Name of template to use. Defaults to "article".
+
+        Returns:
+            List[str]: List of processed LaTeX content strings.
+        """
         # 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(f".{os.sep}Figures{os.sep}", f".{os.sep}{figure_folder_name}{os.sep}")
+                data_list_body[i] = data_list_body[i].replace(
+                    f".{os.sep}Figures{os.sep}", f".{os.sep}{figure_folder_name}{os.sep}"
+                )
                 data_list_body[i] = data_list_body[i].replace(f"Figures{os.sep}", f"{figure_folder_name}{os.sep}")
         write_list(data_list_body, output_tex_name, "w", os.path.join(path_output, tex_folder_name), False)
 
@@ -58,7 +76,6 @@ class PythonRunTex(BasicInput):
         )
         return data_list_body
 
-    # for tex files
     def _special_operate_tex(
         self,
         data_list_body: List[str],
@@ -69,6 +86,17 @@ class PythonRunTex(BasicInput):
         bib_folder_name: str,
         bib_name: str,
     ) -> None:
+        """Perform special operations on LaTeX files.
+
+        Args:
+            data_list_body (List[str]): List of body content strings.
+            template_name (str): Name of template to use.
+            output_tex_name (str): Name of output LaTeX file.
+            path_output (str): Path to output directory.
+            tex_folder_name (str): Name of LaTeX folder.
+            bib_folder_name (str): Name of bibliography folder.
+            bib_name (str): Name of bibliography file.
+        """
         # read template data
         template_h, template_t = [], []
         if template_name.lower() == "paper":
@@ -133,19 +161,22 @@ class PythonRunTex(BasicInput):
 
         # run latex
         if self.run_latex:
-            os.chdir(path_output)
-            cmd = "latexmk -{} {}".format(self.pdflatex_xelatex, main_name)
-            try:
-                subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
-            except subprocess.CalledProcessError as e:
-                print("Error in Run LaTex:", e.stderr)
+            if shutil.which("latexmk"):
+                os.chdir(path_output)
+                cmd = "latexmk -{} {}".format(self.pdflatex_xelatex, main_name)
+                try:
+                    subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
+                except subprocess.CalledProcessError as e:
+                    print("Error in Run LaTex:", e.stderr)
+            else:
+                print("latexmk not found. Please install Texlive.")
 
         # 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'])
+                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