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

pyeasyphd/bib/bibtexparser/middlewares_str_to_library.py

@@ -1,35 +0,0 @@
-from typing import Any, Dict
-
-from .library import Library
-from .model import ImplicitComment
-
-
-class MiddlewaresStrToLibrary(object):
-    """Middlewares for converting a string to a library.
-
-    Args:
-        options (dict): Options for the middlewares.
-
-    Attributes:
-        is_display_implicit_comments (bool): Display implicit comments. Default is True.
-    """
-
-    def __init__(self, options: Dict[str, Any]):
-        self.is_display_implicit_comments = options.get("is_display_implicit_comments", True)
-
-    def functions(self, library: Library) -> Library:
-        # Display implicit comments
-        if self.is_display_implicit_comments:
-            other_blocks, implicit_comment_blocks = [], []
-            for block in library.blocks:
-                if isinstance(block, ImplicitComment):
-                    implicit_comment_blocks.append(block)
-                else:
-                    other_blocks.append(block)
-
-            library = Library(other_blocks)
-
-            if implicit_comment_blocks:
-                print(implicit_comment_blocks)
-
-        return library

pyeasyphd/bib/bibtexparser/middlewares_str_to_str.py

@@ -1,29 +0,0 @@
-import re
-from typing import Any, Dict, List
-
-
-class MiddlewaresStrToStr(object):
-    r"""Middlewares for converting a string to a string.
-
-    Args:
-        options (dict): Options for the middlewares.
-
-    Attributes:
-        substitute_in_bib (bool): Substitute in the bib. Default is True.
-        substitute_old_list (list): List of old strings to substitute. Default is [].
-        substitute_new_list (list): List of new strings to substitute. Default is [].
-    """
-
-    def __init__(self, options: Dict[str, Any]):
-        self.substitute_in_bib = options.get("substitute_in_bib", True)
-        self.substitute_old_list = options.get("substitute_old_list", [])
-        self.substitute_new_list = options.get("substitute_new_list", [])
-
-    def functions(self, data_list: List[str]) -> List[str]:
-        # Substitute
-        if self.substitute_in_bib:
-            for i in range(len(data_list)):
-                for old, new in zip(self.substitute_old_list, self.substitute_new_list):
-                    data_list[i] = re.sub(old, new, data_list[i])
-
-        return data_list

pyeasyphd/bib/bibtexparser/model.py

@@ -1,481 +0,0 @@
-import abc
-from typing import Any, Dict, List, Optional, Set
-
-
-class Block(abc.ABC):
-    """A abstract superclass of all top-level building blocks of a bibtex file.
-
-    E.g. a ``@string`` block, a ``@preamble`` block, an ``@entry`` block, a comment, etc.
-    """
-
-    def __init__(
-        self,
-        start_line: Optional[int] = None,
-        raw: Optional[str] = None,
-        parser_metadata: Optional[Dict[str, Any]] = None,
-    ):
-        self._start_line = start_line
-        self._raw = raw
-        self._parser_metadata: Dict[str, Any] = {}
-        if parser_metadata is not None:
-            self._parser_metadata: Dict[str, Any] = parser_metadata
-
-    @property
-    def start_line(self) -> Optional[int]:
-        """The line number of the first line of this block in the parsed string."""
-        return self._start_line
-
-    @property
-    def raw(self) -> Optional[str]:
-        """The raw, unmodified string (bibtex) representation of this block.
-
-        Note: Middleware does not update this field, hence, after applying middleware
-        to a library, this field may be outdated.
-        """
-        return self._raw
-
-    @property
-    def parser_metadata(self) -> Dict[str, Any]:
-        """EXPERIMENTAL: field for middleware to store auxiliary information.
-
-        As an end-user, as long as you are not writing middleware, you probably
-        do not need to use this field.
-
-        ** Warning (experimental) **
-        The content of this field is undefined and may change at any time.
-
-        This field is intended for middleware to store auxiliary information.
-        It is a key-value store, where the key is a string and the value is any
-        python object.
-        This allows for example to pass information between different middleware.
-        """
-        return self._parser_metadata
-
-    def get_parser_metadata(self, key: str) -> Optional[Any]:
-        """EXPERIMENTAL: get auxiliary information stored in ``parser_metadata``.
-
-        See attribute ``parser_metadata`` for more information.
-        """
-        return self._parser_metadata.get(key, None)
-
-    def set_parser_metadata(self, key: str, value: Any):
-        """EXPERIMENTAL: set auxiliary information stored in ``parser_metadata``.
-
-        See attribute ``parser_metadata`` for more information.
-        """
-        self._parser_metadata[key] = value
-
-    def __eq__(self, other):
-        # make sure they have the same type and same content
-        return (
-            isinstance(other, self.__class__)
-            and isinstance(self, other.__class__)
-            and self.__dict__ == other.__dict__
-        )
-
-
-class String(Block):
-    """Bibtex Blocks of the ``@string`` type, e.g. ``@string{me = "My Name"}``."""
-
-    def __init__(
-        self,
-        key: str,
-        value: str,
-        start_line: Optional[int] = None,
-        raw: Optional[str] = None,
-    ):
-        super().__init__(start_line, raw)
-        self._key = key
-        self._value = value
-
-    @property
-    def key(self) -> str:
-        """The key of the string, e.g. ``me`` in ``@string{me = "My Name"}``."""
-        return self._key
-
-    @key.setter
-    def key(self, value: str) -> None:
-        self._key = value
-
-    @property
-    def value(self) -> str:
-        """The value of the string, e.g. ``"My Name"`` in ``@string{me = "My Name"}``."""
-        return self._value
-
-    @value.setter
-    def value(self, value: str) -> None:
-        self._value = value
-
-    def __str__(self) -> str:
-        return f"String (line: {self.start_line}, key: `{self.key}`): `{self.value}`"
-
-    def __repr__(self) -> str:
-        return (
-            f"String(key=`{self.key}`, value=`{self.value}`, "
-            f"start_line={self.start_line}, raw=`{self.raw}`)"
-        )
-
-
-class Preamble(Block):
-    """Bibtex Blocks of the ``@preamble`` type, e.g. ``@preamble{This is a preamble}``."""
-
-    def __init__(self, value: str, start_line: Optional[int] = None, raw: Optional[str] = None):
-        super().__init__(start_line, raw)
-        self._value = value
-
-    @property
-    def value(self) -> str:
-        """The value of the preamble, e.g. ``blabla`` in ``@preamble{blabla}``."""
-        return self._value
-
-    @value.setter
-    def value(self, value: str) -> None:
-        self._value = value
-
-    def __str__(self) -> str:
-        return f"Preamble (line: {self.start_line}): `{self.value}`"
-
-    def __repr__(self) -> str:
-        return f"Preamble(value=`{self.value}`, " f"start_line={self.start_line}, raw=`{self.raw}`)"
-
-
-class ExplicitComment(Block):
-    """Bibtex Blocks of the ``@comment`` type, e.g. ``@comment{This is a comment}``."""
-
-    def __init__(self, comment: str, start_line: Optional[int] = None, raw: Optional[str] = None):
-        super().__init__(start_line, raw)
-        self._comment = comment
-
-    @property
-    def comment(self) -> str:
-        """The value of the comment, e.g. ``blabla`` in ``@comment{blabla}``."""
-        return self._comment
-
-    @comment.setter
-    def comment(self, value: str) -> None:
-        self._comment = value
-
-    def __str__(self) -> str:
-        return f"ExplicitComment (line: {self.start_line}): `{self.comment}`"
-
-    def __repr__(self) -> str:
-        return (
-            f"ExplicitComment(comment=`{self.comment}`, "
-            f"start_line={self.start_line}, raw=`{self.raw}`)"
-        )
-
-
-class ImplicitComment(Block):
-    """Bibtex outside of an ``@{...}`` block, which is treated as a comment."""
-
-    def __init__(self, comment: str, start_line: Optional[int] = None, raw: Optional[str] = None):
-        super().__init__(start_line, raw)
-        self._comment = comment
-
-    @property
-    def comment(self) -> str:
-        """The (possibly multi-line) comment."""
-        return self._comment
-
-    @comment.setter
-    def comment(self, value: str) -> None:
-        self._comment = value
-
-    def __str__(self) -> str:
-        return f"ImplicitComment (line: {self.start_line}): `{self.comment}`"
-
-    def __repr__(self) -> str:
-        return (
-            f"ImplicitComment(comment=`{self.comment}`, "
-            f"start_line={self.start_line}, raw=`{self.raw}`)"
-        )
-
-
-class Field(object):
-    """A field of a Bibtex entry, e.g. ``author = {John Doe}``."""
-
-    def __init__(self, key: str, value: Any, start_line: Optional[int] = None):
-        self._start_line = start_line
-        self._key = key
-        self._value = value
-
-    @property
-    def key(self) -> str:
-        """The key of the field, e.g. ``author`` in ``author = {John Doe}``."""
-        return self._key
-
-    @key.setter
-    def key(self, value: str) -> None:
-        self._key = value
-
-    @property
-    def value(self) -> Any:
-        """The value of the field, e.g. ``{John Doe}`` in ``author = {John Doe}``."""
-        return self._value
-
-    @value.setter
-    def value(self, value: Any) -> None:
-        self._value = value
-
-    @property
-    def start_line(self) -> Optional[int]:
-        """The line number of the first line of this field in the originally parsed string."""
-        return self._start_line
-
-    def __eq__(self, other):
-        # make sure they have the same type and same content
-        return (
-            isinstance(other, self.__class__)
-            and isinstance(self, other.__class__)
-            and self.__dict__ == other.__dict__
-        )
-
-    def __str__(self) -> str:
-        return f"Field (line: {self.start_line}, key: `{self.key}`): `{self.value}`"
-
-    def __repr__(self) -> str:
-        return f"Field(key=`{self.key}`, value=`{self.value}`, " f"start_line={self.start_line})"
-
-
-class Entry(Block):
-    """Bibtex Blocks of the ``@entry`` type, e.g. ``@article{Cesar2013, ...}``."""
-
-    def __init__(
-        self,
-        entry_type: str,
-        key: str,
-        fields: List[Field],
-        start_line: Optional[int] = None,
-        raw: Optional[str] = None,
-    ):
-        super().__init__(start_line, raw)
-        self._entry_type = entry_type
-        self._key = key
-        self._fields = fields
-
-    @property
-    def entry_type(self) -> str:
-        """The type of the entry, e.g. ``article`` in ``@article{Cesar2013, ...}``."""
-        return self._entry_type
-
-    @entry_type.setter
-    def entry_type(self, value: str) -> None:
-        self._entry_type = value
-
-    @property
-    def key(self) -> str:
-        """The key of the entry, e.g. ``Cesar2013`` in ``@article{Cesar2013, ...}``."""
-        return self._key
-
-    @key.setter
-    def key(self, value: str) -> None:
-        self._key = value
-
-    @property
-    def fields(self) -> List[Field]:
-        """The key-value attributes of an entry, as ``Field`` instances."""
-        return self._fields
-
-    @fields.setter
-    def fields(self, value: List[Field]) -> None:
-        self._fields = value
-
-    @property
-    def fields_dict(self) -> Dict[str, Field]:
-        """A dict of fields, with field keys as keys.
-
-        Note that with duplicate field keys, the behavior is undefined.
-        """
-        return {field.key: field for field in self._fields}
-
-    def set_field(self, field: Field):
-        """Add a new field, or replaces existing with same key."""
-        if field.key in self.fields_dict:
-            i = [f.key for f in self._fields].index(field.key)
-            self._fields[i] = field
-        else:
-            self._fields.append(field)
-
-    def pop(self, key: str, default=None) -> Optional[Field]:
-        """Remove and return the field with the given key.
-
-        :param key: The key of the field to remove.
-        :param default: The value to return if the field does not exist.
-        """
-        try:
-            field = self.fields_dict.pop(key)
-        except KeyError:
-            return default
-
-        self._fields = [f for f in self._fields if f.key != key]
-        return field
-
-    def get(self, key: str, default=None) -> Optional[Field]:
-        """Return the field with the given key, or the default value if it does not exist.
-
-        :param key: The key of the field.
-        :param default: The value to return if the field does not exist.
-        """
-        return self.fields_dict.get(key, default)
-
-    def __contains__(self, key: str) -> bool:
-        """Dict-mimicking ``in`` operator."""
-        return key in self.fields_dict
-
-    def __getitem__(self, key: str) -> Any:
-        """Dict-mimicking index.
-
-        This serves for partial v1.x backwards compatibility,
-        as well as for a shorthand for accessing field values.
-
-        Note that with duplicate field keys, the behavior is undefined.
-        """
-        if key == "ENTRYTYPE":
-            return self.entry_type
-        if key == "ID":
-            return self.key
-        return self.fields_dict[key].value
-
-    def __setitem__(self, key: str, value: Any):
-        """Dict-mimicking index.
-
-        This serves for partial v1.x backwards compatibility,
-        as well as for a shorthand for `set_field`.
-        """
-        self.set_field(Field(key, value))
-
-    def __delitem__(self, key):
-        """Dict-mimicking index.
-
-        This serves for partial v1.x backwards compatibility,
-        as well as for a shorthand for `pop`.
-        """
-        self.pop(key)
-
-    def items(self):
-        """Dict-mimicking, for partial v1.x backwards compatibility.
-
-        For newly written code, it's recommended to use `entry.entry_type`,
-        `entry.key` and `entry.fields` instead.
-        """
-        return [
-            ("ENTRYTYPE", self.entry_type),
-            ("ID", self.key),
-        ] + [(f.key, f.value) for f in self.fields]
-
-    def __str__(self) -> str:
-        lines = [f"Entry (line: {self.start_line}, type: `{self.entry_type}`, key: `{self.key}`):"]
-        lines.extend([f"\t`{f.key}` = `{f.value}`" for f in self.fields])
-        return "\n".join(lines)
-
-    def __repr__(self) -> str:
-        return (
-            f"Entry(entry_type=`{self.entry_type}`, key=`{self.key}`, "
-            f"fields=`{self.fields.__repr__()}`, start_line={self.start_line})"
-        )
-
-
-class ParsingFailedBlock(Block):
-    """A block that could not be parsed due to some raised exception."""
-
-    def __init__(
-        self,
-        error: Exception,
-        start_line: Optional[int] = None,
-        raw: Optional[str] = None,
-        ignore_error_block: Optional[Block] = None,
-    ):
-        super().__init__(start_line, raw)
-        self._error = error
-        self._ignore_error_block = ignore_error_block
-
-    @property
-    def error(self) -> Exception:
-        """The exception that was raised during parsing."""
-        return self._error
-
-    @property
-    def ignore_error_block(self) -> Optional[Block]:
-        """The possibly faulty block when ignoring the error.
-
-        This may be None, as it may not always be possible to ignore the error.
-        For errors caused by middleware, this is typically the block without
-        the middleware applied.
-        """
-        return self._ignore_error_block
-
-
-class MiddlewareErrorBlock(ParsingFailedBlock):
-    """A block that could not be parsed due to a middleware error.
-
-    To get the block that caused this error, call `block.ignore_error_block`
-    (which is the block with the middleware not or only partially applied).
-    """
-
-    def __init__(self, block: Block, error: Exception):
-        super().__init__(
-            start_line=block.start_line,
-            raw=block.raw,
-            error=error,
-            ignore_error_block=block,
-        )
-
-
-class DuplicateBlockKeyBlock(ParsingFailedBlock):
-    """An error-indicating block created for blocks with keys present in the library already.
-
-    To get the block that caused this error, call `block.ignore_error_block`.
-    """
-
-    def __init__(
-        self,
-        key: str,
-        previous_block: Block,
-        duplicate_block: Block,
-        start_line: Optional[int] = None,
-        raw: Optional[str] = None,
-    ):
-        super().__init__(
-            error=Exception(f"Duplicate entry key '{key}'"),
-            start_line=start_line,
-            raw=raw,
-            ignore_error_block=duplicate_block,
-        )
-        self._key = key
-        self._previous_block = previous_block
-
-    @property
-    def key(self) -> str:
-        """The key of the entry, e.g. ``Cesar2013`` in ``@article{Cesar2013, ...}``."""
-        return self._key
-
-    @key.setter
-    def key(self, value: str) -> None:
-        self._key = value
-
-    @property
-    def previous_block(self) -> Block:
-        """A reference to a previous block with the same key."""
-        return self._previous_block
-
-
-class DuplicateFieldKeyBlock(ParsingFailedBlock):
-    """An error-indicating block indicating a duplicate field key in an entry."""
-
-    def __init__(self, duplicate_keys: Set[str], entry: Entry):
-        sorted_duplicate_keys = sorted(list(duplicate_keys))
-        super().__init__(
-            error=Exception(
-                f"Duplicate field keys on entry: '{', '.join(sorted_duplicate_keys)}'."
-                f"Note: The entry (containing duplicate) is available as `failed_block.entry`"
-            ),
-            start_line=entry.start_line,
-            raw=entry.raw,
-            ignore_error_block=entry,
-        )
-        self._duplicate_keys: Set[str] = duplicate_keys
-
-    @property
-    def duplicate_keys(self) -> Set[str]:
-        """The field-keys that occurred more than once in the entry."""
-        return self._duplicate_keys

pyeasyphd/bib/bibtexparser/splitter.py

@@ -1,151 +0,0 @@
-import re
-from typing import List, Tuple, Union
-
-from .library import Library
-from .model import Block, Entry, ExplicitComment, Field, ImplicitComment, Preamble, String
-
-
-class Splitter(object):
-    """Splitter class to split standardizing bib data list to library.
-
-    Attributes:
-        regex_block_type: Regular expression to match block type.
-    """
-
-    def __init__(self):
-        self.regex_block_type = re.compile(r"@([a-zA-Z]+){")
-
-    def splitter(self, data_list: List[str], implicit_coments: List[List[str]]):
-        """Split standardizing bib data list to library."""
-        _blocks = []
-
-        _blocks.extend([ImplicitComment(i[0]) for i in implicit_coments if i])
-
-        implicit_comment_blocks = []
-        explicit_comment_blocks = []
-        string_blocks = []
-        preamble_blocks = []
-        entry_blocks = []
-
-        # Initialize
-        data_list = "".join(data_list).splitlines(keepends=True)
-        data_list = [line for line in data_list if line.strip()]
-
-        line_index, len_data = 0, len(data_list)
-        while line_index < len_data:
-            line = data_list[line_index]
-            line_index += 1
-
-            if not (mch_block := self.regex_block_type.search(line)):
-                implicit_comment_blocks.append(ImplicitComment(line, line_index))
-                continue
-
-            block_type = mch_block.group(1)
-            if block_type == "comment":
-                block, line_index = self._splitter_comment(block_type, line, line_index, len_data, data_list)
-                if isinstance(block, Block):
-                    explicit_comment_blocks.append(block)
-                elif isinstance(block, str):
-                    implicit_comment_blocks.append(ImplicitComment(block, line_index - 1))
-
-            elif block_type == "string":
-                block, line_index = self._splitter_string(block_type, line, line_index, len_data, data_list)
-                if isinstance(block, Block):
-                    string_blocks.append(block)
-                elif isinstance(block, str):
-                    implicit_comment_blocks.append(ImplicitComment(block, line_index - 1))
-
-            elif block_type == "preamble":
-                block, line_index = self._splitter_preamble(block_type, line, line_index, len_data, data_list)
-                if isinstance(block, Block):
-                    preamble_blocks.append(block)
-                elif isinstance(block, str):
-                    implicit_comment_blocks.append(ImplicitComment(block, line_index - 1))
-
-            else:
-                block, line_index, temp = self._splitter_entry(block_type, line, line_index, len_data, data_list)
-                entry_blocks.append(block)
-                implicit_comment_blocks.extend(temp)
-
-        _blocks.extend(implicit_comment_blocks)
-        _blocks.extend(explicit_comment_blocks)
-        _blocks.extend(string_blocks)
-        _blocks.extend(preamble_blocks)
-        _blocks.extend(entry_blocks)
-        return Library(_blocks)
-
-    def _splitter_entry(self, block_type, line, line_idx, len_data, data_list) -> Tuple[Union[Block, str], int, list]:
-        regex = re.compile(r"@([a-zA-Z]+){(.*),")
-        if not (mch_entry := regex.search(line)):
-            block = Entry(block_type, "", [], line_idx)
-        else:
-            block = Entry(mch_entry.group(1), mch_entry.group(2).strip(), [], line_idx)
-
-        regex_field_type = re.compile(r"[%\s]*([\w\-]+)" + r'\s*=\s*["{](.*)["}],\n', flags=re.I)
-        regex_field_type_abbr = re.compile(r"[%\s]*([\w\-]+)" + r"\s*=\s*([\w\-]+),\n", flags=re.I)
-        implicit_comment_blocks = []
-        while line_idx < len_data:
-            new_line = data_list[line_idx]
-            if self.regex_block_type.match(new_line):
-                break
-
-            if mch := regex_field_type.match(new_line):
-                block.set_field(Field(mch.group(1), mch.group(2), start_line=None))
-            elif mch := regex_field_type_abbr.match(new_line):
-                block.set_field(Field(mch.group(1), mch.group(2), start_line=None))
-            elif (new_line.strip() == "}") or (new_line.strip() == ""):
-                pass
-            else:
-                implicit_comment_blocks.append(ImplicitComment(new_line, line_idx))
-            line_idx += 1
-
-        if not block.key:
-            block.key = self._generate_entry_key(block)
-        return block, line_idx, implicit_comment_blocks
-
-    @staticmethod
-    def _generate_entry_key(entry: Entry) -> str:
-        title = entry["title"] if "title" in entry else ""
-        year = entry["year"] if "year" in entry else ""
-        doi = entry["doi"] if "doi" in entry else ""
-        author = entry["author"] if "author" in entry else ""
-        keys = [entry.entry_type[:3]]
-        if year:
-            keys.append(year)
-        if doi:
-            keys.append(doi)
-        if author:
-            keys.append(author[:20])
-        if title:
-            keys.append(title[:70])
-
-        citation_key = re.sub(r"\W", "", "_".join(keys).lower())[:80]
-        while citation_key and citation_key[-1] == "_":
-            citation_key = citation_key[:-1]
-        return citation_key
-
-    def _splitter_comment(self, block_type, line, line_idx, len_data, data_list) -> Tuple[Union[Block, str], int]:
-        regex = re.compile(r"@comment{" + r"(.*)" + "}\n")
-        if not (mch := regex.search(line)):
-            return line, line_idx
-
-        block = ExplicitComment(mch.group(1), line_idx)
-        return block, line_idx
-
-    def _splitter_string(self, block_type, line, line_idx, len_data, data_list) -> Tuple[Union[Block, str], int]:
-        regex = re.compile(r"@string{" + r"\s*([\w]+)\s*=\s*" + r'(["{])' + r"([\w\-]+)" + r'(["}])' + "}\n")
-        if not (mch := regex.search(line)):
-            return line, line_idx
-
-        block = String(mch.group(1), mch.group(3), line_idx)
-        if not block.key:
-            block.key = re.sub(r"\W", "", block.value.lower())[:80]
-        return block, line_idx
-
-    def _splitter_preamble(self, block_type, line, line_idx, len_data, data_list) -> Tuple[Union[Block, str], int]:
-        regex = re.compile(r"@preamble{" + r'\s*(")' + r"([\w\-\\\[\]\{\}\s]+)" + r'(")\s*' + "}\n")
-        if not (mch := regex.search(line)):
-            return line, line_idx
-
-        block = Preamble(mch.group(2), line_idx)
-        return block, line_idx