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

pyeasyphd/main/python_run_tex.py

@@ -1,37 +1,38 @@
 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
         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.pdflatex_xelatex: str = options.get("pdflatex_xelatex", "xelatex")  # 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)
 
@@ -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

pyeasyphd/pyeasyphd.py

@@ -8,7 +8,12 @@ from pyeasyphd.tools.py_run_bib_md_tex import PyRunBibMdTex
 
 
 def delete_files(path_storage: str, extensions) -> None:
-    """Delete."""
+    """Delete files with specified extensions from storage path.
+
+    Args:
+        path_storage (str): Path to the storage directory.
+        extensions: List of file extensions to 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)):
@@ -16,7 +21,16 @@ def delete_files(path_storage: str, extensions) -> None:
 
 
 class PypapersCommand(sublime_plugin.WindowCommand):
+    """Sublime Text command for processing papers with various templates."""
+
     def run(self, template="Paper", output_level="next", delete_cache=False):
+        """Run the paper processing command.
+
+        Args:
+            template (str, optional): Template type to use. Defaults to "Paper".
+            output_level (str, optional): Output level for processing. Defaults to "next".
+            delete_cache (bool, optional): Whether to delete cache files. Defaults to False.
+        """
         vars_dict = self.window.extract_variables()
 
         packages_path = vars_dict["packages"]
@@ -48,13 +62,13 @@ class PypapersCommand(sublime_plugin.WindowCommand):
                 options[key] = os.path.expandvars(os.path.expanduser(options[key]))
 
         if delete_cache:
-            file_path = vars_dict['file_path']
+            file_path = vars_dict["file_path"]
 
-            if latex_clean_file_types := options.get('latex_clean_file_types', []):
+            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'])
+                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)
@@ -69,4 +83,4 @@ class PypapersCommand(sublime_plugin.WindowCommand):
             p_r_l_m.run_files([vars_dict["file"]], vars_dict["file_base_name"], output_level)
 
         # display
-        self.window.status_message('Successful.')
+        self.window.status_message("Successful.")

pyeasyphd/pyeasyphd.sublime-settings

@@ -1,14 +1,4 @@
 {
-    // config
-    // config path
-    // Must be configured by the user.
-    "path_config": "",
-
-    // figures, templates, bibs
-    "path_bibs": "",
-    "path_figures": "",
-    "path_templates": "",
-
     // pyeasyphd/main/pandoc_md_to.py
     // for pandoc
     "csl_name": "apa-no-ampersand",
@@ -47,7 +37,7 @@
     // true, false
     "run_latex": false,
     // "pdflatex", "xelatex"
-    "pdflatex_xelatex": "pdflatex",
+    "pdflatex_xelatex": "xelatex",
     // true, false
     "delete_run_latex_cache": true,
     "latex_clean_file_types": [

pyeasyphd/tools/__init__.py

@@ -1,13 +1,10 @@
-"""Initialization."""
+"""Tools module for PyEasyPhD advanced functionality.
 
-__all__ = [
-    "PyRunBibMdTex",
+This module provides advanced tools for bibliography processing,
+search functionality, and content generation.
+"""
 
-    "Searchkeywords",
-
-    "generate_from_bibs_and_write",
-    "PaperLinksGenerator",
-]
+__all__ = ["PyRunBibMdTex", "Searchkeywords", "generate_from_bibs_and_write", "PaperLinksGenerator"]
 
 from .generate.generate_from_bibs import generate_from_bibs_and_write
 from .generate.generate_links import PaperLinksGenerator

pyeasyphd/tools/generate/generate_from_bibs.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Union
 from pyadvtools import standard_path, write_list
 from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
 
-from ...main import BasicInput, PandocMdTo
+from ...main import PandocMdTo
 from .generate_html import generate_html_content, generate_html_from_bib_data
 from .generate_library import generate_library_by_filters
 
@@ -21,20 +21,26 @@ def preparation(
 ):
     """Prepare paths and flags for data generation.
 
-    Examples
-    --------
-    |              | current_issue | current_month | all_months |
-    |--------------|---------------|---------------|------------|
-    | current_year | YES           | YES           | YES        |
-    | all_years    | NO            | NO            | YES        |
-    | given_years  | NO            | NO            | YES        |
-
-    given_years = ["2020", "2025"]
-
-    Returns
-    -------
-    Tuple[str, str, bool]
-        Returns (path_root, path_output, combine_flag)
+    Args:
+        path_storage (str): Path to storage directory.
+        path_output (str): Path to output directory.
+        output_basename (str): Base name for output files.
+        pub_type (str): Type of publication.
+        issue_or_month_flag (Union[str, List[str]], optional): Issue or month flag. Defaults to "current_issue".
+        year_flag (Union[str, List[str]], optional): Year flag. Defaults to "current_year".
+        options (Dict[str, Any], optional): Additional options. Defaults to {}.
+
+    Examples:
+        |              | current_issue | current_month | all_months |
+        |--------------|---------------|---------------|------------|
+        | current_year | YES           | YES           | YES        |
+        | all_years    | NO            | NO            | YES        |
+        | given_years  | NO            | NO            | YES        |
+
+        given_years = ["2020", "2025"]
+
+    Returns:
+        Tuple[str, str, bool]: Returns (path_root, path_output, combine_flag).
     """
     # default settings
     path_storage = standard_path(path_storage)
@@ -77,31 +83,20 @@ def generate_from_bibs_and_write(
 ) -> None:
     """Generate or combine data from bibliographies.
 
-    Parameters
-    ----------
-    path_storage : str
-        Path to storage directory
-    path_output : str
-        Path to output directory
-    generate_or_combine : str
-        Either "generate_data" or "combine_data"
-    year_flag : Union[str, List[str]], optional
-        Flag for year selection, by default "current_year"
-    issue_or_month_flag : Union[str, List[str]], optional
-        Flag for issue/month selection, by default "current_issue"
-    options : Dict[str, Any], optional
-        Additional options, by default {}
+    Args:
+        path_storage (str): Path to storage directory.
+        path_output (str): Path to output directory.
+        output_basename (str): Base name for output files.
+        pub_type (str): Type of publication.
+        generate_or_combine (str): Either "generate_data" or "combine_data".
+        year_flag (Union[str, List[str]], optional): Flag for year selection. Defaults to "current_year".
+        issue_or_month_flag (Union[str, List[str]], optional): Flag for issue/month selection. Defaults to "current_issue".
+        options (Dict[str, Any], optional): Additional options. Defaults to {}.
     """
     path_root, path_output, combine_flag = preparation(
         path_storage, path_output, output_basename, pub_type, issue_or_month_flag, year_flag, options
     )
 
-    # Default settings
-    x = BasicInput(options)
-    options = x.options
-    full_json_c = x.full_json_c
-    full_json_j = x.full_json_j
-
     if generate_or_combine == "generate_data":
         publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(path_storage, options)
         for publisher in publisher_abbr_dict:
@@ -123,11 +118,11 @@ def generate_from_bibs_and_write(
 
                 # Generate and process library
                 library = generate_library_by_filters(
-                    path_abbr, issue_or_month_flag, year_flag, new_options, full_json_c, full_json_j
+                    path_abbr, issue_or_month_flag, year_flag, new_options
                 )
 
                 # Generate md, tex, pdf, html
-                html_body = generate_html_from_bib_data(abbr, library, pp, new_options, full_json_c, full_json_j)
+                html_body = generate_html_from_bib_data(abbr, library, pp, new_options)
                 if combine_flag and html_body:
                     publisher_html_body.extend(html_body + ["\n"])
 
@@ -143,6 +138,15 @@ def generate_from_bibs_and_write(
 
 
 def _combine_data(path_storage, path_root, path_output, combine_flag, options):
+    """Combine data from multiple sources.
+
+    Args:
+        path_storage: Path to storage directory.
+        path_root: Root path for output.
+        path_output: Path to output directory.
+        combine_flag: Flag indicating whether to combine data.
+        options: Configuration options.
+    """
     # Compulsory
     options["include_abbr_list"] = []
     options["exclude_abbr_list"] = []

pyeasyphd/tools/generate/generate_html.py

@@ -9,7 +9,15 @@ from ...utils.utils import html_head, html_style, html_tail, textarea_header, te
 
 
 def generate_html_content(html_body, abbr_standard):
-    """Create complete HTML document from body content."""
+    """Create complete HTML document from body content.
+
+    Args:
+        html_body: List of HTML body content lines.
+        abbr_standard (str): Standard abbreviation for the document.
+
+    Returns:
+        List[str]: Complete HTML document as list of lines.
+    """
     return [html_head.format(abbr_standard), html_style, "\n"] + html_body + [html_tail]
 
 
@@ -18,10 +26,20 @@ def generate_html_from_bib_data(
     original_bib_data: Union[List[str], str, Library],
     path_output: str,
     options: Dict[str, Any] = {},
-    full_json_c: str = "",
-    full_json_j: str = ""
 ) -> List[str]:
-    """Generate html from bibliography data."""
+    """Generate HTML from bibliography data.
+
+    Args:
+        abbr_standard (str): Standard abbreviation for the publication.
+        original_bib_data (Union[List[str], str, Library]): Bibliography data in various formats.
+        path_output (str): Path to output directory.
+        options (Dict[str, Any], optional): Additional processing options. Defaults to {}.
+        full_json_c (str, optional): Path to conferences JSON file. Defaults to "".
+        full_json_j (str, optional): Path to journals JSON file. Defaults to "".
+
+    Returns:
+        List[str]: List of HTML body content lines.
+    """
     # Set processing options
     processing_options: dict = {
         # convert_str_to_library
@@ -49,10 +67,10 @@ def generate_html_from_bib_data(
     processing_options.update(options)
 
     # Process bibliography data
-    _python_bib = PythonRunBib(full_json_c, full_json_j, processing_options)
+    _python_bib = PythonRunBib(processing_options)
     _, zotero_library, _ = _python_bib.parse_to_multi_standard_library(original_bib_data)
 
-    _python_writer = PythonWriters(full_json_c, full_json_j, processing_options)
+    _python_writer = PythonWriters(processing_options)
 
     # Generate HTML content for each entry
     html_body = []
@@ -77,7 +95,16 @@ def generate_html_from_bib_data(
 
 
 def _format_entry_to_html(entry, abbr, data_list):
-    """Format a single bibliography entry into HTML."""
+    """Format a single bibliography entry into HTML.
+
+    Args:
+        entry: Bibliography entry dictionary.
+        abbr (str): Publication abbreviation.
+        data_list: List of formatted bibliography data.
+
+    Returns:
+        str: HTML formatted entry string.
+    """
     # Extract entry fields
     number = entry["number"] if "number" in entry else ""
     pages = entry["pages"] if "pages" in entry else ""
@@ -103,7 +130,20 @@ def _format_entry_to_html(entry, abbr, data_list):
 
 
 def _format_entry_to_apa_style(title, year, volume, number, pages, url, abbr):
-    """Format entry in APA citation style."""
+    """Format entry in APA citation style.
+
+    Args:
+        title (str): Article title.
+        year (str): Publication year.
+        volume (str): Journal volume.
+        number (str): Issue number.
+        pages (str): Page numbers.
+        url (str): Article URL.
+        abbr (str): Publication abbreviation.
+
+    Returns:
+        str: APA formatted citation string.
+    """
     line = f"({year}). {title}. <em>{abbr}</em>"
 
     if volume:

pyeasyphd/tools/generate/generate_library.py

@@ -10,30 +10,19 @@ def generate_library_by_filters(
     issue_or_month_flag: Union[str, List[str]],  # filter
     year_flag: Union[str, List[str]] = "current_year",  # filter
     options: Dict[str, Any] = {},
-    full_json_c: str = "",
-    full_json_j: str = ""
 ) -> Library:
     """Generate a Library object from input data with given filters.
 
-    Parameters
-    ----------
-    original_data : Union[List[str], str, Library]
-        Input bibliography data
-    issue_or_month_flag : Union[str, List[str]]
-        Flag for issue/month selection
-    year_flag : Union[str, List[str]], optional
-        Flag for year selection, by default "current_year"
-    options : Dict[str, Any], optional
-        Additional options, by default {}
-    full_json_c : str, optional
-        JSON configuration for conference proceedings, by default "".
-    full_json_j : str, optional
-        JSON configuration for journal articles, by default "".
-
-    Returns
-    -------
-    Library
-        Processed library object
+    Args:
+        original_data (Union[List[str], str, Library]): Input bibliography data.
+        issue_or_month_flag (Union[str, List[str]]): Flag for issue/month selection.
+        year_flag (Union[str, List[str]], optional): Flag for year selection. Defaults to "current_year".
+        options (Dict[str, Any], optional): Additional options. Defaults to {}.
+        full_json_c (str, optional): JSON configuration for conference proceedings. Defaults to "".
+        full_json_j (str, optional): JSON configuration for journal articles. Defaults to "".
+
+    Returns:
+        Library: Processed library object.
     """
     _options = {}
     # convert_str_to_library
@@ -62,7 +51,7 @@ def generate_library_by_filters(
     _options["substitute_in_bib"] = False  # default is True
 
     _options.update(options)
-    _python_bib = PythonRunBib(full_json_c, full_json_j, _options)
+    _python_bib = PythonRunBib(_options)
 
     # Generate nested entries dictionary
     entry_type_year_volume_number_month_entry_dict = _python_bib.parse_to_nested_entries_dict(original_data)
@@ -87,7 +76,15 @@ def _obtain_year_flag_library(
     nested_entries: Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, List[Entry]]]]]],
     year_flag: Union[str, List[str]] = "current_year",
 ):
-    """Filter dict by year flag."""
+    """Filter dictionary by year flag.
+
+    Args:
+        nested_entries: Nested dictionary containing bibliography entries.
+        year_flag (Union[str, List[str]], optional): Year filter flag. Defaults to "current_year".
+
+    Returns:
+        Dict: Filtered dictionary by year.
+    """
     new_dict = {}
     for entry_type in nested_entries:
         years = [year for year in nested_entries[entry_type]]
@@ -111,9 +108,17 @@ def _obtain_year_flag_library(
 
 def _obtain_issue_flag_library(
     nested_entries: Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, List[Entry]]]]]],
-    issue_flag: str = "current_issue"
+    issue_flag: str = "current_issue",
 ) -> Library:
-    """Filter dict by issue flag."""
+    """Filter dictionary by issue flag.
+
+    Args:
+        nested_entries: Nested dictionary containing bibliography entries.
+        issue_flag (str, optional): Issue filter flag. Defaults to "current_issue".
+
+    Returns:
+        Library: Filtered library object.
+    """
     nested_entries = IterateSortDict(True).dict_update(nested_entries)
 
     entries = []
@@ -149,7 +154,15 @@ def _obtain_month_flag_library(
     nested_entries: Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, List[Entry]]]]]],
     month_flag: Union[str, List[str]] = "current_month",
 ) -> Library:
-    """Filter dict by month flag."""
+    """Filter dictionary by month flag.
+
+    Args:
+        nested_entries: Nested dictionary containing bibliography entries.
+        month_flag (Union[str, List[str]], optional): Month filter flag. Defaults to "current_month".
+
+    Returns:
+        Library: Filtered library object.
+    """
     new_dict = {}
     for entry_type in nested_entries:
         for year in nested_entries[entry_type]:

pyeasyphd/tools/generate/generate_links.py

@@ -19,12 +19,14 @@ class PaperLinksGenerator(object):
         keywords_category_name: str = "",
         display_year_period: int = 10,
     ):
-        """
-        Initialize the generator with base paths.
+        """Initialize the generator with base paths.
 
         Args:
-            json_base_path: Path to JSON files directory
-            data_base_path: Path to data files directory
+            full_json_c (str): Path to conferences JSON file.
+            full_json_j (str): Path to journals JSON file.
+            data_base_path (str): Path to data files directory.
+            keywords_category_name (str, optional): Category name for keywords. Defaults to "".
+            display_year_period (int, optional): Number of years to display. Defaults to 10.
         """
         self.full_json_c = full_json_c
         self.full_json_j = full_json_j
@@ -46,11 +48,11 @@ class PaperLinksGenerator(object):
         self.display_year_period = display_year_period
 
     def generate_yearly_links(self, cj: str, folder_name=os.path.join("data", "Yearly")) -> None:
-        """
-        Generate yearly markdown table with paper links.
+        """Generate yearly markdown table with paper links.
 
         Args:
-            cj: Publication type - 'conferences' or 'journals'
+            cj (str): Publication type - 'conferences' or 'journals'.
+            folder_name (str, optional): Output folder name. Defaults to "data/Yearly".
         """
         flags = self._get_yearly_flags(cj)
         folder_flags = [f"{f}_all_months" for f in flags]
@@ -58,7 +60,11 @@ class PaperLinksGenerator(object):
         self._generate_links(cj, flags, folder_flags, folder_name)
 
     def generate_weekly_links(self, folder_name=os.path.join("data", "Weekly")) -> None:
-        """Generate weekly markdown table with journal paper links."""
+        """Generate weekly markdown table with journal paper links.
+
+        Args:
+            folder_name (str, optional): Output folder name. Defaults to "data/Weekly".
+        """
         cj = "Journals"
 
         flags = ["Current Issue", "Current Month", "All Months"]