Allow adding nickname delimiter patterns at runtime (#112)

parse_nicknames() looped over a hardcoded tuple of three named regexes,
so overriding an existing pattern in CONSTANTS.regexes and re-parsing
worked, but adding a brand new delimiter had no effect since nothing
iterated a variable set of patterns.

Constants now exposes nickname_delimiters, a named TupleManager of
delimiter patterns (seeded with the existing quoted_word/double_quotes/
parenthesis regexes) that parse_nicknames() iterates. Adding an entry
and calling parse_full_name() again picks it up.

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

Author: derek73

docs/customize.rst

@@ -53,6 +53,29 @@ Each set of constants comes with :py:func:`~nameparser.config.SetManager.add` an
 the constants for your project. These methods automatically lower case and
 remove punctuation to normalize them for comparison.
 
+Adding Custom Nickname Delimiters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+:py:obj:`~nameparser.config.Constants.nickname_delimiters` is a named,
+appendable group of the delimiter patterns that
+:py:meth:`~nameparser.parser.HumanName.parse_nicknames` loops through
+(``quoted_word``, ``double_quotes`` and ``parenthesis`` by default). Add
+your own pattern under a new key to recognize additional delimiters, then
+re-run :py:meth:`~nameparser.parser.HumanName.parse_full_name` to pick it
+up:
+
+.. doctest::
+
+    >>> import re
+    >>> from nameparser import HumanName
+    >>> hn = HumanName("Benjamin {Ben} Franklin", constants=None)
+    >>> hn.nickname
+    ''
+    >>> hn.C.nickname_delimiters['curly_braces'] = re.compile(r'\{(.*?)\}', re.U)
+    >>> hn.parse_full_name()
+    >>> hn.nickname
+    'Ben'
+
 Other editable attributes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 

nameparser/config/__init__.py

@@ -263,6 +263,7 @@ class Constants:
     suffix_acronyms_ambiguous: SetManager
     capitalization_exceptions: TupleManager[str]
     regexes: RegexTupleManager
+    nickname_delimiters: TupleManager[re.Pattern[str]]
     _pst: Set[str] | None
 
     string_format = "{title} {first} {middle} {last} {suffix} ({nickname})"
@@ -414,6 +415,15 @@ def __init__(self,
         self.suffix_acronyms_ambiguous = SetManager(suffix_acronyms_ambiguous)
         self.capitalization_exceptions = TupleManager(capitalization_exceptions)
         self.regexes = RegexTupleManager(regexes)
+        # Named, appendable group of delimiter patterns that parse_nicknames()
+        # iterates in order -- see nameparser.config.regexes for the defaults.
+        # Add a pattern here (and re-parse) to recognize a new delimiter
+        # without needing to override parse_nicknames() itself. See issue #112.
+        self.nickname_delimiters = TupleManager({
+            'quoted_word': self.regexes.quoted_word,
+            'double_quotes': self.regexes.double_quotes,
+            'parenthesis': self.regexes.parenthesis,
+        })
         self.patronymic_name_order = patronymic_name_order
 
     def _invalidate_pst(self) -> None:

nameparser/parser.py

@@ -788,10 +788,6 @@ def parse_nicknames(self) -> None:
         `quoted_word`, `double_quotes` and `parenthesis`.
         """
 
-        re_quoted_word = self.C.regexes.quoted_word
-        re_double_quotes = self.C.regexes.double_quotes
-        re_parenthesis = self.C.regexes.parenthesis
-
         def handle_match(m: 're.Match[str]') -> str:
             # Fall back to the whole match when the regex has no capturing
             # group (e.g. a custom override regex without one, like
@@ -826,10 +822,13 @@ def handle_match(m: 're.Match[str]') -> str:
             self.nickname_list.append(content)
             return ''
 
-        # Same handle_match for all three delimiters: suffix-shaped content
+        # Same handle_match for every delimiter: suffix-shaped content
         # is rare in quotes but not impossible, and the logic is delimiter-
         # agnostic, so there's no reason to special-case parenthesis here.
-        for _re in (re_quoted_word, re_double_quotes, re_parenthesis):
+        # Iterating self.C.nickname_delimiters (rather than a hardcoded
+        # tuple) lets callers add new delimiter patterns at runtime -- see
+        # issue #112.
+        for _re in self.C.nickname_delimiters.values():
             self._full_name = _re.sub(handle_match, self._full_name)
 
     def squash_emoji(self) -> None:

tests/test_nicknames.py

@@ -1,3 +1,5 @@
+import re
+
 import pytest
 
 from nameparser import HumanName
@@ -14,6 +16,17 @@ def test_nickname_in_parenthesis(self) -> None:
         self.m(hn.last, "Franklin", hn)
         self.m(hn.nickname, "Ben", hn)
 
+    # https://github.com/derek73/python-nameparser/issues/112
+    def test_add_custom_nickname_delimiter(self) -> None:
+        hn = HumanName("Benjamin {Ben} Franklin", constants=None)
+        # curly braces aren't a recognized delimiter by default
+        self.m(hn.nickname, "", hn)
+        hn.C.nickname_delimiters['curly_braces'] = re.compile(r'\{(.*?)\}', re.U)
+        hn.parse_full_name()
+        self.m(hn.first, "Benjamin", hn)
+        self.m(hn.last, "Franklin", hn)
+        self.m(hn.nickname, "Ben", hn)
+
     def test_two_word_nickname_in_parenthesis(self) -> None:
         hn = HumanName("Benjamin (Big Ben) Franklin")
         self.m(hn.first, "Benjamin", hn)