pyeasyphd 0.4.42__py3-none-any.whl

pyeasyphd/tools/generate/generate_html.py

@@ -0,0 +1,166 @@
+import os
+from typing import Any
+
+from pyadvtools import write_list
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonRunBib, PythonWriters
+
+from ...utils.utils import html_head, html_style, html_tail, textarea_header, textarea_tail
+
+
+def generate_html_content(html_body, abbr_standard):
+    """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]
+
+
+def generate_html_from_bib_data(
+    abbr_standard: str,
+    original_bib_data: list[str] | str | Library,
+    path_output: str,
+    options: dict[str, Any] | None = None,
+) -> list[str]:
+    """Generate HTML from bibliography data.
+
+    Args:
+        abbr_standard (str): Standard abbreviation for the publication.
+        original_bib_data (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.
+    """
+    if options is None:
+        options = {}
+
+    # Set processing options
+    processing_options: dict = {
+        # convert_str_to_library
+        "is_standardize_bib": False,
+        # middlewares_str_to_library.py
+        "is_display_implicit_comments": False,
+        #
+        # convert_library_to_library.py
+        # middlewares_library_to_library.py
+        "function_common_again": False,
+        "function_common_again_for_abbr": False,
+        "function_common_again_for_zotero": False,
+        "function_common_again_for_save": False,
+        "abbr_index_article_for_abbr": 2,
+        "abbr_index_inproceedings_for_abbr": 2,
+        #
+        # convert_library_to_str.py
+        "empty_entry_cite_keys": True,
+        # middlewares_library_to_str.py
+        "is_sort_entry_fields": True,
+        "is_sort_blocks": True,
+        "sort_entries_by_field_keys_reverse": True,
+    }
+    # Update with provided options
+    processing_options.update(options)
+
+    # Process bibliography data
+    _python_bib = PythonRunBib(processing_options)
+    _, zotero_library, _ = _python_bib.parse_to_multi_standard_library(original_bib_data)
+
+    _python_writer = PythonWriters(processing_options)
+
+    # Generate HTML content for each entry
+    html_body = []
+    for entry in zotero_library.entries:
+        html_body.append(_format_entry_to_html(entry, abbr_standard, _python_writer.write_to_str([entry])))
+
+    # Create complete HTML document if entries exist
+    if len(html_body) > 0:
+        html_body = [
+            f'<h2 id="{abbr_standard.lower()}">{abbr_standard} - {len(zotero_library.entries)}</h2>\n',
+            "<ul>\n",
+            *html_body,
+            "</ul>\n",
+        ]
+
+        html_content = generate_html_content(html_body, abbr_standard)
+        output_dir = os.path.join(path_output, abbr_standard)
+
+        # Write output file
+        write_list(html_content, f"{abbr_standard}.html", "w", output_dir, False)
+
+    return html_body
+
+
+def _format_entry_to_html(entry, abbr, data_list):
+    """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 ""
+    title = entry["title"] if "title" in entry else ""
+    year = entry["year"] if "year" in entry else ""
+    volume = entry["volume"] if "volume" in entry else ""
+
+    # Get URL (DOI preferred, fall back to URL)
+    url = ""
+    if "doi" in entry:
+        doi = entry["doi"]
+        url = doi if doi.startswith("http") else f"https://doi.org/{doi}"
+    elif "url" in entry:
+        url = entry["url"]
+
+    # Format entry in APA style
+    line = _format_entry_to_apa_style(title, year, volume, number, pages, url, abbr)
+
+    line = f"<li><details>\n<summary>\n{line.strip()}\n</summary>\n"
+
+    # Create HTML structure with details
+    return line + textarea_header + "".join(data_list).rstrip() + textarea_tail + "\n</details></li>\n"
+
+
+def _format_entry_to_apa_style(title, year, volume, number, pages, url, abbr):
+    """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:
+        line += f", <em>{volume}</em>"
+        if number:
+            line += f"({number})"
+
+    if pages:
+        line += f", {pages}"
+
+    line += "."
+
+    if url:
+        line += f" (<a href='{url}'>www</a>)"
+
+    return line

pyeasyphd/tools/generate/generate_library.py

@@ -0,0 +1,203 @@
+from typing import Any
+
+from pyadvtools import IterateSortDict
+from pybibtexer.bib.bibtexparser import Entry, Library
+from pybibtexer.main import PythonRunBib
+
+
+def generate_library_by_filters(
+    original_data: list[str] | str | Library,
+    issue_or_month_flag: str | list[str],  # filter
+    year_flag: str | list[str] = "current_year",  # filter
+    options: dict[str, Any] | None = None,
+) -> Library:
+    """Generate a Library object from input data with given filters.
+
+    Args:
+        original_data (list[str] | str | Library): Input bibliography data.
+        issue_or_month_flag (str | list[str]): Flag for issue/month selection.
+        year_flag (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.
+    """
+    if options is None:
+        options = {}
+
+    _options = {}
+    # convert_str_to_library
+    _options["is_standardize_bib"] = False  # default is True
+    # middlewares_str_to_library.py
+    _options["is_display_implicit_comments"] = False  # default is True
+
+    # convert_library_to_library.py
+    _options["choose_abbr_zotero_save"] = "save"  # default is "save"
+    # middlewares_library_to_library.py
+    _options["generate_entry_cite_keys"] = False  # default is False
+    _options["function_common_again"] = False  # default is True
+    _options["function_common_again_for_abbr"] = False  # default is True
+    _options["function_common_again_for_zotero"] = False  # default is True
+    _options["function_common_again_for_save"] = False  # default is True
+
+    # convert_library_to_str.py
+    # middlewares_library_to_str.py
+    _options["is_sort_entry_fields"] = True  # compulsory
+    _options["is_sort_blocks"] = True  # compulsory
+    _options["sort_entries_by_field_keys_reverse"] = True  # compulsory
+
+    # convert_str_to_str.py
+    _options["default_additional_field_list"] = []
+    # middlewares_str_to_str.py
+    _options["substitute_in_bib"] = False  # default is True
+
+    _options.update(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)
+    old_dict = entry_type_year_volume_number_month_entry_dict
+
+    # Filter by year flag
+    new_dict = _obtain_year_flag_library(old_dict, year_flag)
+
+    # Filter by year flag
+    if not (isinstance(year_flag, str) and (year_flag.lower().strip() == "current_year")):
+        issue_or_month_flag = "all_months"
+
+    # Filter by issue flag
+    if issue_or_month_flag in ["current_issue"]:
+        return _obtain_issue_flag_library(new_dict, issue_or_month_flag)
+
+    # Filter by month flag
+    return _obtain_month_flag_library(new_dict, issue_or_month_flag)
+
+
+def _obtain_year_flag_library(
+    nested_entries: dict[str, dict[str, dict[str, dict[str, dict[str, list[Entry]]]]]],
+    year_flag: str | list[str] = "current_year",
+):
+    """Filter dictionary by year flag.
+
+    Args:
+        nested_entries: Nested dictionary containing bibliography entries.
+        year_flag (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 = list(nested_entries[entry_type])
+
+        # Update years
+        if isinstance(year_flag, list):  # given_years
+            years = sorted(set(years).intersection(set(year_flag)))
+        elif year_flag.lower().strip() == "all_years":  # all_years
+            years = years
+        elif year_flag.lower().strip() == "current_year":  # current_year
+            years = years[:1]
+        else:
+            years = []
+            print(f"Unknown year flag: {year_flag}.")
+
+        for year in years:
+            new_dict.setdefault(entry_type, {}).update({year: nested_entries[entry_type][year]})
+
+    return new_dict
+
+
+def _obtain_issue_flag_library(
+    nested_entries: dict[str, dict[str, dict[str, dict[str, dict[str, list[Entry]]]]]],
+    issue_flag: str = "current_issue",
+) -> Library:
+    """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 = []
+    for entry_type in nested_entries:
+        for year in nested_entries[entry_type]:
+            temp_dict = nested_entries[entry_type][year]
+
+            # Article entries
+            if entry_type.lower() == "article":
+                volumes, numbers, months = [], [], []
+                for volume in (volumes := list(temp_dict)):
+                    for number in (numbers := list(temp_dict[volume])):
+                        months = list(temp_dict[volume][number])
+                        break
+                    break
+
+                if issue_flag == "current_issue":  # current volume, current issue, and current month
+                    entries.extend(temp_dict[volumes[0]][numbers[0]][months[0]])
+                else:
+                    print(f"Unknown issue flag: {issue_flag}.")
+
+            else:
+                # Non-article entries
+                for volume in temp_dict:
+                    for number in temp_dict[volume]:
+                        for month in temp_dict[volume][number]:
+                            entries.extend(temp_dict[volume][number][month])
+
+    return Library(entries)
+
+
+def _obtain_month_flag_library(
+    nested_entries: dict[str, dict[str, dict[str, dict[str, dict[str, list[Entry]]]]]],
+    month_flag: str | list[str] = "current_month",
+) -> Library:
+    """Filter dictionary by month flag.
+
+    Args:
+        nested_entries: Nested dictionary containing bibliography entries.
+        month_flag (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]:
+            for volume in nested_entries[entry_type][year]:
+                for number in nested_entries[entry_type][year][volume]:
+                    for month in nested_entries[entry_type][year][volume][number]:
+                        new_dict.setdefault(entry_type, {}).setdefault(year, {}).setdefault(month, {}).setdefault(
+                            volume, {}
+                        ).setdefault(number, []).extend(nested_entries[entry_type][year][volume][number][month])
+
+    # Sort
+    nested_entries = IterateSortDict(True).dict_update(new_dict)
+
+    entries = []
+    for entry_type in nested_entries:
+        for year in nested_entries[entry_type]:
+            temp_dict = nested_entries[entry_type][year]
+            default_months = list(temp_dict)
+
+            # Update month
+            new_months = []
+            if month_flag == "current_month":  # current_month
+                new_months = default_months[:1]
+            elif month_flag == "all_months":  # all months
+                new_months = default_months
+            else:
+                print(f"Unknown month flag: {month_flag}.")
+
+            # Filter by month
+            for month in new_months:
+                for volume in temp_dict[month]:
+                    for number in temp_dict[month][volume]:
+                        entries.extend(temp_dict[month][volume][number])
+
+    return Library(entries)