Address PR review findings

- Fix stale parse_pieces docstring that still described adding derived
  parts "to the constant"
- Document the derived-set branch in the is_prefix / is_suffix /
  is_conjunction docstrings, and reword is_leading_title's now-vacuous
  "does not mutate C.titles" contrast into the narrower load-bearing
  fact (the regex match is not registered anywhere, even per-parse)
- Remove the redundant _derived_suffixes check from is_suffix_lenient:
  it falls through to is_suffix(), which already consults the overlay,
  and derived suffixes always contain an interior period so they can
  never trip the is_an_initial() veto that "lenient" exists to bypass
- Add mutation-verified regression tests for the two coverage gaps:
  is_rootname's derived-title exclusion (its overlay checks were
  deletable without any test failing, yet dropping them misparses
  "Lt.Gov. juan e garcia" into an empty first name) and the
  __setstate__ backfill for pickles predating the derived sets (whose
  absence crashes capitalize() with AttributeError)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derek73

nameparser/parser.py

@@ -582,14 +582,16 @@ def is_leading_title(self, piece: str) -> bool:
         ``is_an_initial()`` check, is what excludes single-letter initials
         like ``"J."``. Only meaningful for pieces in the title position
         (before the first name is set) — a period-abbreviation appearing
-        later in the name is left as a middle name. Does not mutate
-        ``C.titles``, so the periodless form (``"Major"``) is never affected
-        in later parses.
+        later in the name is left as a middle name. The match is not
+        registered in ``C.titles`` or the per-parse derived titles, so
+        matching ``"Major."`` here never makes ``"Major"`` (or ``"Major."``)
+        a recognized title elsewhere, even within the same parse.
         """
         return self.is_title(piece) or bool(self.C.regexes.period_abbreviation.match(piece))
 
     def is_conjunction(self, piece: str) -> bool:
-        """Is in the conjunctions set and not :py:func:`is_an_initial()`."""
+        """Is in the conjunctions set — config or derived earlier in this
+        parse (e.g. ``"of the"``) — and not :py:func:`is_an_initial()`."""
         if isinstance(piece, list):
             for item in piece:
                 if self.is_conjunction(item):
@@ -602,7 +604,8 @@ def is_conjunction(self, piece: str) -> bool:
     def is_prefix(self, piece: str) -> bool:
         """
         Lowercased, leading/trailing-periods-stripped version of piece is in the
-        :py:data:`~nameparser.config.prefixes.PREFIXES` set.
+        :py:data:`~nameparser.config.prefixes.PREFIXES` set, or was derived as
+        a prefix earlier in this parse (e.g. ``"von und"``).
         """
         if isinstance(piece, list):
             for item in piece:
@@ -657,7 +660,9 @@ def is_roman_numeral(self, value: str) -> bool:
 
     def is_suffix(self, piece: str) -> bool:
         """
-        Is in the suffixes set and not :py:func:`is_an_initial()`.
+        Is in the suffixes set — or was derived as a period-joined suffix
+        earlier in this parse (e.g. ``"JD.CPA"``) — and not
+        :py:func:`is_an_initial()`.
 
         Some suffixes may be acronyms (M.B.A) while some are not (Jr.),
         so we remove the periods from `piece` when testing against
@@ -697,10 +702,7 @@ def is_suffix_lenient(self, piece: str) -> bool:
         is_suffix() would otherwise reject. Only safe for pieces in
         unambiguous positions, e.g. after a comma ("John Ingram, V").
         """
-        word = lc(piece)
-        return word in self.C.suffix_not_acronyms \
-            or word in self._derived_suffixes \
-            or self.is_suffix(piece)
+        return lc(piece) in self.C.suffix_not_acronyms or self.is_suffix(piece)
 
     def expand_suffix_delimiter(self, part: str) -> list[str]:
         """Split a single post-comma part on :py:attr:`suffix_delimiter`,
@@ -1211,8 +1213,9 @@ def parse_pieces(self, parts: Iterable[str], additional_parts_count: int = 0) ->
         lastname prefixes. Tokens that are empty after stripping spaces and
         commas are dropped, so the returned pieces never contain empty
         strings. If parts have periods in the middle, try splitting
-        on periods and check if the parts are titles or suffixes. If they are
-        add to the constant so they will be found.
+        on periods and check if the parts are titles or suffixes. If they are,
+        register the periods-joined part as a derived title/suffix for this
+        parse so it will be recognized; the constants are not modified.
 
         :param list parts: name part strings from the comma split
         :param int additional_parts_count:

tests/test_python_api.py

@@ -95,6 +95,27 @@ def test_name_instance_deepcopy_isolates_instance_config(self) -> None:
         self.assertIn('chancellor', dup.C.titles)
         self.assertNotIn('marker', hn.C.titles)
 
+    def test_unpickle_legacy_state_without_derived_sets(self) -> None:
+        """Pickles from before the per-parse derived sets existed must still work.
+
+        Their state lacks the ``_derived_*`` attributes, which the ``is_*``
+        predicates (and through them ``capitalize()``) read directly, so
+        ``__setstate__`` must backfill them rather than crash with
+        AttributeError on first use.
+        """
+        hn = HumanName("dr. juan de la vega jr.")
+        legacy_state = {
+            k: v for k, v in hn.__getstate__().items()
+            if not k.startswith('_derived_')
+        }
+
+        restored = HumanName.__new__(HumanName)
+        restored.__setstate__(legacy_state)
+
+        self.assertTrue(restored.is_title('dr.'))
+        restored.capitalize()  # reads _derived_prefixes via cap_word/is_prefix
+        self.assertEqual(str(restored), "Dr. Juan de la Vega Jr.")
+
     def test_pickle_default_name_preserves_singleton_identity(self) -> None:
         """A default HumanName must re-attach to CONSTANTS after a pickle round-trip.
 

tests/test_titles.py

@@ -225,6 +225,18 @@ def test_title_with_periods_lastname_comma(self) -> None:
         self.m(hn.first, "John", hn)
         self.m(hn.last, "Doe", hn)
 
+    def test_title_with_periods_and_single_letter_middle_name(self) -> None:
+        # A derived title ("Lt.Gov.") must be excluded from the rootname
+        # count that join_on_conjunctions() uses for its single-letter
+        # conjunction heuristic. If is_rootname() misses the derived titles,
+        # the count reaches 4 and "e" is treated as a conjunction, joining
+        # "juan e garcia" into a single last-name piece with no first name.
+        hn = HumanName("Lt.Gov. juan e garcia")
+        self.m(hn.title, "Lt.Gov.", hn)
+        self.m(hn.first, "juan", hn)
+        self.m(hn.middle, "e", hn)
+        self.m(hn.last, "garcia", hn)
+
     def test_mac_with_spaces(self) -> None:
         hn = HumanName("Jane Mac Beth")
         self.m(hn.first, "Jane", hn)