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

pyeasyphd/bib/bibtexparser/exceptions.py

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

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

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

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

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

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

@@ -1,47 +0,0 @@
-import logging
-from typing import Dict, List, Set
-
-from ...library import Library
-from ...model import Entry, Field
-from ..middleware import BlockMiddleware
-
-logger = logging.getLogger(__name__)
-
-
-class NormalizeEntryFieldKeys(BlockMiddleware):
-    """Normalize field keys to lowercase.
-
-    In case of conflicts (e.g. both 'author' and 'Author' exist in the same entry),
-    a warning is emitted, and the last value wins.
-
-    Some other middlewares, such as `SeparateCoAuthors`, assume lowercase key names.
-    """
-
-    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) -> Entry:
-        seen_normalized_keys: Set[str] = set()
-        new_fields_dict: Dict[str, Field] = {}
-        for field in entry.fields:
-            normalized_key: str = field.key.lower()
-            # if the normalized key is already present, apply "last one wins"
-            # otherwise preserve insertion order
-            # if a key is overwritten, emit a detailed warning
-            # if performance is a concern, we could emit a warning with only {entry.key}
-            # to remove "seen_normalized_keys" and this if statement
-            if normalized_key in seen_normalized_keys:
-                logger.warning(
-                    f"NormalizeFieldKeys: in entry '{entry.key}': "
-                    + f"duplicate normalized key '{normalized_key}' "
-                    + f"(original '{field.key}'); overriding previous value"
-                )
-            seen_normalized_keys.add(normalized_key)
-            field.key = normalized_key
-            new_fields_dict[normalized_key] = field
-
-        new_fields: List[Field] = list(new_fields_dict.values())
-        entry.fields = new_fields
-
-        return entry

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

@@ -1,31 +0,0 @@
-from typing import List
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class ReplaceFieldKeyInEntry(BlockMiddleware):
-    """Replace field key by user."""
-
-    def __init__(
-        self,
-        entry_type: str,
-        old_field_keys: List[str],
-        new_field_keys: List[str],
-        allow_inplace_modification: bool = True
-    ):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-
-        self.entry_type = entry_type
-        self.old_field_keys = old_field_keys
-        self.new_field_keys = new_field_keys
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        if self.entry_type == entry.entry_type:
-            for old, new in zip(self.old_field_keys, self.new_field_keys):
-                if (old != new) and (old in entry):
-                    entry[new] = entry[old]
-                    del entry[old]
-        return entry