pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/bib/core/__init__.py

@@ -0,0 +1,18 @@
+"""Initialization.
+
+This submodule incorporates modified source code from the python-bibtexparser project
+(https://github.com/sciunto-org/python-bibtexparser), which is licensed under the MIT License.
+The original copyright notice and license terms have been preserved in accordance with the license requirements.
+"""
+
+__all__ = [
+    "ConvertStrToStr",
+    "ConvertStrToLibrary",
+    "ConvertLibrayToLibrary",
+    "ConvertLibrayToStr",
+]
+
+from .convert_library_to_library import ConvertLibrayToLibrary
+from .convert_library_to_str import ConvertLibrayToStr
+from .convert_str_to_library import ConvertStrToLibrary
+from .convert_str_to_str import ConvertStrToStr

pyeasyphd/bib/core/convert_library_to_library.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict, Tuple
+
+from ..bibtexparser import Library, MiddlewaresLibraryToLibrary
+
+
+class ConvertLibrayToLibrary(object):
+    """Convert library to library.
+
+    Args:
+        options (Dict[str, Any]): Options. Default is {}.
+
+    Attributes:
+        choose_abbr_zotero_save (str): Choose "abbr", "zotero", or "save". Default is "save".
+    """
+
+    def __init__(self, options: Dict[str, Any] = {}) -> None:
+
+        self.choose_abbr_zotero_save = options.get("choose_abbr_zotero_save", "save")
+
+        self._middleware_library_library = MiddlewaresLibraryToLibrary(options)
+
+    def generate_single_library(self, library: Library) -> Library:
+        func = eval(f"_x.function_{self.choose_abbr_zotero_save}", {}, {"_x": self._middleware_library_library})
+        library = func(library)
+
+        return library
+
+    def generate_multi_libraries(self, library: Library) -> Tuple[Library, Library, Library]:
+        abbr_library, zotero_library, save_library = self._middleware_library_library.functions(library)
+
+        return abbr_library, zotero_library, save_library

pyeasyphd/bib/core/convert_library_to_str.py

@@ -0,0 +1,199 @@
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Union
+
+from ..bibtexparser import (
+    BibtexFormat,
+    Block,
+    DuplicateBlockKeyBlock,
+    Entry,
+    ExplicitComment,
+    Field,
+    ImplicitComment,
+    Library,
+    MiddlewaresLibraryToStr,
+    ParsingFailedBlock,
+    Preamble,
+    String,
+)
+from .convert_library_to_library import ConvertLibrayToLibrary
+
+VAL_SEP = " = "
+PARSING_FAILED_COMMENT = "% WARNING Parsing failed for the following {n} lines."
+
+
+class ConvertLibrayToStr(object):
+    """Convert library to str.
+
+    Args:
+        options (Dict[str, Any]): Options. Default is {}.
+
+    Attributes:
+        is_standardize_library (bool): Is standardize library. Default is False.
+        empty_entry_cite_keys (bool): Empty entry cite keys. Default is False.
+        add_index_to_entries (bool): Add index to entries. Default is False.
+    """
+
+    def __init__(self, options: Dict[str, Any]):
+
+        self.is_standardize_library = options.get("is_standardize_library", False)
+        self.empty_entry_cite_keys = options.get("empty_entry_cite_keys", False)
+        self.add_index_to_entries = options.get("add_index_to_entries", False)
+        self.entries_necessary = options.get("entries_necessary", True)
+
+        self.options = options
+
+    def generate_str(
+        self, library: Union[Library, List[Block]], bibtex_format: Optional[BibtexFormat] = None
+    ) -> List[str]:
+        """Serialize a BibTeX database.
+
+        :param library: BibTeX database to serialize.
+        :param bibtex_format: Customized BibTeX format to use (optional).
+        """
+        # --------- --------- --------- #
+        if not isinstance(library, Library):
+            library = Library(library)
+
+        # standardizer
+        if self.is_standardize_library:
+            library = ConvertLibrayToLibrary(self.options).generate_single_library(library)
+
+        # --------- --------- --------- #
+        library = MiddlewaresLibraryToStr(self.options).functions(library)
+
+        # --------- --------- --------- #
+        if bibtex_format is None:
+            bibtex_format = BibtexFormat()
+
+        if bibtex_format.value_column == "auto":
+            auto_val: int = self._calculate_auto_value_align(library)
+            # Copy the format instance to avoid modifying the original
+            # (which would be bad if the format is used for multiple libraries)
+            bibtex_format = deepcopy(bibtex_format)
+            bibtex_format.value_column = auto_val
+
+        # --------- --------- --------- #
+        if self.entries_necessary:
+            if not library.entries:
+                return []
+
+        data_list = []
+        j = 0
+        for i, block in enumerate(library.blocks):
+            if self.add_index_to_entries and isinstance(block, Entry):
+                data_list.append(f"% {j + 1}\n")
+                j += 1
+
+            # Get str representation of block
+            pieces = self._treat_block(bibtex_format, block)
+            data_list.extend(pieces)
+
+            # Separate Blocks
+            if i < len(library.blocks) - 1:
+                data_list.append(bibtex_format.block_separator)
+        return data_list
+
+    @staticmethod
+    def _calculate_auto_value_align(library: Library) -> int:
+        max_key_len = 0
+        for entry in library.entries:
+            for key in entry.fields_dict:
+                max_key_len = max(max_key_len, len(key))
+        return max_key_len
+
+    def _treat_block(self, bibtex_format, block) -> List[str]:
+        if isinstance(block, Entry):
+            pieces = self._treat_entry(block, bibtex_format)
+        elif isinstance(block, String):
+            pieces = self._treat_string(block, bibtex_format)
+        elif isinstance(block, Preamble):
+            pieces = self._treat_preamble(block, bibtex_format)
+        elif isinstance(block, ExplicitComment):
+            pieces = self._treat_expl_comment(block, bibtex_format)
+        elif isinstance(block, ImplicitComment):
+            pieces = self._treat_impl_comment(block, bibtex_format)
+        elif isinstance(block, ParsingFailedBlock):
+            pieces = self._treat_failed_block(block, bibtex_format)
+        else:
+            raise ValueError(f"Unknown block type: {type(block)} in {__file__}")
+        return pieces
+
+    # entry
+    def _treat_entry(self, block: Entry, bibtex_format: BibtexFormat) -> List[str]:
+        if self.empty_entry_cite_keys:
+            result = ["@" + block.entry_type + "{" + " " + ",\n"]
+        else:
+            result = ["@" + block.entry_type + "{" + block.key + ",\n"]
+        field: Field
+        for i, field in enumerate(block.fields):
+            res = []
+            res.append(bibtex_format.indent)
+            res.append(field.key)
+            res.append(self._val_intent_string(bibtex_format, field.key))
+            res.append(VAL_SEP)
+            res.append("{")  # add by me
+            res.append(field.value)
+            res.append("}")  # add by me
+            if bibtex_format.trailing_comma or i < len(block.fields) - 1:
+                res.append(",")
+            res.append("\n")
+            result.append("".join(res))
+
+        result.append("}\n")
+        return result
+
+    @staticmethod
+    def _val_intent_string(bibtex_format: BibtexFormat, key: str) -> str:
+        """Calculate the spaces which have to be added after the ` = `."""
+        if isinstance(bibtex_format.value_column, int):
+            length = bibtex_format.value_column - len(key)
+            return "" if length <= 0 else " " * length
+        else:
+            return ""
+
+    # string
+    @staticmethod
+    def _treat_string(block: String, bibtex_format: BibtexFormat) -> List[str]:
+        result = [
+            "@string{",
+            block.key,
+            VAL_SEP,
+            "{",
+            block.value,
+            "}",
+            "}\n",
+        ]
+        return ["".join(result)]
+
+    # preamble
+    @staticmethod
+    def _treat_preamble(block: Preamble, bibtex_format: BibtexFormat) -> List[str]:
+        result = ["@preamble{" + f' "{block.value.rstrip()} "' + " }", "\n"]
+        return ["".join(result)]
+
+    # implicit comment
+    @staticmethod
+    def _treat_impl_comment(block: ImplicitComment, bibtex_format: BibtexFormat) -> List[str]:
+        # Note: No explicit escaping is done here - that should be done in middleware
+        result = [block.comment.rstrip(), "\n"]
+        return ["".join(result)]
+
+    # explicit comment
+    @staticmethod
+    def _treat_expl_comment(block: ExplicitComment, bibtex_format: BibtexFormat) -> List[str]:
+        result = ["@comment{", block.comment.rstrip(), "}\n"]
+        return ["".join(result)]
+
+    # failed block
+    @staticmethod
+    def _treat_failed_block(block: ParsingFailedBlock, bibtex_format: BibtexFormat) -> List[str]:
+        if isinstance(block.raw, str):
+            lines = len(block.raw.splitlines())
+            parsing_failed_comment = PARSING_FAILED_COMMENT.format(n=lines)
+            return [parsing_failed_comment.rstrip(), "\n", block.raw.rstrip(), "\n"]
+        else:
+            if isinstance(block, DuplicateBlockKeyBlock):
+                print(f"Duplicate key block: previous block key is `{block.key}`.")
+            else:
+                print(f"The raw of the field block: {block} is None.")
+            return []

pyeasyphd/bib/core/convert_str_to_library.py

@@ -0,0 +1,34 @@
+from typing import Any, Dict, List
+
+from ..bibtexparser import Library, MiddlewaresStrToLibrary, Splitter
+from .convert_str_to_str import ConvertStrToStr
+
+
+class ConvertStrToLibrary(object):
+    """Convert str to library.
+
+    Args:
+        options (Dict[str, Any]): Options. Default is {}.
+
+    Attributes:
+        is_standardize_bib (bool): Is standardize bib. Default is True.
+    """
+
+    def __init__(self, options: Dict[str, Any] = {}) -> None:
+
+        self.is_standardize_bib = options.get("is_standardize_bib", True)
+
+        self.options = options
+
+    def generate_library(self, data_list: List[str]) -> Library:
+        implicit_coments = []
+        # standardizer
+        if self.is_standardize_bib:
+            data_list, implicit_coments = ConvertStrToStr(self.options).generate_str(data_list)
+
+        # splitter
+        library = Splitter().splitter(data_list, implicit_coments)
+
+        # middlewares
+        library = MiddlewaresStrToLibrary(self.options).functions(library)
+        return library

pyeasyphd/bib/core/convert_str_to_str.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, List, Tuple
+
+from ..bibtexbase import StandardizeBib
+from ..bibtexparser import MiddlewaresStrToStr
+
+
+class ConvertStrToStr(object):
+    """Convert str to str.
+
+    Args:
+        options (Dict[str, Any]): Options. Default is {}.
+
+    Attributes:
+        default_additional_field_list (List[str]): Default additional field list. Default is [].
+    """
+
+    def __init__(self, options: Dict[str, Any] = {}) -> None:
+
+        self.default_additional_field_list = options.get("default_additional_field_list", [])
+
+        self.options = options
+
+    def generate_str(self, data_list: List[str]) -> Tuple[List[str], List[List[str]]]:
+        data_list, implicit_comment_list = StandardizeBib(self.default_additional_field_list).standardize(data_list)
+
+        data_list = MiddlewaresStrToStr(self.options).functions(data_list)
+        return data_list, implicit_comment_list

pyeasyphd/main/__init__.py

@@ -0,0 +1,17 @@
+"""Initialization."""
+
+__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/main/basic_input.py

@@ -0,0 +1,149 @@
+import json
+import os
+from typing import Any, Dict
+
+from pyadvtools import read_list, standard_path
+
+
+class BasicInput(object):
+    """Basic input.
+
+    Args:
+        options (Dict[str, Any]): Options.
+
+    Attributes:
+        path_bibs (str): Path bibs.
+        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.
+
+        article_template_header_tex (List[str]): Article template header for LaTex.
+        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.
+        handly_preamble (bool): Handly preamble.
+
+        options (Dict[str, Any]): Options.
+    """
+
+    def __init__(self, options: Dict[str, Any]) -> None:
+        # The paths of Figures, Bibs, and Templates
+        self.path_bibs: str = standard_path(options.get("path_bibs", ""))
+        self.path_figures: str = standard_path(options.get("path_figures", ""))
+        self.path_templates: str = standard_path(options.get("path_templates", ""))
+
+        # Update
+        path_config = standard_path(options.get("path_config", ""))
+        if len(self.path_bibs) == 0:
+            for folder in ["bib", "bibs", "Bib", "Bibs", "BIB", "BIBS"]:
+                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"]:
+                if os.path.exists(p := os.path.join(path_config, folder)):
+                    self.path_figures = p
+                    break
+
+        if len(self.path_templates) == 0:
+            for folder in ["template", "templates", "Template", "Templates", "TEMPLATE", "TEMPLATES"]:
+                if os.path.exists(p := os.path.join(path_config, folder)):
+                    self.path_templates = p
+                    break
+
+        # bib/core
+        self._initialize_middlewares(options)
+
+        # main
+        self._initialize_pandoc_md_to(options)
+        self._initialize_python_run_tex(options)
+
+        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")
+        if len(csl_name) == 0:
+            csl_name = "apa-no-ampersand"
+        self.full_csl_style_pandoc = os.path.join(self.path_templates, f"CSL/{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"))
+
+    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"))
+
+        # handly preamble
+        self.handly_preamble = options.get("handly_preamble", False)
+        if self.handly_preamble:
+            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 = [], []