pyeasyphd 0.0.9__py3-none-any.whl → 0.1.1__py3-none-any.whl

pyeasyphd/tools/generate/generate_library.py

@@ -0,0 +1,188 @@
+from typing import Any, Dict, List, Union
+
+from pyadvtools import IterateSortDict
+from pybibtexer.bib.bibtexparser import Entry, Library
+from pybibtexer.main import PythonRunBib
+
+
+def generate_library_by_filters(
+    original_data: Union[List[str], str, Library],
+    issue_or_month_flag: Union[str, List[str]],  # filter
+    year_flag: Union[str, List[str]] = "current_year",  # filter
+    options: Dict[str, Any] = {},
+    full_json_c: str = "",
+    full_json_j: str = ""
+) -> Library:
+    """Generate a Library object from input data with given filters.
+
+    Parameters
+    ----------
+    original_data : Union[List[str], str, Library]
+        Input bibliography data
+    issue_or_month_flag : Union[str, List[str]]
+        Flag for issue/month selection
+    year_flag : Union[str, List[str]], optional
+        Flag for year selection, by default "current_year"
+    options : Dict[str, Any], optional
+        Additional options, by default {}
+    full_json_c : str, optional
+        JSON configuration for conference proceedings, by default "".
+    full_json_j : str, optional
+        JSON configuration for journal articles, by default "".
+
+    Returns
+    -------
+    Library
+        Processed library object
+    """
+    _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_abbr"] = False  # default is True
+    _options["function_common_again_zotero"] = False  # default is True
+    _options["function_common_again_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(full_json_c, full_json_j, _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: Union[str, List[str]] = "current_year",
+):
+    """Filter dict by year flag."""
+    new_dict = {}
+    for entry_type in nested_entries:
+        years = [year for year in nested_entries[entry_type]]
+
+        # Update years
+        if isinstance(year_flag, List):  # given_years
+            years = sorted(list(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 dict by issue flag."""
+    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 := [volume for volume in temp_dict]):
+                    for number in (numbers := [number for number in temp_dict[volume]]):
+                        months = [month for month in 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: Union[str, List[str]] = "current_month",
+) -> Library:
+    """Filter dict by month flag."""
+    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 = [month for month in 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)

pyeasyphd/tools/generate/generate_links.py

@@ -8,12 +8,13 @@ from typing import Dict, List
 from pyadvtools import standard_path
 
 
-class PaperLinksGenerator:
+class PaperLinksGenerator(object):
     """Generate markdown files with paper links from JSON data."""
 
     def __init__(
         self,
-        json_base_path: str,
+        full_json_c: str,
+        full_json_j: str,
         data_base_path: str,
         keywords_category_name: str = "",
         display_year_period: int = 10,
@@ -25,7 +26,9 @@ class PaperLinksGenerator:
             json_base_path: Path to JSON files directory
             data_base_path: Path to data files directory
         """
-        self.json_base_path = standard_path(json_base_path)
+        self.full_json_c = full_json_c
+        self.full_json_j = full_json_j
+
         self.data_base_path = standard_path(data_base_path)
 
         # Process keyword category name and load data
@@ -115,7 +118,13 @@ class PaperLinksGenerator:
     def _load_json_data(self, file_name: str) -> Dict:
         """Load JSON data from file."""
         try:
-            file_path = os.path.join(self.json_base_path, f"{file_name}.json")
+            if file_name.lower().strip() == "conferences":
+                file_path = os.path.expanduser(self.full_json_c)
+            elif file_name.lower().strip() == "journals":
+                file_path = os.path.expanduser(self.full_json_j)
+            else:
+                file_path = ""
+
             if not os.path.exists(file_path):
                 return {}
 
@@ -249,7 +258,6 @@ class PaperLinksGenerator:
 
         return None
 
-    #
     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]
@@ -298,7 +306,6 @@ class PaperLinksGenerator:
             # Pandoc
             self._convert_md_to_html_keyword(folder_name, cj, keyword)
 
-            # 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")
 

pyeasyphd/tools/py_run_bib_md_tex.py

@@ -3,15 +3,11 @@ import re
 import shutil
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from pyadvtools import (
-    combine_content_in_list,
-    read_list,
-    standard_path,
-    write_list,
-)
+from pyadvtools import combine_content_in_list, read_list, standard_path, write_list
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonRunBib, PythonWriters
 
-from ..bib.bibtexparser import Library
-from ..main import BasicInput, PythonRunBib, PythonRunMd, PythonRunTex, PythonWriters
+from ..main import BasicInput, PythonRunMd, PythonRunTex
 
 
 class PyRunBibMdTex(BasicInput):
@@ -69,10 +65,11 @@ class PyRunBibMdTex(BasicInput):
         self.delete_original_bib_in_output_folder = options.get("delete_original_bib_in_output_folder", False)
 
         # Initialize helper classes
-        self._python_bib = PythonRunBib(self.options)
+        self._python_bib = PythonRunBib(self.full_json_c, self.full_json_j, self.options)
+        self._python_writer = PythonWriters(self.full_json_c, self.full_json_j, self.options)
+
         self._python_md = PythonRunMd(self.options)
         self._python_tex = PythonRunTex(self.options)
-        self._python_writer = PythonWriters(self.options)
 
     def run_files(
         self, file_list_md_tex: List[str], output_prefix: str = "", output_level: str = "next"
@@ -206,8 +203,10 @@ class PyRunBibMdTex(BasicInput):
 
             # Write bibliography files
             _path_output = os.path.join(self.path_output, self.bib_folder_name)
-            full_bib_for_abbr, full_bib_for_zotero, full_bib_for_save = self._python_writer.write_multi_library_to_file(
-                _path_output, abbr_library, zotero_library, save_library, key_in_md_tex
+            full_bib_for_abbr, full_bib_for_zotero, full_bib_for_save = (
+                self._python_writer.write_multi_library_to_multi_file(
+                    _path_output, abbr_library, zotero_library, save_library, key_in_md_tex
+                )
             )
 
         # Process content based on format

pyeasyphd/tools/search/search_base.py

@@ -2,8 +2,10 @@ import copy
 import re
 from typing import Dict, List, Tuple
 
-from ...bib.bibtexparser import Library
-from ...main import PythonRunBib, PythonWriters
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonRunBib, PythonWriters
+
+from ...main import BasicInput
 from .search_writers import WriteInitialResult, WriteSeparateResult
 
 
@@ -33,7 +35,7 @@ def search_keywords_core(keywords_list_list: List[List[str]], library: Library,
     return Library(search_library), Library(no_search_library)
 
 
-class SearchInitialResult(object):
+class SearchInitialResult(BasicInput):
     """Search initial result.
 
     Args:
@@ -48,16 +50,17 @@ class SearchInitialResult(object):
 
     def __init__(self, options: dict) -> None:
         self.options = options
+        super().__init__(options)
 
         self.print_on_screen: bool = options.get("print_on_screen", False)
         self.deepcopy_library_for_every_field = options.get("deepcopy_library_for_every_field", False)
 
-        self._python_bib = PythonRunBib(options)
+        self._python_bib = PythonRunBib(self.full_json_c, self.full_json_j, options)
 
         _options = {}
         _options["empty_entry_cite_keys"] = True
         _options.update(self.options)
-        self._python_writer = PythonWriters(_options)
+        self._python_writer = PythonWriters(self.full_json_c, self.full_json_j, _options)
 
     def main(
         self,

pyeasyphd/tools/search/search_core.py

@@ -14,9 +14,10 @@ from pyadvtools import (
     standard_path,
     write_list,
 )
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonRunBib
 
-from ...bib.bibtexparser import Library
-from ...main import BasicInput, PythonRunBib
+from ...main import BasicInput
 from .search_base import SearchInitialResult
 from .search_writers import WriteAbbrCombinedResults
 from .utils import keywords_type_for_title, switch_keywords_list, switch_keywords_type
@@ -95,7 +96,7 @@ class SearchResultsCore(BasicInput):
         self.deepcopy_library_for_every_keywords = options.get("deepcopy_library_for_every_keywords", False)
 
         # for bib
-        self._python_bib = PythonRunBib(options)
+        self._python_bib = PythonRunBib(self.full_json_c, self.full_json_j, options)
 
     def optimize(self, search_year_list: List[str] = []) -> Dict[str, Dict[str, Dict[str, Dict[str, int]]]]:
         search_year_list = list(set([str(i) for i in search_year_list]))

pyeasyphd/tools/search/search_keywords.py

@@ -10,10 +10,10 @@ from pyadvtools import (
     standard_path,
     write_list,
 )
+from pybibtexer.tools.experiments_base import generate_standard_publisher_abbr_options_dict
 
 from ...main import PandocMdTo
 from ...utils.utils import html_head, html_style, html_tail
-from ..experiments_base import generate_standard_publisher_abbr_options_dict
 from .data import obtain_search_keywords
 from .search_core import SearchResultsCore
 from .utils import extract_information, temp_html_style

pyeasyphd/tools/search/search_writers.py

@@ -7,9 +7,10 @@ from pyadvtools import (
     read_list,
     write_list,
 )
+from pybibtexer.bib.bibtexparser import Library
+from pybibtexer.main import PythonWriters
 
-from ...bib.bibtexparser import Library
-from ...main import PandocMdTo, PythonWriters
+from ...main import BasicInput, PandocMdTo
 from ...tools.search.utils import (
     combine_keywords_for_file_name,
     combine_keywords_for_title,
@@ -17,7 +18,7 @@ from ...tools.search.utils import (
 )
 
 
-class WriteInitialResult(object):
+class WriteInitialResult(BasicInput):
     """Write initial results for single keyword.
 
     Args:
@@ -28,6 +29,8 @@ class WriteInitialResult(object):
     """
 
     def __init__(self, options: dict) -> None:
+        super().__init__(options)
+
         self.options = options
 
         self._level_title_md = "###"
@@ -53,7 +56,7 @@ class WriteInitialResult(object):
         # update options
         _options = copy.deepcopy(self.options)
         _options["keep_entries_by_cite_keys"] = cite_keys
-        _python_writer = PythonWriters(_options)
+        _python_writer = PythonWriters(self.full_json_c, self.full_json_j, _options)
 
         # generate tex and md data
         data_list_tex, data_list_md, header = self.generate_content_tex_md(
@@ -112,7 +115,7 @@ class WriteInitialResult(object):
 
         # library
         _options = copy.deepcopy(self.options)
-        _python_writer = PythonWriters(_options)
+        _python_writer = PythonWriters(self.full_json_c, self.full_json_j, _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(

{pyeasyphd-0.0.9.dist-info → pyeasyphd-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyeasyphd
-Version: 0.0.9
+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.dist-info/RECORD

@@ -0,0 +1,27 @@
+pyeasyphd/.python-version,sha256=Auc1s9_hwygz61ULf_j_oX9fK8P6HnuuYaj1o4g845g,5
+pyeasyphd/Main.sublime-menu,sha256=6IKSvXyUSqq-eXrzSVGbzakbrPzw9n7hKe-p-FXmDXM,1561
+pyeasyphd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyeasyphd/main/__init__.py,sha256=2PXcpkfVEni4Snq5OJ_B8drhunh5npFp9J8QaM88BXI,266
+pyeasyphd/main/basic_input.py,sha256=LF1wf7oGXZVQ03BmEFe2EZRBswjIlp93omCjYiwlqr4,5497
+pyeasyphd/main/pandoc_md_to.py,sha256=SPbQBlAvfB5hcXmfKlMDc2zoT2nJ_uQNyw8bHeiyy1s,15280
+pyeasyphd/main/python_run_md.py,sha256=AypAh-GN5P0jCAZrtcBIYSRGul7-DXjzF2RJLZK7FUg,10413
+pyeasyphd/main/python_run_tex.py,sha256=BNSXp0KnxvYyXr5q43Sr4NwD32EiGaqZJ0QYDwit0tw,5937
+pyeasyphd/pyeasyphd.py,sha256=vPM4uPmr6jSxVOy0zYetoijc8wUkQdXExUVdJyWynVQ,2875
+pyeasyphd/pyeasyphd.sublime-settings,sha256=KCCZ9jiTPbFXw_00HvcZeSB8e-yjWnnOsbjjebsj5-o,2294
+pyeasyphd/pyeasyphd.sublime-syntax,sha256=pXylbA-tye-K5dCTjEJLFVRqtY1T7AgWZ4laxo-dnaE,73
+pyeasyphd/tools/__init__.py,sha256=9JvQ_Sl_l2bV9b_IyLYPDrPUxTV27zr1wv7xMbIHDPw,369
+pyeasyphd/tools/generate/generate_from_bibs.py,sha256=TNj5icRi_Sq8PaQxdDAvEtVznxLVPGx6H-xOLULCxYo,6960
+pyeasyphd/tools/generate/generate_html.py,sha256=VV-fVsxMMhnwLvzuAu0i-Avp6RcwLGRcrYMSrb_3z3U,4127
+pyeasyphd/tools/generate/generate_library.py,sha256=Qq8JYmPMeCoiBejkd-jMbJoLKaAlgmDh1SjbM6zIM-k,7294
+pyeasyphd/tools/generate/generate_links.py,sha256=BKDCNIzw9cZ0KHRnwKDcI-riqwFmEj2Vv5IVKjBeFTc,14652
+pyeasyphd/tools/py_run_bib_md_tex.py,sha256=MWeGEJYft4qvEHM1DBK53S_Athx87-R_eBOGBo9ThcI,14791
+pyeasyphd/tools/search/data.py,sha256=7uHXfHTcn88zkfqAGZMNcSd2OjS2LhkpE9paNuSUUqw,10754
+pyeasyphd/tools/search/search_base.py,sha256=-nHa0gXF9zu2-qFTlhFUyHtVQbi7-orua4lKQB8cIzw,4665
+pyeasyphd/tools/search/search_core.py,sha256=2OOGzA81f_u0fGAopqtU7KEyjJfQJ_2rPt782S53FAk,13853
+pyeasyphd/tools/search/search_keywords.py,sha256=zhHdg97VT92AxrWuabsvPKe7OyQsssipTrepoXOLSGc,10445
+pyeasyphd/tools/search/search_writers.py,sha256=5n4JA0qPvCNeK3KMx5WSYFCb5M640TjIekHcD4HTwo4,12722
+pyeasyphd/tools/search/utils.py,sha256=yLKrMmM2x-fHdm6P8haFZzagd9sLkViTdwJTHyGRgXY,6092
+pyeasyphd/utils/utils.py,sha256=yuHy6D2mTsd2aAwNBSMC7CU4LV-MkWwzKeO_0Iehbyg,1655
+pyeasyphd-0.1.1.dist-info/METADATA,sha256=N7M4KOnDOaxkuMXinHswecsXX_---ecfARQVITTj0QU,933
+pyeasyphd-0.1.1.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+pyeasyphd-0.1.1.dist-info/RECORD,,

pyeasyphd/bib/__init__.py

@@ -1 +0,0 @@
-"""Initialization."""

pyeasyphd/bib/bibtexbase/__init__.py

@@ -1,7 +0,0 @@
-"""Initialization."""
-
-__all__ = [
-    "StandardizeBib"
-]
-
-from .standardize_bib import StandardizeBib

pyeasyphd/bib/bibtexbase/standardize/_base.py

@@ -1,36 +0,0 @@
-import re
-from typing import List
-
-
-def split_data_list(split_pattern: str, data_list: List[str], last_next: str = "next") -> List[str]:
-    r"""Split data list according to the split pattern.
-
-    The capturing parentheses must be used in the pattern, such as `(\n)`.
-
-    Args:
-        split_pattern (str): split pattern.
-        data_list (List[str]): data list.
-        last_next (str): "next" or "last".
-
-    Returns:
-        List[str]: new data list.
-
-    Examples:
-        split_pattern = r"(\n)", last_next = "next" or "last".
-    """
-    new_data_list = []
-    for line in data_list:
-        split_list = re.split(split_pattern, line)
-        list_one = split_list[0:len(split_list):2]
-        list_two = split_list[1:len(split_list):2]
-
-        temp = []
-        if last_next == "next":
-            list_two.insert(0, "")
-            temp = [list_two[i] + list_one[i] for i in range(len(list_one))]
-        if last_next == "last":
-            list_two.append("")
-            temp = [list_one[i] + list_two[i] for i in range(len(list_one))]
-        new_data_list.extend(temp)
-    new_data_list = [line for line in new_data_list if line.strip()]
-    return new_data_list

pyeasyphd/bib/bibtexbase/standardize/default_data.py

@@ -1,97 +0,0 @@
-FIELD_FORMAT_FLAG = [r'"', r"{", r"\w"]
-
-DEFAULT_FIELDS_LIST = [
-    "abstract",
-    "accepted",
-    "accessdate",
-    "address",
-    "affiliation",
-    "affiliations",
-    "annotation",
-    "archive",
-    "article-number",
-    "articleno",
-    "audio",
-    "author",
-    "author-email",
-    "authors",
-    "bibsource",
-    "biburl",
-    "book-group-author",
-    "booktitle",
-    "cited-references",
-    "code",
-    "copyright",
-    "crossref",
-    "data",
-    "date",
-    "doc-delivery-number",
-    "doi",
-    "edition",
-    "editor",
-    "editors",
-    "eissn",
-    "eprint",
-    "extra",
-    "fjournal",
-    "funding-acknowledgement",
-    "funding-text",
-    "howpublished",
-    "institution",
-    "isbn",
-    "isbn-13",
-    "issn",
-    "issue",
-    "issue_date",
-    "journal",
-    "journal-iso",
-    "journalabbr",
-    "journalabbreviation",
-    "key",
-    "keywords",
-    "keywords-plus",
-    "language",
-    "lccn",
-    "location",
-    "month",
-    "note",
-    "number",
-    "number-of-cited-references",
-    "numpages",
-    "orcid-numbers",
-    "organization",
-    "pages",
-    "pdf",
-    "place",
-    "pubdates",
-    "publisher",
-    "remark",
-    "research-areas",
-    "researcherid-numbers",
-    "rights",
-    "school",
-    "series",
-    "shortjournal"
-    "shorttitle",
-    "slide",
-    "submitted",
-    "summary",
-    "supplementary",
-    "times-cited",
-    "timestamp",
-    "title",
-    "type",
-    "unique-id",
-    "url",
-    "usage-count-last-180-days",
-    "usage-count-since-2013",
-    "video",
-    "volume",
-    "web-of-science-categories",
-    "web-of-science-index",
-    "xxeditor",
-    "xxnote",
-    "xxtitle",
-    "xxyear",
-    "year",
-]

pyeasyphd/bib/bibtexbase/standardize/do_on_bib.py

@@ -1,54 +0,0 @@
-import re
-from typing import Dict, List, Tuple
-
-from ._base import split_data_list
-
-
-class SplitBibAccordingToMark(object):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def split_marks(self, data_list: List[str]) -> List[str]:
-        return split_data_list(r"(@[a-zA-Z]+{)", data_list, "next")
-
-
-class ObtainMarkBlocksDict(object):
-    def __init__(self) -> None:
-        pass
-
-    def obtain_dict(
-        self, data_list: List[str], is_lower_mark: bool = True
-    ) -> Tuple[Dict[str, List[List[str]]], List[List[str]]]:
-        r"""Generate blocks.
-
-        Args:
-            data_list (List[str]): data list.
-
-        Returns:
-            Tuple[Dict[str, List[List[str]]], List[str]]: dict and implicit comments.
-        """
-        regex_mark = re.compile(r"@([a-zA-Z]+){")
-        line_index, len_data, implicit_comment_list = 0, len(data_list), []
-        mark_patch_bib_list_dict: Dict[str, List[List[str]]] = {}
-        while line_index < len_data:
-            line = data_list[line_index]
-            line_index += 1
-            if mch := regex_mark.match(line):
-                mark = mch.group(1)
-                temp = [line]
-                while line_index < len_data:
-                    line = data_list[line_index]
-                    if regex_mark.match(line):
-                        break
-                    temp.append(line)
-                    line_index += 1
-                if is_lower_mark:
-                    mark = mark.lower()
-                mark_patch_bib_list_dict.setdefault(mark, []).append(temp)
-            else:
-                implicit_comment_list.append([line, __class__.__name__])
-        return mark_patch_bib_list_dict, implicit_comment_list
-
-
-if __name__ == "__main__":
-    pass