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

pyeasyphd/tools/search/search_core.py

@@ -24,37 +24,45 @@ from .utils import keywords_type_for_title, switch_keywords_list, switch_keyword
 
 
 class SearchResultsCore(BasicInput):
-    """Generate tex, md, html, and pdf.
+    """Core class for generating tex, md, html, and pdf from search results.
 
     Args:
-        path_storage (str): the path of storage `abbr`
-        path_output (str): the path of output `abbr`
-        path_separate (str): the path of separate `abbr`
-        j_conf_abbr (str): the abbreviation of journal or conference
-        options (dict): options
+        path_storage (str): Path to storage directory for bibliography files.
+        path_output (str): Path to output directory for generated files.
+        path_separate (str): Path to separate directory for individual results.
+        j_conf_abbr (str): Abbreviation of journal or conference.
+        options (dict): Configuration options.
 
     Attributes:
-        path_storage (str): the path of storage
-        path_output (str): the path of output
-        path_separate (str): the path of separate
-        j_conf_abbr (str): the abbreviation of journal or conference
-
-        is_standard_bib_file_name (bool = True): whether the bib file name is standard
-        keywords_type_list (List[str] = []): keywords type list
-        keywords_dict (dict = {}): keywords dict
-        delete_redundant_files (bool = True): delete redundant files
-        generate_basic_md (bool = False): generate basic md
-        generate_beauty_md (bool = False): generate beauty md
-        generate_complex_md (bool = True): generate complex md
-        generate_tex (bool = False): generate tex
-        first_field_second_keywords (bool = True): first field second keywords
-        deepcopy_library_for_every_field (bool = False): deepcopy library for every field
-        deepcopy_library_for_every_keywords (bool = False): deepcopy library for every keywords
+        path_storage (str): Path to storage directory.
+        path_output (str): Path to output directory.
+        path_separate (str): Path to separate directory.
+        j_conf_abbr (str): Abbreviation of journal or conference.
+        is_standard_bib_file_name (bool): Whether the bib file name follows standard format.
+        keywords_type_list (List[str]): List of keyword types to search.
+        keywords_dict (dict): Dictionary of keywords for searching.
+        delete_redundant_files (bool): Whether to delete redundant files after processing.
+        generate_basic_md (bool): Whether to generate basic markdown files.
+        generate_beauty_md (bool): Whether to generate beautiful markdown files.
+        generate_complex_md (bool): Whether to generate complex markdown files.
+        generate_tex (bool): Whether to generate LaTeX files.
+        first_field_second_keywords (bool): Whether to search fields first, then keywords.
+        deepcopy_library_for_every_field (bool): Whether to deep copy library for every field.
+        deepcopy_library_for_every_keywords (bool): Whether to deep copy library for every keywords.
     """
 
     def __init__(
         self, path_storage: str, path_output: str, path_separate: str, j_conf_abbr: str, options: Dict[str, Any]
     ) -> None:
+        """Initialize SearchResultsCore with paths and configuration.
+
+        Args:
+            path_storage (str): Path to storage directory for bibliography files.
+            path_output (str): Path to output directory for generated files.
+            path_separate (str): Path to separate directory for individual results.
+            j_conf_abbr (str): Abbreviation of journal or conference.
+            options (Dict[str, Any]): Configuration options.
+        """
         super().__init__(options)
         self.path_storage: str = standard_path(path_storage)
         self.path_output: str = standard_path(path_output)
@@ -96,9 +104,17 @@ class SearchResultsCore(BasicInput):
         self.deepcopy_library_for_every_keywords = options.get("deepcopy_library_for_every_keywords", False)
 
         # for bib
-        self._python_bib = PythonRunBib(self.full_json_c, self.full_json_j, options)
+        self._python_bib = PythonRunBib(options)
 
     def optimize(self, search_year_list: List[str] = []) -> Dict[str, Dict[str, Dict[str, Dict[str, int]]]]:
+        """Optimize search results for given years.
+
+        Args:
+            search_year_list (List[str], optional): List of years to search. Defaults to [].
+
+        Returns:
+            Dict[str, Dict[str, Dict[str, Dict[str, int]]]]: Nested dictionary containing search results.
+        """
         search_year_list = list(set([str(i) for i in search_year_list]))
 
         data_list = self._obtain_full_files_data(self.path_storage, "bib", search_year_list)
@@ -107,6 +123,16 @@ class SearchResultsCore(BasicInput):
         return entry_type_keyword_type_keyword_field_number_dict
 
     def _obtain_full_files_data(self, path_storage: str, extension: str, search_year_list: List[str] = []) -> List[str]:
+        """Obtain data from all files with specified extension in storage path.
+
+        Args:
+            path_storage (str): Path to storage directory.
+            extension (str): File extension to search for.
+            search_year_list (List[str], optional): List of years to filter by. Defaults to [].
+
+        Returns:
+            List[str]: Combined content from all matching files.
+        """
         regex = None
         if self.is_standard_bib_file_name and search_year_list:
             regex = re.compile(f'({"|".join(search_year_list)})')
@@ -123,6 +149,15 @@ class SearchResultsCore(BasicInput):
         return combine_content_in_list([read_list(f, "r") for f in sort_int_str(file_list)], None)
 
     def optimize_core(self, data_list: List[str], search_year_list) -> Dict[str, Dict[str, Dict[str, Dict[str, int]]]]:
+        """Core optimization logic for processing bibliography data.
+
+        Args:
+            data_list (List[str]): List of bibliography data strings.
+            search_year_list: List of years to search.
+
+        Returns:
+            Dict[str, Dict[str, Dict[str, Dict[str, int]]]]: Nested dictionary containing search results.
+        """
         print("\n" + "*" * 9 + f" Search in {self.j_conf_abbr} " + "*" * 9)
 
         entry_type_year_volume_number_month_entry_dict = self._python_bib.parse_to_nested_entries_dict(data_list)
@@ -176,18 +211,25 @@ class SearchResultsCore(BasicInput):
         return entry_type_keyword_type_keyword_field_number_dict
 
     def _optimize_fields_keyword(self, keywords_type, library, output_prefix, p_origin, p_separate, p_combine):
+        """Optimize search by fields first, then keywords.
+
+        Args:
+            keywords_type: Type of keywords to search.
+            library: Bibliography library to search.
+            output_prefix (str): Prefix for output files.
+            p_origin (str): Path to origin directory.
+            p_separate (str): Path to separate directory.
+            p_combine (str): Path to combine directory.
+
+        Returns:
+            dict: Dictionary containing keyword field numbers.
+        """
         no_search_library = library
 
         keyword_field_number_dict_ = {}
         for field in self.search_field_list:
             keyword_field_number_dict, no_search_library = self.core_optimize(
-                [field],
-                keywords_type,
-                no_search_library,
-                output_prefix,
-                p_origin,
-                p_separate,
-                p_combine,
+                [field], keywords_type, no_search_library, output_prefix, p_origin, p_separate, p_combine
             )
 
             if self.deepcopy_library_for_every_field:
@@ -198,16 +240,23 @@ class SearchResultsCore(BasicInput):
         return keyword_field_number_dict_
 
     def _optimize_keywords_field(self, keywords_type, library, output_prefix, p_origin, p_separate, p_combine):
+        """Optimize search by keywords first, then fields.
+
+        Args:
+            keywords_type: Type of keywords to search.
+            library: Bibliography library to search.
+            output_prefix (str): Prefix for output files.
+            p_origin (str): Path to origin directory.
+            p_separate (str): Path to separate directory.
+            p_combine (str): Path to combine directory.
+
+        Returns:
+            dict: Dictionary containing keyword field numbers.
+        """
         no_search_library = library
 
         keyword_field_number_dict, no_search_library = self.core_optimize(
-            self.search_field_list,
-            keywords_type,
-            no_search_library,
-            output_prefix,
-            p_origin,
-            p_separate,
-            p_combine,
+            self.search_field_list, keywords_type, no_search_library, output_prefix, p_origin, p_separate, p_combine
         )
         return keyword_field_number_dict
 
@@ -221,6 +270,20 @@ class SearchResultsCore(BasicInput):
         p_separate: str,
         p_combine: str,
     ) -> Tuple[Dict[str, Dict[str, int]], Library]:
+        """Core optimization method for processing search results.
+
+        Args:
+            search_field_list (List[str]): List of fields to search.
+            keywords_type: Type of keywords to search.
+            library (Library): Bibliography library to search.
+            output_prefix (str): Prefix for output files.
+            p_origin (str): Path to origin directory.
+            p_separate (str): Path to separate directory.
+            p_combine (str): Path to combine directory.
+
+        Returns:
+            Tuple[Dict[str, Dict[str, int]], Library]: Tuple containing keyword field numbers and remaining library.
+        """
         error_pandoc_md_md: List[str] = []
         save_field_data_dict: Dict[str, List[List[str]]] = {}
         keyword_field_number_dict: Dict[str, Dict[str, int]] = {}
@@ -290,7 +353,14 @@ class SearchResultsCore(BasicInput):
         return keyword_field_number_dict, no_search_library
 
     def delete_files(self, keywords_type: str, p_origin: str, p_separate: str, p_combine: str) -> None:
-        """Delete some redundant files."""
+        """Delete redundant files after processing.
+
+        Args:
+            keywords_type (str): Type of keywords being processed.
+            p_origin (str): Path to origin directory.
+            p_separate (str): Path to separate directory.
+            p_combine (str): Path to combine directory.
+        """
         # for initial tex md bib
         if os.path.exists(p_origin):
             shutil.rmtree(p_origin)

pyeasyphd/tools/search/search_keywords.py

@@ -4,12 +4,7 @@ import re
 from pathlib import Path
 from typing import Any, Dict, List
 
-from pyadvtools import (
-    generate_nested_dict,
-    read_list,
-    standard_path,
-    write_list,
-)
+from pyadvtools import generate_nested_dict, read_list, standard_path, write_list
 from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
 
 from ...main import PandocMdTo
@@ -20,22 +15,28 @@ from .utils import extract_information, temp_html_style
 
 
 class Searchkeywords(object):
-    """Search.
+    """Search keywords in bibliography data.
 
     Args:
-        path_storage (str): the path of storage journals or conferences
-        path_output (str): the path of output journals or conferences
-        options (dict): options
+        path_storage (str): Path to storage directory for journals or conferences.
+        path_output (str): Path to output directory for journals or conferences.
+        options (dict): Configuration options.
 
     Attributes:
-        path_storage (str): the path of storage
-        path_output (str): the path of output
-        options (dict): options
-
-        search_year_list (List[str] = []): search year list
+        path_storage (str): Path to storage directory.
+        path_output (str): Path to output directory.
+        options (dict): Configuration options.
+        search_year_list (List[str]): List of years to search. Defaults to [].
     """
 
     def __init__(self, path_storage: str, path_output: str, options: Dict[str, Any]) -> None:
+        """Initialize Searchkeywords with storage and output paths.
+
+        Args:
+            path_storage (str): Path to storage directory.
+            path_output (str): Path to output directory.
+            options (Dict[str, Any]): Configuration options.
+        """
         self.path_storage = standard_path(path_storage)
         self.path_output = standard_path(path_output)
 
@@ -64,6 +65,7 @@ class Searchkeywords(object):
         self._path_combine = self.path_output + "-Combine"
 
     def run(self) -> None:
+        """Run the keyword search process."""
         all_dict = {}
         publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(self.path_storage, self.options)
         for publisher in publisher_abbr_dict:
@@ -196,7 +198,7 @@ class Searchkeywords(object):
                     for file in nested_dict[entry_type][keywords_type][ext]:
                         data_dict.setdefault(os.path.basename(file).split(".")[0], []).append(file)
 
-            data_list = self._html_format(entry_type, data_dict, "Keywords",  "separate")
+            data_list = self._html_format(entry_type, data_dict, "Keywords", "separate")
             write_list(data_list, f"{entry_type.lower()}_links.html", "w", self._path_separate, False)
         return None
 

pyeasyphd/tools/search/search_writers.py

@@ -2,36 +2,31 @@ import copy
 import os
 from typing import Dict, List, Tuple
 
-from pyadvtools import (
-    combine_content_in_list,
-    read_list,
-    write_list,
-)
+from pyadvtools import combine_content_in_list, read_list, write_list
 from pybibtexer.bib.bibtexparser import Library
 from pybibtexer.main import PythonWriters
 
 from ...main import BasicInput, PandocMdTo
-from ...tools.search.utils import (
-    combine_keywords_for_file_name,
-    combine_keywords_for_title,
-    keywords_type_for_title,
-)
+from ...tools.search.utils import combine_keywords_for_file_name, combine_keywords_for_title, keywords_type_for_title
 
 
 class WriteInitialResult(BasicInput):
     """Write initial results for single keyword.
 
     Args:
-        options: dict
+        options (dict): Configuration options.
 
     Attributes:
-        options (dict): options
+        options (dict): Configuration options.
     """
 
     def __init__(self, options: dict) -> None:
-        super().__init__(options)
+        """Initialize WriteInitialResult with configuration options.
 
-        self.options = options
+        Args:
+            options (dict): Configuration options.
+        """
+        super().__init__(options)
 
         self._level_title_md = "###"
         self._level_title_tex = "subsection"
@@ -48,6 +43,21 @@ class WriteInitialResult(BasicInput):
         library_for_zotero: Library,
         library_for_save: Library,
     ) -> Tuple[List[List[str]], List[str]]:
+        """Main method to write initial results.
+
+        Args:
+            path_initial (str): Path to initial directory.
+            output_prefix (str): Prefix for output files.
+            field (str): Field being searched.
+            keywords_type (str): Type of keywords.
+            combine_keywords (str): Combined keywords string.
+            library_for_abbr (Library): Abbreviated bibliography library.
+            library_for_zotero (Library): Zotero bibliography library.
+            library_for_save (Library): Save bibliography library.
+
+        Returns:
+            Tuple[List[List[str]], List[str]]: Tuple containing data and error messages.
+        """
         error_pandoc_md_md = []
 
         # generate
@@ -56,7 +66,7 @@ class WriteInitialResult(BasicInput):
         # update options
         _options = copy.deepcopy(self.options)
         _options["keep_entries_by_cite_keys"] = cite_keys
-        _python_writer = PythonWriters(self.full_json_c, self.full_json_j, _options)
+        _python_writer = PythonWriters(_options)
 
         # generate tex and md data
         data_list_tex, data_list_md, header = self.generate_content_tex_md(
@@ -78,11 +88,7 @@ class WriteInitialResult(BasicInput):
         # pandoc md to generate md file
         path_bib = os.path.join(path_write, f"{file_prefix}{mid_list[2]}.bib")  # bib_for_abbr
         data_list_pandoc_md = self._pandoc_md_to.pandoc_md_to_md(
-            path_bib,
-            path_write,
-            path_write,
-            f"{file_prefix}.md",
-            f"{file_prefix}-pandoc.md",
+            path_bib, path_write, path_write, f"{file_prefix}.md", f"{file_prefix}-pandoc.md"
         )
 
         # mian part
@@ -111,11 +117,22 @@ class WriteInitialResult(BasicInput):
     def generate_basic_beauty_complex_md(
         self, header: str, cite_key_list: List[str], data_list_pandoc_md: List[str], library_for_zotero: Library
     ) -> Tuple[List[str], List[str], List[str]]:
+        """Generate basic, beauty, and complex markdown content.
+
+        Args:
+            header (str): Header string for the content.
+            cite_key_list (List[str]): List of citation keys.
+            data_list_pandoc_md (List[str]): List of pandoc markdown data.
+            library_for_zotero (Library): Zotero bibliography library.
+
+        Returns:
+            Tuple[List[str], List[str], List[str]]: Tuple containing basic, beauty, and complex markdown content.
+        """
         data_basic_md, data_beauty_md, data_complex_md = [], [], []
 
         # library
         _options = copy.deepcopy(self.options)
-        _python_writer = PythonWriters(self.full_json_c, self.full_json_j, _options)
+        _python_writer = PythonWriters(_options)
         key_url_http_bib_dict = _python_writer.output_key_url_http_bib_dict(library_for_zotero)
 
         key_basic_dict, key_beauty_dict, key_complex_dict = self._pandoc_md_to.generate_key_data_dict(
@@ -136,6 +153,14 @@ class WriteInitialResult(BasicInput):
 
     @staticmethod
     def _convert_to_special_list(data_list: List[str]) -> List[str]:
+        """Convert data list to special formatted list.
+
+        Args:
+            data_list (List[str]): List of data strings.
+
+        Returns:
+            List[str]: Formatted list with proper indentation.
+        """
         if len(data_list) > 0:
             data_list[0] = "- " + data_list[0]
         for j in range(len(data_list) - 1):
@@ -146,7 +171,17 @@ class WriteInitialResult(BasicInput):
     def generate_content_tex_md(
         self, cite_key_list: List[str], output_prefix: str, field: str, combine_keywords: str
     ) -> Tuple[List[str], List[str], str]:
-        """Generate."""
+        """Generate LaTeX and markdown content.
+
+        Args:
+            cite_key_list (List[str]): List of citation keys.
+            output_prefix (str): Prefix for output files.
+            field (str): Field being searched.
+            combine_keywords (str): Combined keywords string.
+
+        Returns:
+            Tuple[List[str], List[str], str]: Tuple containing LaTeX content, markdown content, and header.
+        """
         c_k_f_t = combine_keywords_for_title(combine_keywords)
 
         number_references = len(cite_key_list)
@@ -164,15 +199,25 @@ class WriteInitialResult(BasicInput):
 
 
 class WriteSeparateResult(object):
-    """Write separate result."""
+    """Write separate result for different keyword types."""
 
     def __init__(self) -> None:
+        """Initialize WriteSeparateResult with title levels."""
         self._level_title_md = "##"
         self._level_title_tex = "section"
 
     def main(
         self, data_temp: List[List[str]], field: str, keywords_type: str, combine_keywords: str, path_separate: str
     ) -> None:
+        """Main method to write separate results.
+
+        Args:
+            data_temp (List[List[str]]): List of data lists for different file types.
+            field (str): Field being processed.
+            keywords_type (str): Type of keywords.
+            combine_keywords (str): Combined keywords string.
+            path_separate (str): Path to separate directory.
+        """
         k_t_f_t = keywords_type_for_title(keywords_type)
         _title = f"{field.title()} contains {k_t_f_t}"
 
@@ -199,23 +244,27 @@ class WriteSeparateResult(object):
 
 
 class WriteAbbrCombinedResults(object):
-    """Write combined results for abbr (such as `TEVC`, `PNAS`).
+    """Write combined results for abbreviations (such as `TEVC`, `PNAS`).
 
     Args:
-        options: dict
+        options (dict): Configuration options.
 
     Attributes:
-        options (dict): options
-        pandoc_md_basic_to_pdf (bool): whether to convert basic md to pdf
-        pandoc_md_beauty_to_pdf (bool): whether to convert beauty md to pdf
-        pandoc_md_complex_to_pdf (bool): whether to convert complex md to pdf
-        pandoc_md_basic_to_html (bool): whether to convert basic md to html
-        pandoc_md_beauty_to_html (bool): whether to convert beauty md to html
-        pandoc_md_complex_to_html (bool): whether to convert complex md to html
-
+        options (dict): Configuration options.
+        pandoc_md_basic_to_pdf (bool): Whether to convert basic markdown to PDF.
+        pandoc_md_beauty_to_pdf (bool): Whether to convert beauty markdown to PDF.
+        pandoc_md_complex_to_pdf (bool): Whether to convert complex markdown to PDF.
+        pandoc_md_basic_to_html (bool): Whether to convert basic markdown to HTML.
+        pandoc_md_beauty_to_html (bool): Whether to convert beauty markdown to HTML.
+        pandoc_md_complex_to_html (bool): Whether to convert complex markdown to HTML.
     """
 
     def __init__(self, options: dict) -> None:
+        """Initialize WriteAbbrCombinedResults with configuration options.
+
+        Args:
+            options (dict): Configuration options.
+        """
         self.pandoc_md_basic_to_pdf: bool = options.get("pandoc_md_basic_to_pdf", False)
         self.pandoc_md_beauty_to_pdf: bool = options.get("pandoc_md_beauty_to_pdf", False)
         self.pandoc_md_complex_to_pdf: bool = options.get("pandoc_md_complex_to_pdf", False)
@@ -230,6 +279,17 @@ class WriteAbbrCombinedResults(object):
     def main(
         self, search_field_list, keywords_type: str, field_data_dict: Dict[str, List[List[str]]], path_combine: str
     ) -> Tuple[List[str], List[str]]:
+        """Main method to write combined results for abbreviations.
+
+        Args:
+            search_field_list: List of search fields.
+            keywords_type (str): Type of keywords.
+            field_data_dict (Dict[str, List[List[str]]]): Dictionary containing field data.
+            path_combine (str): Path to combine directory.
+
+        Returns:
+            Tuple[List[str], List[str]]: Tuple containing error messages for PDF and HTML conversion.
+        """
         path_subsection = os.path.join(path_combine, "tex-subsection")
         path_md = os.path.join(path_combine, "md")
         path_bib = os.path.join(path_combine, "bib")
@@ -284,7 +344,7 @@ class WriteAbbrCombinedResults(object):
                         os.path.join(path_combine, f"html-{i}"),
                         f"{file_prefix}-{i}.md",
                         f"{file_prefix}-{i}.html",
-                        True
+                        True,
                     )
                     if error_flag_html:
                         error_pandoc_md_html.append(error_flag_html)

pyeasyphd/tools/search/utils.py

@@ -2,19 +2,20 @@ import os
 import re
 from typing import Dict, List, Tuple, Union
 
-from pyadvtools import (
-    IterateSortDict,
-    is_list_contain_list_contain_str,
-    is_list_contain_str,
-    write_list,
-)
+from pyadvtools import IterateSortDict, is_list_contain_list_contain_str, is_list_contain_str, write_list
 
 
 def switch_keywords_list(xx: Union[List[str], List[List[str]]]) -> Tuple[List[List[str]], str]:
-    """Switch keyword.
+    """Switch keyword list format and generate combined keywords string.
 
-    Input: ["evolutionary", "algorithm"] or [["evolution"], ["evolutionary"]]
-    Output: [["evolutionary", "algorithm"]] or [["evolution"], ["evolutionary"]]
+    Args:
+        xx (Union[List[str], List[List[str]]]): Input keyword list or nested keyword list.
+            Examples: ["evolutionary", "algorithm"] or [["evolution"], ["evolutionary"]]
+
+    Returns:
+        Tuple[List[List[str]], str]: Tuple containing:
+            - List of keyword lists with regex word boundaries
+            - Combined keywords string for file naming
     """
     yyy: List[List[str]] = [[]]
 
@@ -54,6 +55,14 @@ def switch_keywords_list(xx: Union[List[str], List[List[str]]]) -> Tuple[List[Li
 
 
 def combine_keywords_for_title(combine_keywords: str) -> str:
+    """Convert combined keywords string to human-readable title format.
+
+    Args:
+        combine_keywords (str): Combined keywords string with special characters.
+
+    Returns:
+        str: Human-readable title format with proper spacing and punctuation.
+    """
     combine_keywords = combine_keywords.replace("_without_", " without ")
     combine_keywords = combine_keywords.replace("_and_", "; ")
     combine_keywords = combine_keywords.replace("0", "")
@@ -66,6 +75,14 @@ def combine_keywords_for_title(combine_keywords: str) -> str:
 
 
 def combine_keywords_for_file_name(combine_keywords: str) -> str:
+    """Convert combined keywords string to valid file name format.
+
+    Args:
+        combine_keywords (str): Combined keywords string.
+
+    Returns:
+        str: File name safe string with underscores and hyphens.
+    """
     combine_keywords = combine_keywords_for_title(combine_keywords)
     combine_keywords = combine_keywords.replace("/", "-")
     combine_keywords = combine_keywords.replace("; ", "_and_")
@@ -74,6 +91,14 @@ def combine_keywords_for_file_name(combine_keywords: str) -> str:
 
 
 def switch_keywords_type(keywords_type: str) -> str:
+    """Normalize keywords type string for consistent formatting.
+
+    Args:
+        keywords_type (str): Keywords type string to normalize.
+
+    Returns:
+        str: Normalized keywords type with consistent separators.
+    """
     keywords_type = keywords_type.replace("/", "-")
     keywords_type = keywords_type.replace(" ", "_")
     keywords_type = re.sub(r"-+", "-", keywords_type)
@@ -82,11 +107,25 @@ def switch_keywords_type(keywords_type: str) -> str:
 
 
 def keywords_type_for_title(keywords_type: str) -> str:
+    """Convert keywords type string to title format.
+
+    Args:
+        keywords_type (str): Keywords type string with underscores.
+
+    Returns:
+        str: Title format with spaces instead of underscores.
+    """
     keywords_type = keywords_type.replace("_", " ")
     return keywords_type.strip()
 
 
 def extract_information(old_dict: Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, int]]]]], path_output: str) -> None:
+    """Extract and organize search information into markdown tables.
+
+    Args:
+        old_dict (Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, int]]]]]): Nested dictionary containing search results.
+        path_output (str): Output directory path for generated markdown files.
+    """
     new_dict: Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, int]]]]] = {}
 
     for abbr in old_dict:

pyeasyphd/utils/utils.py

@@ -1,11 +1,7 @@
 import os
 import re
 
-from pyadvtools import (
-    combine_content_in_list,
-    read_list,
-    write_list,
-)
+from pyadvtools import combine_content_in_list, read_list, write_list
 
 html_head = """<!DOCTYPE html>
 <html>
@@ -47,10 +43,15 @@ textarea_tail = "\n</textarea>"
 
 
 def operate_on_generate_html(html_name: str) -> None:
+    """Operate on generated HTML file to add styling and functionality.
+
+    Args:
+        html_name (str): Name of the HTML file to process.
+    """
     if not (data_list := read_list(html_name, "r", None)):
         return None
 
-    head_list = [html_head.format(os.path.basename(html_name).split('.')[0].strip()), html_style, "\n"]
+    head_list = [html_head.format(os.path.basename(html_name).split(".")[0].strip()), html_style, "\n"]
     tail_list = [html_tail]
 
     content = "".join(data_list)

{pyeasyphd-0.1.2.dist-info → pyeasyphd-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeasyphd
-Version: 0.1.2
+Version: 0.1.6
 Summary: pyeasyphd
 License: GPL-3.0-or-later
 Keywords: Python,Markdown,LaTex
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: pyadvtools (>=0.0.5,<0.0.6)
-Requires-Dist: pybibtexer (>=0.0.3,<0.0.4)
+Requires-Dist: pyadvtools (>=0.1.5,<0.2.0)
+Requires-Dist: pybibtexer (>=0.1.6,<0.2.0)
 Project-URL: Documentation, https://github.com/NextArtifIntell/pyeasyphd
 Project-URL: Homepage, https://github.com/NextArtifIntell/pyeasyphd
 Project-URL: Repository, https://github.com/NextArtifIntell/pyeasyphd