fix: strip internal periods before suffix_acronyms check in parse_nicknames

handle_match() checked stripped (lc()-only, leading/trailing periods
stripped) against suffix_acronyms, unlike is_suffix() which also
strips internal periods. This meant an acronym suffix like "M.D"
(periods between letters, no trailing period) fell through to
nickname_list instead of being recognized as a suffix. Found during
PR review by the pr-test-analyzer subagent.

Also adds the release_log.rst entries for this fix, per CLAUDE.md's
maintenance requirement, flagged by the code-reviewer subagent.

Author: derek73

docs/release_log.rst

@@ -7,6 +7,9 @@ Release Log
     to 1.2.1 first (which includes a one-version compatibility shim), load and
     re-pickle under 1.2.1, then upgrade to 1.3.0.
 
+    - Fix suffix-shaped parenthesized/quoted content (e.g. ``"(Ret)"``, ``"(MBA)"``) being misclassified as a nickname instead of a suffix (closes #111)
+    - Add ``suffix_acronyms_ambiguous`` to ``Constants`` for acronym suffixes that also read as given-name nicknames (e.g. ``"JD"``, ``"Ed"``), used when disambiguating parenthesized/quoted content (#111)
+    - Fix missing comma between ``'msc'`` and ``'mscmsm'`` in ``suffix_acronyms``, which silently concatenated them into a bogus ``'mscmscmsm'`` entry (#111)
     - Add ``given_names`` (and ``given_names_list``) attribute as aggregate of first and middle names, mirroring ``surnames`` (closes #157)
     - Add ``suffix_delimiter`` to ``Constants`` and ``HumanName`` for parsing suffixes separated by arbitrary delimiters, e.g. ``"RN - CRNA"`` (#156)
     - Add ``initials_separator`` to ``Constants`` and ``HumanName`` to control spacing between consecutive initials within a name group (#171)

nameparser/config/__init__.py

@@ -42,7 +42,6 @@
 from nameparser.config.conjunctions import CONJUNCTIONS
 from nameparser.config.suffixes import SUFFIX_ACRONYMS
 from nameparser.config.suffixes import SUFFIX_NOT_ACRONYMS
-from nameparser.config.suffixes import SUFFIX_ACRONYMS_AMBIGUOUS
 from nameparser.config.titles import TITLES
 from nameparser.config.titles import FIRST_NAME_TITLES
 from nameparser.config.regexes import EMPTY_REGEX, REGEXES
@@ -237,10 +236,8 @@ class Constants:
         :py:attr:`~titles.FIRST_NAME_TITLES` wrapped with :py:class:`SetManager`.
     :param set suffix_acronyms: 
         :py:attr:`~suffixes.SUFFIX_ACRONYMS`  wrapped with :py:class:`SetManager`.
-    :param set suffix_not_acronyms:
+    :param set suffix_not_acronyms: 
         :py:attr:`~suffixes.SUFFIX_NOT_ACRONYMS`  wrapped with :py:class:`SetManager`.
-    :param set suffix_acronyms_ambiguous:
-        :py:attr:`~suffixes.SUFFIX_ACRONYMS_AMBIGUOUS` wrapped with :py:class:`SetManager`.
     :param set conjunctions:
         :py:attr:`conjunctions`  wrapped with :py:class:`SetManager`.
     :param set first_name_prefixes:
@@ -260,7 +257,6 @@ class Constants:
     first_name_titles: SetManager
     conjunctions: SetManager
     first_name_prefixes: SetManager
-    suffix_acronyms_ambiguous: SetManager
     capitalization_exceptions: TupleManager[str]
     regexes: RegexTupleManager
     _pst: Set[str] | None
@@ -392,7 +388,6 @@ def __init__(self,
                  prefixes: Iterable[str] = PREFIXES,
                  suffix_acronyms: Iterable[str] = SUFFIX_ACRONYMS,
                  suffix_not_acronyms: Iterable[str] = SUFFIX_NOT_ACRONYMS,
-                 suffix_acronyms_ambiguous: Iterable[str] = SUFFIX_ACRONYMS_AMBIGUOUS,
                  titles: Iterable[str] = TITLES,
                  first_name_titles: Iterable[str] = FIRST_NAME_TITLES,
                  conjunctions: Iterable[str] = CONJUNCTIONS,
@@ -411,7 +406,6 @@ def __init__(self,
         self.first_name_titles = SetManager(first_name_titles)
         self.conjunctions = SetManager(conjunctions)
         self.first_name_prefixes = SetManager(first_name_prefixes)
-        self.suffix_acronyms_ambiguous = SetManager(suffix_acronyms_ambiguous)
         self.capitalization_exceptions = TupleManager(capitalization_exceptions)
         self.regexes = RegexTupleManager(regexes)
         self.patronymic_name_order = patronymic_name_order

nameparser/config/suffixes.py

@@ -13,38 +13,16 @@
     'iii',
     'iv',
     'v',
-    'ret',
-    'vet',
 ])
 """
 
 Post-nominal pieces that are not acronyms. The parser does not remove periods
 when matching against these pieces.
 
-"""
-SUFFIX_ACRONYMS_AMBIGUOUS = set([
-    # Suffix acronyms that also commonly work as given-name nicknames on
-    # their own (e.g. "Ed", "JD"). Read only by HumanName.parse_nicknames()
-    # when deciding whether parenthesized/quoted content is a nickname or a
-    # suffix -- content matching one of these stays a nickname rather than
-    # being reclassified as a suffix, since that's the more common reading
-    # in ambiguous, delimiter-only context.
-    #
-    # When adding a new entry to SUFFIX_ACRONYMS, also add it here only if
-    # the exact letter sequence could plausibly be someone's given name or
-    # common nickname on its own (e.g. 'jd', 'ed'). Unambiguous
-    # certifications/degrees (e.g. 'mba', 'cpa', 'phd') don't need an entry.
-    'ed',
-    'jd',
-])
-"""
-
-Acronym suffixes from SUFFIX_ACRONYMS that also plausibly collide with a
-common given-name nickname. Not a partition of SUFFIX_ACRONYMS -- a small,
-standalone exception list consulted only by parse_nicknames().
-
 """
 SUFFIX_ACRONYMS = set([
+    '(ret)',
+    '(vet)',
     '8-vsb',
     'aas',
     'aba',
@@ -523,7 +501,7 @@
     'mra',
     'ms',
     'msa',
-    'msc',
+    'msc'
     'mscmsm',
     'msm',
     'mt',

nameparser/parser.py

@@ -803,10 +803,17 @@ def handle_match(m: 're.Match[str]') -> str:
             # also rejects single-letter initials via is_an_initial(), which
             # isn't relevant here, and the suffix_acronyms_ambiguous exclusion
             # needs to be interleaved into the acronym branch specifically.
+            # Acronym suffixes may have periods between every letter (e.g.
+            # "M.D", "Ph.D") that aren't necessarily trailing, so -- exactly
+            # like is_suffix() -- strip all periods before checking
+            # suffix_acronyms/suffix_acronyms_ambiguous membership. Bare
+            # `stripped` (lc() only strips leading/trailing periods) is still
+            # used for suffix_not_acronyms, matching is_suffix()'s asymmetry.
+            acronym_stripped = stripped.replace('.', '')
             is_unambiguous_suffix = (
                 stripped in self.C.suffix_not_acronyms
-                or (stripped in self.C.suffix_acronyms
-                    and stripped not in self.C.suffix_acronyms_ambiguous)
+                or (acronym_stripped in self.C.suffix_acronyms
+                    and acronym_stripped not in self.C.suffix_acronyms_ambiguous)
             )
             if is_unambiguous_suffix or content.endswith('.'):
                 # Leave the bare content -- no delimiters -- so downstream

tests/test_suffixes.py

@@ -325,6 +325,17 @@ def test_acronym_suffix_in_parenthesis(self) -> None:
         self.m(hn.suffix, "MBA", hn)
         self.m(hn.nickname, "", hn)
 
+    def test_acronym_suffix_with_internal_periods_in_parenthesis(self) -> None:
+        # "M.D" has a non-trailing period between every letter -- unlike
+        # is_suffix(), handle_match()'s suffix_acronyms check must also strip
+        # internal periods (not just rely on the trailing content.endswith('.')
+        # heuristic, which doesn't fire here since "M.D" has no trailing period).
+        hn = HumanName("Andrew Perkins (M.D)")
+        self.m(hn.first, "Andrew", hn)
+        self.m(hn.last, "Perkins", hn)
+        self.m(hn.suffix, "M.D", hn)
+        self.m(hn.nickname, "", hn)
+
     def test_period_terminated_content_in_parenthesis_not_forced_either_way(self) -> None:
         # "Mgr." isn't in any suffix list, but it ends in a period, so the
         # period heuristic (rule 2) excludes it from nickname_list. It flows