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

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

@@ -1,222 +0,0 @@
-import logging
-import re
-from typing import Dict, List, Set
-
-from ...library import Library
-from ...model import Block, Entry, Field
-from ..middleware import BlockMiddleware
-from ..utils import SKIP_WORD_IN_CITATION_KEY
-
-logger = logging.getLogger(__name__)
-
-
-class NormalizeEntryFieldValues(BlockMiddleware):
-    """Normalize some field values (journal and booktitle) to upper case."""
-
-    def __init__(
-        self,
-        field_keys: List[str] = ["journal", "booktitle"],
-        title_lower_upper: str = 'upper',
-        allow_inplace_modification: bool = True
-    ):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-
-        self._field_keys = field_keys
-        self.title_lower_upper = title_lower_upper
-
-    # 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:
-            if self.title_lower_upper == "upper":
-                normalized_key: str = field.key.upper()
-            elif self.title_lower_upper == "lower":
-                normalized_key: str = field.key.lower()
-            else:
-                normalized_key: str = field.key.upper()
-            # 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
-
-
-class AddUrlToFieldValueInEntry(BlockMiddleware):
-    """Add url link to title."""
-
-    # docstr-coverage: inherited
-    def __init__(self, field_key: str, allow_inplace_modification: bool = True):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-
-        self.field_key = field_key
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        url = ""
-        if "doi" in entry:
-            url = entry["doi"]
-            if (len(url) != 0) and (not re.match(r"https*://", url)):
-                url = f"https://doi.org/{url}"
-        elif "url" in entry:
-            url = entry["url"]
-
-        if (len(url) != 0) and self.field_key in entry:
-            entry[self.field_key] = r"\href{" + str(url) + "}" + "{" + entry[self.field_key] + "}"
-        return entry
-
-
-class NormalizeFieldValuesInEntry(BlockMiddleware):
-    """Sentence field values."""
-
-    # docstr-coverage: inherited
-    def __init__(self, field_key: str, sentence_title: str, allow_inplace_modification: bool = True):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-
-        self.field_key = field_key
-        self.sentence_title = sentence_title
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        if self.field_key in entry:
-            if self.sentence_title == "sentence":
-                entry[self.field_key] = self.generate_standard_sentence_case(entry[self.field_key])
-            if self.sentence_title == "title":
-                entry[self.field_key] = self.generate_standard_title_case(entry[self.field_key])
-        return entry
-
-    @staticmethod
-    def __upper_or_lower_first_letter(input_str: str, flag: str) -> str:
-        """Upper or lower first letter.
-
-        Check whether the first is in the a-zA-Z and then UPPER or LOWER it.
-        flag = upper
-        Input: about; $food; About; aBout
-        Output: About; $food; About; ABout
-        flag = lower
-        Input: About; $food; about; ABout
-        Output: about; $food; about; aBout
-        """
-        new_input_str = input_str.strip()
-        if new_input_str and re.search(r"[a-zA-Z]", new_input_str[0]):
-            if flag == "lower":
-                new_input_str = new_input_str[0].lower() + new_input_str[1:]
-            elif flag == "upper":
-                new_input_str = new_input_str[0].upper() + new_input_str[1:]
-            else:
-                new_input_str = input_str
-        return new_input_str
-
-    def __lower_first_letter_and_others_not_contain_uppers(self, input_str: str) -> str:
-        """Lower.
-
-        Input: About; A; $about; ABOUT; aBOUT
-        Output: about; a; $about; ABOUT; aBOUT
-        """
-        new_input_str = input_str.strip()
-        if new_input_str and (not re.search(r"[A-Z]", new_input_str[1:])):  # Others not contain upper letter
-            input_str = self.__upper_or_lower_first_letter(input_str, "lower")  # Lower
-        return input_str
-
-    def __upper_first_letter_and_others_not_contain_uppers(self, input_str: str) -> str:
-        """Upper.
-
-        Input: about; a; $about; ABOUT; abOUT
-        Output: About; A; $about; ABOUT; abOUT
-        """
-        new_input_str = input_str.strip()
-        if new_input_str.lower() in SKIP_WORD_IN_CITATION_KEY:
-            return new_input_str.lower()
-
-        if new_input_str and (not re.search(r"[A-Z]", new_input_str[1:])):  # Others not contain upper letter
-            input_str = self.__upper_or_lower_first_letter(input_str, "upper")  # upper
-        return input_str
-
-    def __generate_new_case_title(self, old_title: str, flag: str) -> str:
-        """Generate new title."""
-        old_list, new_list = re.split(r"\s+", old_title), []
-        for i in range(len(old_list)):
-            old_str = old_list[i]
-            if re.search(r"-", old_str):
-                temp_list, new_temp_list = re.split("-", old_str), []
-                if i == 0:  # for the first element
-                    new_temp_list = [self.__upper_or_lower_first_letter(temp_list[0], "upper")]
-                    temp_list = temp_list[1:]
-                for t in temp_list:
-                    if len(t.strip()) == 1:
-                        new_temp_list.append(t)  # not change
-                    else:
-                        if flag == "sentence":
-                            new_temp_list.append(self.__lower_first_letter_and_others_not_contain_uppers(t))
-                        elif flag == "title":
-                            new_temp_list.append(self.__upper_first_letter_and_others_not_contain_uppers(t))
-                        else:
-                            pass
-                new_list.append("-".join(new_temp_list))
-            else:
-                if i == 0:
-                    new_list.append(self.__upper_or_lower_first_letter(old_str, "upper"))
-                else:
-                    if flag == "sentence":
-                        new_list.append(self.__lower_first_letter_and_others_not_contain_uppers(old_str))
-                    elif flag == "title":
-                        new_list.append(self.__upper_first_letter_and_others_not_contain_uppers(old_str))
-                    else:
-                        pass
-        return " ".join(new_list)
-
-    def _generate_standard_title(self, title_content: str, flag: str) -> str:
-        title_list, relative_flags = [title_content], []
-        flags = [r":\s+", r"\s+-\s+", r"\s+--\s+", r"\s+—\s+", r"\s+——\s+", r"\s+–\s+", r"\s+––\s+"]
-        for i in range(len(flags)):
-            new_title_list = []
-            for j in range(len(title_list)):
-                temp_list = re.split(flags[i], title_list[j])
-                new_title_list.extend(temp_list)
-                if len(temp_list) > 1:
-                    relative_flags[j:j] = [flags[i].replace(r"\s+", " ") for _ in range(len(temp_list) - 1)]
-            title_list = new_title_list
-
-        new_title = ""
-        title_list = [self.__generate_new_case_title(t.strip(), flag) for t in title_list]
-        for i in range(ll := len(title_list)):
-            new_title = new_title + title_list[i]
-            if i < (ll - 1):
-                new_title = new_title + relative_flags[i]
-        return new_title
-
-    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
-    def generate_standard_sentence_case(self, title_content: str) -> str:
-        """Generate standard title.
-
-        "Hello, world".upper() # HELLO WORLD
-        "HELLO, WORLD".lower() # hello world
-        "hello, world".capitalize() # Hello, world
-        "hello, world".title() # Hello, World
-        """
-        return self._generate_standard_title(title_content, "sentence")
-
-    # --------- --------- --------- --------- --------- --------- --------- --------- --------- #
-    def generate_standard_title_case(self, title_content: str) -> str:
-        """Generate standard title.
-
-        "Hello, world".upper() # HELLO WORLD
-        "HELLO, WORLD".lower() # hello world
-        "hello, world".capitalize() # Hello, world
-        "hello, world".title() # Hello, World
-        """
-        return self._generate_standard_title(title_content, "title")

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

@@ -1,34 +0,0 @@
-from typing import List, Optional
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class DeleteFieldsInEntry(BlockMiddleware):
-    """Delete fields by user."""
-
-    def __init__(
-        self, delete_field_keys: List[str], entry_type: Optional[str] = None, allow_inplace_modification: bool = True
-    ):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-
-        self.entry_type = entry_type
-        self.delete_field_keys = delete_field_keys
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        if self.entry_type is None:
-            entry_type = entry.entry_type
-        else:
-            entry_type = self.entry_type
-
-        if entry_type == entry.entry_type:
-            for key in self.delete_field_keys:
-                del entry[key]
-        return entry
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "delete_custom_fields"

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

@@ -1,33 +0,0 @@
-import copy
-from typing import List
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class KeepFieldsInEntry(BlockMiddleware):
-    """Keep the fields of an entry according to a custom list of field keys provided by user."""
-
-    def __init__(self, entry_type: str, keep_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.keep_field_keys = keep_field_keys
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        if self.entry_type == entry.entry_type:
-            keep_field_keys = copy.deepcopy(self.keep_field_keys)
-            if ("editor" in entry) and ("author" not in entry) and ("author" in self.keep_field_keys):
-                keep_field_keys.append("editor")
-
-            delete_field_keys = [k for k in entry.fields_dict.keys() if k not in keep_field_keys]
-            for key in delete_field_keys:
-                del entry[key]
-        return entry
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "keep_fields_custom"

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

@@ -1,70 +0,0 @@
-from typing import Tuple
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class SortFieldsAlphabeticallyMiddleware(BlockMiddleware):
-    """Sort the fields of an entry alphabetically by key."""
-
-    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:
-        entry.fields = sorted(entry.fields, key=lambda f: f.key)
-        entry.parser_metadata[self.metadata_key()] = True
-        return entry
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "sorted_fields_alphabetically"
-
-
-class SortFieldsCustomMiddleware(BlockMiddleware):
-    """Sort the fields of an entry according to a custom order provided by user.
-
-    The order is a list of field keys. Fields not in the list are put at the end.
-    """
-
-    def __init__(
-        self,
-        order: Tuple[str, ...],
-        case_sensitive: bool = False,
-        allow_inplace_modification: bool = True,
-    ):
-        super().__init__(allow_inplace_modification=allow_inplace_modification, allow_parallel_execution=True)
-        self._case_sensitive = case_sensitive
-        if not case_sensitive:
-            self._order = [x.lower() for x in order]
-        else:
-            self._order = order
-
-        if len(self._order) != len(set(self._order)):
-            duplicate_keys = {x for x in self._order if self._order.count(x) > 1}
-            raise ValueError(
-                "Order list must not contain duplicates. "
-                "The following keys are duplicated: "
-                f"{', '.join(duplicate_keys)}"
-            )
-
-    # docstr-coverage: inherited
-    def transform_entry(self, entry: Entry, library: Library) -> Block:
-        def _sort_key(field):
-            try:
-                key = field.key.lower() if not self._case_sensitive else field.key
-                return self._order.index(key)
-            except ValueError:
-                # If the field is not in the order list, put it at the end
-                return len(self._order)
-
-        entry.fields = sorted(entry.fields, key=_sort_key)
-        entry.parser_metadata[self.metadata_key()] = self._order
-        return entry
-
-    # docstr-coverage: inherited
-    @classmethod
-    def metadata_key(cls) -> str:
-        return "sorted_fields_custom"

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

@@ -1,15 +0,0 @@
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class NormalizeEntryTypes(BlockMiddleware):
-    """Normalize Entry types."""
-
-    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:
-        entry.entry_type = entry.entry_type.lower()
-        return entry

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

@@ -1,113 +0,0 @@
-import re
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class AbbreviateJournalBooktitle(BlockMiddleware):
-    """Abbreviate the field `journal` or `booktitle` value of an entry."""
-
-    def __init__(
-        self,
-        full_abbr_article_dict: dict,
-        full_abbr_inproceedings_dict: dict,
-        abbr_index_article_for_abbr: int,
-        abbr_index_inproceedings_for_abbr: int,
-        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.abbr_index_article_for_abbr = abbr_index_article_for_abbr
-        self.abbr_index_inproceedings_for_abbr = abbr_index_inproceedings_for_abbr
-        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.abbreviate_journal_booktitle(entry)
-
-    def abbreviate_journal_booktitle(self, entry: Entry) -> Entry:
-        """Abbreviate."""
-        if entry.entry_type.lower() == "article":
-            full_abbr_dict = self.full_abbr_article_dict
-            field_key = "journal"
-            abbr_index = self.abbr_index_article_for_abbr
-        elif entry.entry_type.lower() == "inproceedings":
-            full_abbr_dict = self.full_abbr_inproceedings_dict
-            field_key = "booktitle"
-            abbr_index = self.abbr_index_inproceedings_for_abbr
-        else:
-            return entry
-
-        if abbr_index not in [1, 2]:
-            return entry
-
-        # Case 1
-        if abbr_index == 2:
-            regex = re.compile(r"([a-zA-Z])_([\w\-]+)_(.*)")
-            if mch := regex.search(entry.key):
-                if mch.group(1).lower() in ["j", "c"]:
-                    entry[field_key] = mch.group(2)
-                    return entry
-
-        # Case 2
-        # 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
-        content_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, [])
-
-            # long abbreviation
-            if abbr_index == 1:
-                for full, long_abbr in zip(full_name_list, long_abbr_name_list):
-                    if re.match('{' + full + '}', '{' + field_content + '}', re.I):
-                        content_list.append(long_abbr)
-
-            # short abbreviation
-            elif abbr_index == 2:
-                full_abbr = []
-                full_abbr.extend(full_name_list)
-                full_abbr.extend(long_abbr_name_list)
-
-                if re.match("{" + rf'({"|".join(full_abbr)})' + "}", "{" + field_content + "}", flags=re.I):
-                    content_list.append(abbr)
-
-        # check
-        content_list = list(set(content_list))
-        if len(content_list) > 1:
-            print(f"Multiple match: {content_list} for {field_content}.")
-        elif len(content_list) == 1:
-            entry[field_key] = content_list[0]
-        return entry
-
-
-class DeleteRedundantInJournalBooktitle(BlockMiddleware):
-    """Delete redundant part such as `(CEC)` in field `journal` or `booktitle` value of an entry."""
-
-    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 entry.entry_type.lower() in ["article", "inproceedings"]:
-            for i in ["journal", "booktitle"]:
-                value = entry[i] if i in entry else ""
-                if value:
-                    entry[i] = re.sub(r"\(.*\)", "", value).strip()
-        return entry

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

@@ -1,34 +0,0 @@
-from pyadvtools.core.convert import convert_str_month_to_number_month
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class ConvertStrMonthToInt(BlockMiddleware):
-    """Convert the field `month` value of an entry when it is str to int type if possible."""
-
-    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 "month" in entry:
-            entry["month"] = convert_str_month_to_number_month(entry["month"])
-        return entry
-
-
-class ExtractYear(BlockMiddleware):
-    """Convert the field `month` value of an entry when it is str to int type if possible."""
-
-    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:
-        year = entry["year"] if "year" in entry else ""
-        if year:
-            year_list = [i for j in year.split("/") for i in j.split("-")]
-            year_list = sorted(set(year_list), key=len, reverse=True)
-            entry["year"] = f"{year_list[0]}"
-        return entry

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

@@ -1,21 +0,0 @@
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class ConvertStrNumberVolumeToInt(BlockMiddleware):
-    """Convert the field `number` or `volume` value of an entry when it is str to int type if possible."""
-
-    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:
-        for i in ["number", "volume"]:
-            value = entry[i] if i in entry else ""
-            if value:
-                try:
-                    entry[i] = f"{int(value)}"
-                except ValueError:
-                    pass
-        return entry

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

@@ -1,28 +0,0 @@
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class NormalizePagesInEntry(BlockMiddleware):
-    """Normalize field `pages` of an entry by deleting redundant part or generating when not 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 "pages" in entry:
-            # 5-10-5-10 -> 5-10
-            page_list = []
-            for page in entry["pages"].split("-"):  # English hyphen
-                for p in page.strip().split("—"):  # Chinese hyphen
-                    if p.strip():
-                        page_list.append(p.strip())
-
-            page_list = sorted(set(page_list), key=page_list.index)
-            entry["pages"] = "-".join(page_list)
-        else:
-            # pages = {12:1-37}
-            if "articleno" in entry and "numpages" in entry:
-                entry["pages"] = f'{entry["articleno"]}:1-{entry["numpages"]}'
-        return entry

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

@@ -1,20 +0,0 @@
-import re
-
-from ...library import Library
-from ...model import Block, Entry
-from ..middleware import BlockMiddleware
-
-
-class NormalizeTitleInEntry(BlockMiddleware):
-    r"""Normalize field `title` of an entry by deleting \href{}{} 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:
-        regex = re.compile(r"\\href{(.*)}{(.*)}")
-        if "title" in entry:
-            if mch := regex.search(entry["title"]):
-                entry["title"] = mch.group(2)
-        return entry