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

pyeasyphd/bib/bibtexparser/middlewares/library/generating_entrykeys.py

@@ -1,98 +0,0 @@
-import re
-
-from ...library import Library
-from ...model import Entry
-from ..middleware import LibraryMiddleware
-from ..utils import SKIP_WORD_IN_CITATION_KEY, generate_cite_key_prefix
-
-
-class GenerateEntriesCiteKey(LibraryMiddleware):
-    """Generate entries key of a library.
-
-    The entry.key is also `Cite Key`.
-    """
-
-    # docstr-coverage: inherited
-    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(self, library: Library) -> Library:
-        library = super().transform(library)
-        for entry in library.entries:
-            generate_key = self.generate_cite_key(entry)
-            while generate_key in [e.key for e in library.entries if e != entry]:
-                generate_key = generate_key + "-a"
-            entry.key = generate_key
-        return library
-
-    def generate_cite_key(self, entry: Entry) -> str:
-        """Generate user citation key."""
-        prefix = 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
-            )
-
-        cite_key = self.generate_google_cite_key(entry)
-        if prefix != "":
-            cite_key = prefix + "_" + cite_key
-        return cite_key
-
-    @staticmethod
-    def _obtain_family_name(author: str) -> str:
-        """Obtain the family name of first author."""
-        author = re.sub(r"\noopsort", "", author)
-        author = re.sub("}{", " ", author)
-        if re.search(r"\s+and\s+", author):  # Zhe Feng, Tianxi Li, Haifeng Xu and Fei Zhang
-            author = re.split(r"\s+and\s+", author)[0]
-
-        if re.search(r",", author):  # Zhe Feng, Tianxi Li, Haifeng Xu
-            author = re.split(r",", author)[0]
-
-        author = author.strip()
-
-        if re.search(r"\s+", author):  # M. Li or Ming Li (given name family name)
-            f_list = re.split(r"\s+", author)
-            f_list = [f.strip() for f in f_list if len(f.strip()) != 0]
-            family_name = f_list[-1]
-        else:
-            family_name = author
-        return family_name
-
-    def generate_google_cite_key(self, entry: Entry) -> str:
-        """Generate google citation key."""
-        author = entry["author"] if "author" in entry else ""
-        family_name = self._obtain_family_name(author).lower()
-
-        year = entry["year"] if "year" in entry else ""
-
-        first_word_of_title = ""
-        title = entry["title"] if "title" in entry else ""
-        regex = re.compile(r"\\href{(.*)}{(.*)}")
-        if mch := regex.search(title):
-            title = mch.group(2)
-
-        word_list = [w.lower() for w in re.split(r"\s+", title) if w.strip()]
-        word_list = [re.sub(r"[^a-zA-Z0-9]", "", w) for w in word_list]
-        for w in word_list:
-            if w not in SKIP_WORD_IN_CITATION_KEY:
-                first_word_of_title = w
-                break
-
-        citation_key = family_name + year + first_word_of_title
-        return re.sub(r"[^a-zA-Z0-9]", "", citation_key)

pyeasyphd/bib/bibtexparser/middlewares/library/keeping_blocks.py

@@ -1,29 +0,0 @@
-from typing import List
-
-from ...library import Library
-from ..middleware import LibraryMiddleware
-
-
-class KeepEntriesByCiteKey(LibraryMiddleware):
-    """Keep the entries of a library by `Cite Key`.
-
-    The entry.key is also `Cite Key`.
-    """
-
-    def __init__(self, entry_keys: List[str], allow_inplace_modification: bool = True):
-        super().__init__(allow_inplace_modification=allow_inplace_modification)
-
-        self.entry_keys = [e.lower() for e in entry_keys]
-
-    # docstr-coverage: inherited
-    def transform(self, library: Library) -> Library:
-        library = super().transform(library)
-        for entry in library.entries:
-            if entry.key.lower() not in self.entry_keys:
-                library.remove(entry)
-        return library
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "keep_entry_according_cite_keys"

pyeasyphd/bib/bibtexparser/middlewares/library/sorting_blocks.py

@@ -1,124 +0,0 @@
-import re
-from copy import deepcopy
-from typing import List
-
-from ...library import Library
-from ...model import (
-    Block,
-    Entry,
-    ExplicitComment,
-    ImplicitComment,
-    ParsingFailedBlock,
-    Preamble,
-    String,
-)
-from ..middleware import LibraryMiddleware
-
-DEFAULT_BLOCK_TYPE_ORDER = (ImplicitComment, ExplicitComment, String, Preamble, Entry, ParsingFailedBlock, Block)
-
-
-class SortBlocksByTypeAndUserSortKeyMiddleware(LibraryMiddleware):
-    """Sorts the blocks of a library by type and `User Sort Key`."""
-
-    def __init__(
-        self,
-        keep_entry_according_cite_keys: List[str] = [],
-        sort_entry_according_field_keys: List[str] = ["year", "volume", "number", "month", "pages"],
-        sort_entry_according_field_keys_reverse: bool = True,
-    ):
-        self._verify_all_types_are_block_types(DEFAULT_BLOCK_TYPE_ORDER)
-        self.keep_entry_according_cite_keys = keep_entry_according_cite_keys
-        self.sort_entry_according_field_keys = sort_entry_according_field_keys
-        self.sort_entry_according_field_keys_reverse = sort_entry_according_field_keys_reverse
-
-        # In-place modification is not yet supported, we make this explicit here,
-        super().__init__(allow_inplace_modification=False)
-
-    @staticmethod
-    def _verify_all_types_are_block_types(sort_order):
-        for t in sort_order:
-            if not issubclass(t, Block):
-                raise ValueError(
-                    "Sort order must only contain Block subclasses, " f"but got {str(t)}"
-                )
-
-    # docstr-coverage: inherited
-    def transform(self, library: Library) -> Library:
-        library = super().transform(library)
-        blocks = library.blocks
-
-        _blocks = []
-
-        _implicit_comments = [b for b in blocks if isinstance(b, ImplicitComment)]
-        _implicit_comments = sorted(_implicit_comments, key=lambda x: len(x.comment), reverse=False)
-
-        _explicit_comments = [b for b in blocks if isinstance(b, ExplicitComment)]
-        _explicit_comments = sorted(_explicit_comments, key=lambda x: len(x.comment), reverse=False)
-
-        _strings = sorted(library.strings, key=lambda x: x.key, reverse=False)
-
-        _preambles = sorted(library.preambles, key=lambda x: len(x.value), reverse=False)
-
-        _entries = library.entries
-        if self.keep_entry_according_cite_keys:
-            _entries = sorted(_entries, key=self._sort_entry_one, reverse=False)
-        else:
-            _entries = sorted(_entries, key=self._sort_entry_two, reverse=self.sort_entry_according_field_keys_reverse)
-
-        _failed_blocks = deepcopy(library.failed_blocks)
-        _failed_blocks = sorted(_failed_blocks, key=lambda x: len(x.__class__.__name__), reverse=False)
-
-        _others = [b for b in blocks if not (
-                isinstance(b, ImplicitComment) or
-                isinstance(b, ExplicitComment) or
-                isinstance(b, String) or
-                isinstance(b, Preamble) or
-                isinstance(b, Entry) or
-                isinstance(b, ParsingFailedBlock)
-            )
-        ]
-        _others = sorted(_others, key=lambda x: len(x.__class__.__name__), reverse=False)
-
-        # order of blocks
-        _blocks.extend(_strings)
-        _blocks.extend(_entries)
-        _blocks.extend(_preambles)
-        _blocks.extend(_explicit_comments)
-        _blocks.extend(_implicit_comments)
-        _blocks.extend(_failed_blocks)
-        _blocks.extend(_others)
-        return Library(blocks=_blocks)
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "sort_blocks_by_type_and_user_sort_key"
-
-    def _sort_entry_one(self, entry):
-        if entry.key in self.keep_entry_according_cite_keys:
-            return self.keep_entry_according_cite_keys.index(entry.key)
-        else:
-            return -1
-
-    def _sort_entry_two(self, entry):
-        _sorting_index = []
-        _sorting_index.append(entry.entry_type)
-        for k in self.sort_entry_according_field_keys:
-            if k in entry.fields_dict:
-                v = entry.fields_dict[k].value
-                # for sorting
-                if k == "pages":
-                    v = v.split("——")[0].split("--")[0].split("–")[0].split("-")[0]
-                if k == "month":
-                    v = v.split("–")[0].split("-")[0].split("/")[0]
-                _sorting_index.append(v)
-            else:
-                _sorting_index.append("0")
-        return self.sort_strings_with_embedded_numbers("_".join(_sorting_index))
-
-    @staticmethod
-    def sort_strings_with_embedded_numbers(s: str) -> List[str]:
-        re_digits = re.compile(r"(\d+)")
-        pieces = re_digits.split(s)
-        pieces[1::2] = map(int, pieces[1::2])
-        return pieces

pyeasyphd/bib/bibtexparser/middlewares/middleware.py

@@ -1,222 +0,0 @@
-import abc
-import logging
-from copy import deepcopy
-from typing import Collection, Union
-
-from ..library import Library
-from ..model import Block, Entry, ExplicitComment, ImplicitComment, Preamble, String
-
-logger = logging.getLogger(__name__)
-
-
-class Middleware(abc.ABC):
-    """Implements a function to transform a block or library.
-
-    Abstract Class. You should extend either BlockMiddleware
-    or LibraryMiddleware
-    """
-
-    def __init__(
-        self,
-        allow_parallel_execution: bool = True,
-        allow_inplace_modification: bool = True,
-    ):
-        """Create a new Middleware.
-
-        :param allow_inplace_modification: See corresponding property.
-        :param allow_parallel_execution: See corresponding property.
-        """
-        self._allow_inplace_modification = allow_inplace_modification
-        self._allow_parallel_execution = allow_parallel_execution
-
-    @property
-    def allow_inplace_modification(self) -> bool:
-        """If true, the middleware **may** modify the block in-place.
-
-        I.e., if true, the output of `transform` may be the same instance
-        as the input. If false, new instances must be returned.
-        """
-        return self._allow_inplace_modification
-
-    @property
-    def allow_parallel_execution(self) -> bool:
-        """True indicates that the middleware is threadsafe."""
-        return self._allow_parallel_execution
-
-    @abc.abstractmethod
-    def transform(self, library: Library) -> Library:
-        """Apply transformation to a library. Main entrypoint of the middleware."""
-        raise NotImplementedError("called abstract method")
-
-
-class BlockMiddleware(Middleware, abc.ABC):
-    """Transform a library on a per-block basis.
-
-    The `BlockMiddleware` replaces a block with zero, one or more
-    new (transformed) blocks.
-
-    Changes may rely on the state of the overall library,
-    but must not change the state of the library directly,
-    except if `allow_inplace_modification` is true.
-    """
-
-    @classmethod
-    def metadata_key(cls) -> str:
-        """Tt is the identifier of the middleware.
-
-        This key is used to identify the middleware in a blocks metadata.
-        """
-        return cls.__name__
-
-    # docstr-coverage: inherited
-    def transform(self, library: Library) -> Library:
-        # TODO Multiprocessing (only for large library and if allow_multi..)
-        blocks = []
-        for b in library.blocks:
-            transformed = self.transform_block(b, library)
-            # Case 1: None. Skip it.
-            if transformed is None:
-                pass
-
-            # Case 2: A single block. Add it to the list.
-            elif isinstance(transformed, Block):
-                blocks.append(transformed)
-
-            # Case 3: A collection. Append all the elements.
-            elif isinstance(transformed, Collection):
-                # check that all the items are indeed blocks
-                for item in transformed:
-                    if not isinstance(item, Block):
-                        raise TypeError(
-                            f"Non-Block type found in transformed collection: {type(item)}"
-                        )
-                blocks.extend(transformed)
-
-            # Case 4: Something else. Error.
-            else:
-                raise TypeError(f"Illegal output type from transform_block: {type(transformed)}")
-        return Library(blocks=blocks)
-
-    def transform_block(
-        self, block: Block, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform a block.
-
-        :param block: Block to transform.
-        :param library: Library containing the block.
-            Should typically not be modified during
-            the transformation, but be considered as read-only.
-            If the library is modified, make sure to set the `allow_multithreading`
-            constructor argument to false
-        :return: Transformed block. If the block should be removed, return None.
-            If the block should be replaced by multiple blocks, return a collection
-            of blocks. If the block should be replaced by a single block, return
-            the single block. If the block should not be modified, return a copy of
-            the original block.
-            The returned block has to be a new instance, except if
-            `self.allow_inplace_modification` is True (in which case the block
-            may also return the original block).
-        """
-        block = block if self.allow_inplace_modification else deepcopy(block)
-        if isinstance(block, Entry):
-            return self.transform_entry(block, library)
-        elif isinstance(block, String):
-            return self.transform_string(block, library)
-        elif isinstance(block, Preamble):
-            return self.transform_preamble(block, library)
-        elif isinstance(block, ExplicitComment):
-            return self.transform_explicit_comment(block, library)
-        elif isinstance(block, ImplicitComment):
-            return self.transform_implicit_comment(block, library)
-
-        # logger.warning(f"Unknown block type {type(block)}")
-        return block
-
-    def transform_entry(
-        self, entry: Entry, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform an entry. Called by `transform_block` if the block is an entry.
-
-        Note: This method modifies the passed entry. For a method
-        respecting the `allow_inplace_modification` property,
-        you should use `transform` or `transform_block` instead.
-        """
-        return entry
-
-    def transform_string(
-        self, string: String, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform a string. Called by `transform_block` if the block is a string.
-
-        Note: This method modifies the passed string. For a method
-        respecting the `allow_inplace_modification` property,
-        you should use `transform` or `transform_block` instead.
-        """
-        return string
-
-    def transform_preamble(
-        self, preamble: Preamble, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform a preamble. Called by `transform_block` if the block is a preamble.
-
-        Note: This method modifies the passed preamble. For a method
-        respecting the `allow_inplace_modification` property,
-        you should use `transform` or `transform_block` instead.
-        """
-        return preamble
-
-    def transform_explicit_comment(
-        self, explicit_comment: ExplicitComment, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform an explicit comment. Called by `transform_block` if the block is an explicit comment.
-
-        Note: This method modifies the passed explicit comment. For a method
-        respecting the `allow_inplace_modification` property,
-        you should use `transform` or `transform_block` instead.
-        """
-        return explicit_comment
-
-    def transform_implicit_comment(
-        self, implicit_comment: ImplicitComment, library: Library
-    ) -> Union[Block, Collection[Block], None]:
-        """Transform an implicit comment. Called by `transform_block` if the block is an implicit comment.
-
-        Note: This method modifies the passed implicit comment. For a method
-        respecting the `allow_inplace_modification` property,
-        you should use `transform` or `transform_block` instead.
-        """
-        return implicit_comment
-
-
-class LibraryMiddleware(Middleware, abc.ABC):
-    """Changes an overall library at once (not just on a per-block basis).
-
-    Examples of library-wide changes are:
-    - Re-Sorting the blocks in the library.
-    - Transforming the library instance to a custom subclass of Library.
-
-    Whatever can be done in a BlockMiddleware, should be done
-    in a BlockMiddleware (and not in a LibraryMiddleware),
-    for performance reasons (e.g. deleting blocks, ...).
-    """
-
-    def __init__(self, allow_inplace_modification: bool = True):
-        # As library middleware is run per library (not per block individually),
-        #   it cannot be parallelized.
-        super().__init__(
-            allow_inplace_modification=allow_inplace_modification,
-            allow_parallel_execution=False,
-        )
-
-    def transform(self, library: Library) -> Library:
-        """Transform a library.
-
-        :param library: Library to transform.
-        :return: Transformed library. If the library should not be modified,
-            return a copy of the original library.
-            The returned library has to be a new instance, except if
-            `self.allow_inplace_modification` is True (in which case the library
-            may also return the original library).
-        """
-        library = library if self.allow_inplace_modification else deepcopy(library)
-        return library

pyeasyphd/bib/bibtexparser/middlewares/parsestack.py

@@ -1,13 +0,0 @@
-from typing import List
-
-from .middleware import Middleware
-
-
-def default_parse_stack(allow_inplace_modification: bool = True) -> List[Middleware]:
-    """Give the default parse stack to be applied after splitting, if not specified otherwise."""
-    return []
-
-
-def default_unparse_stack(allow_inplace_modification: bool = False) -> List[Middleware]:
-    """Give the default unparse stack to be applied before writing, if not specified otherwise."""
-    return []