pyeasyphd 0.1.0__tar.gz → 0.1.1__tar.gz

{pyeasyphd-0.1.0 → pyeasyphd-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeasyphd
-Version: 0.1.0
+Version: 0.1.1
 Summary: pyeasyphd
 License: GPL-3.0-or-later
 Keywords: Python,Markdown,LaTex
@@ -8,17 +8,14 @@ Author: NextAI
 Author-email: nextartifintell@gmail.com
 Maintainer: NextAI
 Maintainer-email: nextartifintell@gmail.com
-Requires-Python: >=3.8.1
+Requires-Python: >=3.13
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 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)
 Project-URL: Documentation, https://github.com/NextArtifIntell/pyeasyphd
 Project-URL: Homepage, https://github.com/NextArtifIntell/pyeasyphd
 Project-URL: Repository, https://github.com/NextArtifIntell/pyeasyphd

pyeasyphd-0.1.1/pyeasyphd/.python-version

@@ -0,0 +1 @@
+3.13

{pyeasyphd-0.1.0 → pyeasyphd-0.1.1}/pyeasyphd/main/__init__.py

@@ -3,15 +3,11 @@
 __all__ = [
     "BasicInput",
     "PandocMdTo",
-    "PythonRunBib",
     "PythonRunMd",
     "PythonRunTex",
-    "PythonWriters",
 ]
 
 from .basic_input import BasicInput
 from .pandoc_md_to import PandocMdTo
-from .python_run_bib import PythonRunBib
 from .python_run_md import PythonRunMd
 from .python_run_tex import PythonRunTex
-from .python_writers import PythonWriters

{pyeasyphd-0.1.0 → pyeasyphd-0.1.1}/pyeasyphd/main/basic_input.py

@@ -1,11 +1,11 @@
-import json
 import os
 from typing import Any, Dict
 
 from pyadvtools import read_list, standard_path
+from pybibtexer.main import BasicInput as BasicInputInPyBibtexer
 
 
-class BasicInput(object):
+class BasicInput(BasicInputInPyBibtexer):
     """Basic input.
 
     Args:
@@ -16,11 +16,6 @@ class BasicInput(object):
         path_figures (str): Path figures.
         path_templates (str): Path templates.
 
-        full_abbr_article_dict (Dict[str, str]): Full abbr article dict.
-        full_abbr_inproceedings_dict (Dict[str, str]): Full abbr inproceedings dict.
-        full_names_in_json (str): Full names in json.
-        abbr_names_in_json (str): Abbr names in json.
-
         full_csl_style_pandoc (str): Full path to csl style for pandoc.
         full_tex_article_template_pandoc (str): Full path to tex article template for pandoc.
         article_template_tex (List[str]): Article template for LaTex.
@@ -29,8 +24,8 @@ class BasicInput(object):
         article_template_tail_tex (List[str]): Article template tail for LaTex.
         beamer_template_header_tex (List[str]): Beamer template header for LaTex.
         beamer_template_tail_tex (List[str]): Beamer template tail for LaTex.
-        tex_math_commands_tex (List[str]): Tex math commands for LaTex.
-        tex_usepackages_tex (List[str]): Tex usepackages for LaTex.
+        math_commands_tex (List[str]): Tex math commands for LaTex.
+        usepackages_tex (List[str]): Tex usepackages for LaTex.
         handly_preamble (bool): Handly preamble.
 
         options (Dict[str, Any]): Options.
@@ -68,8 +63,9 @@ class BasicInput(object):
                     self.path_templates = p
                     break
 
-        # bib/core
-        self._initialize_middlewares(options)
+        full_json_c = os.path.join(self.path_templates, "AbbrFull", "conferences.json")
+        full_json_j = os.path.join(self.path_templates, "AbbrFull", "journals.json")
+        super().__init__(full_json_c, full_json_j, options)
 
         # main
         self._initialize_pandoc_md_to(options)
@@ -77,58 +73,6 @@ class BasicInput(object):
 
         self.options = options
 
-    # bib/core
-    def _initialize_middlewares(self, options: Dict[str, Any]) -> None:
-        full_json_c = os.path.join(self.path_templates, "AbbrFull", "conferences.json")
-        full_json_j = os.path.join(self.path_templates, "AbbrFull", "journals.json")
-        if os.path.isfile(full_json_c):
-            with open(full_json_c, "r") as f:
-                try:
-                    json_dict = json.loads(f.read())
-                except Exception as e:
-                    print(e)
-                    json_dict = {}
-                full_abbr_inproceedings_dict = {p: json_dict[p].get("conferences", {}) for p in json_dict}
-        else:
-            full_abbr_inproceedings_dict = {}
-
-        if os.path.isfile(full_json_j):
-            with open(full_json_j, "r") as f:
-                try:
-                    json_dict = json.loads(f.read())
-                except Exception as e:
-                    print(e)
-                    json_dict = {}
-                full_abbr_article_dict = {p: json_dict[p].get("journals", {}) for p in json_dict}
-        else:
-            full_abbr_article_dict = {}
-
-        inproceedings_dict = options.get("full_abbr_inproceedings_dict", {})
-        if len(inproceedings_dict) == 0:
-            inproceedings_dict = full_abbr_inproceedings_dict
-        self.full_abbr_inproceedings_dict = full_abbr_inproceedings_dict
-
-        article_dict = options.get("full_abbr_article_dict", {})
-        if len(article_dict) == 0:
-            article_dict = full_abbr_article_dict
-        self.full_abbr_article_dict = full_abbr_article_dict
-
-        full_names_in_json = options.get("full_names_in_json", "names_full")
-        if len(full_names_in_json) == 0:
-            full_names_in_json = "names_full"
-        self.full_names_in_json = full_names_in_json
-
-        abbr_names_in_json = options.get("abbr_names_in_json", "names_abbr")
-        if len(abbr_names_in_json) == 0:
-            abbr_names_in_json = "names_abbr"
-        self.abbr_names_in_json = abbr_names_in_json
-
-        options["full_abbr_article_dict"] = self.full_abbr_article_dict
-        options["full_abbr_inproceedings_dict"] = self.full_abbr_inproceedings_dict
-
-        options["full_names_in_json"] = self.full_names_in_json
-        options["abbr_names_in_json"] = self.abbr_names_in_json
-
     # main
     def _initialize_pandoc_md_to(self, options: Dict[str, Any]) -> None:
         csl_name = options.get("csl_name", "apa-no-ampersand")

{pyeasyphd-0.1.0 → pyeasyphd-0.1.1}/pyeasyphd/main/python_run_md.py

@@ -11,11 +11,11 @@ from pyadvtools import (
     read_list,
     write_list,
 )
+from pybibtexer.bib.core import ConvertStrToLibrary
+from pybibtexer.main.python_writers import PythonWriters
 
-from ..bib.core import ConvertStrToLibrary
 from .basic_input import BasicInput
 from .pandoc_md_to import PandocMdTo
-from .python_writers import PythonWriters
 
 
 class PythonRunMd(BasicInput):
@@ -135,7 +135,7 @@ class PythonRunMd(BasicInput):
         _options = {}
         _options.update(self.options)
         _options["add_index_to_enties"] = False
-        _python_writers = PythonWriters(_options)
+        _python_writers = PythonWriters(self.full_json_c, self.full_json_j, _options)
         key_url_http_bib_dict = _python_writers.output_key_url_http_bib_dict(library)
 
         content_md = []

pyeasyphd-0.1.1/pyeasyphd/pyeasyphd.sublime-settings

@@ -0,0 +1,78 @@
+{
+    // config
+    // config path
+    // Must be configured by the user.
+    "path_config": "",
+
+    // figures, templates, bibs
+    "path_bibs": "",
+    "path_figures": "",
+    "path_templates": "",
+
+    // pyeasyphd/main/pandoc_md_to.py
+    // for pandoc
+    "csl_name": "apa-no-ampersand",
+    // the number of columns in md files
+    "columns_in_md": 120,
+    // display one line reference note
+    "google_connected_paper_scite": true,
+    "display_one_line_reference_note": false,
+    // "fullcite", "cite"
+    "cite_flag_in_tex": "cite",
+
+    // for md file
+    // pyeasyphd/main/python_run_md.py
+    // default is ""
+    "final_output_main_md_name": "",
+    // true, false
+    "delete_temp_generate_md": true,
+    // add reference to markdown files
+    "add_reference_in_md": true,
+    // add bib to markdown files
+    "add_bib_in_md": false,
+    // true, false
+    "replace_cite_to_fullcite_in_md": false,
+    // basic, beauty, complex
+    "replace_by_basic_beauty_complex_in_md": "beauty",
+    // basic, beauty, complex
+    "display_basic_beauty_complex_references_in_md": "beauty",
+
+    // for tex file
+    // pyeasyphd/main/python_run_tex.py
+    // handly preamble
+    "handly_preamble": false,
+
+    // default is ""
+    "final_output_main_tex_name": "",
+    // true, false
+    "run_latex": false,
+    // "pdflatex", "xelatex"
+    "pdflatex_xelatex": "pdflatex",
+    // true, false
+    "delete_run_latex_cache": true,
+    "latex_clean_file_types": [
+        ".aux", ".bbl", ".bcf", ".blg", ".fdb_latexmk", ".fls", ".log", ".out", ".run.xml", ".synctex.gz", ".gz",
+        ".nav", ".snm", ".toc", ".xdv"
+    ],
+
+    // pyeasyphd/tools/python_run_latex_md.py
+    // true, false
+    "generate_html": false,
+
+    // true, false
+    "generate_tex": true,
+
+    // ture, false
+    "shutil_figures": true,
+
+    // for figure, bib, tex, and md
+    "figure_folder_name": "fig", // "" or "figs" or "main"
+    "bib_folder_name": "bib", // "" or "bibs" or "main"
+    "md_folder_name": "md", // "" or "mds" or "main"
+    "tex_folder_name": "tex", // "" or "texs" or "main"
+
+    // for delete original md, tex, and bib files in output folder
+    "delete_original_md_in_output_folder": false,
+    "delete_original_tex_in_output_folder": false,
+    "delete_original_bib_in_output_folder": false,
+}

pyeasyphd-0.1.1/pyeasyphd/tools/__init__.py

@@ -0,0 +1,15 @@
+"""Initialization."""
+
+__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-0.1.1/pyeasyphd/tools/generate/generate_from_bibs.py

@@ -0,0 +1,173 @@
+import os
+import re
+from typing import Any, Dict, List, Union
+
+from pyadvtools import standard_path, write_list
+from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
+
+from ...main import BasicInput, PandocMdTo
+from .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: Union[str, List[str]] = "current_issue",
+    year_flag: Union[str, List[str]] = "current_year",
+    options: Dict[str, Any] = {},
+):
+    """Prepare paths and flags for data generation.
+
+    Examples
+    --------
+    |              | current_issue | current_month | all_months |
+    |--------------|---------------|---------------|------------|
+    | current_year | YES           | YES           | YES        |
+    | all_years    | NO            | NO            | YES        |
+    | given_years  | NO            | NO            | YES        |
+
+    given_years = ["2020", "2025"]
+
+    Returns
+    -------
+    Tuple[str, str, bool]
+        Returns (path_root, path_output, combine_flag)
+    """
+    # 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: Union[str, List[str]] = "current_year",
+    issue_or_month_flag: Union[str, List[str]] = "current_issue",
+    options: Dict[str, Any] = {},
+) -> None:
+    """Generate or combine data from bibliographies.
+
+    Parameters
+    ----------
+    path_storage : str
+        Path to storage directory
+    path_output : str
+        Path to output directory
+    generate_or_combine : str
+        Either "generate_data" or "combine_data"
+    year_flag : Union[str, List[str]], optional
+        Flag for year selection, by default "current_year"
+    issue_or_month_flag : Union[str, List[str]], optional
+        Flag for issue/month selection, by default "current_issue"
+    options : Dict[str, Any], optional
+        Additional options, by default {}
+    """
+    path_root, path_output, combine_flag = preparation(
+        path_storage, path_output, output_basename, pub_type, issue_or_month_flag, year_flag, options
+    )
+
+    # Default settings
+    x = BasicInput(options)
+    options = x.options
+    full_json_c = x.full_json_c
+    full_json_j = x.full_json_j
+
+    if generate_or_combine == "generate_data":
+        publisher_abbr_dict = generate_standard_publisher_abbr_options_dict(path_storage, options)
+        for publisher in publisher_abbr_dict:
+            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, full_json_c, full_json_j
+                )
+
+                # Generate md, tex, pdf, html
+                html_body = generate_html_from_bib_data(abbr, library, pp, new_options, full_json_c, full_json_j)
+                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):
+    # 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)

pyeasyphd-0.1.1/pyeasyphd/tools/generate/generate_html.py

@@ -0,0 +1,122 @@
+import os
+from typing import Any, Dict, List, Union
+
+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."""
+    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: Union[List[str], str, Library],
+    path_output: str,
+    options: Dict[str, Any] = {},
+    full_json_c: str = "",
+    full_json_j: str = ""
+) -> List[str]:
+    """Generate html from bibliography data."""
+    # 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_abbr": False,
+        "function_common_again_zotero": False,
+        "function_common_again_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(full_json_c, full_json_j, processing_options)
+    _, zotero_library, _ = _python_bib.parse_to_multi_standard_library(original_bib_data)
+
+    _python_writer = PythonWriters(full_json_c, full_json_j, processing_options)
+
+    # 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."""
+    # 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."""
+    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