bibtexparser 2.0.0b4__tar.gz → 2.0.0b6__tar.gz

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bibtexparser
-Version: 2.0.0b4
+Version: 2.0.0b6
 Summary: Bibtex parser for python 3
 Home-page: https://github.com/sciunto-org/python-bibtexparser
 Author: Michael Weiss and other contributors
@@ -35,7 +35,7 @@ Welcome to python-bibtexparser, a parser for `.bib` files with a long history an
 Bibtexparser is available in two versions: V1 and V2. For new projects, we recommend using v2 which, in the long run, will provide an overall more robust and faster experience. **For now, however, note that v2 is an early beta, and does not contain all features of v1**. Install v2 using pip:
 
 ```bash
-pip install python-bibtexparser --pre
+pip install bibtexparser --pre
 ```
 
 Or you can install the latest development version directly from the main branch:

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/README.md

@@ -5,7 +5,7 @@ Welcome to python-bibtexparser, a parser for `.bib` files with a long history an
 Bibtexparser is available in two versions: V1 and V2. For new projects, we recommend using v2 which, in the long run, will provide an overall more robust and faster experience. **For now, however, note that v2 is an early beta, and does not contain all features of v1**. Install v2 using pip:
 
 ```bash
-pip install python-bibtexparser --pre
+pip install bibtexparser --pre
 ```
 
 Or you can install the latest development version directly from the main branch:

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/bibtexparser/__init__.py

@@ -4,3 +4,5 @@ import bibtexparser.model
 from bibtexparser.entrypoint import parse_file, parse_string, write_file, write_string
 from bibtexparser.library import Library
 from bibtexparser.writer import BibtexFormat
+
+__version__ = "2.0.0b6"

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/bibtexparser/library.py

@@ -24,7 +24,9 @@ class Library:
         if blocks is not None:
             self.add(blocks)
 
-    def add(self, blocks: Union[List[Block], Block]):
+    def add(
+        self, blocks: Union[List[Block], Block], fail_on_duplicate_key: bool = False
+    ):
         """Add blocks to library.
 
         The adding is key-safe, i.e., it is made sure that no duplicate keys are added.
@@ -32,14 +34,30 @@ class Library:
         a DuplicateKeyBlock.
 
         :param blocks: Block or list of blocks to add.
+        :param fail_on_duplicate_key: If True, raises ValueError if a block was replaced with a DuplicateKeyBlock.
         """
         if isinstance(blocks, Block):
             blocks = [blocks]
 
+        _added_blocks = []
         for block in blocks:
             # This may replace block with a DuplicateEntryKeyBlock
             block = self._add_to_dicts(block)
             self._blocks.append(block)
+            _added_blocks.append(block)
+
+        if fail_on_duplicate_key:
+            duplicate_keys = []
+            for original, added in zip(blocks, _added_blocks):
+                if not original is added and isinstance(added, DuplicateBlockKeyBlock):
+                    duplicate_keys.append(added.key)
+
+            if len(duplicate_keys) > 0:
+                raise ValueError(
+                    f"Duplicate keys found: {duplicate_keys}. "
+                    f"Duplicate entries have been added to the library as DuplicateBlockKeyBlock."
+                    f"Use `library.failed_blocks` to access them. "
+                )
 
     def remove(self, blocks: Union[List[Block], Block]):
         """Remove blocks from library.
@@ -73,19 +91,19 @@ class Library:
         except ValueError:
             raise ValueError("Block to replace is not in library.")
 
-        self._blocks.insert(index, new_block)
         block_after_add = self._add_to_dicts(new_block)
+        self._blocks.insert(index, block_after_add)
 
         if (
             new_block is not block_after_add
-            and isinstance(new_block, DuplicateBlockKeyBlock)
+            and isinstance(block_after_add, DuplicateBlockKeyBlock)
             and fail_on_duplicate_key
         ):
             # Revert changes to old_block
             #   Don't fail on duplicate key, as this would lead to an infinite recursion
             #   (should never happen for a clean library, but could happen if the user
             #   tampered with the internals of the library).
-            self.replace(new_block, old_block, fail_on_duplicate_key=False)
+            self.replace(block_after_add, old_block, fail_on_duplicate_key=False)
             raise ValueError("Duplicate key found.")
 
     @staticmethod
@@ -160,7 +178,9 @@ class Library:
     @property
     def entries(self) -> List[Entry]:
         """All entry (@article, ...) blocks in the library, preserving order of insertion."""
-        return list(self._entries_by_key.values())
+        # Note: Taking this from the entries dict would be faster, but does not preserve order
+        #   e.g. in cases where `replace` has been called.
+        return [b for b in self._blocks if isinstance(b, Entry)]
 
     @property
     def entries_dict(self) -> Dict[str, Entry]:

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/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.0b4 → bibtexparser-2.0.0b6}/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.0b4 → bibtexparser-2.0.0b6}/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.0b4 → bibtexparser-2.0.0b6}/bibtexparser/middlewares/middleware.py

@@ -62,14 +62,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.0b4 → bibtexparser-2.0.0b6}/bibtexparser/middlewares/month.py

@@ -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.0b4 → bibtexparser-2.0.0b6}/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:
-                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.
+            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)
-                word.append(escaped)
-                continue
 
         # Start of a braced expression.
         if char == "{":
@@ -424,11 +478,17 @@ def parse_single_name_into_parts(name, strict=True):
         else:
             lcases = cases[0]
 
-            #
+            def rindex(l, x, default):
+                """Returns the index of the rightmost occurence of x in l."""
+                for i in range(len(l) - 1, -1, -1):
+                    if l[i] == x:
+                        return i
+                return default
+
+            # Check if at least one of the words is lowercase
             if 0 in lcases:
-                split = len(lcases) - lcases[::-1].index(0)
-                if split == len(lcases):
-                    split = 0  # Last cannot be empty.
+                # Excluding the last word, find the index of the last lower word
+                split = rindex(lcases[:-1], 0, -1) + 1
                 parts.von = sections[0][:split]
                 parts.last = sections[0][split:]
 
@@ -504,7 +564,11 @@ 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
 

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/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.0b4 → bibtexparser-2.0.0b6}/bibtexparser/model.py

@@ -304,6 +304,16 @@ class Entry(Block):
         else:
             self._fields.append(field)
 
+    def pop_field(self, key: str) -> Optional[Field]:
+        """Removes and returns the field with the given key, if present."""
+        try:
+            field = self.fields_dict.pop(key)
+        except KeyError:
+            return None
+
+        self._fields = [f for f in self._fields if f.key != key]
+        return field
+
     def __getitem__(self, key: str) -> Any:
         """Dict-mimicking index.
 
@@ -318,6 +328,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_field`.
+        """
+        self.pop_field(key)
+
     def items(self):
         """Dict-mimicking, for partial v1.x backwards compatibility.
 

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/bibtexparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bibtexparser
-Version: 2.0.0b4
+Version: 2.0.0b6
 Summary: Bibtex parser for python 3
 Home-page: https://github.com/sciunto-org/python-bibtexparser
 Author: Michael Weiss and other contributors
@@ -35,7 +35,7 @@ Welcome to python-bibtexparser, a parser for `.bib` files with a long history an
 Bibtexparser is available in two versions: V1 and V2. For new projects, we recommend using v2 which, in the long run, will provide an overall more robust and faster experience. **For now, however, note that v2 is an early beta, and does not contain all features of v1**. Install v2 using pip:
 
 ```bash
-pip install python-bibtexparser --pre
+pip install bibtexparser --pre
 ```
 
 Or you can install the latest development version directly from the main branch:

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/bibtexparser.egg-info/SOURCES.txt

@@ -24,5 +24,6 @@ bibtexparser/middlewares/parsestack.py
 bibtexparser/middlewares/sorting_blocks.py
 bibtexparser/middlewares/sorting_entry_fields.py
 tests/test_entrypoint.py
+tests/test_library.py
 tests/test_model.py
 tests/test_writer.py

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/setup.py

@@ -1,13 +1,15 @@
 #!/usr/bin/env python
 import setuptools
 
-version = "2.0.0b4"
+version = None
 
 with open("bibtexparser/__init__.py") as fh:
     for line in fh:
         if line.startswith("__version__"):
             version = line.strip().split()[-1][1:-1]
             break
+    if not version:
+        raise RuntimeError("Could not determine version")
 
 
 def load_readme():

bibtexparser-2.0.0b6/tests/test_library.py

@@ -0,0 +1,75 @@
+from copy import deepcopy
+
+import pytest
+
+from bibtexparser import Library
+from bibtexparser.model import Entry, Field
+
+
+def get_dummy_entry():
+    return Entry(
+        entry_type="article",
+        key="duplicateKey",
+        fields=[
+            Field(key="title", value="A title"),
+            Field(key="author", value="An author"),
+        ],
+    )
+
+
+def test_replace_with_duplicates():
+    """Test that replace() works when there are duplicate values. See issue 404."""
+    library = Library()
+    library.add(get_dummy_entry())
+    library.add(get_dummy_entry())
+    # Test precondition
+    assert len(library.blocks) == 2
+    assert len(library.failed_blocks) == 1
+
+    replacement_entry = get_dummy_entry()
+    replacement_entry.fields_dict["title"].value = "A new title"
+
+    library.replace(
+        library.failed_blocks[0], replacement_entry, fail_on_duplicate_key=False
+    )
+    assert len(library.blocks) == 2
+    assert len(library.failed_blocks) == 1
+    assert library.failed_blocks[0].ignore_error_block["title"] == "A new title"
+
+    replacement_entry_2 = get_dummy_entry()
+    replacement_entry_2.fields_dict["title"].value = "Another new title"
+
+    library.replace(
+        library.entries[0], replacement_entry_2, fail_on_duplicate_key=False
+    )
+    assert len(library.blocks) == 2
+    assert len(library.failed_blocks) == 1
+    # The new block replaces the previous "non-duplicate" and should thus not become a duplicate itself
+    assert library.entries[0].fields_dict["title"].value == "Another new title"
+
+
+def test_replace_fail_on_duplicate():
+    library = Library()
+    replaceable_entry = get_dummy_entry()
+    replaceable_entry.key = "Just a regular entry, to be replaced"
+    future_duplicate_entry = get_dummy_entry()
+    library.add([replaceable_entry, future_duplicate_entry])
+
+    with pytest.raises(ValueError):
+        library.replace(
+            replaceable_entry, get_dummy_entry(), fail_on_duplicate_key=True
+        )
+
+    assert len(library.blocks) == 2
+    assert len(library.failed_blocks) == 0
+    assert library.entries[0].key == "Just a regular entry, to be replaced"
+    assert library.entries[1].key == "duplicateKey"
+
+
+def test_fail_on_duplicate_add():
+    library = Library()
+    library.add(get_dummy_entry())
+    with pytest.raises(ValueError):
+        library.add(get_dummy_entry(), fail_on_duplicate_key=True)
+    assert len(library.blocks) == 2
+    assert len(library.failed_blocks) == 1

{bibtexparser-2.0.0b4 → bibtexparser-2.0.0b6}/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,
@@ -290,3 +292,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"]