bibtexparser 2.0.0b5__tar.gz → 2.0.0b7__tar.gz

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bibtexparser
-Version: 2.0.0b5
+Version: 2.0.0b7
 Summary: Bibtex parser for python 3
 Home-page: https://github.com/sciunto-org/python-bibtexparser
 Author: Michael Weiss and other contributors
@@ -120,7 +120,7 @@ Writes the content of a bibtex library to a `.bib` file. Optional formatting par
 
 ## About
 
-Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). 
+Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). In 2024, Tom de Geus ([@tdegeus](https://github.com/tdegeus)) joined as co-maintainer. 
 
 Credits and thanks to the many contributors who helped creating this library, including
 François Boulogne ([@sciunto](https://github.com/sciunto/), creator of the first version) and Olivier Mangin ([@omangin](https://github.com/omangin/), long-term contributor).

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/README.md

@@ -90,7 +90,7 @@ Writes the content of a bibtex library to a `.bib` file. Optional formatting par
 
 ## About
 
-Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). 
+Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). In 2024, Tom de Geus ([@tdegeus](https://github.com/tdegeus)) joined as co-maintainer. 
 
 Credits and thanks to the many contributors who helped creating this library, including
 François Boulogne ([@sciunto](https://github.com/sciunto/), creator of the first version) and Olivier Mangin ([@omangin](https://github.com/omangin/), long-term contributor).

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/__init__.py

@@ -5,4 +5,4 @@ from bibtexparser.entrypoint import parse_file, parse_string, write_file, write_
 from bibtexparser.library import Library
 from bibtexparser.writer import BibtexFormat
 
-__version__ = "2.0.0b5"
+__version__ = "2.0.0b7"

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/entrypoint.py

@@ -76,14 +76,19 @@ def parse_string(
 ):
     """Parse a BibTeX string.
 
-    Args:
-        bibtex_str (str): BibTeX string to parse
-        parse_stack (Optional[Iterable[Middleware]], optional): List of middleware to apply to the database after splitting. If None (default), a default stack will be used providing simple standard functionality will be used.
-        append_middleware (Optional[Iterable[Middleware]], optional): List of middleware to append to the default stack (ignored if a not-None parse_stack is passed).
-        library (Optional[Library], optional): Library to add entries to. If None (default), a new library will be created.
-
-    Returns:
-        Library: Parsed BibTeX database
+    :param bibtex_str: BibTeX string to parse
+    :param parse_stack:
+        List of middleware to apply to the database after splitting.
+        If ``None`` (default), a default stack will be used providing simple standard functionality.
+
+    :param append_middleware:
+        List of middleware to append to the default stack
+        (ignored if a not-``None`` parse_stack is passed).
+
+    :param library:
+        Library to add entries to. If ``None`` (default), a new library will be created.
+
+    :return: Library: Parsed BibTeX database
     """
     splitter = Splitter(bibstr=bibtex_str)
     library = splitter.split(library=library)
@@ -103,14 +108,17 @@ def parse_file(
 ) -> Library:
     """Parse a BibTeX file
 
-    Args:
-        path (str): Path to BibTeX file
-        parse_stack (Optional[Iterable[Middleware]], optional): List of middleware to apply to the database after splitting. If None (default), a default stack will be used providing simple standard functionality will be used.
-        append_middleware (Optional[Iterable[Middleware]], optional): List of middleware to append to the default stack (ignored if a not-None parse_stack is passed).
-        encoding: Encoding of the .bib file. Default encoding is "UTF-8".
+    :param path: Path to BibTeX file
+    :param parse_stack:
+        List of middleware to apply to the database after splitting.
+        If ``None`` (default), a default stack will be used providing simple standard functionality.
+
+    :param append_middleware:
+        List of middleware to append to the default stack
+        (ignored if a not-``None`` parse_stack is passed).
 
-    Returns:
-        Library: Parsed BibTeX library
+    :param encoding: Encoding of the .bib file. Default encoding is ``"UTF-8"``.
+    :return: Library: Parsed BibTeX library
     """
     with open(path, encoding=encoding) as f:
         bibtex_str = f.read()

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/exceptions.py

@@ -40,8 +40,8 @@ class ParserStateException(ParsingException):
 class RegexMismatchException(ParserStateException):
     """Raised when regex matches are inconsistent, implying a bug in the parser.
 
-    For example, raised when first match `@string{`
-    is not followed by an overlapping match `}`.
+    For example, raised when first match ``@string{``
+    is not followed by an overlapping match ``}``.
     """
 
     def __init__(self, first_match, expected_match, second_match):

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/__init__.py

@@ -7,6 +7,7 @@ from bibtexparser.middlewares.latex_encoding import (
     LatexDecodingMiddleware,
     LatexEncodingMiddleware,
 )
+from bibtexparser.middlewares.middleware import BlockMiddleware, LibraryMiddleware
 from bibtexparser.middlewares.month import (
     MonthAbbreviationMiddleware,
     MonthIntMiddleware,

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/enclosing.py

@@ -37,8 +37,8 @@ class RemoveEnclosingMiddleware(BlockMiddleware):
         )
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return REMOVED_ENCLOSING_KEY
 
     @staticmethod
@@ -109,8 +109,8 @@ class AddEnclosingMiddleware(BlockMiddleware):
         self._enclose_integers = enclose_integers
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "remove_enclosing"
 
     def _enclose(

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/interpolate.py

@@ -28,8 +28,8 @@ class ResolveStringReferencesMiddleware(LibraryMiddleware):
         super().__init__(allow_inplace_modification)
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "ResolveStringReferences"
 
     # docstr-coverage: inherited

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/middleware.py

@@ -21,7 +21,9 @@ class Middleware(abc.ABC):
     or LibraryMiddleware"""
 
     def __init__(
-        self, allow_parallel_execution: bool, allow_inplace_modification: bool = True
+        self,
+        allow_parallel_execution: bool = True,
+        allow_inplace_modification: bool = True,
     ):
         """
 
@@ -62,14 +64,12 @@ class BlockMiddleware(Middleware, abc.ABC):
     except if `allow_inplace_modification` is true.
     """
 
-    @staticmethod
-    @abc.abstractmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         """Identifier of the middleware.
-
         This key is used to identify the middleware in a blocks metadata.
         """
-        pass
+        return cls.__name__
 
     # docstr-coverage: inherited
     def transform(self, library: "Library") -> "Library":

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/month.py

@@ -12,7 +12,7 @@ class _MonthInterpolator(BlockMiddleware, abc.ABC):
     """Abstract class to handle month-conversions."""
 
     # docstr-coverage: inherited
-    def __init__(self, allow_inplace_modification: bool):
+    def __init__(self, allow_inplace_modification: bool = True):
         super().__init__(
             allow_inplace_modification=allow_inplace_modification,
             allow_parallel_execution=True,
@@ -80,8 +80,8 @@ class MonthLongStringMiddleware(_MonthInterpolator):
     and unenclosed."""
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "MonthLongStringMiddleware"
 
     # docstr-coverage: inherited
@@ -124,8 +124,8 @@ class MonthAbbreviationMiddleware(_MonthInterpolator):
     The created abbreviations are always lowercase and unenclosed."""
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "MonthAbbreviationMiddleware"
 
     # docstr-coverage: inherited
@@ -159,8 +159,8 @@ class MonthIntMiddleware(_MonthInterpolator):
     The created int-months are always integers and unenclosed."""
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "MonthIntMiddleware"
 
     # docstr-coverage: inherited

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/names.py

@@ -5,7 +5,7 @@ Much of the code is taken from Blair Bonnetts never merged v0 pull request
 """
 import abc
 import dataclasses
-from typing import List, Tuple
+from typing import List, Literal, Tuple
 
 from bibtexparser.model import Block, Entry, Field, MiddlewareErrorBlock
 
@@ -62,8 +62,8 @@ class SeparateCoAuthors(_NameTransformerMiddleware):
     """Middleware to separate multi-person fields (e.g. co-authors, co-editors)."""
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "separate_coauthors"
 
     # docstr-coverage: inherited
@@ -75,8 +75,8 @@ class MergeCoAuthors(_NameTransformerMiddleware):
     """Middleware to merge multi-person-list fields (e.g. co-authors, co-editors)."""
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "merge_coauthors"
 
     # docstr-coverage: inherited
@@ -114,6 +114,35 @@ class NameParts:
             ]
         )
 
+    @property
+    def merge_last_name_first(self) -> str:
+        """Merging the name parts into a single string, last-name-first (with commas) format.
+
+        The structure of the output is: `von Last, Jr, First`
+        """
+
+        def escape_last_slash(string: str) -> str:
+            """Escape the last slash in a string if it is not escaped."""
+            # Find the number of trailing slashes
+            stripped = string.rstrip("\\")
+            num_slashes = len(string) - len(stripped)
+            if num_slashes % 2 == 0:
+                # Even number: everything is escaped
+                return string
+            else:
+                # Odd number: need to escape one.
+                return string + "\\"
+
+        first = " ".join(self.first) if self.first else None
+        von = " ".join(self.von) if self.von else None
+        last = " ".join(self.last) if self.last else None
+        jr = " ".join(self.jr) if self.jr else None
+
+        von_last = " ".join(name for name in [von, last] if name)
+        return ", ".join(
+            escape_last_slash(name) for name in [von_last, jr, first] if name
+        )
+
 
 class SplitNameParts(_NameTransformerMiddleware):
     """Middleware to split a persons name into its parts (first, von, last, jr).
@@ -123,8 +152,8 @@ class SplitNameParts(_NameTransformerMiddleware):
     """
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "split_name_parts"
 
     def _transform_field_value(self, name) -> List[NameParts]:
@@ -142,18 +171,38 @@ class MergeNameParts(_NameTransformerMiddleware):
     """Middleware to merge a persons name parts (first, von, last, jr) into a single string.
 
     Name fields (e.g. author, editor, translator) are expected to be lists of NameParts.
+
+    The merging style indicates whether:
+    - the merging is done without commas in first-name-first order ("first"), or
+    - the merging is done with commas in last-name-first order ("last").
     """
 
+    def __init__(
+        self,
+        style: Literal["last", "first"] = "last",
+        allow_inplace_modification: bool = True,
+        name_fields: Tuple[str] = ("author", "editor", "translator"),
+    ):
+        self.style = style
+        super().__init__(allow_inplace_modification, name_fields)
+
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "merge_name_parts"
 
     def _transform_field_value(self, name) -> List[str]:
         if not isinstance(name, list) and all(isinstance(n, NameParts) for n in name):
             raise ValueError("Expected a list of NameParts, got {}. ".format(name))
 
-        return [n.merge_first_name_first for n in name]
+        if self.style == "last":
+            return [n.merge_last_name_first for n in name]
+        elif self.style == "first":
+            return [n.merge_first_name_first for n in name]
+        else:
+            raise ValueError(
+                """Expected "first" or "last" style, got {}. """.format(self.style)
+            )
 
 
 def parse_single_name_into_parts(name, strict=True):
@@ -229,33 +278,38 @@ def parse_single_name_into_parts(name, strict=True):
     for char in nameiter:
         # An escape.
         if char == "\\":
-            escaped = next(nameiter)
-
-            # BibTeX doesn't allow whitespace escaping. Copy the slash and fall
-            # through to the normal case to handle the whitespace.
-            if escaped in whitespace:
+            try:
+                escaped = next(nameiter)
+
+                # BibTeX doesn't allow whitespace escaping. Copy the slash and fall
+                # through to the normal case to handle the whitespace.
+                if escaped in whitespace:
+                    word.append(char)
+                    char = escaped
+
+                else:
+                    # Is this the first character in a brace?
+                    if bracestart:
+                        bracestart = False
+                        controlseq = escaped.isalpha()
+                        specialchar = True
+
+                    # Can we use it to determine the case?
+                    elif (case == -1) and escaped.isalpha():
+                        if escaped.isupper():
+                            case = 1
+                        else:
+                            case = 0
+
+                    # Copy the escape to the current word and go to the next
+                    # character in the input.
+                    word.append(char)
+                    word.append(escaped)
+                    continue
+
+            # If we're at the end of the string, then the \ is just a \.
+            except StopIteration:
                 word.append(char)
-                char = escaped
-
-            else:
-                # Is this the first character in a brace?
-                if bracestart:
-                    bracestart = False
-                    controlseq = escaped.isalpha()
-                    specialchar = True
-
-                # Can we use it to determine the case?
-                elif (case == -1) and escaped.isalpha():
-                    if escaped.isupper():
-                        case = 1
-                    else:
-                        case = 0
-
-                # Copy the escape to the current word and go to the next
-                # character in the input.
-                word.append(char)
-                word.append(escaped)
-                continue
 
         # Start of a braced expression.
         if char == "{":
@@ -510,12 +564,19 @@ def split_multiple_persons_names(names):
 
         # Escaped character.
         if char == "\\":
-            next(namesiter)
+            try:
+                next(namesiter)
+            # If we're at the end of the string, then the \ is just a \.
+            except StopIteration:
+                pass
             pos += 1
             continue
 
         # Change in brace level.
         if char == "{":
+            if step == NEXT_WORD:
+                spans[-1].append(possible_end)
+                spans.append([pos - 1])
             bracelevel += 1
             step = START_WHITESPACE
             continue

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/middlewares/sorting_entry_fields.py

@@ -22,8 +22,8 @@ class SortFieldsAlphabeticallyMiddleware(BlockMiddleware):
         return entry
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "sorted_fields_alphabetically"
 
 
@@ -71,6 +71,6 @@ class SortFieldsCustomMiddleware(BlockMiddleware):
         return entry
 
     # docstr-coverage: inherited
-    @staticmethod
-    def metadata_key() -> str:
+    @classmethod
+    def metadata_key(cls) -> str:
         return "sorted_fields_custom"

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser/model.py

@@ -5,7 +5,8 @@ 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."""
+    E.g. a ``@string`` block, a ``@preamble`` block, an ``@entry`` block, a comment, etc.
+    """
 
     def __init__(
         self,
@@ -51,15 +52,15 @@ class Block(abc.ABC):
         return self._parser_metadata
 
     def get_parser_metadata(self, key: str) -> Optional[Any]:
-        """EXPERIMENTAL: get auxiliary information stored in `parser_metadata`.
+        """EXPERIMENTAL: get auxiliary information stored in ``parser_metadata``.
 
-        See attribute `parser_metadata` for more information."""
+        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`.
+        """EXPERIMENTAL: set auxiliary information stored in ``parser_metadata``.
 
-        See attribute `parser_metadata` for more information."""
+        See attribute ``parser_metadata`` for more information."""
         self._parser_metadata[key] = value
 
     def __eq__(self, other):
@@ -72,7 +73,7 @@ class Block(abc.ABC):
 
 
 class String(Block):
-    """Bibtex Blocks of the `@string` type, e.g. @string{me = "My Name"}."""
+    """Bibtex Blocks of the ``@string`` type, e.g. ``@string{me = "My Name"}``."""
 
     def __init__(
         self,
@@ -87,7 +88,7 @@ class String(Block):
 
     @property
     def key(self) -> str:
-        """The key of the string, e.g. `me` in `@string{me = "My Name"}`."""
+        """The key of the string, e.g. ``me`` in ``@string{me = "My Name"}``."""
         return self._key
 
     @key.setter
@@ -96,7 +97,7 @@ class String(Block):
 
     @property
     def value(self) -> str:
-        """The value of the string, e.g. `"My Name"` in `@string{me = "My Name"}`."""
+        """The value of the string, e.g. ``"My Name"`` in ``@string{me = "My Name"}``."""
         return self._value
 
     @value.setter
@@ -114,7 +115,7 @@ class String(Block):
 
 
 class Preamble(Block):
-    """Bibtex Blocks of the `@preamble` type, e.g. @preamble{This is a preamble}."""
+    """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
@@ -124,7 +125,7 @@ class Preamble(Block):
 
     @property
     def value(self) -> str:
-        """The value of the preamble, e.g. `blabla` in `@preamble{blabla}`."""
+        """The value of the preamble, e.g. ``blabla`` in ``@preamble{blabla}``."""
         return self._value
 
     @value.setter
@@ -142,7 +143,7 @@ class Preamble(Block):
 
 
 class ExplicitComment(Block):
-    """Bibtex Blocks of the `@comment` type, e.g. @comment{This is a comment}."""
+    """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
@@ -152,7 +153,7 @@ class ExplicitComment(Block):
 
     @property
     def comment(self) -> str:
-        """The value of the comment, e.g. `blabla` in `@comment{blabla}`."""
+        """The value of the comment, e.g. ``blabla`` in ``@comment{blabla}``."""
         return self._comment
 
     @comment.setter
@@ -170,7 +171,7 @@ class ExplicitComment(Block):
 
 
 class ImplicitComment(Block):
-    """Bibtex outside of an @{...} block, which is treated as a comment."""
+    """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
@@ -198,7 +199,7 @@ class ImplicitComment(Block):
 
 
 class Field:
-    """A field of a Bibtex entry, e.g. `author = {John Doe}`."""
+    """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
@@ -207,7 +208,7 @@ class Field:
 
     @property
     def key(self) -> str:
-        """The key of the field, e.g. `author` in `author = {John Doe}`."""
+        """The key of the field, e.g. ``author`` in ``author = {John Doe}``."""
         return self._key
 
     @key.setter
@@ -216,7 +217,7 @@ class Field:
 
     @property
     def value(self) -> Any:
-        """The value of the field, e.g. `{John Doe}` in `author = {John Doe}`."""
+        """The value of the field, e.g. ``{John Doe}`` in ``author = {John Doe}``."""
         return self._value
 
     @value.setter
@@ -247,7 +248,7 @@ class Field:
 
 
 class Entry(Block):
-    """Bibtex Blocks of the `@entry` type, e.g. @article{Cesar2013, ...}."""
+    """Bibtex Blocks of the ``@entry`` type, e.g. ``@article{Cesar2013, ...}``."""
 
     def __init__(
         self,
@@ -264,7 +265,7 @@ class Entry(Block):
 
     @property
     def entry_type(self):
-        """The type of the entry, e.g. `article` in `@article{Cesar2013, ...}`."""
+        """The type of the entry, e.g. ``article`` in ``@article{Cesar2013, ...}``."""
         return self._entry_type
 
     @entry_type.setter
@@ -273,7 +274,7 @@ class Entry(Block):
 
     @property
     def key(self):
-        """The key of the entry, e.g. `Cesar2013` in `@article{Cesar2013, ...}`."""
+        """The key of the entry, e.g. ``Cesar2013`` in ``@article{Cesar2013, ...}``."""
         return self._key
 
     @key.setter
@@ -282,7 +283,7 @@ class Entry(Block):
 
     @property
     def fields(self) -> List[Field]:
-        """The key-value attributes of an entry, as `Field` instances."""
+        """The key-value attributes of an entry, as ``Field`` instances."""
         return self._fields
 
     @fields.setter
@@ -304,6 +305,30 @@ class Entry(Block):
         else:
             self._fields.append(field)
 
+    def pop(self, key: str, default=None) -> Optional[Field]:
+        """Removes and returns 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]:
+        """Returns 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.
 
@@ -318,6 +343,22 @@ class Entry(Block):
             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.
 
@@ -410,7 +451,7 @@ class DuplicateBlockKeyBlock(ParsingFailedBlock):
 
     @property
     def key(self) -> str:
-        """The key of the entry, e.g. `Cesar2013` in `@article{Cesar2013, ...}`."""
+        """The key of the entry, e.g. ``Cesar2013`` in ``@article{Cesar2013, ...}``."""
         return self._key
 
     @key.setter

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/bibtexparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bibtexparser
-Version: 2.0.0b5
+Version: 2.0.0b7
 Summary: Bibtex parser for python 3
 Home-page: https://github.com/sciunto-org/python-bibtexparser
 Author: Michael Weiss and other contributors
@@ -120,7 +120,7 @@ Writes the content of a bibtex library to a `.bib` file. Optional formatting par
 
 ## About
 
-Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). 
+Since 2022, `bibtexparser` is primarily written and maintained by Michael Weiss ([@MiWeiss](https://github.com/MiWeiss/)). In 2024, Tom de Geus ([@tdegeus](https://github.com/tdegeus)) joined as co-maintainer. 
 
 Credits and thanks to the many contributors who helped creating this library, including
 François Boulogne ([@sciunto](https://github.com/sciunto/), creator of the first version) and Olivier Mangin ([@omangin](https://github.com/omangin/), long-term contributor).

{bibtexparser-2.0.0b5 → bibtexparser-2.0.0b7}/tests/test_model.py

@@ -1,6 +1,8 @@
 from copy import copy, deepcopy
 from textwrap import dedent
 
+import pytest
+
 from bibtexparser.model import (
     Entry,
     ExplicitComment,
@@ -75,6 +77,34 @@ def test_entry_deepcopy():
     assert entry_1.fields_dict["field"] == entry_2.fields_dict["field"]
 
 
+def test_entry_get():
+    entry1 = Entry(
+        "article", "key", [Field("field", "value", 1), Field("foo", "bar", 2)], 1, "raw"
+    )
+    entry2 = Entry(
+        "article", "key", [Field("field", "value", 1), Field("foo", "bar", 2)], 1, "raw"
+    )
+    assert entry1.get("other", "default") == "default"
+    assert entry1.get("foo") == Field("foo", "bar", 2)
+    assert entry1 == entry2
+
+
+def test_entry_pop():
+    entry1 = Entry(
+        "article", "key", [Field("field", "value", 1), Field("foo", "bar", 2)], 1, "raw"
+    )
+    entry2 = Entry("article", "key", [Field("field", "value", 1)], 1, "raw")
+    assert entry1.pop("other", "default") == "default"
+    assert entry1.pop("foo") == Field("foo", "bar", 2)
+    assert entry1 == entry2
+
+
+def test_entry_contains():
+    entry = Entry("article", "key", [Field("field", "value", 1)], 1, "raw")
+    assert "field" in entry
+    assert "other" not in entry
+
+
 def test_string_equality():
     # Equal to itself
     string_1 = String(
@@ -290,3 +320,30 @@ def test_entry_str():
     )
 
     assert str(entry) == expected
+
+
+def test_entry_fields_shorthand():
+    entry = Entry(
+        entry_type="article",
+        key="myEntry",
+        fields=[
+            Field("myFirstField", "firstValue"),
+            Field("mySecondField", "secondValue"),
+        ],
+    )
+
+    entry["myFirstField"] = "changed_value"
+    assert entry["myFirstField"] == "changed_value"
+    assert entry.fields_dict["myFirstField"].value == "changed_value"
+
+    entry["myNewField"] = "new_value"
+    assert entry["myNewField"] == "new_value"
+    assert entry.fields_dict["myNewField"].key == "myNewField"
+    assert entry.fields_dict["myNewField"].value == "new_value"
+    assert entry.fields_dict["myNewField"].start_line is None
+
+    del entry["myNewField"]
+    assert "myNewField" not in entry.fields_dict
+    assert len([f for f in entry.fields if f.key == "myNewField"]) == 0
+    with pytest.raises(KeyError):
+        entry["myNewField"]