Make REGEXES a dict instead of a set of (name, pattern) tuples

A set of tuples consumed as dict(...) means a duplicate name resolves
nondeterministically per process (set iteration order varies with hash
randomization). A dict literal makes a duplicate key a visible overwrite
at write time and is the honest structure for key/value data.

The regexes parameter annotation on Constants.__init__ collapses to
Mapping: both TupleManager arms were dict subclasses already covered by
it, and the new plain-dict default requires it (iterating a dict yields
keys, not pairs, so it never satisfied the Iterable[tuple] arm).

Closes #227

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

Author: derek73

docs/release_log.rst

@@ -43,6 +43,7 @@ Release Log
     - Add German/Austrian nobility and ecclesiastical titles to ``TITLES`` (closes #101)
     - Add German/Dutch last-name prefixes and title/degree suffixes; fix ``join_on_conjunctions()`` to register multi-word prefix chains (e.g. ``"von und zu"``) as prefixes, mirroring existing title handling (closes #18)
     - Change ``Constants.__repr__`` to report collection sizes and non-default scalar config, replacing the uninformative ``<Constants() instance>`` (#221)
+    - Change ``REGEXES`` from a ``set`` of ``(name, pattern)`` tuples to a ``dict``, so a duplicate name is a visible overwrite in the source instead of a nondeterministic winner at import time; code iterating ``REGEXES`` directly now gets keys instead of pairs — use ``.items()`` (#227)
 * 1.2.1 - June 19, 2026
     - Fix ``initials()`` interpolating the literal ``None`` for empty name parts when ``empty_attribute_default = None`` (e.g. ``"J. None D."``); empty parts now render as an empty string and a fully-empty result returns ``empty_attribute_default``
     - Add ``python -m nameparser "Name String"`` command-line helper that prints a parsed name

nameparser/config/__init__.py

@@ -477,7 +477,7 @@ def __init__(self,
                  bound_first_names: Iterable[str] = BOUND_FIRST_NAMES,
                  non_first_name_prefixes: Iterable[str] = NON_FIRST_NAME_PREFIXES,
                  capitalization_exceptions: TupleManager[str] | Iterable[tuple[str, str]] = CAPITALIZATION_EXCEPTIONS,
-                 regexes: RegexTupleManager | TupleManager[re.Pattern[str]] | Iterable[tuple[str, re.Pattern[str]]] = REGEXES,
+                 regexes: Mapping[str, re.Pattern[str]] | Iterable[tuple[str, re.Pattern[str]]] = REGEXES,
                  patronymic_name_order: bool = False,
                  middle_name_as_last: bool = False,
                  ) -> None:

nameparser/config/regexes.py

@@ -8,39 +8,39 @@
 
 EMPTY_REGEX = re.compile('')
 
-REGEXES = set([
-    ("spaces", re.compile(r"\s+")),
-    ("word", re.compile(r"(\w|\.)+")),
-    ("mac", re.compile(r'^(ma?c)(\w{2,})', re.I)),
-    ("initial", re.compile(r'^(\w\.|[A-Z])?$')),
-    ("quoted_word", re.compile(r'(?<!\w)\'([^\s]*?)\'(?!\w)')),
-    ("double_quotes", re.compile(r'\"(.*?)\"')),
-    ("parenthesis", re.compile(r'\((.*?)\)')),
-    ("roman_numeral", re.compile(r'^(X|IX|IV|V?I{0,3})$', re.I)),
-    ("no_vowels",re.compile(r'^[^aeyiuo]+$', re.I)),
-    ("period_not_at_end",re.compile(r'.*\..+$', re.I)),
-    ("emoji",re_emoji),
-    ("phd", re.compile(r'\s(ph\.?\s+d\.?)', re.I)),
-    ("space_before_comma", re.compile(r'\s+,')),
-    ("east_slavic_patronymic", re.compile(
+REGEXES = {
+    "spaces": re.compile(r"\s+"),
+    "word": re.compile(r"(\w|\.)+"),
+    "mac": re.compile(r'^(ma?c)(\w{2,})', re.I),
+    "initial": re.compile(r'^(\w\.|[A-Z])?$'),
+    "quoted_word": re.compile(r'(?<!\w)\'([^\s]*?)\'(?!\w)'),
+    "double_quotes": re.compile(r'\"(.*?)\"'),
+    "parenthesis": re.compile(r'\((.*?)\)'),
+    "roman_numeral": re.compile(r'^(X|IX|IV|V?I{0,3})$', re.I),
+    "no_vowels": re.compile(r'^[^aeyiuo]+$', re.I),
+    "period_not_at_end": re.compile(r'.*\..+$', re.I),
+    "emoji": re_emoji,
+    "phd": re.compile(r'\s(ph\.?\s+d\.?)', re.I),
+    "space_before_comma": re.compile(r'\s+,'),
+    "east_slavic_patronymic": re.compile(
         r'(ovich|ovna|evich|evna|ichna|ilyich|kuzmich|lukich|fomich|fokich)$',
         re.I,
-    )),
-    ("east_slavic_patronymic_cyrillic", re.compile(
+    ),
+    "east_slavic_patronymic_cyrillic": re.compile(
         r'(ович|овна|евич|евна|ична|ильич|кузьмич|лукич|фомич|фокич)$',
         re.I,
-    )),
-    ("turkic_patronymic_marker", re.compile(
+    ),
+    "turkic_patronymic_marker": re.compile(
         r"^(oglu|oğlu|ogly|ogli|o['’ʻ]g['’ʻ]li"
         r"|qizi|qızı|kizi|kyzy|gyzy|uly|uulu)$",
         re.I,
-    )),
-    ("turkic_patronymic_marker_cyrillic", re.compile(
+    ),
+    "turkic_patronymic_marker_cyrillic": re.compile(
         r'^(оглу|оглы|оғлу|ўғли|угли|кызы|гызы|қызы|қизи|улы|ұлы|уулу)$',
         re.I,
-    )),
-    ("period_abbreviation", re.compile(r'^[^\W\d_]{2,}\.$')),
-])
+    ),
+    "period_abbreviation": re.compile(r'^[^\W\d_]{2,}\.$'),
+}
 """
 All regular expressions used by the parser are precompiled and stored in the config.
 """