pyeasyphd 0.0.7__tar.gz → 0.0.9__tar.gz

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pyeasyphd
-Version: 0.0.7
+Version: 0.0.9
 Summary: pyeasyphd
 License: GPL-3.0-or-later
 Keywords: Python,Markdown,LaTex
@@ -16,6 +16,7 @@ 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)
 Project-URL: Documentation, https://github.com/NextArtifIntell/pyeasyphd

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyeasyphd/main/basic_input.py

@@ -45,13 +45,19 @@ class BasicInput(object):
         # Update
         path_config = standard_path(options.get("path_config", ""))
         if len(self.path_bibs) == 0:
-            for folder in ["bib", "bibs", "Bib", "Bibs", "BIB", "BIBS"]:
+            for folder in [
+                "bib", "bibs", "Bib", "Bibs", "BIB", "BIBS",
+                "reference", "references", "Reference", "References", "REFERENCE", "REFERENCES"
+            ]:
                 if os.path.exists(p := os.path.join(path_config, folder)):
                     self.path_bibs = p
                     break
 
         if len(self.path_figures) == 0:
-            for folder in ["figure", "figures", "Figure", "Figures", "FIGURE", "FIGURES"]:
+            for folder in [
+                "figure", "figures", "Figure", "Figures", "FIGURE", "FIGURES",
+                "fig", "figs", "Fig", "Figs", "FIG", "FIGS",
+            ]:
                 if os.path.exists(p := os.path.join(path_config, folder)):
                     self.path_figures = p
                     break
@@ -128,18 +134,26 @@ class BasicInput(object):
         csl_name = options.get("csl_name", "apa-no-ampersand")
         if len(csl_name) == 0:
             csl_name = "apa-no-ampersand"
-        self.full_csl_style_pandoc = os.path.join(self.path_templates, "CSL", f"{csl_name}.csl")
-        self.full_tex_article_template_pandoc = os.path.join(self.path_templates, "TEX", "eisvogel.tex")
 
-        self.article_template_tex = read_list(os.path.join(self.path_templates, "TEX", "Article.tex"))
+        full_csl_style_pandoc = os.path.join(self.path_templates, "CSL", f"{csl_name}.csl")
+        if (p := options.get("full_csl")) is not None:
+            full_csl_style_pandoc = p
+        self.full_csl_style_pandoc = full_csl_style_pandoc
+
+        full_tex_article_template_pandoc = os.path.join(self.path_templates, "TEX", "eisvogel.tex")
+        if (p := options.get("full_eisvogel")) is not None:
+            full_tex_article_template_pandoc = p
+        self.full_tex_article_template_pandoc = full_tex_article_template_pandoc
+
+        self.article_template_tex = self._try_read_list(options, "TEX", "Article.tex", "full_article")
 
     def _initialize_python_run_tex(self, options: Dict[str, Any]) -> None:
-        self.article_template_header_tex = read_list(os.path.join(self.path_templates, "TEX", "Article_Header.tex"))
-        self.article_template_tail_tex = read_list(os.path.join(self.path_templates, "TEX", "Article_Tail.tex"))
-        self.beamer_template_header_tex = read_list(os.path.join(self.path_templates, "TEX", "Beamer_Header.tex"))
-        self.beamer_template_tail_tex = read_list(os.path.join(self.path_templates, "TEX", "Beamer_Tail.tex"))
-        self.math_commands_tex = read_list(os.path.join(self.path_templates, "TEX", "math_commands.tex"))
-        self.usepackages_tex = read_list(os.path.join(self.path_templates, "TEX", "Style.tex"))
+        self.article_template_header_tex = self._try_read_list(options, "TEX", "Article_Header.tex", "full_article_header")
+        self.article_template_tail_tex = self._try_read_list(options, "TEX", "Article_Tail.tex", "full_article_tail")
+        self.beamer_template_header_tex = self._try_read_list(options, "TEX", "Beamer_Header.tex", "full_beamer_header")
+        self.beamer_template_tail_tex = self._try_read_list(options, "TEX", "Beamer_Tail.tex", "full_beamer_tail")
+        self.math_commands_tex = self._try_read_list(options, "TEX", "math_commands.tex", "full_math_commands")
+        self.usepackages_tex = self._try_read_list(options, "TEX", "Style.tex", "full_usepackages_tex")
 
         # handly preamble
         self.handly_preamble = options.get("handly_preamble", False)
@@ -147,3 +161,17 @@ class BasicInput(object):
             self.article_template_header_tex, self.article_template_tail_tex = [], []
             self.beamer_template_header_tex, self.beamer_template_tail_tex = [], []
             self.math_commands_tex, self.usepackages_tex = [], []
+
+    def _try_read_list(self, options: Dict[str, Any], folder_name: str, file_name: str, key: str):
+        path_file = os.path.join(self.path_templates, folder_name, file_name)
+        if (p := options.get(key)) is None:
+            return []
+        else:
+            path_file = p
+
+        try:
+            data_list = read_list(path_file)
+        except Exception as e:
+            print(e)
+            data_list = []
+        return data_list

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyeasyphd/tools/compare/compare_bibs.py

@@ -127,7 +127,7 @@ def _compare_with_local(
             if len(data_list := transform_to_data_list(path_abbr, ".bib")) == 0:
                 continue
 
-            print("*" * 9 + f" Compare in {'/'.join(path_abbr.split('/')[-3:])} for {abbr} " + "*" * 9)
+            print("*" * 9 + f" Compare in {f'{os.sep}'.join(path_abbr.split(os.sep)[-3:])} for {abbr} " + "*" * 9)
 
             _options = {}
             _options["is_standardize_bib"] = False  # default is True

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyeasyphd/tools/generate/generate_from_bibs.py

@@ -47,10 +47,10 @@ def preparation(
     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 = f"{output_basename}/{pub_type.title()}_Early_Access/{yy}_{im}"
+        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 = f"{output_basename}/{pub_type.title()}/{yy}_{im}"
+        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 ""
@@ -106,7 +106,7 @@ def generate_from_bibs_and_write(
                 new_options = publisher_abbr_dict[publisher][abbr]
 
                 # Get bibliography path
-                path_abbr = os.path.join(path_storage, f"{publisher.lower()}/{abbr}")
+                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")]
@@ -134,15 +134,17 @@ def generate_from_bibs_and_write(
         for publisher in publisher_abbr_dict:
             print(f"*** Combining papers for {publisher.upper()} ***")
             pp = os.path.join(path_output, publisher.lower())
-            absolute_path = f"{path_root}/{publisher}" if len(path_root) > 0 else ""
+            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")):
-                    link.append(f"- [{abbr}]({absolute_path}/{abbr}/{abbr}.html)\n")
+                    ll = os.path.join(absolute_path, abbr, f"{abbr}.html")
+                    link.append(f"- [{abbr}]({ll})\n")
 
             if combine_flag:
-                link.insert(1, f"- [All Journals]({absolute_path}/{publisher}_all.html)\n")
+                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:

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyeasyphd/tools/generate/generate_links.py

@@ -3,7 +3,7 @@
 import json
 import os
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Dict, List
 
 from pyadvtools import standard_path
 
@@ -15,7 +15,7 @@ class PaperLinksGenerator:
         self,
         json_base_path: str,
         data_base_path: str,
-        default_publication_keywords: Optional[List[str]] = None,
+        keywords_category_name: str = "",
         display_year_period: int = 10,
     ):
         """
@@ -28,18 +28,21 @@ class PaperLinksGenerator:
         self.json_base_path = standard_path(json_base_path)
         self.data_base_path = standard_path(data_base_path)
 
-        if (default_publication_keywords is None) or (len(default_publication_keywords) == 0):
-            x = self._load_json_data("keywords").get("default_keywords", [])
-            if isinstance(x, list):
-                default_publication_keywords = x
-            else:
-                default_publication_keywords = []
+        # Process keyword category name and load data
+        keywords_category_name = keywords_category_name.lower().strip() if keywords_category_name else ""
+        category_prefix = f"{keywords_category_name}_" if keywords_category_name else ""
+        keywords_list = self._load_json_data("keywords").get(f"{category_prefix}keywords", [])
+
+        # Validate data availability
+        if not keywords_list or not keywords_category_name:
+            keywords_list, keywords_category_name = [], ""
 
-        self.default_publication_keywords: List[str] = default_publication_keywords
+        self.keywords_category_name = keywords_category_name
+        self.keywords_list: List[str] = keywords_list
 
         self.display_year_period = display_year_period
 
-    def generate_yearly_links(self, cj: str, folder_name="data/Yearly") -> None:
+    def generate_yearly_links(self, cj: str, folder_name=os.path.join("data", "Yearly")) -> None:
         """
         Generate yearly markdown table with paper links.
 
@@ -51,7 +54,7 @@ class PaperLinksGenerator:
 
         self._generate_links(cj, flags, folder_flags, folder_name)
 
-    def generate_weekly_links(self, folder_name="data/Weekly") -> None:
+    def generate_weekly_links(self, folder_name=os.path.join("data", "Weekly")) -> None:
         """Generate weekly markdown table with journal paper links."""
         cj = "Journals"
 
@@ -94,7 +97,7 @@ class PaperLinksGenerator:
         except Exception as e:
             print(f"Pandoc conversion error: {e}")
 
-    def generate_ieee_early_access_links(self, folder_name="data/Weekly") -> None:
+    def generate_ieee_early_access_links(self, folder_name=os.path.join("data", "Weekly")) -> None:
         """Generate markdown for IEEE Early Access papers."""
         md_content = [
             "# Papers from Early Access\n\n",
@@ -171,7 +174,7 @@ class PaperLinksGenerator:
         cells = []
 
         for flag in folder_flags:
-            link_path = f"{period}/{cj}/{flag}/{publisher.lower()}/{publisher.lower()}_link.html"
+            link_path = os.path.join(period, cj, flag, publisher.lower(), f"{publisher.lower()}_link.html")
             full_path = os.path.join(self.data_base_path, link_path)
 
             if os.path.exists(full_path):
@@ -205,7 +208,7 @@ class PaperLinksGenerator:
         """Get link cells for a abbr."""
         cells = []
         for flag in folder_flags:
-            link_path = f"{period}/{cj}/{flag}/{publisher.lower()}/{abbr}/{abbr}.html"
+            link_path = os.path.join(period, cj, flag, publisher.lower(), abbr, f"{abbr}.html")
             full_path = os.path.join(self.data_base_path, link_path)
             if os.path.exists(full_path):
                 cells.append(f"[{abbr}]({link_path})")
@@ -214,12 +217,12 @@ class PaperLinksGenerator:
 
         return cells
 
-    def _get_ieee_links(self, folder_name="data/Weekly") -> List[str]:
+    def _get_ieee_links(self, folder_name=os.path.join("data", "Weekly")) -> List[str]:
         """Get IEEE Early Access links."""
         links = []
         link_paths = [
-            f"{folder_name}/Journals_Early_Access/current_year_current_month/ieee/ieee_link.html",
-            f"{folder_name}/Journals_Early_Access/all_years_all_months/ieee/ieee_link.html",
+            os.path.join(folder_name, "Journals_Early_Access", "current_year_current_month", "ieee", "ieee_link.html"),
+            os.path.join(folder_name, "Journals_Early_Access", "all_years_all_months", "ieee", "ieee_link.html"),
         ]
 
         for link_path in link_paths:
@@ -247,13 +250,13 @@ class PaperLinksGenerator:
         return None
 
     #
-    def generate_keywords_links_monthly(self, cj: str, folder_name="data/Weekly"):
+    def generate_keywords_links_monthly(self, cj: str, folder_name=os.path.join("data", "Weekly")):
         flags = ["Current Issue", "Current Month", "All Months"]
         folder_flags = [f"current_year_{f.replace(' ', '_').lower()}" for f in flags]
 
         self._generate_keywords_links(cj, folder_name, flags, folder_flags)
 
-    def generate_keywords_links_yearly(self, cj: str, folder_name="data/Yearly"):
+    def generate_keywords_links_yearly(self, cj: str, folder_name=os.path.join("data", "Yearly")):
         flags = self._get_yearly_flags(cj)
         folder_flags = [f"{f}_all_months" for f in flags]
 
@@ -266,16 +269,9 @@ class PaperLinksGenerator:
 
         keyword_publisher_abbr = self._process_keywords(cj, json_data)
 
-        # Get and sort publication types
-        pub_types = list(keyword_publisher_abbr.keys())
-        default_pub_types = self.default_publication_keywords
-        default_pub_types = self.default_publication_keywords + sorted(
-            list(set(pub_types) - set(self.default_publication_keywords))
-        )
-
         all_data_list = ["# Keywords\n\n", "| |Keywords|Links|\n", "|-|-|-|\n"]
         idx = 1
-        for keyword in sorted(pub_types, key=default_pub_types.index):
+        for keyword in self._default_or_customized_keywords(keyword_publisher_abbr):
             data_list = [
                 f"# {keyword.title()}\n\n",
                 "|Publishers|Abbreviations|" + "|".join(flags) + "|\n",
@@ -285,7 +281,7 @@ class PaperLinksGenerator:
             for publisher in keyword_publisher_abbr[keyword]:
                 for abbr in keyword_publisher_abbr[keyword][publisher]:
                     lines = [
-                        f"[Link]({folder_name}/{cj.title()}/{ff}/{publisher.lower()}/{abbr}/{abbr}.html)"
+                        f"[Link]({os.path.join(folder_name, cj.title(), ff, publisher.lower(), abbr, f'{abbr}.html')})"
                         for ff in folder_flags
                     ]
 
@@ -295,29 +291,46 @@ class PaperLinksGenerator:
             if len(data_list) == 3:
                 continue
 
-            self._write_md_file(data_list, f"{folder_name}/{cj.title()}_Keywords", f"{keyword.replace(' ', '_')}.md")
+            self._write_md_file(
+                data_list, os.path.join(folder_name, f"{cj.title()}_Keywords"), f"{keyword.replace(' ', '_')}.md"
+            )
 
             # Pandoc
             self._convert_md_to_html_keyword(folder_name, cj, keyword)
 
-            all_data_list.append(
-                f"|{idx}|{keyword}|[Link]({folder_name}/{cj.title()}_Keywords/{keyword.replace(' ', '_')}.html)|\n"
-            )
+            # TODO
+            ll = os.path.join(folder_name, f"{cj.title()}_Keywords", f"{keyword.replace(' ', '_')}.html")
+            all_data_list.append(f"|{idx}|{keyword}|[Link]({ll})|\n")
 
             idx += 1
 
-        self._write_md_file(all_data_list, f"{folder_name}", f"{cj.title()}_Keywords.md")
+        category_postfix = f"_{self.keywords_category_name.title()}" if self.keywords_category_name else ""
+        self._write_md_file(all_data_list, f"{folder_name}", f"{cj.title()}_Keywords{category_postfix}.md")
+
+    def _default_or_customized_keywords(self, json_data):
+        keywords = list(json_data.keys())
+
+        # Get and sort publication types
+        if self.keywords_category_name and self.keywords_list:
+            _keywords = []
+            for keyword in self.keywords_list:
+                if keyword in keywords:
+                    _keywords.append(keyword)
+            return _keywords
+        else:
+            # default
+            return sorted(keywords)
 
     def _check_file_exists(self, folder, folder_name, cj, publisher, abbr):
         """Check if HTML file exists for given parameters."""
         file_path = os.path.join(
-            self.data_base_path, f"{folder_name}/{cj.title()}/{folder}/{publisher.lower()}/{abbr}/{abbr}.html"
+            self.data_base_path, folder_name, cj.title(), folder, publisher.lower(), abbr, f"{abbr}.html"
         )
         return os.path.exists(file_path)
 
     def _convert_md_to_html_keyword(self, folder_name, cj, keyword):
         """Convert markdown file to HTML using pandoc."""
-        base_path = os.path.join(self.data_base_path, f"{folder_name}/{cj.title()}_Keywords")
+        base_path = os.path.join(self.data_base_path, folder_name, f"{cj.title()}_Keywords")
         file_md = os.path.join(base_path, f"{keyword.replace(' ', '_')}.md")
         file_html = os.path.join(base_path, f"{keyword.replace(' ', '_')}.html")
 

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyeasyphd/tools/spider/process_spider_url.py

@@ -30,7 +30,8 @@ class ProcessSpiderUrl(object):
     ) -> None:
         if os.path.exists(self.path_abbr):
             for i in [f for f in os.listdir(self.path_abbr) if f.startswith(folder_start_swith)]:
-                print("*" * 5 + f" Check *{extension} ./{os.path.basename(self.path_abbr)}/{i}")
+                ll = os.path.join(os.path.basename(self.path_abbr), i)
+                print("*" * 5 + f" Check *{extension} .{os.sep}{ll}")
                 self._check_delete(os.path.join(self.path_abbr, i), extension, write_flag, iterate_check_url)
 
     def _check_delete(

{pyeasyphd-0.0.7 → pyeasyphd-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyeasyphd"
-version = "0.0.7"
+version = "0.0.9"
 description = "pyeasyphd"
 license = "GPL-3.0-or-later"
 authors = ["NextAI <nextartifintell@gmail.com>"]