fix: recognize trailing suffix_not_acronyms in lastname-comma format (closes #144) (#175)

* fix: recognize trailing suffix_not_acronyms in lastname-comma format (closes #144)

In 'Last, First Middle I' format, a trailing single-letter suffix like 'I'
was silently absorbed into the middle name because is_suffix() rejects single
uppercase letters via is_an_initial().

Add is_suffix_at_lastname_comma_end() which applies when the piece is the
final token of the post-comma segment and no explicit comma-separated suffix
follows (len(parts)==2). When parts[2] exists the caller already declared a
suffix, making the trailing token more likely a middle initial
(e.g. 'Doe, Rev. John V, Jr.'), so that case is excluded.

* test: add coverage for trailing suffix_not_acronyms in lastname-comma format

Add tests for 'V' (same ambiguity as 'I'), no-middle case, single-letter
middle-initial-before-suffix pattern, and an xfail documenting the known
limitation when an explicit comma-suffix segment is present. Also tighten
the is_suffix_at_lastname_comma_end docstring to explain the parts parameter
semantics and the three conditions that must hold.

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: derek73

nameparser/parser.py

@@ -504,6 +504,27 @@ def are_suffixes_after_comma(self, pieces: Iterable[str]) -> bool:
                 return False
         return True
 
+    def is_suffix_at_lastname_comma_end(self, piece: str, nxt: str | None, parts: list[str]) -> bool:
+        """True when ``piece`` is a suffix_not_acronyms member that should be
+        treated as a suffix at the end of ``parts[1]`` (the post-comma segment)
+        in a lastname-comma name, where ``parts`` is the full comma-split of the
+        name string.
+
+        Returns True only when all three conditions hold:
+        - ``nxt is None``: piece is the last token in the post-comma segment
+        - ``len(parts) == 2``: no ``parts[2]`` suffix segment exists
+        - ``lc(piece) in suffix_not_acronyms``
+
+        When ``parts[2]`` exists the caller already declared an explicit suffix
+        via comma (e.g. 'Doe, Rev. John V, Jr.'), making the trailing token more
+        likely a middle initial; ``len(parts) == 2`` excludes that case.
+        Used as an OR alternative to ``is_suffix()`` for pieces that
+        ``is_suffix()`` would reject via ``is_an_initial()``.
+        """
+        return (nxt is None
+                and len(parts) == 2
+                and lc(piece) in self.C.suffix_not_acronyms)
+
     def is_rootname(self, piece: str) -> bool:
         """
         Is not a known title, suffix or prefix. Just first, middle, last names.
@@ -767,7 +788,7 @@ def parse_full_name(self) -> None:
                     if not self.first:
                         self.first_list.append(piece)
                         continue
-                    if self.is_suffix(piece):
+                    if self.is_suffix(piece) or self.is_suffix_at_lastname_comma_end(piece, nxt, parts):
                         self.suffix_list.append(piece)
                         continue
                     self.middle_list.append(piece)

tests/test_suffixes.py

@@ -166,6 +166,48 @@ def test_suffix_with_periods_with_lastname_comma(self) -> None:
         self.m(hn.last, "Doe", hn)
         self.m(hn.suffix, "Msc.Ed.", hn)
 
+    def test_roman_numeral_i_lastname_comma_format(self) -> None:
+        # 'I' is in suffix_not_acronyms; trailing suffix_not_acronyms members in
+        # "Lastname, First Middle Suffix" format (no comma-suffix segment) must
+        # parse as suffix, not middle initial (issue #144)
+        hn = HumanName("Maier, Amy Lauren I")
+        self.m(hn.first, "Amy", hn)
+        self.m(hn.middle, "Lauren", hn)
+        self.m(hn.last, "Maier", hn)
+        self.m(hn.suffix, "I", hn)
+
+    def test_roman_numeral_v_lastname_comma_format(self) -> None:
+        # 'V' shares the same suffix_not_acronyms ambiguity as 'I' (issue #144)
+        hn = HumanName("Smith, John V")
+        self.m(hn.first, "John", hn)
+        self.m(hn.middle, "", hn)
+        self.m(hn.last, "Smith", hn)
+        self.m(hn.suffix, "V", hn)
+
+    def test_roman_numeral_i_no_middle_lastname_comma_format(self) -> None:
+        # no middle name: trailing 'I' must still be a suffix (issue #144)
+        hn = HumanName("Smith, John I")
+        self.m(hn.first, "John", hn)
+        self.m(hn.middle, "", hn)
+        self.m(hn.last, "Smith", hn)
+        self.m(hn.suffix, "I", hn)
+
+    def test_roman_numeral_i_after_single_initial_lastname_comma_format(self) -> None:
+        # single-letter middle initial followed by trailing 'I' (reporter pattern, issue #144)
+        hn = HumanName("Chang, Andy C I")
+        self.m(hn.first, "Andy", hn)
+        self.m(hn.middle, "C", hn)
+        self.m(hn.last, "Chang", hn)
+        self.m(hn.suffix, "I", hn)
+
+    @pytest.mark.xfail
+    def test_roman_numeral_i_with_explicit_suffix_comma_known_limitation(self) -> None:
+        # When an explicit suffix comma is present (len(parts)==3), the trailing 'I'
+        # is conservatively left in middle to avoid misclassifying true initials.
+        # This is a known limitation of is_suffix_at_lastname_comma_end (issue #144).
+        hn = HumanName("Maier, Amy I, Jr.")
+        self.m(hn.suffix, "I, Jr.", hn)
+
     def test_suffix_delimiter_default_on_constants(self) -> None:
         from nameparser.config import CONSTANTS
         self.assertIs(CONSTANTS.suffix_delimiter, None)