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

pyeasyphd/bib/bibtexbase/standardize/do_on_comment_block.py

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

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

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

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

pyeasyphd/bib/bibtexbase/standardize_bib.py

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

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

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