pyeasyphd 0.4.12__py3-none-any.whl → 0.4.14__py3-none-any.whl

pyeasyphd/tools/generate/generate_links.py

@@ -1,14 +1,12 @@
-# coding=utf-8
-
 import json
 import os
+import subprocess
 from datetime import datetime
-from typing import Dict, List
 
 from pyadvtools import standard_path
 
 
-class PaperLinksGenerator(object):
+class PaperLinksGenerator:
     """Generate markdown files with paper links from JSON data."""
 
     def __init__(
@@ -46,11 +44,11 @@ class PaperLinksGenerator(object):
             keywords_list, keywords_category_name = [], ""
 
         self.keywords_category_name = keywords_category_name
-        self.keywords_list: List[str] = keywords_list
+        self.keywords_list: list[str] = keywords_list
 
         self.display_year_period = display_year_period
 
-    def generate_yearly_links(self, cj: str, folder_name=os.path.join("data", "Yearly")) -> None:
+    def generate_yearly_links(self, cj: str, folder_name: str = os.path.join("data", "Yearly")) -> None:
         """Generate yearly markdown table with paper links.
 
         Args:
@@ -62,7 +60,7 @@ class PaperLinksGenerator(object):
 
         self._generate_links(cj, flags, folder_flags, folder_name)
 
-    def generate_monthly_links(self, folder_name=os.path.join("data", "Monthly")) -> None:
+    def generate_monthly_links(self, folder_name: str = os.path.join("data", "Monthly")) -> None:
         """Generate monthly markdown table with journal paper links.
 
         Args:
@@ -75,7 +73,7 @@ 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:
+    def generate_weekly_links(self, folder_name: str = os.path.join("data", "Weekly")) -> None:
         """Generate weekly markdown table with journal paper links.
 
         Args:
@@ -117,12 +115,13 @@ class PaperLinksGenerator(object):
         file_html = os.path.join(base_path, f"{file_name}.html")
 
         try:
-            os.system(f"pandoc {file_md} -o {file_html}")
+            cmd = f"pandoc {file_md} -o {file_html}"
+            subprocess.run(cmd.split(), check=True, capture_output=True, text=True)
             os.remove(file_md)
-        except Exception as e:
-            print(f"Pandoc conversion error: {e}")
+        except subprocess.CalledProcessError as e:
+            print("Pandoc error in pandoc md to html:", e.stderr)
 
-    def generate_ieee_early_access_links(self, folder_name=os.path.join("data", "Weekly")) -> None:
+    def generate_ieee_early_access_links(self, folder_name: str = os.path.join("data", "Weekly")) -> None:
         """Generate markdown for IEEE Early Access papers."""
         md_content = [
             "# Papers from Early Access\n\n",
@@ -137,7 +136,7 @@ class PaperLinksGenerator(object):
 
         return None
 
-    def _load_json_data(self, file_name: str) -> Dict:
+    def _load_json_data(self, file_name: str) -> dict:
         """Load JSON data from file."""
         try:
             if file_name.lower().strip() == "conferences":
@@ -152,25 +151,25 @@ class PaperLinksGenerator(object):
             if not os.path.exists(file_path):
                 return {}
 
-            with open(file_path, "r", encoding="utf-8") as file:
+            with open(file_path, encoding="utf-8") as file:
                 return json.load(file)
 
         except Exception as e:
             print(f"Error loading {file_name}.json: {e}")
             return {}
 
-    def _get_yearly_flags(self, cj: str) -> List[str]:
+    def _get_yearly_flags(self, cj: str) -> list[str]:
         """Get yearly flags based on publication type."""
         current_year = datetime.now().year
         years = [str(y) for y in range(current_year - self.display_year_period, current_year)]
         flags = sorted(years, reverse=True)
 
         if cj.lower() == "conferences":
-            flags = [str(current_year)] + flags
+            flags = [str(current_year), *flags]
 
         return flags
 
-    def _create_md_header_publisher(self, cj: str, flags: List[str]) -> List[str]:
+    def _create_md_header_publisher(self, cj: str, flags: list[str]) -> list[str]:
         """Create markdown table header."""
         return [
             f"# Papers from {cj.title()} of Different Publishers\n\n",
@@ -178,7 +177,7 @@ class PaperLinksGenerator(object):
             f"|-|{'|'.join('-' for _ in flags)}|\n",
         ]
 
-    def _create_md_header_abbr(self, cj: str, flags: List[str]) -> List[str]:
+    def _create_md_header_abbr(self, cj: str, flags: list[str]) -> list[str]:
         """Create markdown table header."""
         return [
             f"# Papers from {cj.title()} of Different Publishers\n\n",
@@ -188,8 +187,8 @@ class PaperLinksGenerator(object):
 
     # publisher
     def _generate_table_rows_publisher(
-        self, json_data: Dict, cj: str, folder_flags: List[str], period: str
-    ) -> List[str]:
+        self, json_data: dict, cj: str, folder_flags: list[str], period: str
+    ) -> list[str]:
         """Generate markdown table rows."""
         rows = []
         idx = 1
@@ -202,7 +201,7 @@ class PaperLinksGenerator(object):
 
         return rows
 
-    def _get_link_cells_publisher(self, publisher: str, cj: str, folder_flags: List[str], period: str) -> List[str]:
+    def _get_link_cells_publisher(self, publisher: str, cj: str, folder_flags: list[str], period: str) -> list[str]:
         """Get link cells for a publisher."""
         cells = []
 
@@ -218,7 +217,7 @@ class PaperLinksGenerator(object):
         return cells
 
     # abbr
-    def _generate_table_rows_abbr(self, json_data: Dict, cj: str, folder_flags: List[str], period: str) -> List[str]:
+    def _generate_table_rows_abbr(self, json_data: dict, cj: str, folder_flags: list[str], period: str) -> list[str]:
         """Generate markdown table rows."""
         rows = []
         idx = 1
@@ -236,8 +235,8 @@ class PaperLinksGenerator(object):
         return rows
 
     def _get_link_cells_abbr(
-        self, publisher: str, abbr: str, cj: str, folder_flags: List[str], period: str
-    ) -> List[str]:
+        self, publisher: str, abbr: str, cj: str, folder_flags: list[str], period: str
+    ) -> list[str]:
         """Get link cells for a abbr."""
         cells = []
         for flag in folder_flags:
@@ -250,7 +249,7 @@ class PaperLinksGenerator(object):
 
         return cells
 
-    def _get_ieee_links(self, folder_name=os.path.join("data", "Weekly")) -> List[str]:
+    def _get_ieee_links(self, folder_name: str = os.path.join("data", "Weekly")) -> list[str]:
         """Get IEEE Early Access links."""
         links = []
         link_paths = [
@@ -267,7 +266,7 @@ class PaperLinksGenerator(object):
 
         return links
 
-    def _write_md_file(self, content: List[str], period: str, file_name: str) -> None:
+    def _write_md_file(self, content: list[str], period: str, file_name: str) -> None:
         """Write markdown content to file."""
         if len(content) == 0:
             return None
@@ -282,25 +281,25 @@ class PaperLinksGenerator(object):
 
         return None
 
-    def generate_keywords_links_weekly(self, cj: str, folder_name=os.path.join("data", "Weekly")):
+    def generate_keywords_links_weekly(self, cj: str, folder_name: str = os.path.join("data", "Weekly")):
         flags = ["Current Issue", "Current Month"]
         folder_flags = [f"current_year_{f.replace(' ', '_').lower()}" for f in flags]
 
         self._generate_keywords_links(cj, folder_name, flags, folder_flags)
 
-    def generate_keywords_links_monthly(self, cj: str, folder_name=os.path.join("data", "Monthly")):
+    def generate_keywords_links_monthly(self, cj: str, folder_name: str = os.path.join("data", "Monthly")):
         flags = ["All Months"]
         folder_flags = [f"current_year_{f.replace(' ', '_').lower()}" for f in flags]
 
         self._generate_keywords_links(cj, folder_name, flags, folder_flags)
 
-    def generate_keywords_links_yearly(self, cj: str, folder_name=os.path.join("data", "Yearly")):
+    def generate_keywords_links_yearly(self, cj: str, folder_name: str = os.path.join("data", "Yearly")):
         flags = self._get_yearly_flags(cj)
         folder_flags = [f"{f}_all_months" for f in flags]
 
         self._generate_keywords_links(cj, folder_name, flags, folder_flags)
 
-    def _generate_keywords_links(self, cj: str, folder_name: str, flags: List[str], folder_flags: List[str]):
+    def _generate_keywords_links(self, cj: str, folder_name: str, flags: list[str], folder_flags: list[str]):
         json_data = self._load_json_data(cj.title())
         if not json_data:
             return None
@@ -385,7 +384,7 @@ class PaperLinksGenerator(object):
                 cleaned_keywords = {}
                 for category, words in keywords_dict.items():
                     if category.strip():
-                        sorted_words = sorted(set([word.strip() for word in words if word.strip()]))
+                        sorted_words = sorted({word.strip() for word in words if word.strip()})
                         cleaned_keywords[category.strip()] = sorted_words
 
                 # For category

pyeasyphd/tools/py_run_bib_md_tex.py

@@ -1,7 +1,7 @@
 import os
 import re
 import shutil
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any
 
 from pyadvtools import combine_content_in_list, read_list, standard_path, write_list
 from pybibtexer.bib.bibtexparser import Library
@@ -18,7 +18,11 @@ class PyRunBibMdTex(BasicInput):
     """
 
     def __init__(
-        self, path_output: str, tex_md_flag: str = ".md", template_name: str = "paper", options: Dict[str, Any] = {}
+        self,
+        path_output: str,
+        tex_md_flag: str = ".md",
+        template_name: str = "paper",
+        options: dict[str, Any] | None = None,
     ) -> None:
         """Initialize the PyRunBibMdTex instance.
 
@@ -26,11 +30,14 @@ class PyRunBibMdTex(BasicInput):
             path_output (str): Output directory path for processed files.
             tex_md_flag (str, optional): Flag indicating whether to process as LaTeX (".tex") or Markdown (".md"). Defaults to ".md".
             template_name (str, optional): Template type to use ("paper" or "beamer"). Defaults to "paper".
-            options (Dict[str, Any], optional): Additional configuration options. Defaults to {}.
+            options (dict[str, Any], optional): Additional configuration options. Defaults to {}.
 
         Raises:
             AssertionError: If tex_md_flag is not ".tex" or ".md" or if template_name is not "paper" or "beamer".
         """
+        if options is None:
+            options = {}
+
         super().__init__(options)
 
         self.tex_md_flag = re.sub(r"\.+", ".", "." + tex_md_flag)
@@ -85,21 +92,21 @@ class PyRunBibMdTex(BasicInput):
         self._python_tex = PythonRunTex(self.options)
 
     def run_files(
-        self, file_list_md_tex: List[str], output_prefix: str = "", output_level: str = "next"
-    ) -> Tuple[List[str], List[str]]:
+        self, file_list_md_tex: list[str], output_prefix: str = "", output_level: str = "next"
+    ) -> tuple[list[str], list[str]]:
         """Process a list of Markdown or LaTeX files.
 
         Args:
-            file_list_md_tex (List[str]): List of input file paths (Markdown or LaTeX).
+            file_list_md_tex (list[str]): list of input file paths (Markdown or LaTeX).
             output_prefix (str, optional): Prefix for output files. Defaults to "".
             output_level (str, optional): Output directory level ("previous", "current", or "next"). Defaults to "next".
 
         Returns:
-            Tuple[List[str], List[str]]: Tuple containing processed Markdown content and LaTeX content.
+            tuple[list[str], list[str]]: Tuple containing processed Markdown content and LaTeX content.
         """
         file_list_md_tex = [f for f in file_list_md_tex if f.endswith(self.tex_md_flag)]
         data_list_list = [read_list(standard_path(f), "r") for f in file_list_md_tex]
-        if all([len(data_list) == 0 for data_list in data_list_list]):
+        if all(len(data_list) == 0 for data_list in data_list_list):
             return [], []
 
         file_base_name = os.path.splitext(os.path.basename(file_list_md_tex[0]))[0]
@@ -115,20 +122,20 @@ class PyRunBibMdTex(BasicInput):
     def python_run_bib_md_tex(
         self,
         output_prefix: str,
-        data_list_md_tex: List[str],
-        original_bib_data: Union[List[str], str, Library],
+        data_list_md_tex: list[str],
+        original_bib_data: list[str] | str | Library,
         output_level: str = "next",
-    ) -> Tuple[List[str], List[str]]:
+    ) -> tuple[list[str], list[str]]:
         """Process BibTeX, Markdown and LaTeX content.
 
         Args:
             output_prefix (str): Prefix for output files.
-            data_list_md_tex (List[str]): List of content lines (Markdown or LaTeX).
-            original_bib_data (Union[List[str], str, Library]): BibTeX data in various formats.
+            data_list_md_tex (list[str]): list of content lines (Markdown or LaTeX).
+            original_bib_data (list[str] | str | Library): BibTeX data in various formats.
             output_level (str, optional): Output directory level ("previous", "current", or "next"). Defaults to "next".
 
         Returns:
-            Tuple[List[str], List[str]]: Tuple containing processed Markdown content and LaTeX content.
+            tuple[list[str], list[str]]: Tuple containing processed Markdown content and LaTeX content.
         """
         # Basic file names
         output_tex, output_md = output_prefix + ".tex", output_prefix + ".md"
@@ -163,19 +170,19 @@ class PyRunBibMdTex(BasicInput):
         self,
         output_md: str,
         output_tex: str,
-        data_list_md_tex: List[str],
-        original_bib_data: Union[List[str], str, Library],
-    ) -> Tuple[List[str], List[str]]:
+        data_list_md_tex: list[str],
+        original_bib_data: list[str] | str | Library,
+    ) -> tuple[list[str], list[str]]:
         """Process BibTeX, Markdown and LaTeX content.
 
         Args:
             output_md (str): Output Markdown filename.
             output_tex (str): Output LaTeX filename.
-            data_list_md_tex (List[str]): List of content lines (Markdown or LaTeX).
-            original_bib_data (Union[List[str], str, Library]): BibTeX data in various formats.
+            data_list_md_tex (list[str]): list of content lines (Markdown or LaTeX).
+            original_bib_data (list[str] | str | Library): BibTeX data in various formats.
 
         Returns:
-            Tuple[List[str], List[str]]: Tuple containing processed Markdown content and LaTeX content.
+            tuple[list[str], list[str]]: Tuple containing processed Markdown content and LaTeX content.
         """
         # Copy figures if enabled
         if self.shutil_includegraphics_figs:
@@ -209,7 +216,13 @@ class PyRunBibMdTex(BasicInput):
             abbr_library, zotero_library, save_library = self._python_bib.parse_to_multi_standard_library(
                 original_bib_data, key_in_md_tex
             )
-            key_in_md_tex = sorted(list(abbr_library.entries_dict.keys()), key=key_in_md_tex.index)
+
+            # Update entries
+            abbr_library = self._update_library_by_entry_keys(abbr_library, key_in_md_tex)
+            zotero_library = self._update_library_by_entry_keys(zotero_library, key_in_md_tex)
+            save_library = self._update_library_by_entry_keys(save_library, key_in_md_tex)
+
+            key_in_md_tex = sorted(abbr_library.entries_dict.keys(), key=key_in_md_tex.index)
 
             # Write bibliography files
             _path_output = os.path.join(self.path_output, self.bib_folder_name)
@@ -265,17 +278,23 @@ class PyRunBibMdTex(BasicInput):
         return data_list_md, data_list_tex
 
     @staticmethod
-    def search_subfile_names(data_list: List[str], postfixes: List[str]) -> List[str]:
+    def _update_library_by_entry_keys(library: Library, keys: list[str]):
+        remove_entries = [entry for entry in library.entries if entry.key not in keys]
+        library.remove(remove_entries)
+        return library
+
+    @staticmethod
+    def search_subfile_names(data_list: list[str], postfixes: list[str]) -> list[str]:
         """Search for figure filenames in content.
 
         Args:
-            data_list (List[str]): List of content lines to search.
-            figure_postfixes (Optional[List[str]], optional): List of figure file extensions to look for. Defaults to None.
+            data_list (list[str]): list of content lines to search.
+            figure_postfixes (Optional[list[str]], optional): list of figure file extensions to look for. Defaults to None.
 
         Returns:
-            List[str]: List of found figure filenames.
+            list[str]: list of found figure filenames.
         """
-        regex = re.compile(rf'[\w\-]+\.(?:{"|".join(postfixes)})', re.I)
+        regex = re.compile(rf"[\w\-]+\.(?:{'|'.join(postfixes)})", re.I)
         figure_names = []
         for line in data_list:
             figure_names.extend(regex.findall(line))
@@ -283,7 +302,7 @@ class PyRunBibMdTex(BasicInput):
 
     @staticmethod
     def shutil_copy_files(
-        path_file: str, file_names: List[str], path_output: str, output_folder_name: str, relative_path: bool
+        path_file: str, file_names: list[str], path_output: str, output_folder_name: str, relative_path: bool
     ) -> None:
         """Copy specified files from source directory to output directory.
 
@@ -292,7 +311,7 @@ class PyRunBibMdTex(BasicInput):
 
         Args:
             path_file: Source directory path to search for files.
-            file_names: List of filenames to copy.
+            file_names: list of filenames to copy.
             path_output: Destination directory path.
             output_folder_name: Name of the subfolder in output directory (used when relative_path=False).
             relative_path: If True, preserves relative path structure; if False, uses flat structure.
@@ -341,15 +360,15 @@ class PyRunBibMdTex(BasicInput):
         return None
 
     @staticmethod
-    def search_cite_keys(data_list: List[str], tex_md_flag: str = ".tex") -> List[str]:
+    def search_cite_keys(data_list: list[str], tex_md_flag: str = ".tex") -> list[str]:
         r"""Extract citation keys from content according to their places.
 
         Args:
-            data_list (List[str]): List of content lines to search.
+            data_list (list[str]): list of content lines to search.
             tex_md_flag (str, optional): Flag indicating content format (".tex" or ".md"). Defaults to ".tex".
 
         Returns:
-            List[str]: List of found citation keys.
+            list[str]: list of found citation keys.
 
         Note:
             For LaTeX, searches for \\cite, \\citep, \\citet patterns.

pyeasyphd/tools/search/data.py

@@ -1,11 +1,11 @@
-from typing import Any, Dict
+from typing import Any
 
 
-def obtain_search_keywords() -> Dict[str, Any]:
+def obtain_search_keywords() -> dict[str, Any]:
     """Obtain search keywords dictionary.
 
     Returns:
-        Dict[str, Any]: Dictionary containing categorized search keywords.
+        dict[str, Any]: dictionary containing categorized search keywords.
     """
     _h_ = "(?:| |-)"  # hyphen
 

pyeasyphd/tools/search/search_base.py

@@ -1,6 +1,5 @@
 import copy
 import re
-from typing import Dict, List, Tuple
 
 from pybibtexer.bib.bibtexparser import Library
 from pybibtexer.main import PythonRunBib, PythonWriters
@@ -9,16 +8,16 @@ from ...main import BasicInput
 from .search_writers import WriteInitialResult, WriteSeparateResult
 
 
-def search_keywords_core(keywords_list_list: List[List[str]], library: Library, field: str) -> Tuple[Library, Library]:
+def search_keywords_core(keywords_list_list: list[list[str]], library: Library, field: str) -> tuple[Library, Library]:
     """Search keywords in specified field such as title, abstract, or keywords.
 
     Args:
-        keywords_list_list (List[List[str]]): List of keyword lists to search for.
+        keywords_list_list (list[list[str]]): list of keyword lists to search for.
         library (Library): Bibliography library to search.
         field (str): Field to search in (e.g., 'title', 'abstract', 'keywords').
 
     Returns:
-        Tuple[Library, Library]: Tuple containing (matching_library, non_matching_library).
+        tuple[Library, Library]: Tuple containing (matching_library, non_matching_library).
     """
     search_library = []
     no_search_library = []
@@ -31,10 +30,10 @@ def search_keywords_core(keywords_list_list: List[List[str]], library: Library,
             content = re.sub("}", "", content)
 
             # All keywords from keyword_list_list[0] should be found in bib
-            flag = all([re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[0]])
+            flag = all(re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[0])
             if flag and (len(keywords_list_list) == 2):
                 # Any keywords from keyword_list_list[1] found in bib will results in False flag.
-                flag = not any([re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[1]])
+                flag = not any(re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[1])
 
         if flag:
             search_library.append(entry)
@@ -76,32 +75,32 @@ class SearchInitialResult(BasicInput):
 
     def main(
         self,
-        search_field_list: List[str],
+        search_field_list: list[str],
         path_initial: str,
         library: Library,
         keywords_type: str,
-        keywords_list_list: List[List[str]],
+        keywords_list_list: list[list[str]],
         combine_keywords: str,
         output_prefix: str,
         path_separate: str,
-    ) -> Tuple[List[str], Dict[str, List[List[str]]], Dict[str, int], Library]:
+    ) -> tuple[list[str], dict[str, list[list[str]]], dict[str, int], Library]:
         """Main search method for processing search results.
 
         Args:
-            search_field_list (List[str]): List of fields to search.
+            search_field_list (list[str]): list of fields to search.
             path_initial (str): Path to initial directory.
             library (Library): Bibliography library to search.
             keywords_type (str): Type of keywords being searched.
-            keywords_list_list (List[List[str]]): List of keyword lists.
+            keywords_list_list (list[list[str]]): list of keyword lists.
             combine_keywords (str): Combined keywords string.
             output_prefix (str): Prefix for output files.
             path_separate (str): Path to separate directory.
 
         Returns:
-            Tuple[List[str], Dict[str, List[List[str]]], Dict[str, int], Library]: Tuple containing error messages, field data, field numbers, and remaining library.
+            tuple[list[str], dict[str, list[list[str]]], dict[str, int], Library]: Tuple containing error messages, field data, field numbers, and remaining library.
         """
         error_pandoc_md_md, field_data_dict, no_search_library = [], {}, library
-        field_number_dict: Dict[str, int] = {}
+        field_number_dict: dict[str, int] = {}
 
         for field in search_field_list:
             if len(no_search_library.entries) == 0: