pyeasyphd 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

pyeasyphd/bib/core/__init__.py

@@ -1,18 +0,0 @@
-"""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

@@ -1,31 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/python_run_bib.py

@@ -1,73 +0,0 @@
-from typing import Any, Dict, List, Tuple, Union
-
-from pyadvtools import (
-    transform_to_data_list,
-)
-
-from ..bib.bibtexparser import Entry, Library
-from ..bib.core import ConvertLibrayToLibrary, ConvertStrToLibrary
-from .basic_input import BasicInput
-
-
-class PythonRunBib(BasicInput):
-    """Python bib.
-
-    Args:
-        options (Dict[str, Any]): Options.
-    """
-
-    def __init__(self, options: Dict[str, Any]) -> None:
-        super().__init__(options)
-
-    def parse_to_single_standard_library(
-        self,
-        original_data: Union[List[str], str, Library],
-        given_cite_keys: List[str] = [],
-        **kwargs,
-    ) -> Library:
-        # update
-        self.options["keep_entries_by_cite_keys"] = given_cite_keys
-
-        if not isinstance(original_data, Library):
-            original_data = transform_to_data_list(original_data, extension=".bib", **kwargs)
-            original_data = ConvertStrToLibrary(self.options).generate_library(original_data)
-
-        library = ConvertLibrayToLibrary(self.options).generate_single_library(original_data)
-        return library
-
-    def parse_to_multi_standard_library(
-        self,
-        original_data: Union[List[str], str, Library],
-        given_cite_keys: List[str] = [],
-        **kwargs,
-    ) -> Tuple[Library, Library, Library]:
-        # update
-        self.options["keep_entries_by_cite_keys"] = given_cite_keys
-
-        if not isinstance(original_data, Library):
-            original_data = transform_to_data_list(original_data, extension=".bib", **kwargs)
-            original_data = ConvertStrToLibrary(self.options).generate_library(original_data)
-
-        libraries = ConvertLibrayToLibrary(self.options).generate_multi_libraries(original_data)
-        abbr_library, zotero_library, save_library = libraries
-        return abbr_library, zotero_library, save_library
-
-    def parse_to_nested_entries_dict(
-        self,
-        original_data: Union[List[str], str, Library],
-        given_cite_keys: List[str] = [],
-        **kwargs,
-    ) -> Dict[str, Dict[str, Dict[str, Dict[str, Dict[str, List[Entry]]]]]]:
-        library = self.parse_to_single_standard_library(original_data, given_cite_keys, **kwargs)
-
-        entry_type_year_volume_number_month_entry_dict = {}
-        for entry in library.entries:
-            entry_type = entry.entry_type
-            year = entry["year"] if "year" in entry else "year"
-            volume = entry["volume"] if "volume" in entry else "volume"
-            number = entry["number"] if "number" in entry else "number"
-            month = entry["month"] if "month" in entry else "month"
-            entry_type_year_volume_number_month_entry_dict.setdefault(entry_type, {}).setdefault(year, {}).setdefault(
-                volume, {}
-            ).setdefault(number, {}).setdefault(month, []).append(entry)
-        return entry_type_year_volume_number_month_entry_dict

pyeasyphd/main/python_writers.py

@@ -1,212 +0,0 @@
-import os
-import re
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-from pyadvtools import (
-    write_list,
-)
-
-from ..bib.bibtexparser import BibtexFormat, Block, Library
-from ..bib.core import ConvertLibrayToStr
-from .basic_input import BasicInput
-from .python_run_bib import PythonRunBib
-
-
-class PythonWriters(BasicInput):
-    """Python writers.
-
-    Args:
-        options (Dict[str, Any]): Options.
-
-    Attributes:
-        bib_for_abbr_name (str = "abbr.bib"): Bib for abbr name.
-        bib_for_zotero_name (str = "zotero.bib"): Bib for zotero name.
-        bib_for_save_name (str = "save.bib"): Bib for save name.
-        choose_abbr_zotero_save (str = "save"): Choose "abbr", "zotero", or "save".
-        display_google_connected_scite (List[str] = ["google", "connected", "scite"]): Choose multiple items.
-    """
-
-    def __init__(self, options: Dict[str, Any]) -> None:
-        options["is_sort_entry_fields"] = options.get("is_sort_entry_fields", True)
-        options["is_sort_blocks"] = options.get("is_sort_blocks", True)
-        options["sort_entries_by_field_keys_reverse"] = options.get("sort_entries_by_field_keys_reverse", True)
-        super().__init__(options)
-
-        self.bib_for_abbr_name = options.get("bib_for_abbr_name", "abbr.bib")
-        self.bib_for_zotero_name = options.get("bib_for_zotero_name", "zotero.bib")
-        self.bib_for_save_name = options.get("bib_for_save_name", "save.bib")
-        self.choose_abbr_zotero_save = options.get("choose_abbr_zotero_save", "save")
-
-        self.display_google_connected_scite = options.get(
-            "display_google_connected_scite", ["google", "connected", "scite"]
-        )
-
-        self.bibtex_format_indent = options.get("bibtex_format_indent", "  ")
-        self.bibtex_format_trailing_comma = options.get("bibtex_format_trailing_comma", True)
-        self.bibtex_format_block_separator = options.get("bibtex_format_block_separator", "")
-
-        bibtex_format = BibtexFormat()
-        bibtex_format.indent = self.bibtex_format_indent
-        bibtex_format.block_separator = self.bibtex_format_block_separator
-        bibtex_format.trailing_comma = self.bibtex_format_trailing_comma
-        self.bibtex_format: Optional[BibtexFormat] = bibtex_format
-
-        self._python_bib = PythonRunBib(self.options)
-
-    def write_to_str(self, library: Union[Library, List[Block]]) -> List[str]:
-        """Serialize a BibTeX database to a string.
-
-        Args:
-            library (Library | List[Block]): BibTeX database to serialize.
-            bibtex_format (Optional[BibtexFormat] = None):
-
-        """
-        return ConvertLibrayToStr(self.options).generate_str(library, self.bibtex_format)
-
-    def write_to_file(
-        self,
-        original_data: Union[Library, List[Block], List[str]],
-        file_name: str,
-        write_flag: str = "w",
-        path_storage: Optional[str] = None,
-        check: bool = True,
-        delete_first_empty: bool = True,
-        delete_last_empty: bool = True,
-        compulsory: bool = False,
-        delete_original_file: bool = False,
-    ) -> None:
-        """Write.
-
-        Args:
-            original_data (Union[Library, List[Block], List[str]]): data
-            file_name (str): file name
-            write_flag (str = "w"): write flag
-            path_storage (Optional[str] = None): path storage
-            check (bool = True): check
-            delete_first_empty (bool = True): delete first empty
-            delete_last_empty (bool = True): delete last empty
-            compulsory (bool = False): compulsory
-            delete_original_file (bool = False): delete original file
-            bibtex_format (Optional[BibtexFormat] = None):
-
-        """
-        _options = {}
-        _options.update(self.options)
-        _library_str = ConvertLibrayToStr(_options)
-
-        if isinstance(original_data, Library):
-            data_list = _library_str.generate_str(original_data, self.bibtex_format)
-        elif isinstance(original_data, list):
-            if all([isinstance(line, str) for line in original_data]):
-                data_list = [line for line in original_data if isinstance(line, str)]
-            else:
-                data_list = [line for line in original_data if isinstance(line, Block)]
-                data_list = _library_str.generate_str(data_list, self.bibtex_format)
-
-        write_list(
-            data_list,
-            file_name,
-            write_flag,
-            path_storage,
-            check,
-            delete_first_empty,
-            delete_last_empty,
-            compulsory,
-            delete_original_file,
-        )
-        return None
-
-    def write_multi_library_to_file(
-        self,
-        path_output: str,
-        bib_for_abbr: Union[Library, List[Block]],
-        bib_for_zotero: Union[Library, List[Block]],
-        bib_for_save: Union[Library, List[Block]],
-        given_cite_keys: List[str] = [],
-        **kwargs,
-    ) -> Tuple[str, str, str]:
-        _options = {}
-        _options.update(self.options)
-        _options["keep_entries_by_cite_keys"] = given_cite_keys
-        _options["sort_entries_by_cite_keys"] = given_cite_keys
-
-        bib_abbr = ConvertLibrayToStr(_options).generate_str(bib_for_abbr, **kwargs)
-        write_list(bib_abbr, self.bib_for_abbr_name, "w", path_output, False, **kwargs)
-
-        bib_zotero = ConvertLibrayToStr(_options).generate_str(bib_for_zotero, **kwargs)
-        write_list(bib_zotero, self.bib_for_zotero_name, "w", path_output, False, **kwargs)
-
-        bib_save = ConvertLibrayToStr(_options).generate_str(bib_for_save, **kwargs)
-        write_list(bib_save, self.bib_for_save_name, "w", path_output, False, **kwargs)
-
-        full_bib_for_abbr = os.path.join(path_output, self.bib_for_abbr_name)
-        full_bib_for_zotero = os.path.join(path_output, self.bib_for_zotero_name)
-        full_bib_for_save = os.path.join(path_output, self.bib_for_save_name)
-        return full_bib_for_abbr, full_bib_for_zotero, full_bib_for_save
-
-    def output_key_url_http_bib_dict(self, library: Library) -> Dict[str, List[List[str]]]:
-        _options = {}
-        _options.update(self.options)
-        _options["empty_entry_cite_keys"] = True
-
-        key_url_http_bib_dict: Dict[str, List[List[str]]] = {}
-
-        for key, entry in library.entries_dict.items():
-
-            url = entry["url"] if "url" in entry else ""
-            if len(url) == 0:
-                url = entry["doi"] if "doi" in entry else ""
-                if (len(url) != 0) and (not re.match(r"https*://", url)):
-                    url = f"https://doi.org/{url}"
-
-            link_list = self._generate_link_list(entry)
-            patch_bib = ConvertLibrayToStr(_options).generate_str([entry])
-
-            v: List[List[str]] = [[], [], patch_bib]
-
-            if len(url) != 0:
-                v[0] = [url + "\n"]
-                link_list.insert(0, rf"[www]({url})")
-
-            join_link = []
-            if link_list:
-                for i in range(len(link_list) - 1):
-                    join_link.append(link_list[i].strip() + " |\n")
-                join_link.append(link_list[-1].strip() + "\n")
-
-                join_link[0] = "(" + join_link[0]
-                join_link[-1] = join_link[-1].strip() + ")\n"
-
-                v[1] = join_link
-
-            key_url_http_bib_dict.update({key: v})
-        return key_url_http_bib_dict
-
-    def _generate_link_list(self, entry) -> List[str]:
-        title = entry["title"] if "title" in entry else ""
-        if not title:
-            return []
-
-        title = re.sub(r"\s+", "+", title)
-        url_google = f"https://scholar.google.com/scholar?q={title}"
-        url_connected = f"https://www.connectedpapers.com/search?q={title}"
-        url_scite = f"https://scite.ai/search?q={title}"
-
-        # Search cited number
-        cited_number = entry["annotation"] if "annotation" in entry else ""
-        if cited_number:
-            cited_number = re.sub(r"[^0-9]+", "", cited_number)
-            cited_number = int(cited_number) if cited_number.isdigit() else ""
-            google = f"[Google Scholar: {cited_number}]({url_google})"
-        else:
-            google = f"[Google Scholar]({url_google})"
-
-        connected = f"[Connected Papers]({url_connected})"
-        scite = f"[Scite]({url_scite})"
-
-        link_list = []
-        for i, j in zip(["google", "connected", "scite"], [google, connected, scite]):
-            if i in self.display_google_connected_scite:
-                link_list.append(j)
-
-        return link_list