pyeasyphd 0.4.42__py3-none-any.whl

pyeasyphd/scripts/run_generate.py

@@ -0,0 +1,211 @@
+import os
+
+from pyeasyphd.tools import PaperLinksGenerator, generate_from_bibs_and_write
+from pyeasyphd.utils.utils import is_last_week_of_month
+
+from ._base import build_base_options, expand_paths
+
+
+def run_generate_j_weekly(
+    options: dict,
+    path_weekly_docs: str,
+    keywords_category_names: list[str],
+    path_spidering_bibs: str,
+    path_conf_j_jsons: str,
+):
+    # Expand and normalize file paths
+    path_weekly_docs, path_spidering_bibs = expand_paths(path_weekly_docs, path_spidering_bibs)
+
+    # Update options
+    options_ = build_base_options([], [], ["arXiv"], [], path_conf_j_jsons)
+    options_.update(options)
+
+    # Generate md and html files
+    for gc in ["generate_data", "combine_data"]:
+        path_storage = os.path.join(path_spidering_bibs, "spider_j")
+        output_basename = os.path.join("data", "Weekly")
+        path_output = os.path.expanduser(os.path.join(path_weekly_docs, output_basename, "Journals"))
+        # "current_issue", "current_month"
+        for flag in ["current_issue", "current_month"]:
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Journals", gc, "current_year", flag, options_
+            )
+
+    # Generate links
+    for keywords_category_name in keywords_category_names:
+        full_json_c, full_json_j, full_json_k = (
+            options_["full_json_c"],
+            options_["full_json_j"],
+            options_["full_json_k"],
+        )
+        output_basename = os.path.join("data", "Weekly")
+        generator = PaperLinksGenerator(full_json_c, full_json_j, full_json_k, path_weekly_docs, keywords_category_name)
+        generator.generate_weekly_links(output_basename)
+        generator.generate_keywords_links_weekly("Journals", output_basename)
+
+
+def run_generate_j_e_weekly(
+    options: dict,
+    path_weekly_docs: str,
+    keywords_category_names: list[str],
+    path_spidering_bibs: str,
+    path_conf_j_jsons: str,
+):
+    # Expand and normalize file paths
+    path_weekly_docs, path_spidering_bibs = expand_paths(path_weekly_docs, path_spidering_bibs)
+
+    # Update options
+    options_ = build_base_options([], [], ["arXiv"], [], path_conf_j_jsons)
+    options_.update(options)
+    options_["early_access"] = True
+
+    # Generate md and html files
+    for gc in ["generate_data", "combine_data"]:
+        path_storage = os.path.join(path_spidering_bibs, "spider_j_e")
+        output_basename = os.path.join("data", "Weekly")
+        path_output = os.path.expanduser(os.path.join(path_weekly_docs, output_basename, "Journals"))
+        # "current_month"
+        for flag in ["current_month"]:
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Journals", gc, "current_year", flag, options_
+            )
+
+        # "all_years"
+        for year in ["all_years"]:
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Journals", gc, year, "all_months", options_
+            )
+
+    # Generate links
+    for keywords_category_name in keywords_category_names:
+        full_json_c, full_json_j, full_json_k = (
+            options_["full_json_c"],
+            options_["full_json_j"],
+            options_["full_json_k"],
+        )
+        output_basename = os.path.join("data", "Weekly")
+        generator = PaperLinksGenerator(full_json_c, full_json_j, full_json_k, path_weekly_docs, keywords_category_name)
+        generator.generate_ieee_early_access_links(output_basename)
+        generator.generate_keywords_links_weekly("Journals", output_basename)
+
+
+def run_generate_j_monthly(
+    options: dict,
+    path_monthly_docs: str,
+    keywords_category_names: list[str],
+    path_spidering_bibs: str,
+    path_conf_j_jsons: str,
+):
+    # Expand and normalize file paths
+    path_monthly_docs, path_spidering_bibs = expand_paths(path_monthly_docs, path_spidering_bibs)
+
+    # Update options
+    options_ = build_base_options([], [], ["arXiv"], [], path_conf_j_jsons)
+    options_.update(options)
+
+    # Generate md and html files
+    for gc in ["generate_data", "combine_data"]:
+        path_storage = os.path.join(path_spidering_bibs, "spider_j")
+        output_basename = os.path.join("data", "Monthly")
+        path_output = os.path.expanduser(os.path.join(path_monthly_docs, output_basename, "Journals"))
+        # "all_months"
+        for flag in ["all_months"]:
+            if flag == "all_months":
+                if not is_last_week_of_month():
+                    continue
+
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Journals", gc, "current_year", flag, options_
+            )
+
+    # Generate links
+    for keywords_category_name in keywords_category_names:
+        full_json_c, full_json_j, full_json_k = (
+            options_["full_json_c"],
+            options_["full_json_j"],
+            options_["full_json_k"],
+        )
+        output_basename = os.path.join("data", "Monthly")
+        generator = PaperLinksGenerator(
+            full_json_c, full_json_j, full_json_k, path_monthly_docs, keywords_category_name
+        )
+        generator.generate_monthly_links(output_basename)
+        generator.generate_keywords_links_monthly("Journals", output_basename)
+
+
+def run_generate_j_yearly(
+    options: dict,
+    path_yearly_docs: str,
+    keywords_category_names: list[str],
+    path_spidered_bibs: str,
+    path_conf_j_jsons: str,
+    year_list: list[str],
+):
+    # Expand and normalize file paths
+    path_yearly_docs, path_spidered_bibs = expand_paths(path_yearly_docs, path_spidered_bibs)
+
+    # Update options
+    options_ = build_base_options([], [], ["arXiv"], [], path_conf_j_jsons)
+    options_.update(options)
+
+    # Generate md and html files
+    for gc in ["generate_data", "combine_data"]:
+        path_storage = os.path.join(path_spidered_bibs, "Journals")
+        output_basename = os.path.join("data", "Yearly")
+        path_output = os.path.expanduser(os.path.join(path_yearly_docs, output_basename, "Journals"))
+        # "2024", "2023", "2022", "2021", "2020", "2019", "2018", "2017", "2016", "2015"
+        for year in year_list:
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Journals", gc, [year], "all_months", options_
+            )
+
+    # Generate links
+    for keywords_category_name in keywords_category_names:
+        full_json_c, full_json_j, full_json_k = (
+            options_["full_json_c"],
+            options_["full_json_j"],
+            options_["full_json_k"],
+        )
+        output_basename = os.path.join("data", "Yearly")
+        generator = PaperLinksGenerator(full_json_c, full_json_j, full_json_k, path_yearly_docs, keywords_category_name)
+        generator.generate_yearly_links("Journals", output_basename)
+        generator.generate_keywords_links_yearly("Journals", output_basename)
+
+
+def run_generate_c_yearly(
+    options: dict,
+    path_yearly_docs: str,
+    keywords_category_names: list[str],
+    path_spidered_bibs: str,
+    path_conf_j_jsons: str,
+    year_list: list[str],
+):
+    # Expand and normalize file paths
+    path_yearly_docs, path_spidered_bibs = expand_paths(path_yearly_docs, path_spidered_bibs)
+
+    # Update options
+    options_ = build_base_options([], [], ["arXiv"], [], path_conf_j_jsons)
+    options_.update(options)
+
+    # Generate md and html files
+    for gc in ["generate_data", "combine_data"]:
+        path_storage = os.path.join(path_spidered_bibs, "Conferences")
+        output_basename = os.path.join("data", "Yearly")
+        path_output = os.path.expanduser(os.path.join(path_yearly_docs, output_basename, "Conferences"))
+        # "2025", "2024", "2023", "2022", "2021", "2020", "2019", "2018", "2017", "2016", "2015"
+        for year in year_list:
+            generate_from_bibs_and_write(
+                path_storage, path_output, output_basename, "Conferences", gc, [year], "all_months", options_
+            )
+
+    # Generate links
+    for keywords_category_name in keywords_category_names:
+        full_json_c, full_json_j, full_json_k = (
+            options_["full_json_c"],
+            options_["full_json_j"],
+            options_["full_json_k"],
+        )
+        output_basename = os.path.join("data", "Yearly")
+        generator = PaperLinksGenerator(full_json_c, full_json_j, full_json_k, path_yearly_docs, keywords_category_name)
+        generator.generate_yearly_links("Conferences", output_basename)
+        generator.generate_keywords_links_yearly("Conferences", output_basename)

pyeasyphd/scripts/run_replace.py

@@ -0,0 +1,34 @@
+from pybibtexer.tools import replace_to_standard_cite_keys
+
+from ._base import build_base_options, expand_paths
+
+
+def run_replace_to_standard_cite_keys(
+    full_tex_md: str, full_bib: str, path_output: str, path_conf_j_jsons: str, options: dict | None = None
+) -> None:
+    """Replace citation keys in LaTeX documents with standardized versions.
+
+    Processes LaTeX and BibTeX files to normalize citation keys according to
+    configuration standards, then outputs the results to the specified location.
+
+    Args:
+        options: dictionary of configuration options for citation processing
+        full_tex_md: Path to TeX or Markdown file containing citations
+        full_bib: Path to the BibTeX bibliography file
+        path_output: Output directory path for processed files
+        path_conf_j_jsons: Path to journal configuration JSON files
+
+    Returns:
+        None: Results are written to the output directory
+    """
+    if options is None:
+        options = {}
+
+    # Expand and normalize file paths
+    full_tex_md, full_bib, path_output = expand_paths(full_tex_md, full_bib, path_output)
+
+    # Update options
+    options_ = build_base_options([], [], [], [], path_conf_j_jsons)
+    options_.update(options)
+
+    replace_to_standard_cite_keys(full_tex_md, full_bib, path_output, options=options_)

pyeasyphd/scripts/run_search.py

@@ -0,0 +1,251 @@
+import os
+from typing import Any
+
+from pyadvtools import transform_to_data_list
+from pybibtexer.tools import compare_bibs_with_zotero
+
+from pyeasyphd.tools import Searchkeywords
+
+from ._base import build_base_options, build_search_options, expand_path, expand_paths
+
+
+def run_search_for_screen(
+    acronym: str, year: int, title: str, path_spidered_bibs: str, path_spidering_bibs: str, path_conf_j_jsons: str
+) -> None:
+    """Run search for screen display with specific conference/journal parameters.
+
+    Args:
+        acronym: Conference/journal acronym to search for
+        year: Publication year to filter by (0 means all years)
+        title: Paper title used as search keyword
+        path_spidered_bibs: Path to spidered bibliography files
+        path_spidering_bibs: Path to spidering bibliography files
+        path_conf_j_jsons: Path to conferences/journals JSON files
+    """
+    # Handle year filtering: if year is 0, search all years (empty list)
+    search_year_list = [str(year)]
+    if year == 0:
+        search_year_list = []  # Empty list means no year filtering
+
+    # Expand and normalize file paths
+    path_spidered_bibs, path_spidering_bibs, path_conf_j_jsons = expand_paths(
+        path_spidered_bibs, path_spidering_bibs, path_conf_j_jsons
+    )
+
+    # Configure search options
+    options = {
+        **build_base_options(
+            include_publisher_list=[],
+            include_abbr_list=[acronym],
+            exclude_publisher_list=["arXiv"],
+            exclude_abbr_list=[],
+            path_conf_j_jsons=path_conf_j_jsons,
+        ),
+        **build_search_options(
+            print_on_screen=True,
+            search_year_list=search_year_list,  # Empty list for all years, otherwise specific year
+            keywords_type="Temp",
+            keywords_list_list=[[title]],  # Use title as search keyword
+        ),
+    }
+
+    # Execute searches across different bibliography sources
+    _execute_searches(options, "", path_spidered_bibs, path_spidering_bibs, True, True)
+
+    return None
+
+
+def run_search_for_files(
+    keywords_type: str,
+    keywords_list_list: list[list[str]],
+    path_main_output: str,
+    path_spidered_bibs: str,
+    path_spidering_bibs: str,
+    path_conf_j_jsons: str,
+    search_in_spidered_bibs: bool = False,
+    search_in_spidering_bibs: bool = True,
+    options: dict | None = None,
+) -> None:
+    """Run search and save results to files with custom keywords.
+
+    Args:
+        keywords_type: Category name for the search keywords (used for organizing results)
+        keywords_list_list: Nested list of keywords to search for (each inner list represents a search group)
+        path_main_output: Main output directory for search results
+        path_spidered_bibs: Path to spidered bibliography files
+        path_spidering_bibs: Path to spidering bibliography files
+        path_conf_j_jsons: Path to conferences/journals JSON files
+        search_in_spidered_bibs: Whether to search in spidered bibliography files
+        search_in_spidering_bibs: Whether to search in spidering bibliography files
+        options: Additional search options to override defaults
+    """
+    # Initialize options dictionary if not provided
+    if options is None:
+        options = {}
+
+    # Expand and normalize file paths to ensure consistent path formatting
+    path_main_output = expand_path(path_main_output)
+    path_spidered_bibs, path_spidering_bibs, path_conf_j_jsons = expand_paths(
+        path_spidered_bibs, path_spidering_bibs, path_conf_j_jsons
+    )
+
+    # Configure search options by combining base options and search-specific options
+    options_ = {
+        **build_base_options(
+            include_publisher_list=[],  # No specific publishers to include
+            include_abbr_list=[],  # No specific conference/journal abbreviations to include
+            exclude_publisher_list=["arXiv"],  # Exclude arXiv publications from search
+            exclude_abbr_list=[],  # No specific conference/journal abbreviations to exclude
+            path_conf_j_jsons=path_conf_j_jsons,  # Path to conference/journal metadata
+        ),
+        **build_search_options(
+            print_on_screen=False,  # Disable screen output (results go to files only)
+            search_year_list=[],  # Empty list means search all years (no year filtering)
+            keywords_type=keywords_type,  # Use provided keyword category for result organization
+            keywords_list_list=keywords_list_list,  # Use provided nested keyword lists for searching
+        ),
+    }
+    # Update with any additional options provided by caller (overrides defaults)
+    options_.update(options)
+
+    # Execute searches across different bibliography sources with configured options
+    _execute_searches(
+        options_,
+        path_main_output,
+        path_spidered_bibs,
+        path_spidering_bibs,
+        search_in_spidered_bibs,  # Flag to control spidered bibliography search
+        search_in_spidering_bibs,  # Flag to control spidering bibliography search
+    )
+
+    return None
+
+
+def _execute_searches(
+    options: dict[str, Any],
+    path_main_output: str,
+    path_spidered_bibs: str,
+    path_spidering_bibs: str,
+    search_in_spidered_bibs: bool = False,
+    search_in_spidering_bibs: bool = True,
+) -> None:
+    """Execute searches across different bibliography sources.
+
+    Args:
+        options: Search configuration options
+        path_main_output: Base path for search results output
+        path_spidered_bibs: Path to spidered bibliography files
+        path_spidering_bibs: Path to spidering bibliography files
+        search_in_spidered_bibs: Whether to search in spidered bibliography files
+        search_in_spidering_bibs: Whether to search in spidering bibliography files
+    """
+    # Search in spidered bibliographies (Conferences and Journals)
+    # If enabled, search through completed/conference and journal bibliographies
+    if search_in_spidered_bibs:
+        for cj in ["Conferences", "Journals"]:
+            # Construct path to stored bibliography files for conferences/journals
+            path_storage = os.path.join(path_spidered_bibs, cj)
+            # Construct output path for search results
+            path_output = os.path.join(path_main_output, "Search_spidered_bib", cj)
+            # Execute search with given options and paths
+            Searchkeywords(path_storage, path_output, options).run()
+
+    # Search in spidering bibliographies (Journals and Journals Early Access)
+    # If enabled, search through actively spidering/in-progress journal bibliographies
+    if search_in_spidering_bibs:
+        for je in ["spider_j", "spider_j_e"]:
+            # Construct path to spidering bibliography files (journals and early access)
+            path_storage = os.path.join(path_spidering_bibs, je)
+            # Construct output path for search results
+            path_output = os.path.join(path_main_output, "Search_spidering_bib", je)
+            # Execute search with given options and paths
+            Searchkeywords(path_storage, path_output, options).run()
+
+    return None
+
+
+def run_compare_after_search(zotero_bib: str, keywords_type: str, path_main_output: str, path_conf_j_jsons: str):
+    """Compare search results with Zotero bibliography and generate comparison report.
+
+    Args:
+        zotero_bib: Path to Zotero bibliography file
+        keywords_type: Category name for the search keywords used
+        path_main_output: Main output directory for search results and comparison
+        path_conf_j_jsons: Path to conferences/journals JSON files
+    """
+    # Expand and normalize file paths
+    zotero_bib = expand_path(zotero_bib)
+    path_main_output = expand_path(path_main_output)
+    path_conf_j_jsons = expand_path(path_conf_j_jsons)
+
+    # Configure search options
+    options = {
+        **build_base_options(
+            include_publisher_list=[],
+            include_abbr_list=[],
+            exclude_publisher_list=["arXiv"],
+            exclude_abbr_list=[],
+            path_conf_j_jsons=path_conf_j_jsons,
+        ),
+        **build_search_options(
+            print_on_screen=False, search_year_list=[], keywords_type=keywords_type, keywords_list_list=[]
+        ),
+    }
+
+    # Download bibliography files from local search results
+    download_bib = _download_bib_from_local(path_main_output, keywords_type)
+
+    # Generate comparison output path and run comparison
+    path_output = os.path.join(path_main_output, "Compared")
+    compare_bibs_with_zotero(zotero_bib, download_bib, path_output, options)
+
+    return None
+
+
+def _generate_data_list(path_output: str, folder_name: str, keywords_type: str) -> list[str]:
+    """Extract bibliography data content from files in specified folder structure.
+
+    Args:
+        path_output: Base output path for search results
+        folder_name: Specific folder name within the output structure
+        keywords_type: Category name for the search keywords used
+
+    Returns:
+        List of bibliography data content extracted from .bib files in the specified folders
+    """
+    data_list = []
+
+    # Extract data from both title and abstract bibliography folders
+    for bib_type in ["title-bib-zotero", "abstract-bib-zotero"]:
+        folder_path = os.path.join(path_output, f"{folder_name}-Separate", "article", keywords_type, bib_type)
+
+        # Extract bibliography data content if folder exists
+        if os.path.exists(folder_path):
+            data_list.extend(transform_to_data_list(folder_path, ".bib"))
+
+    return data_list
+
+
+def _download_bib_from_local(path_output: str, keywords_type: str) -> list[str]:
+    """Collect bibliography data content from all local search result directories.
+
+    Args:
+        path_output: Base output path containing search results
+        keywords_type: Category name for the search keywords used
+
+    Returns:
+        Combined list of bibliography data content from all .bib files in search results
+    """
+    data_list = []
+
+    # Collect data from spidered bibliographies (Conferences and Journals)
+    for cj in ["Conferences", "Journals"]:
+        folder_name = os.path.join("Search_spidered_bib", cj)
+        data_list.extend(_generate_data_list(path_output, folder_name, keywords_type))
+
+    # Collect data from spidering bibliographies (journal sources)
+    for je in ["spider_j", "spider_j_e"]:
+        folder_name = os.path.join("Search_spidering_bib", je)
+        data_list.extend(_generate_data_list(path_output, folder_name, keywords_type))
+
+    return data_list

pyeasyphd/tools/__init__.py

@@ -0,0 +1,12 @@
+"""Tools module for PyEasyPhD advanced functionality.
+
+This module provides advanced tools for bibliography processing,
+search functionality, and content generation.
+"""
+
+__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
+from .py_run_bib_md_tex import PyRunBibMdTex
+from .search.search_keywords import Searchkeywords

pyeasyphd/tools/generate/generate_from_bibs.py

@@ -0,0 +1,181 @@
+import os
+import re
+from typing import Any
+
+from pyadvtools import standard_path, write_list
+from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
+
+from ...main import PandocMdTo
+from .generate_html import generate_html_content, generate_html_from_bib_data
+from .generate_library import generate_library_by_filters
+
+
+def preparation(
+    path_storage: str,
+    path_output: str,
+    output_basename: str,
+    pub_type: str,
+    issue_or_month_flag: str | list[str] = "current_issue",
+    year_flag: str | list[str] = "current_year",
+    options: dict[str, Any] | None = None,
+):
+    """Prepare paths and flags for data generation.
+
+    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 (str | list[str], optional): Issue or month flag. Defaults to "current_issue".
+        year_flag (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).
+    """
+    if options is None:
+        options = {}
+
+    # default settings
+    path_storage = standard_path(path_storage)
+    path_output = standard_path(path_output)
+
+    # "absolute_path" or "relative_path"
+    absolute_or_relative_path = options.get("absolute_or_relative_path", "absolute_path")
+
+    # Create path components
+    yy = "-".join(year_flag) if isinstance(year_flag, list) else year_flag
+    im = "-".join(issue_or_month_flag) if isinstance(issue_or_month_flag, list) else issue_or_month_flag
+
+    if options.get("early_access", False):
+        base_path = os.path.join(output_basename, f"{pub_type.title()}_Early_Access", f"{yy}_{im}")
+        path_output = os.path.join(path_output + "_Early_Access", f"{yy}_{im}")
+    else:
+        base_path = os.path.join(output_basename, f"{pub_type.title()}", f"{yy}_{im}")
+        path_output = os.path.join(path_output, f"{yy}_{im}")
+
+    path_root = base_path if absolute_or_relative_path == "absolute_path" else ""
+
+    # Determine combine flag
+    b = options.get("early_access", False) and (year_flag != "all_years")
+    c = year_flag == "current_year"
+    c = c and (not isinstance(issue_or_month_flag, list)) and (issue_or_month_flag != "all_months")
+    combine_flag = b or c
+
+    return path_root, path_output, combine_flag
+
+
+def generate_from_bibs_and_write(
+    path_storage: str,
+    path_output: str,
+    output_basename: str,
+    pub_type: str,
+    generate_or_combine: str,
+    year_flag: str | list[str] = "current_year",
+    issue_or_month_flag: str | list[str] = "current_issue",
+    options: dict[str, Any] | None = None,
+) -> None:
+    """Generate or combine data from bibliographies.
+
+    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 (str | list[str], optional): Flag for year selection. Defaults to "current_year".
+        issue_or_month_flag (str | list[str], optional): Flag for issue/month selection. Defaults to "current_issue".
+        options (dict[str, Any], optional): Additional options. Defaults to {}.
+    """
+    if options is None:
+        options = {}
+
+    path_root, path_output, combine_flag = preparation(
+        path_storage, path_output, output_basename, pub_type, issue_or_month_flag, year_flag, options
+    )
+
+    if generate_or_combine == "generate_data":
+        publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(path_storage, options)
+        for publisher in publisher_abbr_dict:
+            pp = os.path.join(path_output, publisher.lower())
+
+            publisher_html_body = []
+            # Separate for abbr
+            for abbr in publisher_abbr_dict[publisher]:
+                print(f"*** Processing {publisher.upper()}: {abbr} ***")
+                new_options = publisher_abbr_dict[publisher][abbr]
+
+                # Get bibliography path
+                path_abbr = os.path.join(path_storage, publisher.lower(), abbr)
+                if isinstance(year_flag, str) and year_flag.isdigit():
+                    for root, _, files in os.walk(path_abbr, topdown=True):
+                        files = [f for f in files if f.endswith(".bib")]
+                        if files := [f for f in files if re.search(f"_{year_flag}.bib", f)]:
+                            path_abbr = os.path.join(root, files[0])
+
+                # Generate and process library
+                library = generate_library_by_filters(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)
+                if combine_flag and html_body:
+                    publisher_html_body.extend([*html_body, "\n"])
+
+            # Combine for publisher
+            if publisher_html_body:
+                html_content = generate_html_content(publisher_html_body[:-1], publisher)
+                write_list(html_content, f"{publisher}_all.html", "w", pp, False)
+
+    elif generate_or_combine == "combine_data":
+        _combine_data(path_storage, path_root, path_output, combine_flag, options)
+
+    return None
+
+
+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"] = []
+    publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(path_storage, options)
+    for publisher in publisher_abbr_dict:
+        print(f"*** Combining papers for {publisher.upper()} ***")
+        pp = os.path.join(path_output, publisher.lower())
+        absolute_path = os.path.join(path_root, publisher) if len(path_root) > 0 else ""
+
+        link = [f"# {publisher.upper()}\n\n"]
+        for abbr in publisher_abbr_dict[publisher]:
+            if os.path.exists(os.path.join(pp, abbr, f"{abbr}.html")):
+                ll = os.path.join(absolute_path, abbr, f"{abbr}.html")
+                link.append(f"- [{abbr}]({ll})\n")
+
+        if combine_flag:
+            ll = os.path.join(absolute_path, f"{publisher}_all.html")
+            link.insert(1, f"- [All Journals]({ll})\n")
+
+        # Process combined content
+        if len(link) > 1:
+            write_list(link, f"{publisher}_link.md", "w", pp, False)
+            PandocMdTo({}).pandoc_md_to_html(pp, pp, f"{publisher}_link.md", f"{publisher}_link.html", True)
+
+        # Clean up
+        for name in ["_link"]:
+            if os.path.exists(file := os.path.join(pp, f"{publisher}{name}.md")):
+                os.remove(file)