pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/bib/bibtexbase/standardize_bib.py

@@ -0,0 +1,75 @@
+from typing import List, Tuple
+
+from .standardize.do_on_bib import ObtainMarkBlocksDict, SplitBibAccordingToMark
+from .standardize.do_on_comment_block import StandardizeCommentBlock
+from .standardize.do_on_entry_block import StandardizeEntryBlock
+from .standardize.do_on_preamble_block import StandardizePreambleBlock
+from .standardize.do_on_string_block import StandardizeStringBlock
+
+MARKS_FLAGS = [
+    ["comment", "comment", "C"],        # comment
+    ["string", "string", "S"],          # string
+    ["preamble", "preamble", "P"],      # preamble
+    ["article", "entry", "J"],          # entry
+    ["inproceedings", "entry", "C"],    # entry
+    ["proceedings", "entry", "B"],      # entry
+    ["book", "entry", "B"],             # entry
+    ["incollection", "entry", "BS"],    # entry
+    ["misc", "entry", "D"],             # entry
+    ["unpublished", "entry", "M"],      # entry
+    ["techreport", "entry", "R"],       # entry
+    ["phdthesis", "entry", "T_D"],      # entry
+    ["mastersthesis", "entry", "T_M"],  # entry
+]
+
+
+class StandardizeBib(object):
+    """Stanndardize bib.
+
+    Args:
+        default_additional_field_list (List[str] = []): Additional default fields.
+    """
+
+    def __init__(self, default_additional_field_list: List[str] = []) -> None:
+        self._standardize_comment_block = StandardizeCommentBlock()
+        self._standardize_entry_block = StandardizeEntryBlock(default_additional_field_list)
+        self._standardize_preamble_block = StandardizePreambleBlock()
+        self._standardize_string_block = StandardizeStringBlock()
+
+    def standardize(self, data_list: List[str]) -> Tuple[List[str], List[List[str]]]:
+        """Generate standard bib.
+
+        Args:
+            data_list (List[str]): Bib data.
+
+        Returns:
+            List[str]: Standard bib.
+        """
+        # Initialize
+        data_list = "".join(data_list).splitlines(keepends=True)
+        data_list = [line for line in data_list if line.strip()]
+
+        # Split data according to mark pattern
+        data_list = SplitBibAccordingToMark().split_marks(data_list)
+
+        new_data_list: List[str] = []
+        implicit_comment_list: List[List[str]] = []
+
+        # Generate dict
+        mark_blocks_dict, temp_implicit_comment_list = ObtainMarkBlocksDict().obtain_dict(data_list, True)
+        implicit_comment_list.extend(temp_implicit_comment_list)
+
+        marks, flags = [i[0] for i in MARKS_FLAGS], [i[1] for i in MARKS_FLAGS]
+        if not_in := {k: v for k, v in mark_blocks_dict.items() if k not in marks}:
+            print(f"Warning: Not standard parts - {not_in}")
+
+        for mark in mark_blocks_dict:
+            if mark in marks:
+                flag = flags[marks.index(mark)]
+
+                for block in mark_blocks_dict[mark]:
+                    block, temp = eval(f"self._standardize_{flag}_block.standardize")(block)
+                    new_data_list.extend(block)
+                    implicit_comment_list.extend(temp)
+
+        return new_data_list, implicit_comment_list

pyeasyphd/bib/bibtexparser/__init__.py

@@ -0,0 +1,47 @@
+"""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__ = [
+    "Block",
+    "Field",
+    "Entry",
+    "ImplicitComment",
+    "ExplicitComment",
+    "String",
+    "Preamble",
+    "ParsingFailedBlock",
+    "DuplicateBlockKeyBlock",
+    "Library",
+
+    "MiddlewaresStrToStr",
+    "MiddlewaresStrToLibrary",
+    "MiddlewaresLibraryToLibrary",
+    "MiddlewaresLibraryToStr",
+
+    "Splitter",
+
+    "BibtexFormat",
+]
+
+from .bibtex_format import BibtexFormat
+from .library import Library
+from .middlewares_library_to_library import MiddlewaresLibraryToLibrary
+from .middlewares_library_to_str import MiddlewaresLibraryToStr
+from .middlewares_str_to_library import MiddlewaresStrToLibrary
+from .middlewares_str_to_str import MiddlewaresStrToStr
+from .model import (
+    Block,
+    DuplicateBlockKeyBlock,
+    Entry,
+    ExplicitComment,
+    Field,
+    ImplicitComment,
+    ParsingFailedBlock,
+    Preamble,
+    String,
+)
+from .splitter import Splitter

pyeasyphd/bib/bibtexparser/bibtex_format.py

@@ -0,0 +1,87 @@
+from typing import Union
+
+PARSING_FAILED_COMMENT = "% WARNING Parsing failed for the following {n} lines."
+
+
+class BibtexFormat(object):
+    """Definition of formatting (alignment, ...) when writing a BibTeX file.
+
+    Hint: For more manual, GUI-based formatting, see the `bibtex-tidy` tool:
+        https://flamingtempura.github.io/bibtex-tidy/
+    """
+
+    def __init__(self):
+        self._indent: str = "  "  # "\t"
+        self._align_field_values: Union[int, str] = "auto"
+        self._block_separator: str = ""  # "\n\n"
+        self._trailing_comma: bool = True
+        self._parsing_failed_comment: str = PARSING_FAILED_COMMENT
+
+    @property
+    def indent(self) -> str:
+        """Character(s) for indenting BibTeX field-value pairs. Default: single space."""
+        return self._indent
+
+    @indent.setter
+    def indent(self, indent: str) -> None:
+        self._indent = indent
+
+    @property
+    def value_column(self) -> Union[int, str]:
+        """Controls the alignment of field- and string-values. Default: no alignment.
+
+        This impacts String and Entry blocks.
+
+        An integer value x specifies that spaces should be added before the " = ",
+        such that, if possible, the value is written at column `len(self.indent) + x`.
+        Note that for long keys, the value may be written at a later column.
+
+        Thus, a value of 0 means that the value is written directly after the " = ".
+
+        The special value "auto" specifies that the bibtex field value should be aligned
+        based on the longest key in the library.
+        """
+        return self._align_field_values
+
+    @value_column.setter
+    def value_column(self, align_values: Union[int, str]) -> None:
+        if isinstance(align_values, int):
+            if align_values < 0:
+                raise ValueError("align_field_values must be >= 0")
+        elif align_values != "auto":
+            raise ValueError("align_field_values must be an integer or 'auto'")
+        self._align_field_values = align_values
+
+    @property
+    def block_separator(self) -> str:
+        """Character(s) for separating BibTeX entries.
+
+        Default: Two lines breaks, i.e., two blank lines.
+        """
+        return self._block_separator
+
+    @block_separator.setter
+    def block_separator(self, entry_separator: str) -> None:
+        self._block_separator = entry_separator
+
+    @property
+    def trailing_comma(self) -> bool:
+        """Use the trailing comma syntax for BibTeX entries. Default: True.
+
+        BibTeX syntax allows an optional comma at the end
+        of the last field in an entry.
+        """
+        return self._trailing_comma
+
+    @trailing_comma.setter
+    def trailing_comma(self, trailing_comma: bool) -> None:
+        self._trailing_comma = trailing_comma
+
+    @property
+    def parsing_failed_comment(self) -> str:
+        """Comment to use for blocks that could not be parsed."""
+        return self._parsing_failed_comment
+
+    @parsing_failed_comment.setter
+    def parsing_failed_comment(self, parsing_failed_comment: str) -> None:
+        self._parsing_failed_comment = parsing_failed_comment

pyeasyphd/bib/bibtexparser/exceptions.py

@@ -0,0 +1,64 @@
+from typing import List, Optional
+
+
+class ParsingException(Exception):
+    """Generic Exception for parsing errors."""
+
+    def __copy__(self):
+        # We do not copy or deepcopy ParsingExceptions
+        # because they are used as immutables,
+        # and because default memo fails.
+        return self
+
+    def __deepcopy__(self, memo):
+        # We do not copy or deepcopy ParsingExceptions
+        # because they are used as immutables,
+        # and because default memo fails.
+        return self
+
+
+class BlockAbortedException(ParsingException):
+    """Exception where a invalid bibtex file led to an aborted block."""
+
+    def __init__(
+        self,
+        abort_reason: str,
+        # Not provided if end of file is reached
+        end_index: Optional[int] = None,
+    ):
+        self.abort_reason = abort_reason
+        self.end_index = end_index
+
+
+class ParserStateException(ParsingException):
+    """Parser is in a self-inflicted invalid state."""
+
+    def __init__(self, message: str):
+        self.message = message
+
+
+class RegexMismatchException(ParserStateException):
+    """Raised when regex matches are inconsistent, implying a bug in the parser.
+
+    For example, raised when first match ``@string{``
+    is not followed by an overlapping match ``}``.
+    """
+
+    def __init__(self, first_match, expected_match, second_match):
+        self.first_match = first_match
+        self.expected_match = expected_match
+        self.second_match = second_match
+        super().__init__(
+            f"Regex mismatch: {first_match} followed by {second_match},"
+            f"but expected {expected_match}.\n"
+            "This is an python-bibtexparser internal error. "
+            "Please report this issue at our issue tracker."
+        )
+
+
+class PartialMiddlewareException(ParsingException):
+    """Exception raised when a middleware could not be fully applied."""
+
+    def __init__(self, reasons: List[str]):
+        reasons_string = "\n\n=====\n\n".join(reasons)
+        super().__init__(f"Middleware could not be fully applied: {reasons_string}")

pyeasyphd/bib/bibtexparser/library.py

@@ -0,0 +1,207 @@
+from typing import Dict, List, Union
+
+from .model import (
+    Block,
+    DuplicateBlockKeyBlock,
+    Entry,
+    ExplicitComment,
+    ImplicitComment,
+    ParsingFailedBlock,
+    Preamble,
+    String,
+)
+
+# TODO Use functools.lru_cache for library properties (which create lists when called)
+
+
+class Library(object):
+    """A collection of parsed bibtex blocks."""
+
+    def __init__(self, blocks: Union[List[Block], None] = None):
+        self._blocks = []
+        self._entries_by_key = dict()
+        self._strings_by_key = dict()
+        if blocks is not None:
+            self.add(blocks)
+
+    def add(self, blocks: Union[List[Block], Block], fail_on_duplicate_key: bool = False):
+        """Add blocks to library.
+
+        The adding is key-safe, i.e., it is made sure that no duplicate keys are added.
+        for the same type (i.e., String or Entry). Duplicates are silently replaced with
+        a DuplicateKeyBlock.
+
+        :param blocks: Block or list of blocks to add.
+        :param fail_on_duplicate_key:
+            If True, raises ValueError if a block was replaced with a DuplicateKeyBlock.
+        """
+        if isinstance(blocks, Block):
+            blocks = [blocks]
+
+        _added_blocks = []
+        for block in blocks:
+            # This may replace block with a DuplicateEntryKeyBlock
+            block = self._add_to_dicts(block)
+            self._blocks.append(block)
+            _added_blocks.append(block)
+
+        if fail_on_duplicate_key:
+            duplicate_keys = []
+            for original, added in zip(blocks, _added_blocks):
+                if original is not added and isinstance(added, DuplicateBlockKeyBlock):
+                    duplicate_keys.append(added.key)
+
+            if len(duplicate_keys) > 0:
+                raise ValueError(
+                    f"Duplicate keys found: {duplicate_keys}. "
+                    f"Duplicate entries have been added to the library as DuplicateBlockKeyBlock."
+                    f"Use `library.failed_blocks` to access them. "
+                )
+
+    def remove(self, blocks: Union[List[Block], Block]):
+        """Remove blocks from library.
+
+        :param blocks: Block or list of blocks to remove.
+        :raises ValueError: If block is not in library.
+        """
+        if isinstance(blocks, Block):
+            blocks = [blocks]
+
+        for block in blocks:
+            self._blocks.remove(block)
+            if isinstance(block, Entry):
+                del self._entries_by_key[block.key]
+            elif isinstance(block, String):
+                del self._strings_by_key[block.key]
+
+    def convert(self, name: str):
+        """Convert the library to special library.
+
+        Convert the library to special library only contain block
+        whose name is `name`, such as `entry`, 'string', ...
+        """
+        for block in self._blocks:
+            if block.__class__.__name__.lower() != name.lower():
+                self.remove(block)
+
+    def replace(self, old_block: Block, new_block: Block, fail_on_duplicate_key: bool = True):
+        """Replace a block with another block, at the same position.
+
+        :param old_block: Block to replace.
+        :param new_block: Block to replace with.
+        :param fail_on_duplicate_key: If False, adds a DuplicateKeyBlock if
+                a block with new_block.key (other than old_block) already exists.
+        :raises ValueError: If old_block is not in library or if fail_on_duplicate_key is True
+                and a block with new_block.key (other than old_block) already exists.
+        """
+        try:
+            index = self._blocks.index(old_block)
+            self.remove(old_block)
+        except ValueError:
+            raise ValueError("Block to replace is not in library.")
+
+        block_after_add = self._add_to_dicts(new_block)
+        self._blocks.insert(index, block_after_add)
+
+        if (
+            new_block is not block_after_add
+            and isinstance(block_after_add, DuplicateBlockKeyBlock)
+            and fail_on_duplicate_key
+        ):
+            # Revert changes to old_block
+            #   Don't fail on duplicate key, as this would lead to an infinite recursion
+            #   (should never happen for a clean library, but could happen if the user
+            #   tampered with the internals of the library).
+            self.replace(block_after_add, old_block, fail_on_duplicate_key=False)
+            raise ValueError("Duplicate key found.")
+
+    @staticmethod
+    def _cast_to_duplicate(
+        prev_block_with_same_key: Union[Entry, String], duplicate: Union[Entry, String]
+    ):
+        assert isinstance(prev_block_with_same_key, type(duplicate)) or isinstance(
+            duplicate, type(prev_block_with_same_key)
+        ), (
+            "Internal BibtexParser Error. Duplicate blocks share no common type."
+            f"Found {type(prev_block_with_same_key)} and {type(duplicate)}, but both should be"
+            f"either instance of String or instance of Entry."
+            f"Please report this issue at the bibtexparser issue tracker.",
+        )
+
+        assert (
+            prev_block_with_same_key.key == duplicate.key
+        ), "Internal BibtexParser Error. Duplicate blocks have different keys."
+
+        return DuplicateBlockKeyBlock(
+            start_line=duplicate.start_line,
+            raw=duplicate.raw,
+            key=duplicate.key,
+            previous_block=prev_block_with_same_key,
+            duplicate_block=duplicate,
+        )
+
+    def _add_to_dicts(self, block):
+        """Safely add block references to private dict structures.
+
+        :param block: Block to add.
+        :returns: The block that was added to the library. If a block
+            of same type and with same key already existed, a
+            DuplicateKeyBlock is returned (not added to dict).
+        """
+        if isinstance(block, Entry):
+            try:
+                prev_block_with_same_key = self._entries_by_key[block.key]
+                block = self._cast_to_duplicate(prev_block_with_same_key, block)
+            except KeyError:
+                # No duplicate found
+                self._entries_by_key[block.key] = block
+        elif isinstance(block, String):
+            try:
+                prev_block_with_same_key = self._strings_by_key[block.key]
+                block = self._cast_to_duplicate(prev_block_with_same_key, block)
+            except KeyError:
+                # No duplicate found
+                self._strings_by_key[block.key] = block
+        return block
+
+    @property
+    def blocks(self) -> List[Block]:
+        """All blocks in the library, preserving order of insertion."""
+        return self._blocks
+
+    @property
+    def failed_blocks(self) -> List[ParsingFailedBlock]:
+        """All blocks that could not be parsed, preserving order of insertion."""
+        return [block for block in self._blocks if isinstance(block, ParsingFailedBlock)]
+
+    @property
+    def strings(self) -> List[String]:
+        """All @string blocks in the library, preserving order of insertion."""
+        return [block for block in self._blocks if isinstance(block, String)]
+
+    @property
+    def strings_dict(self) -> Dict[str, String]:
+        """Dict representation of all @string blocks in the library."""
+        return self._strings_by_key.copy()
+
+    @property
+    def entries(self) -> List[Entry]:
+        """All entry (@article, ...) blocks in the library, preserving order of insertion."""
+        # Note: Taking this from the entries dict would be faster, but does not preserve order
+        #   e.g. in cases where `replace` has been called.
+        return [block for block in self._blocks if isinstance(block, Entry)]
+
+    @property
+    def entries_dict(self) -> Dict[str, Entry]:
+        """Dict representation of all entry blocks in the library."""
+        return self._entries_by_key.copy()
+
+    @property
+    def preambles(self) -> List[Preamble]:
+        """All @preamble blocks in the library, preserving order of insertion."""
+        return [block for block in self._blocks if isinstance(block, Preamble)]
+
+    @property
+    def comments(self) -> List[Union[ExplicitComment, ImplicitComment]]:
+        """All comment blocks in the library, preserving order of insertion."""
+        return [block for block in self._blocks if isinstance(block, (ExplicitComment, ImplicitComment))]

pyeasyphd/bib/bibtexparser/middlewares/block/add.py

@@ -0,0 +1,94 @@
+import re
+
+from ...library import Library
+from ...model import Block, Entry
+from ..middleware import BlockMiddleware
+from ..utils import generate_cite_key_prefix
+
+
+class AddArchive(BlockMiddleware):
+    """Add Field `archive`."""
+
+    def __init__(
+        self,
+        full_abbr_article_dict: dict,
+        full_abbr_inproceedings_dict: dict,
+        full_names_in_json: str,
+        abbr_names_in_json: str,
+        allow_inplace_modification: bool = True
+    ):
+        super().__init__(allow_inplace_modification=allow_inplace_modification)
+
+        self.full_abbr_article_dict = full_abbr_article_dict
+        self.full_abbr_inproceedings_dict = full_abbr_inproceedings_dict
+        self.full_names_in_json = full_names_in_json
+        self.abbr_names_in_json = abbr_names_in_json
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        entry["archive"] = generate_cite_key_prefix(
+            entry,
+            self.full_abbr_article_dict,
+            self.full_abbr_inproceedings_dict,
+            self.full_names_in_json,
+            self.abbr_names_in_json
+            )
+        return entry
+
+
+class AddJournalLongAbbr(BlockMiddleware):
+    """Add long abbr for field `journal`."""
+
+    def __init__(
+        self,
+        full_abbr_article_dict: dict,
+        full_names_in_json: str,
+        abbr_names_in_json: str,
+        allow_inplace_modification: bool = True
+    ):
+        super().__init__(allow_inplace_modification=allow_inplace_modification)
+
+        self.full_abbr_article_dict = full_abbr_article_dict
+        self.full_names_in_json = full_names_in_json
+        self.abbr_names_in_json = abbr_names_in_json
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        return self.generate_journal_booktitle_long_abbr(entry)
+
+    def generate_journal_booktitle_long_abbr(self, entry) -> Entry:
+        # Only for journal
+        if entry.entry_type.lower() == "article":
+            full_abbr_dict = self.full_abbr_article_dict
+            field_key = "journal"
+        else:
+            return entry
+
+        # obtain new_dict
+        abbr_dict_dict = {}
+        for publisher in full_abbr_dict:
+            abbr_dict_dict.update({abbr: full_abbr_dict[publisher][abbr] for abbr in full_abbr_dict[publisher]})
+
+        field_content = entry[field_key] if field_key in entry else ""
+        field_content = re.sub(r"\(.*\)", "", field_content).strip()
+
+        if not field_content:
+            return entry
+
+        # match
+        long_abbr_list = []
+        for abbr in abbr_dict_dict:
+            full_name_list = abbr_dict_dict[abbr].get(self.full_names_in_json, [])
+            long_abbr_name_list = abbr_dict_dict[abbr].get(self.abbr_names_in_json, [])
+
+            for full, long_abbr in zip(full_name_list, long_abbr_name_list):
+                if re.match('{' + full + '}', '{' + field_content + '}', re.I):
+                    long_abbr_list.append(long_abbr)
+
+        # check
+        long_abbr_list = list(set(long_abbr_list))
+        if len(long_abbr_list) > 1:
+            print(f"Multiple match: {long_abbr_list} for {field_content}.")
+        elif len(long_abbr_list) == 1:
+            entry["shortjournal"] = long_abbr_list[0]
+        return entry

pyeasyphd/bib/bibtexparser/middlewares/block/authors.py

@@ -0,0 +1,22 @@
+from ...library import Library
+from ...model import Block, Entry
+from ..middleware import BlockMiddleware
+
+
+class ConstrainNumberOfAuthors(BlockMiddleware):
+    """Constrain the number of authors."""
+
+    def __init__(self, maximum_authors: int, allow_inplace_modification: bool = True):
+        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
+
+        self.maximum_authors = maximum_authors
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        if "author" in entry:
+            authors = entry["author"].split(" and ")
+            if len(authors) > self.maximum_authors:
+                authors = authors[:self.maximum_authors]
+                authors.append("others")
+                entry["author"] = " and ".join(authors)
+        return entry

pyeasyphd/bib/bibtexparser/middlewares/block/doi_url.py

@@ -0,0 +1,62 @@
+import re
+
+from ...library import Library
+from ...model import Block, Entry
+from ..middleware import BlockMiddleware
+
+
+class SimplifyDoiInEntry(BlockMiddleware):
+    """Simplify doi by delete `https://doi.org/` if existed."""
+
+    def __init__(self, allow_inplace_modification: bool = True):
+        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        if "doi" in entry:
+            entry["doi"] = re.sub(r"https*://doi.org/", "", entry["doi"])
+        return entry
+
+
+class ChooseDoiOrUrlInEntry(BlockMiddleware):
+    """Choose doi when an item has both a doi and a url."""
+
+    def __init__(self, allow_inplace_modification: bool = True):
+        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        if ("doi" in entry) and (len(entry["doi"]) != 0) and ("url" in entry):
+            del entry["url"]
+        return entry
+
+
+class ChangeDoiToUrlInEntry(BlockMiddleware):
+    """Chang doi to url by add `https://doi.org/` if not existed, and then delete doi."""
+
+    def __init__(self, allow_inplace_modification: bool = True):
+        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        if "doi" in entry:
+            if len(doi := entry["doi"]) != 0:
+                if not re.match(r"https*://", doi):
+                    doi = f"https://doi.org/{doi}"
+                entry["url"] = doi
+
+            del entry["doi"]
+        return entry
+
+
+class HttpsUrlInEntry(BlockMiddleware):
+    """Change http to https for security."""
+
+    def __init__(self, allow_inplace_modification: bool = True):
+        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
+
+    # docstr-coverage: inherited
+    def transform_entry(self, entry: Entry, library: Library) -> Block:
+        if "url" in entry:
+            entry["url"] = re.sub(r"https*://", "https://", entry["url"])
+        return entry