pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/.python-version

@@ -0,0 +1 @@
+3.8

pyeasyphd/Main.sublime-menu

@@ -0,0 +1,43 @@
+[
+    {
+        "caption": "Preferences",
+        "id": "preferences",
+        "children":
+        [
+            {
+                "caption": "Package Settings",
+                "id": "package-settings",
+                "children":
+                [
+                    {
+                        "caption": "PyEasyPhD",
+                        "children":
+                        [
+                            {
+                                "command": "open_url",
+                                "args": {"url": "https://github.com/NextArtifIntell/pyeasyphd"},
+                                "caption": "Documentation"
+                            },
+                            { "caption": "-" },
+                            {
+                                "command": "open_file",
+                                "args": {
+                                    "file": "${packages}/pyeasyphd/pyeasyphd.sublime-settings"
+                                },
+                                "caption": "Settings – Default (read-only)"
+                            },
+                            {
+                                "command": "open_file",
+                                "args": {
+                                    "file": "${packages}/User/PyEasyPhD.sublime-settings"
+                                },
+                                "caption": "Settings – User"
+                            },
+                            { "caption": "-" }
+                        ]
+                    }
+                ]
+            }
+        ]
+    }
+]

pyeasyphd/bib/__init__.py

@@ -0,0 +1 @@
+"""Initialization."""

pyeasyphd/bib/bibtexbase/__init__.py

@@ -0,0 +1,7 @@
+"""Initialization."""
+
+__all__ = [
+    "StandardizeBib"
+]
+
+from .standardize_bib import StandardizeBib

pyeasyphd/bib/bibtexbase/standardize/_base.py

@@ -0,0 +1,36 @@
+import re
+from typing import List
+
+
+def split_data_list(split_pattern: str, data_list: List[str], last_next: str = "next") -> List[str]:
+    r"""Split data list according to the split pattern.
+
+    The capturing parentheses must be used in the pattern, such as `(\n)`.
+
+    Args:
+        split_pattern (str): split pattern.
+        data_list (List[str]): data list.
+        last_next (str): "next" or "last".
+
+    Returns:
+        List[str]: new data list.
+
+    Examples:
+        split_pattern = r"(\n)", last_next = "next" or "last".
+    """
+    new_data_list = []
+    for line in data_list:
+        split_list = re.split(split_pattern, line)
+        list_one = split_list[0:len(split_list):2]
+        list_two = split_list[1:len(split_list):2]
+
+        temp = []
+        if last_next == "next":
+            list_two.insert(0, "")
+            temp = [list_two[i] + list_one[i] for i in range(len(list_one))]
+        if last_next == "last":
+            list_two.append("")
+            temp = [list_one[i] + list_two[i] for i in range(len(list_one))]
+        new_data_list.extend(temp)
+    new_data_list = [line for line in new_data_list if line.strip()]
+    return new_data_list

pyeasyphd/bib/bibtexbase/standardize/default_data.py

@@ -0,0 +1,97 @@
+FIELD_FORMAT_FLAG = [r'"', r"{", r"\w"]
+
+DEFAULT_FIELDS_LIST = [
+    "abstract",
+    "accepted",
+    "accessdate",
+    "address",
+    "affiliation",
+    "affiliations",
+    "annotation",
+    "archive",
+    "article-number",
+    "articleno",
+    "audio",
+    "author",
+    "author-email",
+    "authors",
+    "bibsource",
+    "biburl",
+    "book-group-author",
+    "booktitle",
+    "cited-references",
+    "code",
+    "copyright",
+    "crossref",
+    "data",
+    "date",
+    "doc-delivery-number",
+    "doi",
+    "edition",
+    "editor",
+    "editors",
+    "eissn",
+    "eprint",
+    "extra",
+    "fjournal",
+    "funding-acknowledgement",
+    "funding-text",
+    "howpublished",
+    "institution",
+    "isbn",
+    "isbn-13",
+    "issn",
+    "issue",
+    "issue_date",
+    "journal",
+    "journal-iso",
+    "journalabbr",
+    "journalabbreviation",
+    "key",
+    "keywords",
+    "keywords-plus",
+    "language",
+    "lccn",
+    "location",
+    "month",
+    "note",
+    "number",
+    "number-of-cited-references",
+    "numpages",
+    "orcid-numbers",
+    "organization",
+    "pages",
+    "pdf",
+    "place",
+    "pubdates",
+    "publisher",
+    "remark",
+    "research-areas",
+    "researcherid-numbers",
+    "rights",
+    "school",
+    "series",
+    "shortjournal"
+    "shorttitle",
+    "slide",
+    "submitted",
+    "summary",
+    "supplementary",
+    "times-cited",
+    "timestamp",
+    "title",
+    "type",
+    "unique-id",
+    "url",
+    "usage-count-last-180-days",
+    "usage-count-since-2013",
+    "video",
+    "volume",
+    "web-of-science-categories",
+    "web-of-science-index",
+    "xxeditor",
+    "xxnote",
+    "xxtitle",
+    "xxyear",
+    "year",
+]

pyeasyphd/bib/bibtexbase/standardize/do_on_bib.py

@@ -0,0 +1,54 @@
+import re
+from typing import Dict, List, Tuple
+
+from ._base import split_data_list
+
+
+class SplitBibAccordingToMark(object):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def split_marks(self, data_list: List[str]) -> List[str]:
+        return split_data_list(r"(@[a-zA-Z]+{)", data_list, "next")
+
+
+class ObtainMarkBlocksDict(object):
+    def __init__(self) -> None:
+        pass
+
+    def obtain_dict(
+        self, data_list: List[str], is_lower_mark: bool = True
+    ) -> Tuple[Dict[str, List[List[str]]], List[List[str]]]:
+        r"""Generate blocks.
+
+        Args:
+            data_list (List[str]): data list.
+
+        Returns:
+            Tuple[Dict[str, List[List[str]]], List[str]]: dict and implicit comments.
+        """
+        regex_mark = re.compile(r"@([a-zA-Z]+){")
+        line_index, len_data, implicit_comment_list = 0, len(data_list), []
+        mark_patch_bib_list_dict: Dict[str, List[List[str]]] = {}
+        while line_index < len_data:
+            line = data_list[line_index]
+            line_index += 1
+            if mch := regex_mark.match(line):
+                mark = mch.group(1)
+                temp = [line]
+                while line_index < len_data:
+                    line = data_list[line_index]
+                    if regex_mark.match(line):
+                        break
+                    temp.append(line)
+                    line_index += 1
+                if is_lower_mark:
+                    mark = mark.lower()
+                mark_patch_bib_list_dict.setdefault(mark, []).append(temp)
+            else:
+                implicit_comment_list.append([line, __class__.__name__])
+        return mark_patch_bib_list_dict, implicit_comment_list
+
+
+if __name__ == "__main__":
+    pass

pyeasyphd/bib/bibtexbase/standardize/do_on_comment_block.py

@@ -0,0 +1,38 @@
+import re
+from typing import List, Tuple
+
+
+class StandardizeCommentBlock(object):
+    """Stanndardize comment block."""
+
+    def __init__(self) -> None:
+        pass
+
+    def standardize(self, block: List[str]) -> Tuple[List[str], List[List[str]]]:
+        implicit_comments = []
+
+        regex_comment = re.compile(r"@comment{" + r"(.*)", re.DOTALL)
+        if mch := regex_comment.match("".join(block)):
+            a = mch.group(1).strip()
+            if (ll := (a.count("{") + 1)) > (lr := a.count("}")):
+                a += "}" * (ll - lr)
+            elif ll < lr:
+                a = "{" * (lr - ll) + a
+
+            if sub_mch := re.match(r"(.*)" + "}" + r"(.*)(\n*)", a):
+                block = []
+
+                sub_a, sub_b, sub_c = sub_mch.groups()
+                if sub_a.strip():
+                    block = ["@comment{" + sub_a.replace("\n", " ").strip() + "}\n"]
+
+                if sub_b.strip():
+                    implicit_comments = [[sub_b + sub_c, __class__.__name__]]
+
+            else:
+                block = []
+                implicit_comments = [["".join(block), __class__.__name__]]
+        else:
+            block = []
+            implicit_comments = [["".join(block), __class__.__name__]]
+        return block, implicit_comments

pyeasyphd/bib/bibtexbase/standardize/do_on_entry_block.py

@@ -0,0 +1,310 @@
+import re
+from typing import Dict, List, Tuple
+
+from ._base import split_data_list
+from .default_data import DEFAULT_FIELDS_LIST, FIELD_FORMAT_FLAG
+
+
+class StandardizeEntryBlock(object):
+    """Stanndardize entry block.
+
+    Args:
+        default_additional_field_list (List[str] = []): Additional default fields.
+
+    Attributes:
+        default_fields_list (List[str]): Default fields.
+    """
+
+    def __init__(self, default_additional_field_list: List[str] = []) -> None:
+        default_fields_old = [d.lower().strip() for d in DEFAULT_FIELDS_LIST]
+        default_fields_new = [d.lower().strip() for d in default_additional_field_list]
+        self.default_fields_list = list(set(default_fields_old).union(set(default_fields_new)))
+
+    def standardize(self, block: List[str]) -> Tuple[List[str], List[List[str]]]:
+        # obtain braces or quotes
+        implicit_comments = []
+        pre, post = EntryBase().obtain_braces_or_quotes(block)
+        if (len(pre) == 0) or (len(post) == 0):
+            message = f"Obtain braces or quotes: No standard `pre - {pre}` and `post - {post}`"
+            implicit_comments.append(["".join(block), message])
+            return [], implicit_comments
+
+        # Obtain fields
+        # Support for abbreviations
+        field_list = EntryBase().obtain_fields(block, self.default_fields_list)
+        if len(field_list) == 0:
+            message = "`Obtain fields`: No fields found"
+            implicit_comments.append(["".join(block), message])
+            return [], implicit_comments
+
+        # Split according to the field pattern
+        # Not support abbreviations: ['year = {2019}, journal = ECJ,']
+        # TODO Support abbreviations
+        pattern = r"\b((?:{})\s*=\s*(?:{}))".format("|".join(field_list), "|".join([rf"{pre}"]))  # compulsory
+        block = SplitEntry().split_fields(pattern, block)
+
+        # Append according to the field pattern
+        # Support abbreviations
+        block = AppendEntry().append_field(field_list, (pre, post), block)
+
+        # Extract
+        # Support abbreviations
+        block, redundant_list = ExtractEntry().extract(field_list, (pre, post), block)
+        if len(redundant_list) != 0:
+            message = "`Extract`: Redundant content"
+            implicit_comments.append(["".join(redundant_list), message])
+
+        # Check
+        # Support abbreviations
+        error_dict, block, is_standard_bib_flag = CheckEntry().check(field_list, (pre, post), block)
+        if len(error_dict) != 0:
+            for key in error_dict:
+                implicit_comments.append(["".join(error_dict[key]), f"`Check`: {key}"])
+
+        if not is_standard_bib_flag:
+            implicit_comments.append(["".join(block), "`Check`: Not standard bib"])
+            return [], implicit_comments
+
+        return block, implicit_comments
+
+
+class EntryBase(object):
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def obtain_braces_or_quotes(block: List[str]) -> Tuple[str, str]:
+        """Obtain braces or quotes in block.
+
+        Args:
+            block (List[str]): block.
+
+        Returns:
+            Tuple[str, str]: the tuple of braces or quotes.
+        """
+        content = "".join(block)
+        regex_list = [
+            re.compile(r'\btitles*\s*=\s*([{"])', flags=re.I),
+            re.compile(r'\bauthors*\s*=\s*([{"])', flags=re.I),
+            re.compile(r'\byears*\s*=\s*([{"])', flags=re.I),
+            re.compile(r'\bpages*\s*=\s*([{"])', flags=re.I),
+            re.compile(r'\burls*\s*=\s*([{"])', flags=re.I),
+        ]
+        flag_list_list = [sorted(list(set(regex.findall(content)))) for regex in regex_list]
+
+        flag_list_list = [f for f in flag_list_list if len(f) != 0]
+        len_list = [len(f) for f in flag_list_list]
+
+        # 0 or 1 or 2 flags
+        if (len(len_list) == 0) or (2 in len_list) or (not all([f == flag_list_list[0] for f in flag_list_list])):
+            return "", ""
+
+        if flag_list_list[0][0] == "{":
+            return "{", "}"
+        else:
+            return '"', '"'
+
+    def obtain_fields(
+        self,
+        block: List[str],
+        default_fields_list: List[str],
+        field_pattern: str = r'[\w\-]+'
+    ) -> List[str]:
+        r"""Obtain fileds in block.
+
+        Args:
+            block (List[str]): block.
+            field_pattern (str = r'[\w\-]+'): field pattern.
+
+        Returns:
+            List[str]: field list.
+        """
+        regex = re.compile(rf'({field_pattern})\s*=\s*(?:{"|".join(FIELD_FORMAT_FLAG)})')  # support for abbreviation
+        obtain_field_list = list(set(regex.findall("".join(block))))
+        obtain_field_list = [field for field in obtain_field_list if field.lower() in default_fields_list]
+        return sorted(obtain_field_list)
+
+
+class SplitEntry(object):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def split_fields(self, field_pattern: str, block: List[str], last_next: str = "next") -> List[str]:
+        return split_data_list(field_pattern, block, last_next)
+
+
+class AppendEntry(object):
+    """Append Patch Bib."""
+
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def append_field(field_list: List[str], braces_or_quotes: Tuple[str, str], block: List[str]) -> List[str]:
+        """Append.
+
+        Args:
+            field_list (List[str]): Append field list.
+            braces_or_quotes (Tuple[str, str]): Brace or quote.
+            data_list (List[str]): Data list.
+
+        Returns:
+            List[str]: new patch bib after appending.
+        """
+        pre, _ = braces_or_quotes
+
+        temp = rf'[%\s]*(?:{"|".join(field_list)})'
+        regex_field = re.compile(rf"{temp}\s*=\s*{pre}", flags=re.I)
+        regex_field_abbr = re.compile(rf"{temp}\s*=\s*\w+[\w\-]*", flags=re.I)  # journal = EJC,
+        regex_termination = re.compile(r"\s*@[a-zA-Z]*{", flags=re.I)
+
+        # strip and append
+        line_index, len_data, new_block = 0, len(block), []
+        while line_index < len_data:
+            line = block[line_index]
+            line_index += 1
+            if regex_field.match(line) or regex_termination.match(line) or regex_field_abbr.match(line):
+                new_line = line
+                while line_index < len_data:
+                    line = block[line_index]
+                    if regex_field.match(line) or regex_termination.match(line) or regex_field_abbr.match(line):
+                        break
+                    else:
+                        if line.lstrip():
+                            new_line = new_line.rstrip() + " " + line.lstrip()  # append
+                        line_index += 1
+                new_block.append(new_line)
+            else:
+                new_block.append(line)
+        return new_block
+
+
+class ExtractEntry(object):
+    def __init__(self) -> None:
+        pass
+
+    def extract(
+        self, field_list: List[str], brace_or_quote: Tuple[str, str], block: List[str]
+    ) -> Tuple[List[str], List[str]]:
+        """Extract.
+
+        Args:
+            field_list (List[str]): field list
+            brace_or_quote (Tuple[str, str]): (", ") or ({, })
+            block (List[str]): the block
+
+        Return:
+            Tuple[List[str], List[str]]: main block, redundant part
+        """
+        pre, post = brace_or_quote
+
+        temp = rf'[%\s]*(?:{"|".join(field_list)})'
+        regex_field_two = re.compile(rf"({temp}\s*=\s*{pre})(.*)(\n*)", flags=re.I)
+        regex_field_one = re.compile(rf"({temp}\s*=\s*{pre}.*{post})(.*)(\n*)", flags=re.I)
+        regex_field_abbr = re.compile(rf"({temp}\s*=\s*\w+[\w\-]*)(.*)(\n*)", flags=re.I)
+        regex_termination = re.compile(r"(\s*@[a-zA-Z]*{\s*[\w\-:/\\.\']*)(.*)(\n*)", flags=re.I)
+
+        main_list, redundant_list = [], []
+
+        for line in block:
+            new_line, redundant = "", ""
+            if mch := regex_termination.match(line):
+                one, two, three = mch.groups()
+                new_line = one + ",\n"
+                if re.sub(r"[\s,\n\}]+", "", two):
+                    redundant = two + three
+
+            elif mch := regex_field_abbr.match(line):
+                one, two, three = mch.groups()
+                new_line = one + ",\n"
+                if re.sub(r"[\s,\n\}]+", "", two):
+                    redundant = two + three
+
+            elif mch := regex_field_one.match(line):
+                one, two, three = mch.groups()
+                new_line = self._resub_brace_or_quote(pre, post, one + ",\n")
+                if re.sub(r"[\s,\n\}]+", "", two):
+                    redundant = two + three
+
+            elif mch := regex_field_two.match(line):
+                one, two, three = mch.groups()
+                new_line = self._resub_brace_or_quote(pre, post, one + two.strip() + post + ",\n")
+
+            elif line.strip() == "}":
+                pass
+
+            else:
+                return [], block
+
+            if new_line:
+                main_list.append(new_line)
+            if redundant:
+                redundant_list.append(redundant)
+
+        # for enclosing "@[a-zA-Z]{"
+        if main_list:
+            main_list.append("}\n")
+        return main_list, redundant_list
+
+    def _resub_brace_or_quote(self, pre, post, line: str) -> str:
+        if post == "}":
+            if line.count(post) > line.count(pre):
+                line = re.sub(r'(}[}\s\n,]*)$', '},\n', line)
+                line = add_brace_or_quote(pre, post, line)
+
+        elif post == '"':
+            if line.count(post) > line.count(pre):
+                line = re.sub(r'("["\s\n,]*)$', '",\n', line)
+                line = add_brace_or_quote(pre, post, line)
+        return line
+
+
+def add_brace_or_quote(pre, post, line: str):
+    if (cpre := line.count(pre)) != (cpost := line.count(post)):
+        line_list = list(line)
+        if cpre > cpost:
+            line_list = line_list[::-1]
+            line_list.insert(line_list.index(post), post * (cpre - cpost))
+            line_list = line_list[::-1]
+        else:
+            line_list.insert(line.index(pre), pre * (cpost - cpre))
+
+        line = "".join(line_list)
+    return line
+
+
+class CheckEntry(object):
+    @staticmethod
+    def check(
+        field_list: List[str], brace_or_quote: Tuple[str, str], block: List[str]
+    ) -> Tuple[Dict[str, List[str]], List[str], bool]:
+        """Check."""
+        pre, post = brace_or_quote
+
+        regex_entry = re.compile(r"\s*@[a-zA-Z]+{")
+        regex_field = re.compile(fr'\s*(?:{"|".join(field_list)})' + r"\s*=")
+        entry_flag, brace_flag = False, False  # minimal conditions
+        error_dict: Dict[str, List[str]] = {}
+        new_block = []
+        for line in block:
+            if regex_entry.match(line) and (not entry_flag):  # just iff exsiting one time in single patch bib
+                if (line.count("{") != 1) or (line.count(",") != 1):
+                    error_dict.setdefault("Failed entry_type", []).append(line)
+                else:
+                    entry_flag = True
+                    new_block.append(line)
+
+            elif regex_field.match(line):
+                new_block.append(add_brace_or_quote(pre, post, line))
+
+            elif (line.strip() == "}") and (not brace_flag):  # just iff exsiting one time in single patch bib
+                brace_flag = True
+                new_block.append(line)
+
+            else:
+                error_dict.setdefault("Redundant content`", []).append(line)
+        return error_dict, new_block, entry_flag and brace_flag
+
+
+if __name__ == "__main__":
+    pass

pyeasyphd/bib/bibtexbase/standardize/do_on_preamble_block.py

@@ -0,0 +1,35 @@
+import re
+from typing import List, Tuple
+
+
+class StandardizePreambleBlock(object):
+    """Stanndardize preamble block."""
+
+    def __init__(self) -> None:
+        pass
+
+    def standardize(self, block: List[str]) -> Tuple[List[str], List[List[str]]]:
+        # @preamble{ "\providecommand{\noopsort}[1]{} " }
+        implicit_comments = []
+        regex_preamble = re.compile(
+            r"@preamble{" + r'\s*(")' + r"([\w\-\\\[\]\{\}\s]+)" + r'(")\s*' + r"(.*)(\n*)", re.DOTALL
+        )
+        mch = regex_preamble.match("".join(block))
+        if mch:
+            a, b, c, d, e = mch.groups()
+            if (a == '"') and (c == '"'):
+                block = ["@preamble{ " + a + b.replace("\n", " ").strip() + c + " }\n"]
+
+                if d and d.lstrip()[0] == "}":
+                    d = d.lstrip()[1:].lstrip()
+
+                if d.strip():
+                    implicit_comments = [[d + e, __class__.__name__]]
+
+            else:
+                block = []
+                implicit_comments = [["".join(block), __class__.__name__]]
+        else:
+            block = []
+            implicit_comments = [["".join(block), __class__.__name__]]
+        return block, implicit_comments

pyeasyphd/bib/bibtexbase/standardize/do_on_string_block.py

@@ -0,0 +1,34 @@
+import re
+from typing import List, Tuple
+
+
+class StandardizeStringBlock(object):
+    """Stanndardize string block."""
+
+    def __init__(self) -> None:
+        pass
+
+    def standardize(self, block: List[str]) -> Tuple[List[str], List[List[str]]]:
+        implicit_comments = []
+
+        regex = re.compile(
+            r"@string{" + r"\s*([\w]+)\s*=\s*" + r'(["{])' + r"([\w\-\n]+)" + r'(["}])' + r'(.*)(\n*)', re.DOTALL
+        )
+        if mch := regex.match("".join(block)):
+            a, b, c, d, e, f = mch.groups()
+            if ((b == '"') and (d == '"')) or ((b == '{') and (d == '}')):
+                block = ["@string{" + a + " = " + b + c.replace("\n", " ").strip() + d + "}\n"]
+
+                if e and e.lstrip()[0] == "}":
+                    e = e.lstrip()[1:].lstrip()
+
+                if e.strip():
+                    implicit_comments = [[e + f, __class__.__name__]]
+
+            else:
+                block = []
+                implicit_comments = [["".join(block), __class__.__name__]]
+        else:
+            block = []
+            implicit_comments = [["".join(block), __class__.__name__]]
+        return block, implicit_comments